Merge branch 'main' into cleanup-subtype-for-prods

Author: jurgenvinju

pom.xml

@@ -3,7 +3,7 @@
 
     <groupId>org.rascalmpl</groupId>
     <artifactId>rascal</artifactId>
-    <version>0.42.2-RC2-SNAPSHOT</version>
+    <version>0.42.2-RC3-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <scm>
@@ -458,7 +458,7 @@
         <dependency>
             <groupId>org.rascalmpl</groupId>
             <artifactId>typepal</artifactId>
-            <version>0.16.6-RC2</version>
+            <version>0.16.7</version>
            <!-- <scope>provided</scope> for shade plugin it can't be provided. At least the rascal dependency in typepal should be provided -->
            <scope>compile</scope>
         </dependency>

src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDeclaration.rsc

@@ -695,7 +695,7 @@ void collect(current: (Statement) `return <Statement statement>`, Collector c){
     assert !isEmpty(functionScopes);
     for(<_, scopeInfo> <- functionScopes){
         if(signatureInfo(Type returnType) := scopeInfo){
-           c.require("check return type", current, [statement], makeReturnRequirement(statement, returnType));
+           c.require("check return type", current, [statement, returnType], makeReturnRequirement(statement, returnType));
            c.fact(current, returnType); // Note that type of the return statement as a whole is the function's return type
            collect(statement, c);
            return;

src/org/rascalmpl/compiler/lang/rascalcore/check/CollectType.rsc

@@ -814,13 +814,13 @@ void collect(current:(TypeVar) `& <Name n>`, Collector c){
             }
             c.define(pname, typeVarId(), n, defType(aparameter(pname, bound, closed=closed)));
         }
-        c.calculate("xxx", current, [n], AType (Solver s) { return s.getType(n)[closed=closed]; });
+        c.calculate("type parameter without bound", current, [n], AType (Solver s) { return s.getType(n)[closed=closed]; });
         return;
 
     } else if(<true, bool closed> := useTypeParameters(c)){
         c.use(n, {typeVarId() });
         //if(debugTP)println("Use <pname> at <current@\loc>, closed=<closed>");
-        c.calculate("xxx", current, [n], AType (Solver s) { return s.getType(n)[closed=closed]; });
+        c.calculate("type parameter without bound", current, [n], AType (Solver s) { return s.getType(n)[closed=closed]; });
         return;
     } else {
         if(<true, rel[str, Type] tpbounds> := useBoundedTypeParameters(c)){

src/org/rascalmpl/compiler/lang/rascalcore/check/Summary.rsc

@@ -44,7 +44,6 @@ import IO;
 import Relation;
 import String;
 import ValueIO;
-// import lang::rascalcore::CompilerPathConfig;
 
 // Duplicate in lang::rascalcore::compile::util::Names, factor out
 data PathConfig(
@@ -53,11 +52,8 @@ data PathConfig(
     loc generatedTestResources =|unknown:///|
 );
 
-@doc{
-.Synopsis
-Summary of a Rascal module for use in IDE
-
-.Description
+@synopsis{Summary of a Rascal module for use in IDE}
+@description{
 A `ModuleSummary` summarizes a Rascal module for the benefit of IDE support like
 * Show type of current symbol.
 * Goto definition.
@@ -104,53 +100,42 @@ ModuleSummary makeSummary(TModel tm, str qualifiedModuleName) {
         [vocabulary=getVocabulary(tm)]
         [synopses=synopses]
         [docLocs=docLocs];
-}    
-    
-@doc{
-.Synopsis
-Make a ModuleSummary.
 }
+
+ModuleSummary makeSummary(str qualifiedModuleName, loc tplLoc) {
+    try {
+        return makeSummary(readBinaryValueFile(#TModel, tplLoc), qualifiedModuleName);
+    } catch IO(_): {
+        return moduleSummary();
+    }
+}
+
+@synopsis{Make a ModuleSummary.}
 ModuleSummary makeSummary(str qualifiedModuleName, PathConfig pcfg){
     if(<true, tplLoc> := getTPLReadLoc(qualifiedModuleName, pcfg)){
-        try {
-            return makeSummary(readBinaryValueFile(#TModel, tplLoc), qualifiedModuleName);
-        } catch IO(_): {
-            return moduleSummary();
-        }
+        return makeSummary(qualifiedModuleName, tplLoc);
     }
     else {
         return moduleSummary();
     }
 }
 
-@doc{
-.Synopsis
-Get all definitions for a given use.
-}
+@synopsis{Get all definitions for a given use.}
 set[loc] getDefinitions(ModuleSummary summary, loc use){
     return summary.useDef[use] ? {};
 }
 
-@doc{
-.Synopsis
-Get the (pretty printed) type for a given use.
-}
+@synopsis{Get the (pretty printed) type for a given use.}
 str getType(ModuleSummary summary, loc use){
     return summary.locationTypes[use] ? "";
 }
 
-@doc{
-.Synopsis
-Get all definitions for a given definition.
-}
+@synopsis{Get all definitions for a given definition.}
 set[loc] getUses(ModuleSummary s, loc def){
     return invert(s.useDef)[def];
 }
 
-@doc{
-.Synopsis
-Get the doc string for a given definition.
-}
+@synopsis{Get the doc string for a given definition.}
 str getDocForDefinition(loc def){
     try {
         d = readFile(def);

src/org/rascalmpl/compiler/lang/rascalcore/check/tests/StaticTestingUtils.rsc

@@ -455,6 +455,7 @@ list[str] unexpectedDeclarationMsgs = [
 	"Invalid initialization of _",
 	"Undefined _",
 	"Double declaration of _",
+	"Duplicate declaration of _",
 	"Multiple declarations of _ are applicable here",
 	"Constructor _ overlaps with other declaration for type _, see _",
 	"Incompatible field _ in _: _ in constructor _ clashes with _ in constructor _",

src/org/rascalmpl/interpreter/env/GlobalEnvironment.java

@@ -23,6 +23,7 @@
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.rascalmpl.ast.AbstractAST;
 import org.rascalmpl.ast.QualifiedName;
@@ -34,6 +35,7 @@
 import org.rascalmpl.values.IRascalValueFactory;
 
 import io.usethesource.capsule.SetMultimap;
+import io.usethesource.vallang.IConstructor;
 import io.usethesource.vallang.IList;
 import io.usethesource.vallang.IString;
 
@@ -329,4 +331,11 @@ public void clearLookupChaches() {
 	public void clearModuleLoadMessage() {
 		moduleEnvironment.values().forEach(ModuleEnvironment::clearLoadMessages);
 	}
+
+	public Stream<IConstructor> streamModuleLoadMessages() {
+		return moduleEnvironment
+			.values()
+			.stream()
+			.flatMap(me -> me.streamLoadMessages());
+	}
 }

src/org/rascalmpl/interpreter/env/ModuleEnvironment.java

@@ -32,6 +32,7 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Predicate;
+import java.util.stream.Stream;
 
 import org.rascalmpl.ast.AbstractAST;
 import org.rascalmpl.ast.KeywordFormal;
@@ -143,6 +144,10 @@ public void clearLookupCaches() {
 	public void clearLoadMessages() {
 		this.loadMessages.clear();
 	}
+
+	public Stream<IConstructor> streamLoadMessages() {
+		return loadMessages.stream();
+	}
 
 	public void extend(ModuleEnvironment other) {
 		extendNameFlags(other);
@@ -583,22 +588,29 @@ public void getAllFunctions(String name, List<AbstractFunction> collection) {
 		collection.addAll(lookupCachedFunctions(name));
 	}
 
+	private List<AbstractFunction> lookupFunctionsNoCache(String name) {
+		var result = new ArrayList<AbstractFunction>();
+		super.getAllFunctions(name, result);
+			
+		for (ModuleEnvironment mod : importedModulesResolved)  {	
+			if (mod != null) {
+				mod.getLocalPublicFunctions(name, result);
+			}
+		}
+		return result;
+	}
+
 	private List<AbstractFunction> lookupCachedFunctions(String name) {
 		if (cachedPublicFunctions == null) {
 			cachedPublicFunctions = io.usethesource.capsule.Map.Transient.of();
 		}
-		return cachedPublicFunctions.computeIfAbsent(name, n -> {
-			var result = new ArrayList<AbstractFunction>();
-			super.getAllFunctions(n, result);
-			
-			for (ModuleEnvironment mod : importedModulesResolved) {
-				
-				if (mod != null) {
-					mod.getLocalPublicFunctions(n, result);
-				}
-			}
-			return result;
-		});
+
+		if (!initialized) {
+			return lookupFunctionsNoCache(name);
+		}
+		else {
+			return cachedPublicFunctions.computeIfAbsent(name, this::lookupFunctionsNoCache);
+		}
 	}
 
 	@Override

src/org/rascalmpl/library/lang/rascal/tests/basic/FunctionCachesAndGlobals.rsc

@@ -0,0 +1,9 @@
+module lang::rascal::tests::basic::FunctionCachesAndGlobals
+
+default int f(int _) = 42;
+int x = f(0);
+int f(0) = 0;
+
+
+test bool noCacheDuringInit() = f(0) == 0;
+test bool globalInitLast() = x == 0;

src/org/rascalmpl/library/lang/rascal/tests/loading/LoadingErrorModules.rsc

@@ -0,0 +1,130 @@
+module lang::rascal::tests::loading::LoadingErrorModules
+
+import IO;
+import util::Eval;
+import util::PathConfig;
+import Message;
+
+PathConfig init() = pathConfig(srcs=[|memory://LoadingErrorModules/|]);
+
+loc moduleFile(str name) = |memory://LoadingErrorModules/| + "<name>.rsc";
+
+test bool moduleWithParseError() {
+    exec = createRascalRuntime(pcfg=init());
+
+    writeFile(moduleFile("A"), "modle A");
+
+    try {
+        exec.eval(#void, "import A;");
+        return false;
+    }
+    catch ModuleLoadMessages([error(_,_)]): {
+        // that's ok
+        ;
+    }
+
+    writeFile(moduleFile("A"), "module A");
+
+    return exec.eval(#void, "import A;") == ok();
+}
+
+test bool moduleWithTransientParseError() {
+    exec = createRascalRuntime(pcfg=init());
+
+    writeFile(moduleFile("A"), "module A");
+    assert exec.eval(#void, "import A;") == ok();
+    writeFile(moduleFile("A"), "modle A");
+
+    try {
+        exec.eval(#void, "import A;");
+        return false;
+    }
+    catch ModuleLoadMessages([error(_,_)]): {
+        // that's ok
+        ;
+    }
+
+    writeFile(moduleFile("A"), "module A");
+
+    return exec.eval(#void, "import A;") == ok();
+}
+
+test bool moduleWithTransitiveParseError() {
+    exec = createRascalRuntime(pcfg=init());
+
+    writeFile(moduleFile("A"), "modle A");
+    writeFile(moduleFile("B"), "module B import A;");
+
+    try {
+        exec.eval(#void, "import B;");
+        return false;
+    }
+    catch ModuleLoadMessages([error(_,_)]): {
+        // that's ok
+        ;
+    }
+
+    writeFile(moduleFile("A"), "module A");
+
+    return exec.eval(#void, "import A;") == ok()
+        && exec.eval(#void, "import B;") == ok();
+}
+
+test bool moduleWithStaticError() {
+    exec = createRascalRuntime(pcfg=init());
+
+    writeFile(moduleFile("A"), "module A str aap = 42;");
+
+    try {
+        exec.eval(#void, "import A;");
+        return false;
+    }
+    catch ModuleLoadMessages([error(_,_)]): {
+        // that's ok
+        ;
+    }
+
+    writeFile(moduleFile("A"), "module A str aap = \"42\";");
+
+    return exec.eval(#void, "import A;") == ok();
+}
+
+test bool importNonExistingModule() {
+    exec = createRascalRuntime(pcfg=init());
+
+    try {
+        exec.eval(#void, "import Z;");
+        return false;
+    }
+    catch ModuleLoadMessages([error(_,_)]): {
+        // that's ok
+        ;
+    }
+
+    writeFile(moduleFile("Z"), "module Z public str aap = \"aap\";");
+
+    return exec.eval(#void, "import Z;") == ok()
+        && result("aap") == exec.eval(#str, "aap");
+}
+
+
+test bool importBrokenModuleName() {
+    exec = createRascalRuntime(pcfg=init());
+
+    writeFile(moduleFile("AAA"), "module AA public str aap = \"aap\";");
+
+    try {
+        exec.eval(#void, "import AAA;");
+        return false;
+    }
+    catch ModuleLoadMessages([error(_,_)]): {
+        // that's ok
+        ;
+    }
+
+    writeFile(moduleFile("AAA"), "module AAA public str aap = \"aap\";");
+
+    return exec.eval(#void, "import AAA;") == ok()
+        && result("aap") == exec.eval(#str, "aap");
+}
+