Native logical locs

pom.xml

@@ -458,7 +458,7 @@
         <dependency>
             <groupId>org.rascalmpl</groupId>
             <artifactId>typepal</artifactId>
-            <version>0.15.3</version>
+            <version>0.16.0-RC2</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/ADTandGrammar.rsc

@@ -165,19 +165,20 @@ list[&T <: node ] unsetRec(list[&T <: node] args) = [unsetRec(a) | a <- args];
 
 bool isManualLayout(AProduction p) = (p has attributes && atag("manual"()) in p.attributes);
 
-tuple[TModel, ModuleStatus] addGrammar(str qualifiedModuleName, set[str] imports, set[str] extends, map[str,TModel] transient_tms, ModuleStatus ms){
+tuple[TModel, ModuleStatus] addGrammar(MODID moduleId, set[MODID] imports, set[MODID] extends, map[MODID,TModel] transient_tms, ModuleStatus ms){
     try {
         rel[AType,AProduction] definedProductions = {};
         allStarts = {};
-        for(m <- {qualifiedModuleName, *imports, *extends}){
+        qualifiedModuleName = moduleId2moduleName(moduleId);
+        for(m <- {moduleId, *imports, *extends}){
             TModel tm1;
             if(transient_tms[m]?){
                 tm1 = transient_tms[m];
             } else {
                 <found, tm1, ms> = getTModelForModule(m, ms);
                 if(!found) {
-                    msg = error("Cannot add grammar, tmodel for <m> not found", ms.moduleLocs[qualifiedModuleName] ? |unknown:///|);
-                    ms.messages[qualifiedModuleName] ? {} += { msg };
+                    msg = error("Cannot add grammar, tmodel for <m> not found", ms.moduleLocs[moduleId] ? |unknown:///|);
+                    ms.messages[moduleId] ? {} += { msg };
                     tm1 = tmodel(modelName=qualifiedModuleName, messages=[msg]);
                     return <tm1, ms>;
                 }
@@ -223,7 +224,7 @@ tuple[TModel, ModuleStatus] addGrammar(str qualifiedModuleName, set[str] imports
 
         // Check keyword rules
 
-        tm = checkKeywords(allProductions, transient_tms[qualifiedModuleName]);
+        tm = checkKeywords(allProductions, transient_tms[moduleId]);
 
         // Check layout
 

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

@@ -24,17 +24,6 @@ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
-@license{
-  Copyright (c) 2009-2015 CWI
-  All rights reserved. This program and the accompanying materials
-  are made available under the terms of the Eclipse Public License v1.0
-  which accompanies this distribution, and is available at
-  http://www.eclipse.org/legal/epl-v10.html
-}
-@contributor{Jurgen J. Vinju - Jurgen.Vinju@cwi.nl - CWI}
-@contributor{Mark Hills - Mark.Hills@cwi.nl (CWI)}
-@contributor{Paul Klint - Paul.Klint@cwi.nl (CWI)}
-@contributor{Anastasia Izmaylova - Anastasia.Izmaylova@cwi.nl (CWI)}
 @bootstrapParser
 module lang::rascalcore::check::ATypeUtils
 
@@ -366,7 +355,7 @@ AType symbol2atype1(Symbol::\cons(Symbol \adt, str name, list[Symbol] parameters
 AType symbol2atype1(Symbol::sort(str name)) = aadt(name, [], contextFreeSyntax());
 AType symbol2atype1(Symbol::lex(str name)) = aadt(name, [], lexicalSyntax());
 AType symbol2atype1(Symbol::keywords(str name)) = aadt(name, [], keywordSyntax());
-AType symbol2atype1(Symbol::layouts(str name)) = AType::layouts(name);
+AType symbol2atype1(Symbol::layouts(str name)) = aadt(name, [], layoutSyntax());
 
 AType symbol2atype1(Symbol::\parameterized-sort(str name, list[Symbol] parameters)) =
     aadt(name, symbol2atype(parameters), contextFreeSyntax());

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

@@ -750,10 +750,27 @@ void reportMissingNonTerminalCases(Expression current, rel[loc def, IdRole idRol
 // }
 
 private tuple[rel[loc, IdRole, AType], list[bool]] filterOverloads(rel[loc, IdRole, AType] overloads, int arity){
+    // println("filterOverloads: <overloads>, <arity>");
     rel[loc, IdRole, AType] filteredOverloads = {};
     list[AType] prevFormals = [];
     list[bool] identicalFormals = [true | int _ <- [0 .. arity]];
 
+    // Filter constructors first to avoid issues with vararg functions
+    for(ovl:<_, _, tp> <- overloads){
+        if(acons(aadt(_, list[AType] _,_), list[AType] fields, list[Keyword] _) := tp){
+           if(size(fields) == arity){
+              filteredOverloads += ovl;
+              if(isEmpty(prevFormals)){
+                 prevFormals = fields; //<1>;
+              } else {
+                 for(int i <- index(fields)) {
+                   identicalFormals[i] = identicalFormals[i] && (comparable(prevFormals[i], fields[i]/*.fieldType*/));
+                 }
+              }
+            }
+        }
+    }
+
     for(ovl:<_, _, tp> <- overloads){
         if(ft:afunc(AType _, list[AType] formals, list[Keyword] _) := tp){
            if(ft.varArgs ? (arity >= size(formals) - 1) : (arity == size(formals))) {
@@ -769,18 +786,7 @@ private tuple[rel[loc, IdRole, AType], list[bool]] filterOverloads(rel[loc, IdRo
               }
            }
         }
-        else if(acons(aadt(_, list[AType] _,_), list[AType] fields, list[Keyword] _) := tp){
-           if(size(fields) == arity){
-              filteredOverloads += ovl;
-              if(isEmpty(prevFormals)){
-                 prevFormals = fields; //<1>;
-              } else {
-                 for(int i <- index(fields)) {
-                   identicalFormals[i] = identicalFormals[i] && (comparable(prevFormals[i], fields[i]/*.fieldType*/));
-                 }
-              }
-            }
-        }
+
     }
     return <filteredOverloads, identicalFormals>;
 }