Merge branch 'develop' into feature/revert-unify-trackedness

Author: krame505

Jenkinsfile

@@ -14,6 +14,9 @@ melt.trynode('silver') {
 
     checkout scm
 
+    // Fetch tags, so that we can obtain the Silver version when building the compiler jar
+    sh "git fetch --tags"
+
     // Bootstrap logic to obtain jars
     if (params.OVERRIDE_JARS != 'no') {
       def source = params.OVERRIDE_JARS

grammars/silver/compiler/definition/flow/ast/Flow.sv

@@ -187,7 +187,7 @@ abstract production defaultSynEq
 top::FlowDef ::= nt::String  attr::String  deps::[FlowVertex]
 {
   top.defTreeContribs := [(crossnames(nt, attr), top)];
-  top.prodGraphContribs := []; -- defaults don't show up in the prod graph!!
+  top.prodGraphContribs := [(nt ++ ":default", top)];
   top.flowEdges = map(pair(fst=lhsSynVertex(attr), snd=_), deps); -- but their edges WILL end up added to graphs in fixup-phase!!
 }
 

grammars/silver/compiler/definition/flow/driver/ProductionGraph.sv

@@ -98,20 +98,15 @@ Maybe<ProductionGraph> ::=
   | nothing() -> graph.cullSuspect(ntEnv)
   end;
 
--- construct a production graph for each production
-fun computeAllProductionGraphs
-[ProductionGraph] ::= prods::[ValueDclInfo]  flowEnv::FlowEnv  realEnv::Env =
-  if null(prods) then []
-  else constructProductionGraph(head(prods), flowEnv, realEnv) ::
-    computeAllProductionGraphs(tail(prods), flowEnv, realEnv);
-
 
 --------------------------------------------------------------------------------
 -- Below, we have various means of constructing a production graph.
--- Three types are used as part of inference:
+-- Four types are used as part of inference:
 --  1. `constructProductionGraph` builds a graph for a normal production.
---  2. `constructPhantomProductionGraph` builds a "phantom graph" to guide inference.
---  3. `constructDispatchGraph` builds a graph for a dispatch signature,
+--  2. `constructDefaultProductionGraph` builds a graph for default equations for a nonterminal.
+--       (key: like phantom, LHS is stitch point, to make dependencies clear.)
+--  3. `constructPhantomProductionGraph` builds a "phantom graph" to guide inference.
+--  4. `constructDispatchGraph` builds a graph for a dispatch signature,
 --     to make projection stitch points work for them.
 --
 -- There are more types of "production" graphs, used NOT for inference, but
@@ -120,8 +115,6 @@ fun computeAllProductionGraphs
 --       (the key here: `aspect function` contributions `<-` needs to be handled.)
 --  2. `constructAnonymousGraph` builds a graph for a global expression. (also action blocks)
 --       (key: decorate/patterns create stitch points and things that need to be handled.)
---  3. `constructDefaultProductionGraph` builds a graph used locally in a default production.
---       (key: like phantom, LHS is stitch point, to make dependencies clear.)
 --
 -- This latter type should always call `updateGraph` to fill in all edges after construction.
 --------------------------------------------------------------------------------
@@ -307,23 +300,26 @@ ProductionGraph ::= defs::[FlowDef]  realEnv::Env  prodEnv::EnvTree<ProductionGr
 }
 
 {--
- - An graph for checking dependencies in default equations.
- -
- - NOTE: Not used as part of inference. Instead, only used as part of error checking.
+ - A graph for dependencies in default equations.
  -
+ - This is used in checking, and also to handle dependencies of default equations during inference.
  -}
 function constructDefaultProductionGraph
-ProductionGraph ::= ns::NamedSignature  defs::[FlowDef]  realEnv::Env  prodEnv::EnvTree<ProductionGraph>  ntEnv::EnvTree<FlowType>
+[ProductionGraph] ::= nt::NtName  flowEnv::FlowEnv  realEnv::Env
 {
-  local prod :: String = ns.fullName;
-  local nt :: NtName = ns.outputElement.typerep.typeName;
+  -- The stand-in "full name" of this default production
+  local prod :: String = nt ++ ":default";
+  -- The flow defs for this default production
+  local defs :: [FlowDef] = getGraphContribsFor(prod, flowEnv);
+  -- Just synthesized attributes.
+  local syns :: [String] = getSynAttrsOn(nt, realEnv);
 
   local normalEdges :: [(FlowVertex, FlowVertex)] =
     flatMap((.flowEdges), defs);
 
   -- suspectEdges should always be empty! (No "aspects" where they could arise.)
   local suspectEdges :: [(FlowVertex, FlowVertex)] = [];
-    
+
   local initialGraph :: g:Graph<FlowVertex> =
     createFlowGraph(normalEdges);
 
@@ -334,16 +330,19 @@ ProductionGraph ::= ns::NamedSignature  defs::[FlowDef]  realEnv::Env  prodEnv::
     localStitchPoints(realEnv, error("default production shouldn't have a forwarding equation?"), defs) ++
     patternStitchPoints(realEnv, defs);
 
-  local flowTypeVertexes :: [FlowVertex] = []; -- Not used as part of inference.
+  local flowTypeVertexesOverall :: [FlowVertex] = map(lhsSynVertex, syns);
+  local flowTypeSpecs :: [String] = getSpecifiedSynsForNt(nt, flowEnv);
+  
+  local flowTypeVertexes :: [FlowVertex] =
+    filter(\x::FlowVertex -> !contains(x.flowTypeName, flowTypeSpecs), flowTypeVertexesOverall);
 
   local g :: ProductionGraph =
     productionGraph(prod, nt, flowTypeVertexes, initialGraph, suspectEdges, stitchPoints).transitiveClosure;
-
-  return fromMaybe(g, updateGraph(g, prodEnv, ntEnv));
+  
+  -- Optimization: omit the default graph if there are no default equations for the NT.
+  return if null(defs) then [] else [g];
 }
 
-
-
 {--
  - Constructs "phantom graphs" to enforce 'ft(syn) >= ft(fwd)'.
  -
@@ -353,7 +352,7 @@ ProductionGraph ::= ns::NamedSignature  defs::[FlowDef]  realEnv::Env  prodEnv::
  - @return A fixed up graph.
  -}
 function constructPhantomProductionGraph
-ProductionGraph ::= nt::String  flowEnv::FlowEnv  realEnv::Env
+[ProductionGraph] ::= nt::String  flowEnv::FlowEnv  realEnv::Env
 {
   -- Just synthesized attributes.
   local syns :: [String] = getSynAttrsOn(nt, realEnv);
@@ -373,7 +372,11 @@ ProductionGraph ::= nt::String  flowEnv::FlowEnv  realEnv::Env
   local initialGraph :: g:Graph<FlowVertex> = createFlowGraph(phantomEdges);
   local suspectEdges :: [(FlowVertex, FlowVertex)] = [];
 
-  return productionGraph("Phantom for " ++ nt, nt, flowTypeVertexes, initialGraph, suspectEdges, stitchPoints).transitiveClosure;
+  local g::ProductionGraph =
+    productionGraph("Phantom for " ++ nt, nt, flowTypeVertexes, initialGraph, suspectEdges, stitchPoints).transitiveClosure;
+  
+  -- Optimization: omit the phantom graph if there are no extension syns for the NT.
+  return if null(extSyns) then [] else [g];
 }
 
 {--
@@ -444,7 +447,7 @@ fun allFwdProdAttrs [String] ::= d::[FlowDef] =
   | _ :: rest -> allFwdProdAttrs(rest)
   end;
 {--
- - Introduces default equations deps. Realistically, should be empty, always.
+ - Introduces default equations deps.
  -}
 fun addDefEqs
 [(FlowVertex, FlowVertex)] ::= prod::ProdName nt::NtName syns::[String] flowEnv :: FlowEnv =

grammars/silver/compiler/definition/flow/env/ProductionDcl.sv

@@ -85,3 +85,19 @@ top::AspectRHSElem ::= '@' id::Name '::' t::TypeExpr
 {
   propagate flowEnv;
 }
+
+aspect production aspectDefaultProduction
+top::AGDcl ::= 'aspect' 'default' 'production' ns::AspectDefaultProductionSignature body::ProductionBody
+{
+  local myFlow :: EnvTree<FlowType> = head(searchEnvTree(top.grammarName, top.compiledGrammars)).grammarFlowTypes;
+  local myGraphs :: EnvTree<ProductionGraph> = head(searchEnvTree(top.grammarName, top.compiledGrammars)).productionFlowGraphs;
+
+  {-- Used by core to send down with .frame -}
+  production myFlowGraph :: ProductionGraph =
+    case searchEnvTree(ns.namedSignature.fullName, myGraphs) of
+    | g :: _ -> g
+    -- In case we didn't find the flow graph (the nonterminal doesn't exist?)
+    -- build an anonymous flow graph to use instead as a "best effort".
+    | [] -> constructAnonymousGraph(body.flowDefs, top.env, myGraphs, myFlow)
+    end;
+}

grammars/silver/compiler/driver/BuildProcess.sv

@@ -48,13 +48,14 @@ fun computeEnv IOErrorable<(Decorated CmdArgs, BuildEnv)> ::= args::[String] =
   | right(a) -> do {
     -- Figure out build env from environment and args
     benv::BuildEnv <- determineBuildEnv(a);
+    silverVersion::String <- lift(stateIO(getJarVersion));
     -- Because we want printing the version to work even if the environment is messed up
     -- we premptively handle that here. This is slightly unfortunate.
     -- Ideally, version printing would be just another thing we could have the command
     -- line decide to go do, but currently it's hard to re-use code if we do that.
     if a.displayVersion then
       throwRunError(127, -- error code so 'ant' isnt run
-        "Silver Version 0.4.5-dev\n" ++
+        "Silver Version " ++ silverVersion ++ "\n" ++
         "SILVER_HOME = " ++ benv.silverHome ++ "\n" ++
         "SILVER_GEN = " ++ benv.silverGen ++ "\n" ++
         "GRAMMAR_PATH:\n" ++ implode("\n", benv.grammarPath))
@@ -184,3 +185,11 @@ data RunError = runError
 type IOErrorable<a> = EitherT<RunError IO a>;
 
 fun throwRunError IOErrorable<a> ::= c::Integer m::String = throwError(runError(code=c, errMsg=m));
+
+function getJarVersion
+IOVal<String> ::= i::IOToken
+{
+  return error("NYI");
+} foreign {
+  "java" : return "new silver.core.Pioval(%i%, common.Util.getJarVersion(Init.class))";
+}

grammars/silver/compiler/driver/util/FlowTypes.sv

@@ -33,10 +33,11 @@ top::Compilation ::= g::Grammars  r::Grammars  buildGrammars::[String]  a::Decor
 
   -- Construct production graphs.
   production prodGraph :: [ProductionGraph] = 
-    computeAllProductionGraphs(allProds, allFlowEnv, allRealEnv) ++
-      -- Add in phantom and dispatch graphs
-      map(constructPhantomProductionGraph(_, allFlowEnv, allRealEnv), allNts) ++
-      map(constructDispatchGraph(_, allFlowEnv, allRealEnv), allDispatchSigs);
+    map(constructProductionGraph(_, allFlowEnv, allRealEnv), allProds) ++
+    -- Add in phantom, default and dispatch graphs
+    flatMap(constructPhantomProductionGraph(_, allFlowEnv, allRealEnv), allNts) ++
+    flatMap(constructDefaultProductionGraph(_, allFlowEnv, allRealEnv), allNts) ++
+    map(constructDispatchGraph(_, allFlowEnv, allRealEnv), allDispatchSigs);
 
   local initialFT :: EnvTree<FlowType> =
     computeInitialFlowTypes(allSpecDefs);

grammars/silver/compiler/modification/defaultattr/DefaultAttr.sv

@@ -26,13 +26,6 @@ top::AGDcl ::= 'aspect' 'default' 'production' ns::AspectDefaultProductionSignat
 
   local sigDefs :: [Def] = addNewLexicalTyVars(top.grammarName, ns.lexicalTyVarKinds, ns.lexicalTypeVariables);
 
-  -- oh no again!
-  local myFlow :: EnvTree<FlowType> = head(searchEnvTree(top.grammarName, top.compiledGrammars)).grammarFlowTypes;
-  local myProds :: EnvTree<ProductionGraph> = head(searchEnvTree(top.grammarName, top.compiledGrammars)).productionFlowGraphs;
-
-  local myFlowGraph :: ProductionGraph = 
-    constructDefaultProductionGraph(ns.namedSignature, body.flowDefs, top.env, myProds, myFlow);
-
   ns.env = newScopeEnv(sigDefs, top.env);
 
   body.env = newScopeEnv(ns.defs, ns.env);
@@ -55,7 +48,7 @@ top::AspectDefaultProductionSignature ::= lhs::Name '::' te::TypeExpr '::='
   top.unparse = lhs.unparse ++ "::" ++ te.unparse ++ " ::=";
   top.defs := [defaultLhsDef(top.grammarName, lhs.nameLoc, lhs.name, te.typerep)];
   top.namedSignature =
-    namedSignature(top.grammarName ++ ":default" ++ te.typerep.typeName,
+    namedSignature(top.grammarName ++ ":" ++ te.typerep.typeName ++ ":default",
       nilContext(), nilNamedSignatureElement(),
       namedSignatureElement(lhs.name, te.typerep, false),
       foldNamedSignatureElements(annotationsForNonterminal(te.typerep, top.env)));

grammars/silver/compiler/translation/java/driver/BuildProcess.sv

@@ -14,6 +14,7 @@ synthesized attribute relativeJar :: Boolean occurs on CmdArgs;
 synthesized attribute includeRTJars :: [String] occurs on CmdArgs;
 -- TODO: Should this be a Maybe?
 synthesized attribute buildXmlLocation :: [String] occurs on CmdArgs;
+synthesized attribute jarImplVersion :: String occurs on CmdArgs;
 
 aspect production endCmdArgs
 top::CmdArgs ::= _
@@ -23,6 +24,7 @@ top::CmdArgs ::= _
   top.relativeJar = false;
   top.includeRTJars = [];
   top.buildXmlLocation = [];
+  top.jarImplVersion = "";
 }
 abstract production dontTranslateFlag
 top::CmdArgs ::= rest::CmdArgs
@@ -54,6 +56,12 @@ top::CmdArgs ::= s::String rest::CmdArgs
   top.buildXmlLocation = s :: forward.buildXmlLocation;
   forwards to @rest;
 }
+abstract production jarImplVersionFlag
+top::CmdArgs ::= s::String rest::CmdArgs
+{
+  top.jarImplVersion = s;
+  forwards to @rest;
+}
 
 aspect function parseArgs
 Either<String  Decorated CmdArgs> ::= args::[String]
@@ -76,6 +84,9 @@ Either<String  Decorated CmdArgs> ::= args::[String]
            , flagSpec(name="--build-xml-location", paramString=nothing(),
                help="sets the path the Ant build.xml will be saved to",
                flagParser=option(buildXmlFlag))
+           , flagSpec(name="--jar-impl-version", paramString=nothing(),
+               help="set the Implementation-Version header in the JAR's manifest",
+               flagParser=option(jarImplVersionFlag))
            ];
 }
 aspect production compilation
@@ -131,10 +142,12 @@ top::Compilation ::= g::Grammars  _  buildGrammars::[String]  a::Decorated CmdAr
 
   classpathRuntime <- nub(g.includedJars);  -- TODO: include in classpathCompiler too?
 
+  local jarImplVersion :: String = if a.jarImplVersion == "" then "${TIME}" else a.jarImplVersion;
+
   production attribute extraManifestAttributes :: [String] with ++;
   extraManifestAttributes := [
     "<attribute name='Built-By' value='${user.name}' />",
-    "<attribute name='Implementation-Version' value='${TIME}' />",
+    "<attribute name='Implementation-Version' value='" ++ jarImplVersion ++ "' />",
     "<attribute name='Main-Class' value='" ++ makeName(buildGrammar) ++ ".Main' />"]; -- TODO: we "should" make main depend on whether there is a main...
 
   extraManifestAttributes <-

make-compiler

@@ -5,8 +5,11 @@
 
 set -euo pipefail
 
+silver_version=`git describe --tags`
+echo "Build version $silver_version"
+
 export SILVER_HOME=$PWD
-JVM_ARGS=(-Xss20M -Xmx6500M -jar ../jars/silver.compiler.composed.Default.jar --no-stdlib --include-jar ../jars/CopperCompiler.jar --include-jar ../jars/commonmark-0.17.1.jar --relative-jar "$@")
+JVM_ARGS=(-Xss20M -Xmx6500M -jar ../jars/silver.compiler.composed.Default.jar --no-stdlib --include-jar ../jars/CopperCompiler.jar --include-jar ../jars/commonmark-0.17.1.jar --relative-jar "$@" --jar-impl-version "$silver_version")
 export GRAMMAR_PATH="../grammars"
 export ANT_OPTS=-Xss10M
 

runtime/java/src/common/Util.java

@@ -6,6 +6,8 @@
 import java.util.*;
 import java.util.stream.Collectors;
 import java.net.URI;
+import java.util.jar.JarInputStream;
+import java.util.jar.Attributes.Name;
 
 import common.exceptions.*;
 import common.javainterop.ConsCellCollection;
@@ -504,6 +506,16 @@ public static StringCatter determineSilverHomePath(Class<?> clazz) {
 		File home = new File(jarLocation).getParentFile().getParentFile();
 		return new StringCatter(home.getPath());
 	}
+
+	public static StringCatter getJarVersion(Class<?> clazz) {
+		try {
+			URI jarLocation = clazz.getProtectionDomain().getCodeSource().getLocation().toURI();
+			JarInputStream file = new JarInputStream(new FileInputStream(new File(jarLocation)));
+			return new StringCatter(file.getManifest().getMainAttributes().getValue(Name.IMPLEMENTATION_VERSION));
+		} catch (Throwable t) {
+			throw new RuntimeException("Failed to get jar version.", t);
+		}
+	}
 
 	public static ConsCell bitSetToList(BitSet b) {
 		ConsCell result = ConsCell.nil;