From 4ae314e55159305627969468259aa7f2b1099077 Mon Sep 17 00:00:00 2001
From: paulklint <Paul.Klint@cwi.nl>
Date: Mon, 8 Jun 2026 23:04:23 +0200
Subject: [PATCH 1/3] Gradually adapting compiler to logical locations

---
 .../lang/rascalcore/check/CheckerCommon.rsc   |   6 +-
 .../rascalcore/check/CollectExpression.rsc    |   3 -
 .../rascalcore/check/LogicalLocations.rsc     |  12 +-
 .../lang/rascalcore/check/TestConfigs.rsc     |   2 +-
 .../lang/rascalcore/compile/Examples/A.rsc    |  16 +-
 .../lang/rascalcore/compile/Examples/Tst6.rsc |   3 -
 .../Rascal2muRascal/RascalDeclaration.rsc     |  90 +++++------
 .../Rascal2muRascal/RascalExpression.rsc      |  57 ++++---
 .../compile/Rascal2muRascal/RascalPattern.rsc |  32 ++--
 .../Rascal2muRascal/RascalStatement.rsc       |  28 ++--
 .../compile/Rascal2muRascal/TmpAndLabel.rsc   |  19 ++-
 .../compile/Rascal2muRascal/TypeUtils.rsc     |  60 ++++----
 .../lang/rascalcore/compile/muRascal/AST.rsc  |  76 +++++-----
 .../compile/muRascal2Java/CodeGen.rsc         | 141 +++++++++---------
 .../compile/muRascal2Java/Interface.rsc       |  18 ++-
 .../compile/muRascal2Java/JGenie.rsc          |  69 +++++----
 .../compile/muRascal2Java/Resolvers.rsc       |  28 ++--
 .../compile/muRascal2Java/Tests.rsc           |   5 +-
 .../lang/rascalcore/compile/util/Names.rsc    |  10 ++
 19 files changed, 341 insertions(+), 334 deletions(-)

diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/CheckerCommon.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/CheckerCommon.rsc
index 69ab4f43eaf..eb7be1c4b4f 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/CheckerCommon.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/CheckerCommon.rsc
@@ -492,9 +492,9 @@ rel[loc from, PathRole r, loc to] getPaths(rel[MODID from, PathRole r, MODID to]
     return paths;
 }
 
-int closureCounter = 0;
+private int closureCounter = 0;
 
-int nextClosure(){
+private int nextClosure(){
     counter = closureCounter;
     closureCounter += 1;
     return counter;
@@ -503,3 +503,5 @@ int nextClosure(){
 void resetClosureCounter(){
     closureCounter = 0;
 }
+
+str generateClosureName() = "$CLOSURE_<nextClosure()>";
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectExpression.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectExpression.rsc
index 106b590388f..c4fae5bd748 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectExpression.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectExpression.rsc
@@ -213,8 +213,6 @@ void collect(current: (Expression) `( <Expression expression> )`, Collector c){
 
 // ---- closure
 
-str generateClosureName() = "$CLOSURE_<nextClosure()>";
-
 void collect(current: (Expression) `<Type returnType> <Parameters parameters> { <Statement+ statements> }`, Collector c){
     // TODO: experimental check
     //if(!isEmpty(c.getScopeInfo(loopScope())) || inPatternScope(c)){
@@ -252,7 +250,6 @@ void collectClosure(Expression current, Type returnType, Parameters parameters,
 
         alwaysSucceeds = all(pat <- formals, pat is typedVariable && /(Statement) `fail <Target _>;` := stats);
         if(!alwaysSucceeds) dt.canFail = true;
-
         c.defineInScope(parentScope, clos_name, functionId(), current, dt);
 
         if(!returnsViaAll && "<returnType>" != "void"){
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/LogicalLocations.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/LogicalLocations.rsc
index 82e07a08255..2c0cb7741d6 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/LogicalLocations.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/LogicalLocations.rsc
@@ -25,10 +25,20 @@ alias FUNID = loc; // function identification
 
 bool isFunctionId(loc l) = l.scheme == "rascal+function";
 
+str getFunctionName(FUNID fuid){
+    assert isFunctionId(fuid);
+    k = findLast(fuid.path, "/");
+    return fuid.path[k+1..];
+}
+
 alias CONSID = loc; // constructor identification
 
 bool isConstructorId(loc l) = l.scheme == "rascal+constructor";
 
 alias FLDID = loc; // field identification
 
-bool isFieldId(loc l) = l.scheme == "rascal+field";
\ No newline at end of file
+bool isFieldId(loc l) = l.scheme == "rascal+field";
+
+
+alias ADTID = loc; // ADT
+bool isADTId(loc l) = l.scheme == "rascal+adt";
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/TestConfigs.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/TestConfigs.rsc
index 6a001646f96..9e28048727f 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/TestConfigs.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/TestConfigs.rsc
@@ -170,7 +170,7 @@ public PathConfig getAllSrcREPOPathConfig(bool keep = false) {
                             REPO + "typepal/src",
                             LSP_REPO + "src/main/rascal/library",
                             LSP_REPO + "src/main/rascal/lsp",
-                            LSP_REPO + "src/test/rascal",
+                            //LSP_REPO + "src/test/rascal",
                             REPO + "php-analysis/src/main/rascal"
                         ],
                         [ ], 
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
index 2691ad4b174..792ba0b42cb 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
@@ -25,5 +25,17 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
 module  lang::rascalcore::compile::Examples::A
- 
-extend   lang::rascalcore::compile::Examples::B;                
\ No newline at end of file
+              
+
+
+@javaClass{org.rascalmpl.library.Prelude}
+public java bool isEmpty(set[&T] st);
+
+
+// list[&T] sort(list[&T] lst) =
+// 	sort(lst, bool (&T a, &T b) { return a < b; } );
+	
+// @javaClass{org.rascalmpl.library.Prelude}
+// java list[&T] sort(list[&T] l, bool (&T a, &T b) less) ;
+                         
+ 
\ No newline at end of file
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/Tst6.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/Tst6.rsc
index 86ee83a2ebd..12a6f22e8f6 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/Tst6.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/Tst6.rsc
@@ -27,6 +27,3 @@ POSSIBILITY OF SUCH DAMAGE.
 @bootstrapParser
 module lang::rascalcore::compile::Examples::Tst6
 
-data Symbol
-     = \label(str name, Symbol symbol);
-
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalDeclaration.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalDeclaration.rsc
index cca68334fa5..9eccc2c2785 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalDeclaration.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalDeclaration.rsc
@@ -72,14 +72,16 @@ public void translateToplevel((Toplevel) `<Declaration decl>`) {
 // -- variable declaration ------------------------------------------
 
 void translateDecl(d: (Declaration) `<Tags tags> <Visibility visibility> <Type tp> <{Variable ","}+ variables> ;`) {
-	str module_name = asUnqualifiedName(getRascalModuleName());
-    enterFunctionScope("<module_name>_init");
+	// str module_name = asUnqualifiedName(getRascalModuleName());
+    // enterFunctionScope("<module_name>_init");
+    MODID mid = moduleName2moduleId(getRascalModuleName());
+    enterFunctionScope(mid + "/init");
    	for(var <- variables){
    	    unescapedVarName = unescapeName("<var.name>");
    		addVariableToModule(muModuleVar(getType(tp), unescapedVarName));
    		if(var is initialized) {
    		   init_code =  translate(var.initial);
-   		   asg = muAssign( muVar(unescapedVarName, getRascalModuleNameUnderscores(), -1, filterOverloads(getType(tp), {variableId()}), variableId()), init_code);
+   		   asg = muAssign( muVar(unescapedVarName, mid, -1, filterOverloads(getType(tp), {variableId()}), variableId()), init_code);
    		   addVariableInitializationToModule(asg);
    		}
    	}
@@ -146,16 +148,17 @@ private void generateGettersForAdt(AType adtType, loc module_scope, set[AType] c
             kwfield2cons += <kwFieldName, kwType, consType>;
             //str fuid = getGetterNameForKwpField(consType, kwFieldName);
             str getterName = unescapeAndStandardize("$getkw_<adtName>_<consName>_<kwFieldName>");
+            getterId = |rascal+kwfield:///| + getterName;
          
             if(getterName notin generated_getters){
                 generated_getters += getterName;
                 
                 getterType = afunc(kwType, [consType], []);
-                consVar = muVar(consName, getterName, 0, consType, constructorId());
+                consVar = muVar(consName, getterId, 0, consType, constructorId());
                 
                 defExpCode = promoteVarsToFieldReferences(translate(defaultExp), consType, consVar, kw.definingModule);
                 body = muReturn1(kwType, muIfElse(muIsKwpConstructorDefined(consVar, kwFieldName), muGetKwFieldFromConstructor(kwType, consVar, kwFieldName), defExpCode));
-                addFunctionToModule(muFunction(getterName, getterName, getterType, [consVar], [], [], "", false, true, false, {}, {}, {}, getModuleScope(), [], (), body)); 
+                addFunctionToModule(muFunction(getterName, getterId, getterType, [consVar], [], [], |global-scope:///|, false, true, false, {}, {}, {}, getModuleScope(), [], (), body)); 
             } else {
                 println("In generated_getters: <getterName>");
                 
@@ -171,10 +174,11 @@ private void generateGettersForAdt(AType adtType, loc module_scope, set[AType] c
         conses = kwfield2cons[kwFieldName];
         //str fuid = getGetterNameForKwpField(adtType, kwFieldName);
         str getterName = unescapeAndStandardize("$getkw_<adtName>_<kwFieldName>");
+        getterId = |rascal+kwfield:///| + getterName;
             
         returnType = lubList(conses<0>);
         getterType = afunc(returnType, [adtType], []);
-        adtVar = muVar(adtName, getterName, 0, adtType, dataId());
+        adtVar = muVar(adtName, getterId, 0, adtType, dataId());
         failCode = muFailReturn(returnType);
         for(Keyword kw <- common_keyword_fields, kw has defaultExp, isContainedIn(kw.defaultExp.src, module_scope, l2p)){
             kwType = kw.fieldType;
@@ -191,7 +195,7 @@ private void generateGettersForAdt(AType adtType, loc module_scope, set[AType] c
                        ]
                        + failCode
                       );
-        addFunctionToModule(muFunction(getterName, getterName, getterType, [adtVar], [], [], "", false, true, false, {}, {}, {}, getModuleScope(), [], (), body));               
+        addFunctionToModule(muFunction(getterName, getterId, getterType, [adtVar], [], [], |global-scope:///|, false, true, false, {}, {}, {}, getModuleScope(), [], (), body));               
     }
     
         /*
@@ -208,16 +212,17 @@ private void generateGettersForAdt(AType adtType, loc module_scope, set[AType] c
         
         //str fuid = getGetterNameForKwpField(adtType, kwFieldName);
         str getterName = unescapeAndStandardize("$getkw_<adtName>_<kwFieldName>");
+        getterId = |rascal+kwfield:///| + getterName;
         if(getterName == "$getkw_Tree_message"){ // TODO: remove when annotations are gone
                 continue;
         }
        
         getterType = afunc(kwType, [adtType], []);
-        adtVar = muVar(getterName, getterName, 0, adtType, variableId());
+        adtVar = muVar(getterName, getterId, 0, adtType, variableId());
         
         defExprCode = promoteVarsToFieldReferences(translate(defaultExp), adtType, adtVar, kw.definingModule);
         body = muReturn1(kwType, muIfElse(muIsKwpConstructorDefined(adtVar, kwFieldName), muGetKwFieldFromConstructor(kwType, adtVar, kwFieldName), defExprCode));
-        addFunctionToModule(muFunction(getterName, getterName, getterType, [adtVar], [], [], "", false, true, false, {}, {}, {}, getModuleScope(), [], (), body));               
+        addFunctionToModule(muFunction(getterName, getterId, getterType, [adtVar], [], [], |global-scope:///|, false, true, false, {}, {}, {}, getModuleScope(), [], (), body));               
     }
   
     
@@ -241,43 +246,26 @@ private set[TypeVar] getTypeVarsinFunction(FunctionDeclaration fd){
 
 public void translateFunctionDeclaration(FunctionDeclaration fd){
   //println("r2mu: Compiling \uE007[<fd.signature.name>](<fd.src>)");
-  inScope = topFunctionScope();
-  funsrc = fd.src;
-  useTypeParams = getTypeVarsinFunction(fd);
-  enterFunctionDeclaration(funsrc, !isEmpty(useTypeParams));
-
   try {
       ttags =  translateTags(fd.tags);
       tmods = translateModifiers(fd.signature.modifiers);
-    //   if(ignoreTest(ttags)){
-    //       // The type checker does not generate type information for ignored functions
-    //        addFunctionToModule(muFunction("$ignored_<prettyPrintName(fd.signature.name)>_<fd.src.offset>", 
-    //                                      prettyPrintName(fd.signature.name), 
-    //                                      afunc(abool(),[],[]),
-    //                                      [],
-    //                                      [],
-    //                                      [],
-    //                                      inScope, 
-    //                                      false, 
-    //                                      true,
-    //                                      false,
-    //                                      {},
-    //                                      {},
-    //                                      {},
-    //                                      fd.src, 
-    //                                      tmods, 
-    //                                      ttags,
-    //                                      muReturn1(abool(), muCon(false))));
-    //       	return;
-    //   }
+
+      if(ttags["ignore"]? || ttags["ignoreCompiler"]?){
+        return;
+      }
+      inScope = topFunctionScope();
+      funsrc = fd.src;
+      funId = getLogicalLoc(funsrc);
+      useTypeParams = getTypeVarsinFunction(fd);
+      enterFunctionDeclaration(funId, !isEmpty(useTypeParams));
+    
       fname = prettyPrintName(fd.signature.name);
-      ftype = getFunctionType(funsrc);
+      ftype = getFunctionType(funId);
       resultType = ftype.ret;
       bool isVarArgs = ftype.varArgs;
       nformals = size(ftype.formals);
-      fuid = convert2fuid(funsrc);
     
-      enterFunctionScope(fuid);
+      enterFunctionScope(funId);
       
       //// Keyword parameters
       lrel[str name, AType atype, MuExp defaultExp]  kwps = translateKeywordParameters(fd.signature.parameters);
@@ -285,8 +273,8 @@ public void translateFunctionDeclaration(FunctionDeclaration fd){
       my_btscopes = getBTScopesParams([ft | ft <- fd.signature.parameters.formals.formals], fname);
       mubody = muBlock([]);
       if(ttags["javaClass"]?){
-         params = [ muVar(ftype.formals[i].alabel, fuid, i, ftype.formals[i], formalId()) | i <- [ 0 .. nformals] ];
-         mubody = muReturn1(resultType, muCallJava("<fd.signature.name>", ttags["javaClass"], ftype, params, fuid));
+         params = [ muVar(ftype.formals[i].alabel, funId, i, ftype.formals[i], formalId()) | i <- [ 0 .. nformals] ];
+         mubody = muReturn1(resultType, muCallJava("<fd.signature.name>", ttags["javaClass"], ftype, params, funId));
       } else if(fd is \default){ // function declaration with statements
                 body_code = [ translate(stat, my_btscopes) | stat <- fd.body.statements ];
                 if(isVoidAType(ftype.ret)) body_code += muReturn0();
@@ -313,12 +301,12 @@ public void translateFunctionDeclaration(FunctionDeclaration fd){
       }
       
       leaveSignatureSection();
-      externals = getExternalRefs(tbody, fuid, formalVars);
-      extendedFormalVars = getExtendedFunctionFormals(fd.src, fuid);
+      externals = getExternalRefs(tbody, funId, formalVars);
+      extendedFormalVars = getExtendedFunctionFormals(funId, funId);
       localRefs = getLocalRefs(tbody);
        
       addFunctionToModule(muFunction(prettyPrintName(fd.signature.name), 
-                                     fuid, 
+                                     funId, 
       								 ftype,
       								 formalVars,
       								 extendedFormalVars,
@@ -329,7 +317,7 @@ public void translateFunctionDeclaration(FunctionDeclaration fd){
       								 isMemo,
       								 externals,
       								 localRefs,
-      								 getKeywordParameterRefs(tbody, fuid),
+      								 getKeywordParameterRefs(tbody, funId),
       								 fd.src, 
       								 tmods, 
       								 ttags,
@@ -395,18 +383,18 @@ public set[MuExp] getLocalRefs(MuExp exp)
 /*
  * Get all variables that have been introduced outside the given function scope
  */
-public set[MuExp] getExternalRefs(MuExp exp, str fuid, list[MuExp] formals){
+public set[MuExp] getExternalRefs(MuExp exp, loc fuid, list[MuExp] formals){
    formalNames = {f.name | f <- formals};
-   res = { v1 | /v:muVar(str name2, str fuid2, int pos, AType t, IdRole idRole) := exp, pos >= 0, name2 notin formalNames, fuid2 != fuid, fuid2 != "", t1 := unsetRec(t, "alabel"), v1 := v[atype=t1]};
+   res = { v1 | /v:muVar(str name2, loc fuid2, int pos, AType t, IdRole idRole) := exp, pos >= 0, name2 notin formalNames, fuid2 != fuid, fuid2 != |rascal:///|, t1 := unsetRec(t, "alabel"), v1 := v[atype=t1]};
    //println("getExternalRefs, <fuid>, <formals>: <res>");
    return res;
 }
 /*
  * Get all keyword variables that have introduced outside the given function scope
  */
-public set[MuExp] getKeywordParameterRefs(MuExp exp, str fuid){
+public set[MuExp] getKeywordParameterRefs(MuExp exp, loc fuid){
     //println("getKeywordParameterRefs(<exp>, <fuid>)");
-    res = { unsetRec(v, "alabel") | /v:muVarKwp(str _, str fuid2, AType _) := exp, fuid2 != fuid };
+    res = { unsetRec(v, "alabel") | /v:muVarKwp(str _, loc fuid2, AType _) := exp, fuid2 != fuid };
     //println("getKeywordParameterRefs =\> <res>");
     return res;
 }
@@ -451,7 +439,7 @@ private MuExp returnFromFunction(MuExp body, AType ftype, list[MuExp] formalVars
       parameters = { unset(par, "alabel") | /par:aparameter(name, bound) := ftype };
      
       if(!isEmpty(parameters) && /muReturn1(_,_) := res){
-        str fuid = topFunctionScope();
+        loc fuid = topFunctionScope();
         result = muTmpIValue(nextTmp("result"), fuid, ftype.ret);
         res = visit(res){
             case muReturn1(_, e) => muBlock([ muConInit(result, e),
@@ -468,7 +456,7 @@ private MuExp returnFromFunction(MuExp body, AType ftype, list[MuExp] formalVars
          
 private MuExp functionBody(MuExp body, AType ftype, list[MuExp] formalVars, bool isMemo){
     if(isMemo){
-        str fuid = topFunctionScope();
+        loc fuid = topFunctionScope();
         result = muTmpIValue(nextTmp("result"), fuid, avalue());
         return muCheckMemo(ftype, formalVars, body);
     } else {
@@ -480,7 +468,7 @@ public tuple[list[MuExp] formalVars, MuExp funBody] translateFunction(str fname,
      // Create a loop label to deal with potential backtracking induced by the formal parameter patterns  
      
      list[Pattern] formalsList = [f | f <- formals];
-     str fuid = topFunctionScope();
+     loc fuid = topFunctionScope();
      my_btscopes = getBTScopesParams(formalsList, fname);
      parameters = { unset(par, "alabel") | /par:aparameter(name, bound) := ftype };
      
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalExpression.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalExpression.rsc
index b302b0ea2dc..58de7f2cba0 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalExpression.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalExpression.rsc
@@ -128,9 +128,9 @@ private MuExp translateAddFunction(Expression e){
   resType = getResult(eType);
 
   // Generate and add a function ADD<...>
-  str scopeId = topFunctionScope();
+  loc scopeId = topFunctionScope();
   str add_name = "$ADD<e.src.begin.line>A<e.src.offset>L<e.src.length>";
-  str add_fuid = scopeId + "_" + add_name;
+  loc add_fuid = scopeId + "_" + add_name;
 
   MuExp lhsReceiver = translate(e.lhs);
   MuExp rhsReceiver = translate(e.rhs);
@@ -150,7 +150,7 @@ private MuExp translateAddFunction(Expression e){
 
   leaveFunctionScope();
   funType = afunc(resType, lhsFormals, []);
-  fun = muFunction(add_name, add_name, funType, lactuals, [], [], scopeId, false, false, false, getExternalRefs(body, add_fuid, []), {}, {}, e.src, [], (), body);
+  fun = muFunction(add_name, add_fuid, funType, lactuals, [], [], scopeId, false, false, false, getExternalRefs(body, add_fuid, []), {}, {}, e.src, [], (), body);
   loc uid = declareGeneratedFunction(add_name, add_fuid, funType, e.src);
   addFunctionToModule(fun);
   addDefineAndType(<currentFunctionDeclaration(), add_name, add_name, functionId(), /*1000+e@\loc.offset,*/ e.src, defType(funType)>, funType); // TODO: replace arbitrary number
@@ -211,7 +211,7 @@ MuExp translateLiteral((Literal) `<StringLiteral n>`) {
 
 private MuExp translateStringLiteral(s: (StringLiteral) `<PreStringChars pre> <StringTemplate stemplate> <StringTail tail>`) {
     preIndent = computeIndent(pre);
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     template = muTmpTemplate(nextTmp("template"), fuid);
 	return muValueBlock( astr(),
 	                     [ muConInit(template, muTemplate(translatePreChars(pre))),
@@ -223,7 +223,7 @@ private MuExp translateStringLiteral(s: (StringLiteral) `<PreStringChars pre> <S
 
 private MuExp translateStringLiteral(s: (StringLiteral) `<PreStringChars pre> <Expression expression> <StringTail tail>`) {
     preIndent = computeIndent(pre);
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     template = muTmpTemplate(nextTmp("template"), fuid);
     return muValueBlock( astr(),
                          [ muConInit(template, muTemplate(translatePreChars(pre))),
@@ -539,7 +539,7 @@ private MuExp translateConcreteExpressionList(Symbol eltType, list[Tree] elems,
     if(elems == []){
         return muCon([]);
     } else {
-        str fuid = topFunctionScope();
+        loc fuid = topFunctionScope();
 
         writer = muTmpListWriter(nextTmp("writer"), fuid);
 
@@ -564,7 +564,7 @@ private MuExp translateConcreteExpressionList(Symbol eltType, list[Tree] elems,
 private MuExp translateConcreteExpressionSeparatedList(Symbol _, list[Symbol] _, [], loc _) = muCon([]);
 
 private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symbol] _, [Tree single], loc src) {
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
 
     writer = muTmpListWriter(nextTmp("writer"), fuid);
 
@@ -585,7 +585,7 @@ private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symb
 }
 
 private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symbol] sepTypes, list[Tree] elems:[_,_,*_], loc src) {
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
 
     writer = muTmpListWriter(nextTmp("writer"), fuid);
 
@@ -684,30 +684,29 @@ MuExp translate (e:(Expression) `<Parameters parameters> { <Statement* statement
 // Translate a closure
 
  private MuExp translateClosure(Expression e, Parameters parameters, list[Statement] cbody) {
- 	uid = e.src;
-	fuid = convert2fuid(uid);
+	fuid = getLogicalLoc(e.src);
 	surrounding = topFunctionScope();
 
-    ftype = getClosureType(e.src);
+    ftype = getClosureType(fuid);
 	nformals = size(ftype.formals);
 	bool isVarArgs = ftype.varArgs;
 
     typeVarsInParams = getFunctionTypeParameters(ftype);
-    enterFunctionDeclaration(getLoc(e), !isEmpty(typeVarsInParams));
+    enterFunctionDeclaration(getLogicalLoc(getLoc(e)), !isEmpty(typeVarsInParams));
 	enterFunctionScope(fuid);
 
   	// Keyword parameters
      lrel[str name, AType atype, MuExp defaultExp]  kwps = translateKeywordParameters(parameters);
 
     enterSignatureSection();
+    cname = generateClosureName();
     // TODO: we plan to introduce keyword patterns as formal parameters
-    <formalVars, funBody> = translateFunction(fuid, parameters.formals.formals, ftype, muBlock([translate(stat, ()) | stat <- cbody]), false, []);
+    <formalVars, funBody> = translateFunction(cname, parameters.formals.formals, ftype, muBlock([translate(stat, ()) | stat <- cbody]), false, []);
    
 
     leaveSignatureSection();
-    cname = "$CLOSURE_<getNextClosure()>";
-    addFunctionToModule(muFunction(cname, //"$CLOSURE_<uid.begin.line>A<uid.offset>",
-                                   cname, //fuid, //"$CLOSURE_<uid.begin.line>A<uid.offset>",
+    addFunctionToModule(muFunction(cname,
+                                   fuid,
                                    ftype,
                                    formalVars,
                                    [],
@@ -726,13 +725,13 @@ MuExp translate (e:(Expression) `<Parameters parameters> { <Statement* statement
 
   	leaveFunctionScope();
     leaveFunctionDeclaration();
-  	return muFun(uid, ftype); // TODO!
+  	return muFun(fuid, ftype); // TODO!
 }
 
 // -- range expression ----------------------------------------------
 
 MuExp translate (e:(Expression) `[ <Expression first> .. <Expression last> ]`) {
-  str fuid = topFunctionScope();
+  loc fuid = topFunctionScope();
   writer = muTmpListWriter(nextTmp("range_writer"), fuid);
   elemType = alub(getType(first), getType(last));
   elem = muTmpIValue(nextTmp("range_elem"), fuid,elemType);
@@ -749,7 +748,7 @@ MuExp translate (e:(Expression) `[ <Expression first> .. <Expression last> ]`) {
 // -- range with step expression ------------------------------------
 
 MuExp translate (e:(Expression) `[ <Expression first> , <Expression second> .. <Expression last> ]`) {
-  str fuid = topFunctionScope();
+  loc fuid = topFunctionScope();
   writer = muTmpListWriter(nextTmp("range_writer"), fuid);
   elemType = lubList([getType(first), getType(second), getType(last)]);
   elem = muTmpIValue(nextTmp("range_elem"), fuid, elemType);
@@ -767,7 +766,7 @@ MuExp translate (e:(Expression) `[ <Expression first> , <Expression second> .. <
 MuExp translate (e:(Expression) `<Label label> <Visit visitItself>`) = translateVisit(label, visitItself, ());
 
 public MuExp translateVisit(Label label, lang::rascal::\syntax::Rascal::Visit \visit, BTSCOPES btscopes) {
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     subjectType = getType(\visit.subject);
     enterVisit(subjectType);
 
@@ -868,7 +867,7 @@ MuExp translate (e:(Expression) `( <Expression init> | <Expression result> | <{E
 
 private MuExp translateReducer(Expression e){
     redName = nextTmp("REDUCER");
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
 
     //btfree = all(Expression c <- e.generators, backtrackFree(c));
     //enterBacktrackingScope(redName);
@@ -1084,7 +1083,7 @@ private list[MuExp] translateComprehensionContribution(str kind, AType resultTyp
 
 private MuExp translateComprehension(c: (Comprehension) `[ <{Expression ","}+ results> | <{Expression ","}+ generators> ]`) {
     //println("translateComprehension (list): <generators>");
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     writer = muTmpListWriter(nextTmp("listwriter"), fuid);
     resultType = getType(c);
     conds = normalizeAnd([ g | Expression g <- generators ]);
@@ -1100,7 +1099,7 @@ private MuExp translateComprehension(c: (Comprehension) `[ <{Expression ","}+ re
 
 private MuExp translateComprehension(c: (Comprehension) `{ <{Expression ","}+ results> | <{Expression ","}+ generators> }`) {
     //println("translateComprehension (set): <generators>");
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     writer = muTmpSetWriter(nextTmp("setwriter"), fuid);
     resultType = getType(c);
     conds = normalizeAnd([ g | Expression g <- generators ]);
@@ -1116,7 +1115,7 @@ private MuExp translateComprehension(c: (Comprehension) `{ <{Expression ","}+ re
 
 private MuExp translateComprehension(c: (Comprehension) `(<Expression from> : <Expression to> | <{Expression ","}+ generators> )`) {
     //println("translateComprehension (map): <generators>");
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     writer = muTmpMapWriter(nextTmp("mapwriter"), fuid);
     resultType = getType(c);
     conds = normalizeAnd([ g | Expression g <- generators ]);
@@ -1147,7 +1146,7 @@ private bool containsSplices({Expression ","}* es) =
 private MuExp translateSetOrList(Expression e, {Expression ","}* es, str kind){
  elmType = getElementType(getType(e));
  if(containsSplices(es)){
-       str fuid = topFunctionScope();
+       loc fuid = topFunctionScope();
        writer = kind == "list" ? muTmpListWriter(nextTmp("writer"), fuid) : muTmpSetWriter(nextTmp("writer"), fuid);;
 
 
@@ -1503,7 +1502,7 @@ MuExp translateGuarded(exp: (Expression) `<Name name>`)
 // -- isDefinedOtherwise expression ---------------------------------
 
 MuExp translate(e: (Expression) `<Expression lhs> ? <Expression rhs>`) {
-      str fuid = topFunctionScope();
+      loc fuid = topFunctionScope();
       guarded = muTmpGuardedIValue(nextLabel("guarded"), fuid);
       return muValueBlock(getType(e),
                           [ muVarInit(guarded, translateGuarded(lhs)),
@@ -1516,7 +1515,7 @@ MuExp translateBool(e:(Expression) `<Expression lhs> ? <Expression rhs>`, BTSCOP
 
 
 public MuExp translateIfDefinedOtherwise(MuExp muLHS, MuExp muRHS, loc _src) {
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     guarded = muTmpGuardedIValue(nextLabel("guarded"), fuid);
     lhsType = avalue();
     if( muGetField(AType resultType, AType baseType, MuExp baseExp, str fieldName) := muLHS){
@@ -1820,7 +1819,7 @@ MuExp translateGenerator(Expression current, Pattern pat, Expression exp, BTSCOP
     elemType = getElementType(expType);
     if(isVoidAType(elemType)) return falseCont;
 
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     elem = muTmpIValue(nextTmp("elem"), fuid, elemType);
 
     l = getLoc(current).offset;
@@ -2276,7 +2275,7 @@ MuExp translate(Expression e:(Expression) `<Expression lhs> \<==\> <Expression r
 
 MuExp translate(e:(Expression) `<Expression lhs> \<==\> <Expression rhs>`, BTSCOPES btscopes) {
     if(backtrackFree(e)){
-        str fuid = topFunctionScope();
+        loc fuid = topFunctionScope();
         rhs_val = muTmpIValue(nextTmp("rhs_val"), fuid, abool());
         return muValueBlock(abool(), [ muConInit(rhs_val, translate(rhs)),
                                        muIfExp(translate(lhs),
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalPattern.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalPattern.rsc
index c7304fdcd44..8c1b03fb0b2 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalPattern.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalPattern.rsc
@@ -67,7 +67,7 @@ default MuExp translateMatch(Pattern pat, Expression exp, BTSCOPES btscopes, MuE
     if(isVarOrTmp(expTrans)){
         return translatePat(pat, expType, expTrans, btscopes, trueCont, falseCont);
     } else {
-        str fuid = topFunctionScope();
+        loc fuid = topFunctionScope();
         subject_val = muTmpIValue(nextTmp("subject_val"), fuid, getType(exp));
         res = muValueBlock(abool(), [ muConInit(subject_val, expTrans), 
                                       translatePat(pat, expType, subject_val, btscopes, trueCont, falseCont) 
@@ -306,7 +306,7 @@ map[str,str] regexpEscapes = (
 );
 
 MuExp translateRegExpLiteral(re: (RegExpLiteral) `/<RegExp* _>/<RegExpModifier _>`, AType _subjectType, MuExp subject, BTSCOPES _btscopes, MuExp trueCont, MuExp falseCont) {
-   str fuid = topFunctionScope();
+   loc fuid = topFunctionScope();
    <buildRegExp,vars> = processRegExpLiteral(re);
    matcher = muTmpMatcher(nextTmp("matcher"), fuid);
    found = muTmpBool(nextTmp("found"), fuid);
@@ -341,7 +341,7 @@ MuExp translateRegExpLiteral(re: (RegExpLiteral) `/<RegExp* _>/<RegExpModifier _
 }
 
 tuple[MuExp exp, list[MuExp] vars] processRegExpLiteral(e: (RegExpLiteral) `/<RegExp* rexps>/<RegExpModifier modifier>`){
-   str fuid = topFunctionScope();
+   loc fuid = topFunctionScope();
    fragmentCode = [];
    vars = [];
    map[str,int] varnames = ();
@@ -605,7 +605,7 @@ default AType getTypeTree(Tree t){
 private MuExp translateParsedConcretePattern(t:appl(prod:Production::regular(Symbol::\seq(list[Symbol] symbols)), list[Tree] args),
                        AType patType, AType subjectType,  MuExp subject, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont, MuExp restore = muBlock([])) {
    body = trueCont;
-   str fuid = topFunctionScope();
+   loc fuid = topFunctionScope();
    for (int i <- reverse(index(symbols))) {         
         subject_arg = muTmpIValue(nextTmp("subject_arg<i>"), fuid, getTypeTree(args[i]));
         body = muBlock([ muConInit(subject_arg, muSubscript(muTreeGetArgs(subject), alist(treeType), muCon(i))),
@@ -643,7 +643,7 @@ default MuExp translateParsedConcretePattern(t:appl(Production prod, list[Tree]
       return isWildCard(holeName) ? trueCont :  muBlock([muVarInit(mkVar(holeName, holeSrc), subjectExp), trueCont]);
    }
    body = trueCont;
-   str fuid = topFunctionScope();
+   loc fuid = topFunctionScope();
    for (int i <- reverse(index(args))) {
        if(!isLayoutPat(args[i])){
            subject_arg = muTmpIValue(nextTmp("subject_arg<i>"), fuid, getTypeTree(args[i]));   
@@ -814,7 +814,7 @@ MuExp translateConcreteListPat(p:appl(Production _prod, list[Tree] lpats), AType
         return muIfExp(muMatch(subjectExp, muCon(constantPat)), trueCont, falseCont);
     } catch _: /* not a constant pattern, go on computing its translation */;
     
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     subj = nextTmp("subject");
     subject = muTmpIValue(subj, fuid, subjectType);
     cursor = muTmpInt(subj + "_cursor", fuid);
@@ -958,7 +958,7 @@ MuExp translatePatAsConcreteListElem(cc: char(int c), Lookahead lookahead, AType
 }
 
 default MuExp translateApplAsConcreteListElem(t:appl(Production prod, list[Tree] _args), Lookahead _lookahead, AType subjectType, MuExp subject, MuExp sublen, MuExp cursor, int _posInPat, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont, MuExp restore=muBlock([]), int delta=1) {
-   str fuid = topFunctionScope();
+   loc fuid = topFunctionScope();
    lengthCheck = muLessNativeInt(cursor, sublen);
    subject_elm = muTmpITree(nextTmp("subject_elm"), fuid);
    body = translateParsedConcretePattern(t, symbol2atype(prod.def), getIterElementType(subjectType), subject_elm, btscopes, trueCont, falseCont, restore=restore);                 
@@ -1139,7 +1139,7 @@ BTINFO getBTInfo(p:(Pattern) `<Pattern expression> ( <{Pattern ","}* arguments>
 MuExp translatePat(p:(Pattern) `<Pattern expression> ( <{Pattern ","}* arguments> <KeywordArguments[Pattern] keywordArguments> )`, AType subjectType, MuExp subjectExp, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont, bool subjectAssigned=false, MuExp restore=muBlock([])) {
    //iprintln(btscopes);
    //println("translatePat: <p>, <p@\loc>");
-   str fuid = topFunctionScope();
+   loc fuid = topFunctionScope();
    subjectExpIsVar = isVarOrTmp(subjectExp);
    subject = subjectExpIsVar ? subjectExp : muTmpIValue(nextTmp("subject"), fuid, subjectType);
    contExp = trueCont;
@@ -1171,7 +1171,7 @@ MuExp translatePat(p:(Pattern) `<Pattern expression> ( <{Pattern ","}* arguments
       AType arg_type  = getType(lpats[i]);
       // Replace all occurrences of the argument by the var representing its computed value
       body = visit(body){
-        case muVar(str name, str fuid, int pos, AType atype, IdRole idRole) => arg_val
+        case muVar(str name, loc fuid, int pos, AType atype, IdRole idRole) => arg_val
              when name == arg_type.alabel, arg_type := atype
       };
       
@@ -1465,7 +1465,7 @@ BTINFO getBTInfoSet(p:(Pattern) `<Name name> : <Pattern pattern>`,  BTSCOPE btsc
     return registerBTScope(p, btscope, btscopes);
 }
 MuExp translatePatAsSetElem(p:(Pattern) `<Name name> : <Pattern pattern>`, bool last, AType elmType, MuExp subject, MuExp prevSubject, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) { 
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     elem = muTmpIValue(nextTmp("elem"), fuid, elmType);
     var = mkVar(p);
     varPresent = !isWildCard(var.name);
@@ -1502,7 +1502,7 @@ BTINFO getBTInfoSet(p:(Pattern) `<Type tp> <Name name> : <Pattern pattern>`,  BT
 }
 
 MuExp translatePatAsSetElem(p:(Pattern) `<Type tp> <Name name> : <Pattern pattern>`, bool last, AType elmType, MuExp subject, MuExp prevSubject, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) {
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     elem = muTmpIValue(nextTmp("elem"), fuid, elmType);
     var = mkVar(p);
     varPresent = !isWildCard(var.name);
@@ -1571,7 +1571,7 @@ default MuExp translatePatAsSetElem(Pattern p, bool last, AType elmType, MuExp s
                                   trueCont ]),
                         falseCont);                            
   } catch: {
-        str fuid = topFunctionScope();
+        loc fuid = topFunctionScope();
         elem = muTmpIValue(nextTmp("elem"), fuid, elmType);
         my_btscope = btscopes[getLoc(p)];
         // TODO length check?
@@ -1777,7 +1777,7 @@ MuExp translateSetPat(p:(Pattern) `{<{Pattern ","}* _>}`, AType subjectType, MuE
    <fixedLiterals, toBeMatchedPats, fixedVars, fixedMultiVars, leftMostVar> = analyzeSetPattern(p);
    rightMostPat = size(toBeMatchedPats) - 1;
    
-   str fuid = topFunctionScope();
+   loc fuid = topFunctionScope();
    subject = muTmpIValue(nextTmp("subject"), fuid, subjectType); // <<< type?
    fixed = muTmpIValue(nextTmp("fixed"), fuid, subjectType);     // <<<
    subjects = [ muTmpIValue(nextTmp("subject"), fuid, subjectType) | int _ <- reverse(index(toBeMatchedPats)) ];
@@ -1868,7 +1868,7 @@ MuExp translatePat(p:(Pattern) `\<<{Pattern ","}* pats>\>`, AType subjectType, M
     elmTypes = [getType(pat) | pat <- lpats];
     patType = atuple(atypeList(elmTypes));
     
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     subject = muTmpIValue(nextTmp("tuple_subject"), fuid, subjectType);
   
     //iprintln(btscopes);
@@ -2021,7 +2021,7 @@ MuExp translateListPat(p:(Pattern) `[<{Pattern ","}* pats>]`, AType subjectType,
         return muIfExp(muEqual(subjectExp, muCon(constantPat)), trueCont, falseCont);
     } catch _: /* not a constant pattern, go on computing its translation */;
     
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     subj = nextTmp("subject");
     subject = muTmpIValue(subj, fuid, alist(elmType));
     cursor = muTmpInt(subj + "_cursor", fuid);
@@ -2427,7 +2427,7 @@ MuExp translatePat(p:(Pattern) `<Type tp> <Name name> : <Pattern pattern>`, ATyp
          // whether or not the value is accidentally the right trType!
          return asubtype(subjectType, trType) ? trPat : muIfElse(muValueIsSubtypeOf(subjectExp, trType), trPat, falseCont);
     }
-    str fuid = ""; int pos=0;           // TODO: this keeps type checker happy, why?
+    loc fuid = |global-scope:///|; int pos=0;           // TODO: this keeps type checker happy, why?
     <fuid, pos> = getVariableScope(prettyPrintName(name), name.src);
     ppname = prettyPrintName(name);
     var = muVar(ppname, fuid, pos, trType/*[alabel=ppname]*/, patternVariableId());
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalStatement.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalStatement.rsc
index 54bfa55a8fd..dce44d3bc4f 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalStatement.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/RascalStatement.rsc
@@ -110,7 +110,7 @@ MuExp translate((Statement) `<Label label> <Visit visitItself>`, BTSCOPES btscop
 MuExp translate(s: (Statement) `<Label label> while ( <{Expression ","}+ conditions> ) <Statement body>`, BTSCOPES btscopes) {
     whileName = getLabel(label, "WHILE");
     whileBT = "<whileName>_BT";
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     enterLoop(whileName,fuid);
     
     loopBody = muBlock([]);
@@ -169,7 +169,7 @@ MuExp translateLoopBody(Statement body, BTSCOPES btscopes){
 MuExp translateTemplate(MuExp template, str indent, (StringTemplate) `while ( <Expression condition> ) { <Statement* preStats> <StringMiddle body> <Statement* postStats> }`){
     whileName = nextLabel();
     whileBT = "<whileName>_BT";
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     enterLoop(whileName,fuid);
     
     conds = [ condition ];
@@ -197,7 +197,7 @@ MuExp translateTemplate(MuExp template, str indent, (StringTemplate) `while ( <E
 MuExp translate(s: (Statement) `<Label label> do <Statement body> while ( <Expression condition> ) ;`, BTSCOPES btscopes) {
     doName = getLabel(label, "DO");
     //doBT = "<doName>_BT";
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     enterLoop(doName,fuid);
     
     conds = [condition];
@@ -229,7 +229,7 @@ MuExp translate(s: (Statement) `<Label label> do <Statement body> while ( <Expre
 
 MuExp translateTemplate(MuExp template, str indent, (StringTemplate) `do { < Statement* preStats> <StringMiddle body> <Statement* postStats> } while ( <Expression condition> )`) {
     doName = nextLabel();
-    str fuid = topFunctionScope();  
+    loc fuid = topFunctionScope();  
     enterLoop(doName,fuid);
    
     conds = [ condition ];
@@ -251,7 +251,7 @@ MuExp translateTemplate(MuExp template, str indent, (StringTemplate) `do { < Sta
 MuExp translate(s: (Statement) `<Label label> for ( <{Expression ","}+ generators> ) <Statement body>`, BTSCOPES btscopes) {
     //println("translate: <s> at <getLoc(s)>");
     forName = getLabel(label, "FOR");
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     enterLoop(forName,fuid);
     
     conds = normalizeAnd([c | Expression c <- generators]);
@@ -279,7 +279,7 @@ bool containsAppend(Statement body) = /(Statement) `append <DataTarget _> <State
 
 MuExp translateTemplate(MuExp template, str indent, (StringTemplate) `for ( <{Expression ","}+ generators> ) { <Statement* preStats> <StringMiddle body> <Statement* postStats> }`){
     forName = nextLabel();
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     enterLoop(forName,fuid);
     
     conds = normalizeAnd([c | Expression c <- generators]);
@@ -425,7 +425,7 @@ MuExp translate(s: (Statement) `<Label label> switch ( <Expression expression> )
  * 
  */
 MuExp translateSwitch((Statement) `<Label label> switch ( <Expression expression> ) { <Case+ cases> }`, BTSCOPES btscopes) {
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     switchName = getLabel(label, "SWITCH");
     switchVal = muTmpIValue(nextTmp("switchVal"), fuid, getType(expression));
     the_cases = [ c | Case c <- cases ];
@@ -470,7 +470,7 @@ bool isSpoiler(Pattern pattern, int fp){
  	   ;
 }
 
-map[int, list[MuExp]] addPatternWithActionCode(str switchName, MuExp switchVal, str fuid, PatternWithAction pwa, map[int, list[MuExp]] table, int key, str caseLabel, MuExp succeedCase, BTSCOPES btscopes){
+map[int, list[MuExp]] addPatternWithActionCode(str switchName, MuExp switchVal, loc fuid, PatternWithAction pwa, map[int, list[MuExp]] table, int key, str caseLabel, MuExp succeedCase, BTSCOPES btscopes){
     stringVisitUpdate = inStringVisit() && pwa.pattern is literal && pwa.pattern.literal is string ? [ muStringSetMatchedInVisit(size("<pwa.pattern.literal>") - 2)] : [];
  
     patType =  getType(pwa.pattern);
@@ -530,7 +530,7 @@ map[int, list[MuExp]] addPatternWithActionCode(str switchName, MuExp switchVal,
 	 return table;
 }
 
-tuple[list[MuCase], MuExp] translateSwitchCases(str switchName, MuExp switchVal, str fuid, bool useConcreteFingerprint, list[Case] cases, MuExp succeedCase, BTSCOPES btscopes) {
+tuple[list[MuCase], MuExp] translateSwitchCases(str switchName, MuExp switchVal, loc fuid, bool useConcreteFingerprint, list[Case] cases, MuExp succeedCase, BTSCOPES btscopes) {
   map[int,list[MuExp]] table = ();      // label + generated code per case
   MuExp default_code = muBlock([]); //muSucceedSwitchCase(switchName); // default code for default case
   for(c <- cases){
@@ -620,7 +620,7 @@ MuExp translate(s: (Statement) `solve ( <{QualifiedName ","}+ variables> <Bound
     translateSolve(s, btscopes);
 
 MuExp translateSolve((Statement) `solve ( <{QualifiedName ","}+ variables> <Bound bound> ) <Statement body>`, BTSCOPES btscopes) {
-   str fuid = topFunctionScope();
+   loc fuid = topFunctionScope();
    iterations = muTmpInt(nextTmp("iterations"), fuid);          // count number of iterations
    change = muTmpBool(nextTmp("change"), fuid);		            // keep track of any changed value
  
@@ -667,7 +667,7 @@ MuExp translateTry(Statement body, list[Catch] handlers, Statement finallyBody,
         lubOfPatterns = ( lubOfPatterns | alub(it, getType(p.src)) | Pattern p <- patterns );
     }
     // Introduce temporary variables that are bound within a catch block to a thrown exception and to its contained value
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     tmp = nextTmp("thrown");
     thrown = muTmpIValue(tmp, fuid, avalue()/*lubOfPatterns*/);   // TODO: resolve this
     thrown_as_exception = muTmpException("<tmp>_as_exception", fuid);
@@ -800,7 +800,7 @@ MuExp assignTo(Assignable a: (Assignable) `<Assignable receiver> ? <Expression d
     
 
 MuExp assignTo(a: (Assignable) `\<  <{Assignable ","}+ elements> \>`, str operator, AType rhs_type, MuExp rhs) {
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     elems = [ e | Assignable e <- elements];   // hack since elements[i] yields a value result;
     nelems = size(elems); // size_assignables
     
@@ -813,7 +813,7 @@ MuExp assignTo(a: (Assignable) `\<  <{Assignable ","}+ elements> \>`, str operat
 }
 
 MuExp assignTo(Assignable a: (Assignable) `<Name name> ( <{Assignable ","}+ arguments> )`, str operator, AType rhs_type, MuExp rhs) { 
-    str fuid = topFunctionScope();
+    loc fuid = topFunctionScope();
     elems = [ e | Assignable e <- arguments];  // hack since elements[i] yields a value result;
     nelems = size(elems);
     tmp = muTmpIValue(nextTmp(), fuid, rhs_type);
@@ -929,7 +929,7 @@ MuExp translateReturn(AType resultType, Expression expression, BTSCOPES btscopes
 	}
 	//resultType = getType(expression);
 	//if(hasFinally()) { // TODO adapt
-	//    str fuid = topFunctionScope();
+	//    loc fuid = topFunctionScope();
 	//	str varname = asTmp(nextLabel());
 	//	result = muTmpIValue(nextLabel("result"), fuid, resultType);
 	//	return muValueBlock(resultType, [ muConInit(result, translate(statement, btscopes)), muReturn1(resultType, result) ]);
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/TmpAndLabel.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/TmpAndLabel.rsc
index 4d427e856ef..e3c241252c5 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/TmpAndLabel.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/TmpAndLabel.rsc
@@ -97,9 +97,9 @@ str nextLabel(str prefix){
 // - append
 // - break/continue/fail
 
-private lrel[str label,str fuid] loops = []; // *** state
+private lrel[str label,loc fuid] loops = []; // *** state
 
-void enterLoop(str name, str fuid){
+void enterLoop(str name, loc fuid){
   loops = <name,fuid> + loops;
 }
 
@@ -114,14 +114,14 @@ str currentLoop(DataTarget target){
      return "<target.label>";
 }
 
-str getCurrentLoopScope() {
+loc getCurrentLoopScope() {
   return top(loops).fuid;
 }
 
 bool inLoop(str name)
     = name in domain(loops);
 
-str getCurrentLoopScope(DataTarget target) {
+loc getCurrentLoopScope(DataTarget target) {
   if(target is empty) {
       return getCurrentLoopScope();
   } else {
@@ -249,9 +249,9 @@ loc currentFunctionDeclaration(){
 // Administration of function scopes;
 // needed to translate 'visit' expressions and generate function declarations for 'visit' cases
 
-private lrel[str scope,int counter] functionScopes = []; // *** state
+private lrel[loc scope,int counter] functionScopes = []; // *** state
 
-str topFunctionScope() = isEmpty(functionScopes) ? "" : top(functionScopes)[0] /*.scope*/;
+loc topFunctionScope() = isEmpty(functionScopes) ? |global-scope:///| : top(functionScopes)[0] /*.scope*/;
 
 int nextVisit() {
 	int counter = top(functionScopes).counter;
@@ -259,7 +259,7 @@ int nextVisit() {
 	return counter;
 }
 
-void enterFunctionScope(str fuid) {
+void enterFunctionScope(loc fuid) {
 	functionScopes = <fuid,0> + functionScopes;
 }
 
@@ -315,9 +315,10 @@ void resetOrCounter() {
     orCounter = 0;
 }
 
+// TODO: duplicates in CheckerCommon
 private int closureCounter = 0;
 
-int getNextClosure(){
+private int getNextClosure(){
     int counter = closureCounter;
     closureCounter += 1;
     return counter;
@@ -326,3 +327,5 @@ int getNextClosure(){
 void resetClosureCounter(){
     closureCounter = 0;
 }
+
+str generateClosureName() = "$CLOSURE_<getNextClosure()>";
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/TypeUtils.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/TypeUtils.rsc
index 52d87086da2..c99f99b3bac 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/TypeUtils.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Rascal2muRascal/TypeUtils.rsc
@@ -54,6 +54,7 @@ import lang::rascalcore::check::ATypeUtils;
 
 import lang::rascalcore::check::ATypeInstantiation;
 import analysis::typepal::LocationChecks;
+import lang::rascalcore::check::LogicalLocations;
 
 /*
  * This module provides a bridge to the "TModel" delivered by the type checker
@@ -228,9 +229,8 @@ AType getTypeFromDef(Define def){ // Move to Solver
     throw "getTypeFromDef: <def>";
 }
 
-
-private str getScope(UID uid){
-    return convert2fuid(declaredIn[uid]);
+private loc getScope(UID uid){
+    return declaredIn[uid];
 }
 
 bool is_formal(Define d) = d.idRole in formalRoles;
@@ -447,7 +447,7 @@ void extractScopes(TModel tm){
 //           };
 //}
 
-loc declareGeneratedFunction(str _name, str _fuid, AType _rtype, loc src){
+loc declareGeneratedFunction(str _name, loc _fuid, AType _rtype, loc src){
 	//println("declareGeneratedFunction: <name>, <rtype>, <src>");
     uid = src;
     functions += {uid};
@@ -463,15 +463,23 @@ loc declareGeneratedFunction(str _name, str _fuid, AType _rtype, loc src){
 private AType getType0(loc l) {
    //println("getType(<l>)");
     //assert specializedFacts[l]? || facts[l]? : "getType for <l>";
-    if(specializedFacts[l]?){
+    if(l in specializedFacts){
         return specializedFacts[l];
     }
-    if(facts[l]?){
+    if(l in facts){
     	return facts[l];
     }
-    if(definitions[l]?){
+    if(l in definitions){
         return getDefType(l);
     }
+
+    if(l in physical2logical){
+        ll = physical2logical[l];
+        if(ll in definitions){
+            return getDefType(ll);
+        }
+    }
+    
     //println("*** getType0 ***");
     //iprintln(facts, lineLimit=10000);
     throw "getType0 cannot find type for <l>";
@@ -626,12 +634,12 @@ KeywordParamMap getKeywords(Parameters parameters){
     return ("<kwf.name>" : kwtp | kwf <- kwfs.keywordFormalList, kwtp := getType(kwf));
 }
 
-list[MuExp] getExtendedFunctionFormals(loc funsrc, str scopeName){
+list[MuExp] getExtendedFunctionFormals(loc funsrc, loc scopeId){
     vars = vars_per_fun[funsrc];
-    return  [muVar(var.id, scopeName, i, unsetRec(getTypeFromDef(var), "alabel"), formalId()) | i <- index(vars), var := vars[i]];
+    return  [muVar(var.id, scopeId, i, unsetRec(getTypeFromDef(var), "alabel"), formalId()) | i <- index(vars), var := vars[i]];
 }
 
-tuple[str fuid, int pos] getVariableScope(str name, loc l) {
+tuple[loc fuid, int pos] getVariableScope(str name, loc l) {
   //iprintln(definitions);
   //println("getVariableScope: <name>, <l>, <definitions[l] ? "???">, <declaredIn[l] ? "???">, <useDef[l] ? "???">)");
   container = |global-scope:///|;
@@ -650,8 +658,8 @@ tuple[str fuid, int pos] getVariableScope(str name, loc l) {
   }
 
   cdef = definitions[container];
-  if(cdef.idRole == functionId()) return <convert2fuid(container), getPositionInScope(name, l)>;
-  if(cdef.idRole == moduleId()) return <replaceAll(cdef.id, "::", "_"), getPositionInScope(name, l)>;
+  if(cdef.idRole == functionId()) return <container, getPositionInScope(name, l)>;
+  if(cdef.idRole == moduleId()) return <container, getPositionInScope(name, l)>;
   throw "getVariableScope fails for <name>, <l>";
 }
 
@@ -662,24 +670,10 @@ int getPositionInScope(str _name, loc l){
     return res;
 }
 
-str convert2fuid(UID uid) {
-	if(uid == |global-scope:///|)
-	   return "global-scope";
-
-	str name = definitions[uid]? ? definitions[uid].id : "XXX";
-
-    if(declaredIn[uid]?) {
-       def = definitions[uid];
-       if(physical2logical[def.defined]?){
-          lg = physical2logical[def.defined];
-          path = lg.path;
-          if(path[0] == "/"){
-            path = path[1..];
-          }
-          name = replaceAll(path, "/", "_");
-       }
-    }
-	return name;
+loc getLogicalLoc(loc src){
+    if(isRascalLogicalLoc(src)) return src;
+    if(src in physical2logical) return physical2logical[src];
+    throw "getLogicalLoc: no logical loc found for <src>";
 }
 
 public int getTupleFieldIndex(AType s, str fieldName) =
@@ -688,7 +682,6 @@ public int getTupleFieldIndex(AType s, str fieldName) =
 public rel[loc fuid,int pos] getAllVariablesAndFunctionsOfBlockScope(loc block) {
     locally_defined = { v.defined | sc <- td_reachable_scopes[block], v <- (vars_per_scope[sc] ? {}) };
     return { <declaredIn[decl], position_in_container[decl]> | UID decl <-locally_defined, position_in_container[decl]?};
-    //return { <convert2fuid(declaredIn[decl]), position_in_container[decl]> | UID decl <-locally_defined, position_in_container[decl]?};
 }
 
 set[loc] getDefiningScopes(AType root)
@@ -844,7 +837,8 @@ bool occursBefore(loc before, loc after){
 // Generate a MuExp to access a variable
 
 MuExp mkVar(str name, loc l) {
-  //println("<name>, <l>");
+//   println("<name>, <l>");
+  if(l in physical2logical) l = physical2logical[l];
 
   uqname = asUnqualifiedName(name);
   name_type = getType(l);
@@ -864,7 +858,7 @@ MuExp mkVar(str name, loc l) {
         uid = l;
         def = definitions[l];
     } else if(isWildCard(name)){
-        return muVar("_", "", -1, name_type, variableId());
+        return muVar("_", |global-scope:///|, -1, name_type, variableId());
     } else {
         throw "mkVar: <uqname> at <l>";
     }
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal/AST.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal/AST.rsc
index f8167047679..090acafeed5 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal/AST.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal/AST.rsc
@@ -37,6 +37,7 @@ import IO;
 import lang::rascalcore::check::ATypeBase;
 
 extend lang::rascalcore::check::ATypeUtils;
+import lang::rascalcore::check::LogicalLocations;
 //extend lang::rascalcore::compile::muRascal::Primitives;
 
 /*
@@ -70,12 +71,12 @@ MuModule errorMuModule(str name, set[Message] messages, loc src) = muModule(name
          
 public data MuFunction =					
                 muFunction(str name,                        // Function name as in source text
-                           str uniqueName,                  // Function name made unique with position information in file
+                           FUNID funId,                     // Logical location of function
                            AType ftype,                     // Function type
                            list[MuExp] formals,             // List of muVar's representing the positional formals described by the function type
                            list[MuExp] extendedFormalVars,  // List of muVar's representing all nested formals (as occur in patterns)
                            lrel[str name, AType atype, MuExp defaultExp] kwpDefaults, 
-                           str scopeIn,                     // Name of current scope (concatenion of surrounding unique function names)
+                           loc scopeIn,                     // Name of current scope (concatenion of surrounding unique function names)
                            bool isVarArgs,                  // Has it variable arguments?
                            bool isPublic,                   // Is it public?
                            bool isMemo,                     // Is it a memo function?
@@ -112,18 +113,18 @@ data NativeKind
     | nativeITree()
     ;
     
-MuExp muTmpInt(str name, str fuid)                  = muTmpNative(name, fuid, nativeInt());
-MuExp muTmpBool(str name, str fuid)                 = muTmpNative(name, fuid, nativeBool());
-MuExp muTmpListWriter(str name, str fuid)           = muTmpNative(name, fuid, nativeListWriter());
-MuExp muTmpSetWriter(str name, str fuid)            = muTmpNative(name, fuid, nativeSetWriter());
-MuExp muTmpMapWriter(str name, str fuid)            = muTmpNative(name, fuid, nativeMapWriter());
-MuExp muTmpMatcher(str name, str fuid)              = muTmpNative(name, fuid, nativeMatcher());
-MuExp muTmpStrWriter(str name, str fuid)            = muTmpNative(name, fuid, nativeStrWriter());
-MuExp muTmpDescendantIterator(str name, str fuid)   = muTmpNative(name, fuid, nativeDescendantIterator());
-MuExp muTmpTemplate(str name, str fuid)             = muTmpNative(name, fuid, nativeTemplate());
-MuExp muTmpException(str name, str fuid)            = muTmpNative(name, fuid, nativeException());
-MuExp muTmpGuardedIValue(str name, str fuid)        = muTmpNative(name, fuid, nativeGuardedIValue());
-MuExp muTmpITree(str name, str fuid)                = muTmpNative(name, fuid, nativeITree());
+MuExp muTmpInt(str name, loc fuid)                  = muTmpNative(name, fuid, nativeInt());
+MuExp muTmpBool(str name, loc fuid)                 = muTmpNative(name, fuid, nativeBool());
+MuExp muTmpListWriter(str name, loc fuid)           = muTmpNative(name, fuid, nativeListWriter());
+MuExp muTmpSetWriter(str name, loc fuid)            = muTmpNative(name, fuid, nativeSetWriter());
+MuExp muTmpMapWriter(str name, loc fuid)            = muTmpNative(name, fuid, nativeMapWriter());
+MuExp muTmpMatcher(str name, loc fuid)              = muTmpNative(name, fuid, nativeMatcher());
+MuExp muTmpStrWriter(str name, loc fuid)            = muTmpNative(name, fuid, nativeStrWriter());
+MuExp muTmpDescendantIterator(str name, loc fuid)   = muTmpNative(name, fuid, nativeDescendantIterator());
+MuExp muTmpTemplate(str name, loc fuid)             = muTmpNative(name, fuid, nativeTemplate());
+MuExp muTmpException(str name, loc fuid)            = muTmpNative(name, fuid, nativeException());
+MuExp muTmpGuardedIValue(str name, loc fuid)        = muTmpNative(name, fuid, nativeGuardedIValue());
+MuExp muTmpITree(str name, loc fuid)                = muTmpNative(name, fuid, nativeITree());
 
     
 // All executable Rascal code is translated to the following muExps.
@@ -145,11 +146,11 @@ public data MuExp =
           | muAddedFun(MuExp left, MuExp right, AType leftType, AType rightType, AType resultType)
           
           	// Variables and temporaries
-          | muVar(str name, str fuid, int pos, AType atype, IdRole idRole) // Variable: retrieve its value
-          | muTmpIValue(str name, str fuid, AType atype)	    // Temporary variable introduced by compiler
-          | muTmpNative(str name, str fuid, NativeKind nkind)   // Temporary variable introduced by compiler
+          | muVar(str name, loc fuid, int pos, AType atype, IdRole idRole) // Variable: retrieve its value
+          | muTmpIValue(str name, loc fuid, AType atype)	    // Temporary variable introduced by compiler
+          | muTmpNative(str name, loc fuid, NativeKind nkind)   // Temporary variable introduced by compiler
              
-          | muVarKwp(str name, str fuid, AType atype)           // Keyword parameter
+          | muVarKwp(str name, loc fuid, AType atype)           // Keyword parameter
           
           // Call and return    		
           
@@ -159,7 +160,7 @@ public data MuExp =
           | muPrim(str name, AType result, list[AType] details, list[MuExp] exps, loc src)	 // Call a Rascal primitive, defined in Primitives
            
           | muCallJava(str name, str class, AType funType,
-          			   list[MuExp] args, str enclosingFun)		// Call a Java method in given class
+          			   list[MuExp] args, FUNID enclosingFun)		// Call a Java method in given class
  
           | muReturn0()											// Return from a function without value
           | muReturn1(AType result, MuExp exp)			        // Return from a function with value with given type
@@ -346,7 +347,7 @@ data MuCase = muCase(int fingerprint, MuExp exp);
 
 // ==== Checks ================================================================
 
-MuExp muVar(str name, str fuid, int pos, AType atype, IdRole idRole){
+MuExp muVar(str name, loc fuid, int pos, AType atype, IdRole idRole){
     assert !isEmpty(name);
     if(atype.alabel?){
     u_atype = unsetRec(atype, "alabel");
@@ -366,7 +367,7 @@ MuExp muTmpNative(str name, str _fuid, NativeKind _nkind) {
     fail;
 }
              
-MuExp muVarKwp(str name, str _fuid, AType _atype) {
+MuExp muVarKwp(str name, loc _fuid, AType _atype) {
     assert !isEmpty(name);
     fail;
 }
@@ -378,7 +379,7 @@ bool isSameVar(MuExp x, MuExp y)
     = x is muVar && y is muVar && x.name == y.name && x.fuid == y.fuid && x.pos == y.pos;
 
 bool isVarDeclaredInFun(MuExp var, MuFunction fun)
-    = endsWith(var.fuid, fun.uniqueName);
+    = endsWith(var.fuid.path, fun.funId.path);
      
 bool isSyntheticFunctionName(str name)
     = contains(name, "$");
@@ -389,8 +390,11 @@ bool isClosureName(str name)
 bool isMainName("main") = true;
 default bool isMainName(str _) = false;
 
-bool isOuterScopeName(str scope)
-    = isEmpty(scope);
+bool isGlobalScope(loc l)
+    = l.scheme == "global-scope";
+
+bool isOuterScopeName(loc scope)
+    = isGlobalScope(scope);
    
 bool isModuleScope(loc scope, loc moduleScope)
     = scope == moduleScope;
@@ -399,15 +403,7 @@ str getFunctionName(MuFunction fun){
     if(isOuterScopeName(fun.scopeIn)) return fun.name;
     if(isClosureName(fun.name)) return fun.name; // "<fun.scopeIn>_<fun.uniqueName>";
     //return "<fun.scopeIn>_<fun.uniqueName>";
-    return fun.uniqueName;
-}
-
-str getUniqueFunctionName(MuFunction fun){
-    return fun.uniqueName;
-    //if(isModuleScope(fun.scopeIn, scope)){
-    //    return fun.uniqueName;
-    //}
-    //return "<fun.scopeIn>_<fun.uniqueName>";
+    return fun.funId.path;
 }
 
 bool isVarOrTmp(MuExp exp)
@@ -465,14 +461,14 @@ default bool producesNativeGuardedIValue(MuExp exp)
 // Get the result type of a MuExp
 
 AType getType(muCon(value v)) = symbol2atype(typeOf(v));
-AType getType(muVar(str name, str fuid, int pos, AType atype, IdRole idRole)) = atype;
-AType getType(muTmpIValue(str name, str fuid, AType atype)) = atype;
-AType getType(muVarKwp(str name, str fuid, AType atype)) = atype;
+AType getType(muVar(str name, loc fuid, int pos, AType atype, IdRole idRole)) = atype;
+AType getType(muTmpIValue(str name, loc fuid, AType atype)) = atype;
+AType getType(muVarKwp(str name, loc fuid, AType atype)) = atype;
 AType getType(muOCall(MuExp fun, AType atype, list[MuExp] args, lrel[str kwpName, MuExp exp] kwargs, loc src))
     = getResult(atype);                                                               
 AType getType(muPrim(str name, AType result, list[AType] details, list[MuExp] exps, loc src)) 
     = result;
-AType getType(muCallJava(str name, str class, AType funType, list[MuExp] args, str enclosingFun)) =  getResult(funType); 
+AType getType(muCallJava(str name, str class, AType funType, list[MuExp] args, loc enclosingFun)) =  getResult(funType); 
 AType getType(muIfExp(MuExp cond, MuExp thenPart, MuExp elsePart)) = alub(getType(thenPart), getType(elsePart));
 
 AType getType(muGetKwFieldFromConstructor(AType resultType, MuExp var, str fieldName)) = resultType;
@@ -1632,14 +1628,14 @@ tuple[bool flattened, list[MuExp] auxVars, list[MuExp] pre, list[MuExp] post] fl
             }
             case me: muExists(_, _): {
                 nauxVars += 1;
-                aux = muTmpIValue("$aux<nauxVars>", "xxx", abool());
+                aux = muTmpIValue("$aux<nauxVars>", |global-state:///|, abool());
                 auxVars += muVarInit(aux, muCon(false));
                 pre += muAssign(aux, me);
                 newArgs += aux;
             }
             case me: muAll(_, _): {
                 nauxVars += 1;
-                aux = muTmpIValue("$aux<nauxVars>", "xxx", abool());
+                aux = muTmpIValue("$aux<nauxVars>", |global-state:///|, abool());
                 auxVars += muVarInit(aux, muCon(false));
                 pre += muAssign(aux, me);
                 newArgs += aux;
@@ -1658,7 +1654,7 @@ tuple[bool flattened, list[MuExp] auxVars, list[MuExp] pre, list[MuExp] post] fl
             }
             case me: muWhileDo(str _, MuExp _, MuExp _): {
                 nauxVars += 1;
-                aux = muTmpIValue("$aux<nauxVars>", "xxx", alist(avalue()));
+                aux = muTmpIValue("$aux<nauxVars>", |global-state:///|, alist(avalue()));
                 auxVars += muVarInit(aux, muCon([]));
                 pre += muAssign(aux, me);
                 newArgs += aux;
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
index c82d3a97aae..4e952581c48 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
@@ -63,8 +63,8 @@ bool debug = false;
 
 // ---- globals ---------------------------------------------------------------
 
-map[str, MuFunction] muFunctions = ();
-map[loc, MuFunction] loc2muFunction = ();
+map[FUNID, MuFunction] muFunctions = ();
+// map[loc, MuFunction] loc2muFunction = ();
 
 int naux = 0;
 
@@ -89,7 +89,7 @@ tuple[JCode, JCode, JCode, list[value]] muRascal2Java(MuModule m, ModuleStatus m
     imports = { mname | <moduleName, importPath(), mname> <- paths };
     imports += { mname | imp <- imports, <imp, extendPath(), mname> <- paths};
    
-    loc2muFunction = (f.src : f | f <- m.functions);
+    // loc2muFunction = (f.funId : f | f <- m.functions);
     
     // Iteratively propagate external dependencies of functions
     list[MuFunction] functions = m.functions;
@@ -98,15 +98,15 @@ tuple[JCode, JCode, JCode, list[value]] muRascal2Java(MuModule m, ModuleStatus m
     }
     for(int i <- index(functions)){
         f = functions[i];
-        f.externalRefs = { er | er <- f.externalRefs, er.fuid != f.uniqueName };
+        f.externalRefs = { er | er <- f.externalRefs, er.fuid != f.funId };
         functions[i] = f;
     }
     m.functions = functions;
     
-    muFunctions = (f.uniqueName : f | f <- m.functions);
+    muFunctions = (f.funId : f | f <- m.functions);
  
     jg = makeJGenie(m, tmodels, moduleLocs, muFunctions);
-    resolvers = generateResolvers(moduleName, loc2muFunction, imports, extends, tmodels, moduleLocs, pcfg, jg);
+    resolvers = generateResolvers(moduleName, muFunctions, imports, extends, tmodels, moduleLocs, pcfg, jg);
     
     map[loc,AType] facts = tm.facts;
     cons_in_module = { def.defInfo.atype | Define def <-range(tm.definitions), def.idRole == constructorId(), jg.isContainedIn(def.scope, module_scope) }
@@ -125,7 +125,7 @@ tuple[JCode, JCode, JCode, list[value]] muRascal2Java(MuModule m, ModuleStatus m
             hasMainFunction = true;
             mainFunction = f;
             mainType = f.ftype;
-            mainName = getUniqueFunctionName(f);
+            mainName = asJavaName(f.funId);
         }
         jg.addExternalRefs(f.externalRefs); //TODO: remove both?
         jg.addLocalRefs(f.localRefs);
@@ -295,7 +295,7 @@ tuple[JCode, JCode, JCode, list[value]] muRascal2Java(MuModule m, ModuleStatus m
 str newValueRef(str name, str jtype, str code, JGenie jg)
     = "new ValueRef\<<jtype>\>(\"<asJavaName(name)>\", <code>)";
     
-str newValueRef(str vname, AType atype, v:muVar(str name, str _, int pos, AType _, IdRole idRole), JGenie jg)
+str newValueRef(str vname, AType atype, v:muVar(str name, loc _, int pos, AType _, IdRole idRole), JGenie jg)
     = jg.isRef(v) ? "new ValueRef\<<atype2javatype(atype)>\>(\"<vname>\", <varName(v, jg)>.getValue())" : newValueRef(vname, atype2javatype(atype), varName(v, jg), jg)
     ;
 
@@ -308,24 +308,24 @@ set[MuExp] filteredExternalRefs(MuFunction fun)
 MuFunction addTransitiveRefs(MuFunction fun){
     usedFunDefs = {};
     visit (fun.body){
-      case muFun(loc uid, AType _atype): usedFunDefs += uid;
-      case muOFun(list[loc] uids, AType atype): usedFunDefs += toSet(uids);
+      case muFun(FUNID uid, AType _atype): usedFunDefs += uid;
+      case muOFun(list[FUNID] uids, AType atype): usedFunDefs += toSet(uids);
     }
-    usedFuns = { loc2muFunction[uid] | loc uid <- usedFunDefs, loc2muFunction[uid]? };
+    usedFuns = { muFunctions[uid] | loc uid <- usedFunDefs, muFunctions[uid]? };
     
     externalRefs = { *filteredExternalRefs(f) | f <- usedFuns };
     
     deltaExternalRefs = externalRefs - fun.externalRefs ;
-    deltaLocalRefs =  { e | e <- externalRefs, e.fuid == fun.uniqueName } - fun.localRefs;
+    deltaLocalRefs =  { e | e <- externalRefs, e.fuid == fun.funId } - fun.localRefs;
    
     if(!(isEmpty(deltaExternalRefs))){
         fun.externalRefs += deltaExternalRefs;
         //fun.externalRefs = filteredExternalRefs(fun);
-        loc2muFunction[fun.src] = fun;
+        muFunctions[fun.funId] = fun;
     }
     if(!(isEmpty(deltaLocalRefs))){
         fun.localRefs += deltaLocalRefs;
-        loc2muFunction[fun.src] = fun;
+        muFunctions[fun.funId] = fun;
     }
     return fun;
 }
@@ -359,7 +359,7 @@ bool constantDefaults(lrel[str name, AType atype, MuExp defaultExp] kwpDefaults)
 }
 
 tuple[str argTypes, str constantKwpDefaults, str constantKwpDefaultsInit, str nonConstantKwpDefaults, str refInits] getArgTypes(MuFunction fun, JGenie jg){   
-    shortName = asJavaName(getUniqueFunctionName(fun)); 
+    shortName = asJavaName(fun.funId); 
 
     argTypeList = [];
     refInits = "";
@@ -400,10 +400,10 @@ tuple[str argTypes, str constantKwpDefaults, str constantKwpDefaultsInit, str no
             nonConstantKwpDefaults =  "java.util.Map\<java.lang.String,IValue\> $kwpDefaults = Util.kwpMap();\n";
             for(<str name, AType tp, MuExp defaultExp> <- kwpDefaults){
                 escapedName = asJavaName(name);
-                nonConstantKwpDefaults += "<trans(muConInit(muVar("$kwpDefault_<escapedName>","", 10, tp,  keywordFieldId()), defaultExp),jg)>$kwpDefaults.put(\"<escapedName>\", $kwpDefault_<escapedName>);";
+                nonConstantKwpDefaults += "<trans(muConInit(muVar("$kwpDefault_<escapedName>",|global-scope:///|, 10, tp,  keywordFieldId()), defaultExp),jg)>$kwpDefaults.put(\"<escapedName>\", $kwpDefault_<escapedName>);";
             }
          }   
-    } else if(!isEmpty(fun.scopeIn) /*&& !isClosureName(fun.name)*/){
+    } else if(!isGlobalScope(fun.scopeIn) /*&& !isClosureName(fun.name)*/){
         if(!isEmpty(jg.collectDeclaredKwps(fun))){
             nonConstantKwpDefaults = "java.util.Map\<java.lang.String,IValue\> $kwpDefaults = Util.kwpMap();\n";
         }
@@ -418,7 +418,7 @@ tuple[str argTypes, str constantKwpDefaults, str constantKwpDefaultsInit, str no
         if(!isEmpty(fun.keywordParameterRefs) && !contains(argTypes, "$kwpActuals")){
             kwpActuals = "java.util.Map\<java.lang.String,IValue\> $kwpActuals";
     }
-    if(!isEmpty(fun.externalRefs) && !isEmpty(fun.scopeIn)){
+    if(!isEmpty(fun.externalRefs) && !isGlobalScope(fun.scopeIn)){
         externalActuals = intercalate(", ", [ "ValueRef\<<atype2javatype(var.atype)>\> <varName(var, jg)>" 
                                             | var <- sort(fun.externalRefs)
                                             , var.pos >= 0
@@ -461,7 +461,7 @@ bool hasIgnoreCompilerTag(map[str,str] tagsMap)
     = !isEmpty(domain(tagsMap) &  {"ignore", "Ignore", "hasIgnoreCompilerTag", "IgnoreCompiler"});
 
 str getMemoCache(MuFunction fun)
-    = "$memo_<asJavaName(getUniqueFunctionName(fun))>";
+    = "$memo_<asJavaName(fun.funId)>";
     
 tuple[str constantKwpDefaults, str constantKwpDefaultsInit, JCode jcode] trans(MuFunction fun, JGenie jg){
     //iprintln(fun); // print function
@@ -473,7 +473,8 @@ tuple[str constantKwpDefaults, str constantKwpDefaultsInit, JCode jcode] trans(M
     ftype = fun.ftype;
     jg.setFunction(fun);
     
-    shortName = asJavaName(isClosureName(fun.name) ? fun.name : getUniqueFunctionName(fun));
+    // shortName = asJavaName(isClosureName(fun.name) ? fun.name : getUniqueFunctionName(fun));
+    shortName = asJavaName(fun.funId);
     
     visibility = "public "; // isSyntheticFunctionName(shortName) ? "private " : "public "; $getkw_ should be public
     uncheckedWarning = "";
@@ -511,7 +512,7 @@ tuple[str constantKwpDefaults, str constantKwpDefaultsInit, JCode jcode] trans(M
 }
 
 JCode call(MuFunction fun, list[str] actuals, JGenie _jg){
-    return "<fun.uniqueName>(<intercalate(", ", actuals)>)";
+    return "<asJaveName(fun.funId)>(<intercalate(", ", actuals)>)";
 }
 
 JCode trans(muComment(str text), JGenie jg)
@@ -532,27 +533,27 @@ JCode trans(muATypeCon(AType t, map[AType, set[AType]] definitions), JGenie jg)
     return jg.shareReifiedConstant(atype2symbol(t), adefinitions2definitions(definitions));
 } 
                       
-JCode trans(muFun(loc uid, AType ftype), JGenie jg){
+JCode trans(muFun(FUNID uid, AType ftype), JGenie jg){
     nformals = size(ftype.formals);
     sep = nformals > 0 ? "," : "";
-    uniq = uid.offset;
+    fname = getFunctionName(uid);
     
-    needs_no_cast = !(loc2muFunction[uid]? && isClosureName(loc2muFunction[uid].name));
+    needs_no_cast = !(muFunctions[uid]? && isClosureName(muFunctions[uid].name));
    
-    formals = intercalate(", ", ["$<uniq>_<i>" | i <- [0..nformals]]);
+    formals = intercalate(", ", ["$<fname>_<i>" | i <- [0..nformals]]);
   
-    actuals = intercalate(", ", ["<needs_no_cast ? "" : "(<atype2javatype(ftype.formals[i])>)">$<uniq>_<i>" | i <- [0..nformals]]);
+    actuals = intercalate(", ", ["<needs_no_cast ? "" : "(<atype2javatype(ftype.formals[i])>)">$<fname>_<i>" | i <- [0..nformals]]);
     
     if(!isEmpty(ftype.kwFormals)){// || !isEmpty(jg.collectKwpDefaults(jg.getFunction()))){
         actuals = isEmpty(actuals) ?  "$kwpActuals" : "<actuals>, $kwpActuals";
-    } else if(loc2muFunction[uid]?){
-        fun = loc2muFunction[uid];
+    } else if(muFunctions[uid]?){
+        fun = muFunctions[uid];
         if(isClosureName(fun.name)){
             if(/muVarKwp(_,_,_) := fun.body){
                 actuals = isEmpty(actuals) ?  "$kwpActuals, $kwpDefaults" : "<actuals>, $kwpActuals, $kwpDefaults";
             }
         } else
-        if(fun.scopeIn != "" && !isEmpty(fun.keywordParameterRefs)){ 
+        if(!isGlobalScope(fun.scopeIn) && !isEmpty(fun.keywordParameterRefs)){ 
             actuals = isEmpty(actuals) ?  "$kwpActuals" : "<actuals>, $kwpActuals";
         }
     }
@@ -561,8 +562,8 @@ JCode trans(muFun(loc uid, AType ftype), JGenie jg){
     ext_actuals = actuals;
     if(!isEmpty(externalRefs)){
         ext_actuals = "";
-        if(loc2muFunction[uid]?){
-            fun = loc2muFunction[uid];
+        if(muFunctions[uid]?){
+            fun = muFunctions[uid];
             current_fun = jg.getFunction();
             ext_actuals = intercalate(", ", [ fun.scopeIn == var.fuid ? ((jg.isRef(var) || var.idRole notin assignableRoles)  ? vp 
                                                                                                                               : newValueRef(var.name, atype2javatype(var.atype), vp, jg))                                                         
@@ -582,9 +583,9 @@ JCode trans(muFun(loc uid, AType ftype), JGenie jg){
 }          
 // ---- muOFun ----------------------------------------------------------------
        
-JCode trans(muOFun(list[loc] srcs, AType ftype), JGenie jg){
+JCode trans(muOFun(list[FUNID] funIds, AType ftype), JGenie jg){
     overloading = false;
-    fname = jg.getAccessor(srcs);
+    fname = jg.getAccessor(funIds);
    
     nformals = size(getFormals(ftype));
     sep = nformals > 0 ? "," : "";
@@ -596,9 +597,9 @@ JCode trans(muOFun(list[loc] srcs, AType ftype), JGenie jg){
     
     fun_kwFormals = [];
     ext_actuals = [];
-    for(src <- srcs){
-        if(loc2muFunction[src]?){
-            fun = loc2muFunction[src];
+    for(funId <- funIds){
+        if(muFunctions[funId]?){
+            fun = muFunctions[funId];
             fun_kwFormals += jg.collectKwpFormals(fun);
             if(!isEmpty(fun.externalRefs)){
                 ext_actuals += [varName(v, jg) | v <- fun.externalRefs]; 
@@ -707,7 +708,7 @@ str trans(c:muComposedFun(MuExp left, MuExp right, AType leftType, AType rightTy
 
 // ---- muVar -----------------------------------------------------------------
 
-str varName(muVar(str name, str _, int pos, AType _, IdRole idRole), JGenie _jg){
+str varName(muVar(str name, loc _, int pos, AType _, IdRole idRole), JGenie _jg){
     result = asJavaName(name);
     if (name[0] != "$" && (pos >= 0 || isWildCard(name))){
         result += "_<abs(pos)>";
@@ -715,37 +716,37 @@ str varName(muVar(str name, str _, int pos, AType _, IdRole idRole), JGenie _jg)
     return result;
 }
         
-JCode trans(var:muVar(str name, str fuid, int pos, AType atype, IdRole idRole), JGenie jg){
+JCode trans(var:muVar(str name, loc fuid, int pos, AType atype, IdRole idRole), JGenie jg){
     //println("muVar: fuid=<fuid>, functionName: <jg.getFunctionName()>, moduleName: <jg.getModuleName()>");
     return jg.isRef(var) ? "<varName(var, jg)>.getValue()" 
                          : ( pos >= 0 ? varName(var, jg)
-                                      : "<fuid == jg.getFunctionName() ? "" : isEqualModule(fuid, jg.getModuleName()) ? "" : "<module2field(fuid)>."><varName(var, jg)>"
+                                      : "<fuid == jg.getFunction().funId ? |global-scope:///| : (fuid == jg.getModuleLoc()) ? "" : "<module2field(fuid)>."><varName(var, jg)>"
                          );
 }
 
 // ---- muTmpIValue -----------------------------------------------------------------
 
-JCode trans(var: muTmpIValue(str name, str fuid, AType atype), JGenie jg)
+JCode trans(var: muTmpIValue(str name, loc fuid, AType atype), JGenie jg)
     = jg.isRef(var) ? "<name>.getValue()" : name;
     
-JCode trans(var: muTmpNative(str name, str fuid, NativeKind nkind), JGenie jg)
+JCode trans(var: muTmpNative(str name, loc fuid, NativeKind nkind), JGenie jg)
     = jg.isRef(var) ? "<name>.getValue()" : name;
   
 // ---- muVarDecl --------------------------------------------------------------
 
-JCode trans(muVarDecl(v: muVar(str name, str fuid, int pos, AType atype, IdRole idRole)), JGenie jg){
+JCode trans(muVarDecl(v: muVar(str name, loc fuid, int pos, AType atype, IdRole idRole)), JGenie jg){
     jtype = atype2javatype(atype);
     return jg.isRef(v) ? "ValueRef\<<jtype>\> <varName(v, jg)> = new ValueRef\<<jtype>\>();\n"
                        : "<jtype> <varName(v, jg)> = null;\n";  
 }
 
-JCode trans(muVarDecl(v: muTmpIValue(str name, str fuid, AType atype)), JGenie jg){
+JCode trans(muVarDecl(v: muTmpIValue(str name, loc fuid, AType atype)), JGenie jg){
     jtype = atype2javatype(atype);
     return jg.isRef(v) ? "ValueRef\<<jtype>\> <name> = new ValueRef\<<jtype>\>();\n"
                        : "<jtype> <name> = null;\n";
 }
 
-JCode trans(muVarDecl(var: muTmpNative(str name, str fuid, NativeKind nkind)), JGenie jg){
+JCode trans(muVarDecl(var: muTmpNative(str name, loc fuid, NativeKind nkind)), JGenie jg){
     <base, ref> = native2ref[nkind];
     return jg.isRef(var) ? "<ref> <name> = null;\n"
                          : "<base> <name> = null;\n";
@@ -754,12 +755,12 @@ JCode trans(muVarDecl(var: muTmpNative(str name, str fuid, NativeKind nkind)), J
 // ---- muVarInit --------------------------------------------------------------
 
 bool isSameVarModuloRole(MuExp x, MuExp y)
-    = muVar(str name, str fuid, int pos, AType _, IdRole _) := y && x.name == name && x.fuid == fuid && x.pos == pos;
+    = muVar(str name, loc fuid, int pos, AType _, IdRole _) := y && x.name == name && x.fuid == fuid && x.pos == pos;
 
 str parens(str code)
     = endsWith(code, ";\n") ? "(<code[0..-2]>)" : "(<code>)";
 
-JCode trans(muVarInit(v: muVar(str name, str fuid, int pos, AType atype, IdRole idRole), MuExp exp), JGenie jg){
+JCode trans(muVarInit(v: muVar(str name, loc fuid, int pos, AType atype, IdRole idRole), MuExp exp), JGenie jg){
     jtype = atype2javatype(atype);
     if(jtype == "void"){
         return "";
@@ -776,7 +777,7 @@ JCode trans(muVarInit(v: muVar(str name, str fuid, int pos, AType atype, IdRole
     }
 }
 
-JCode trans(muVarInit(v: muTmpIValue(str name, str fuid, AType atype), MuExp exp), JGenie jg){
+JCode trans(muVarInit(v: muTmpIValue(str name, loc fuid, AType atype), MuExp exp), JGenie jg){
     jtype = atype2javatype(atype);
     return jg.isRef(v) ? "final ValueRef\<<jtype>\> <name> = <newValueRef(name, atype, exp, jg)>;\n" //new ValueRef\<<jtype>\>(<transWithCast(atype,exp,jg)>);\n"
                        : "<jtype> <name> = (<jtype>)<parens(trans(exp, jg))>;\n";
@@ -798,7 +799,7 @@ map[NativeKind, tuple[str,str]] native2ref =
      nativeITree()          : <"ITree", "ITreeRef">
      );
 
-JCode trans(muVarInit(var: muTmpNative(str name, str fuid, NativeKind nkind), MuExp exp), JGenie jg){
+JCode trans(muVarInit(var: muTmpNative(str name, loc fuid, NativeKind nkind), MuExp exp), JGenie jg){
     rhs = muCon(value v) := exp ? "<v>" : trans(exp, jg);   // TODO does not work for all constants, e.g. datetime
     if(nkind == nativeGuardedIValue() && !producesNativeGuardedIValue(exp)){
         rhs = "new GuardedIValue(<rhs>)";
@@ -810,7 +811,7 @@ JCode trans(muVarInit(var: muTmpNative(str name, str fuid, NativeKind nkind), Mu
 
 // --- muConInit --------------------------------------------------------------
 
- JCode trans(muConInit(v:muVar(str name, str fuid, int pos, AType atype, IdRole idRole), MuExp exp), JGenie jg){
+ JCode trans(muConInit(v:muVar(str name, loc fuid, int pos, AType atype, IdRole idRole), MuExp exp), JGenie jg){
     if(isSameVarModuloRole(v, exp)){
         return "";
     }
@@ -821,13 +822,13 @@ JCode trans(muVarInit(var: muTmpNative(str name, str fuid, NativeKind nkind), Mu
     return "<jtype> <varName(v, jg)> = <transWithCast(atype, exp, jg)>;\n";
 }
     
-JCode trans(muConInit(v:muTmpIValue(str name, str fuid, AType atype), MuExp exp), JGenie jg){
+JCode trans(muConInit(v:muTmpIValue(str name, loc fuid, AType atype), MuExp exp), JGenie jg){
     jtype = atype2javatype(atype);
     return jg.isRef(v) ? "final ValueRef\<<jtype>\> <varName(v,jg)> = <newValueRef(name, atype, exp, jg)>;\n" //new ValueRef\<<jtype>\>(<transWithCast(atype,exp,jg)>);\n"
                        : "final <jtype> <name> = <transWithCast(atype, exp, jg)>;\n";
 }
 
-JCode trans(muConInit(var:muTmpNative(str name, str fuid, NativeKind nkind), MuExp exp), JGenie jg){
+JCode trans(muConInit(var:muTmpNative(str name, loc fuid, NativeKind nkind), MuExp exp), JGenie jg){
     rhs = muCon(value v) := exp ? "<v>" : trans(exp, jg);
     <base, ref> = native2ref[nkind];
     return jg.isRef(var) ? "final <ref> <varName(var, jg)> = new <ref>(<rhs>);\n"
@@ -836,7 +837,7 @@ JCode trans(muConInit(var:muTmpNative(str name, str fuid, NativeKind nkind), MuE
 
 str transWithCast(AType atype, con:muCon(c), JGenie jg) = trans(con, jg);
 
-str transWithCast(AType atype1, v:muVar(str name, str fuid, int pos, AType atype2, IdRole idRole), JGenie jg){
+str transWithCast(AType atype1, v:muVar(str name, loc fuid, int pos, AType atype2, IdRole idRole), JGenie jg){
     //v = unsetRec(v, "alabel");
     return jg.isRef(v) ? trans(v, jg) : /*(equivalent(atype1, atype2) ? trans(v,jg) :*/ "((<atype2javatype(atype1)>)<trans(v,jg)>)";
 }
@@ -874,7 +875,7 @@ bool producesFunctionInstance(str code)
 
 // ---- muAssign --------------------------------------------------------------
 
-JCode trans(muAssign(v:muVar(str name, str fuid, int pos, AType atype, IdRole idRole), MuExp exp), JGenie jg){
+JCode trans(muAssign(v:muVar(str name, loc fuid, int pos, AType atype, IdRole idRole), MuExp exp), JGenie jg){
     if(jg.isRef(v)){
         if(muPrim(op1, assignable_type, argtypes:[assignable_type, rhs_type],  [v, rhs], src) := exp, muCon(_) !:= rhs){
             // Case x += exp, where x is an external variable. Ensure proper execution order by executing exp first.
@@ -890,11 +891,11 @@ JCode trans(muAssign(v:muVar(str name, str fuid, int pos, AType atype, IdRole id
     }
 }
     
-JCode trans(muAssign(v:muTmpIValue(str name, str fuid, AType atype), MuExp exp), JGenie jg)
+JCode trans(muAssign(v:muTmpIValue(str name, loc fuid, AType atype), MuExp exp), JGenie jg)
     = jg.isRef(v) ? "<name>.setValue(<trans(exp, jg)>);\n"
                   : "<name> = <transWithCast(atype, exp, jg)>;\n";
 
-JCode trans(muAssign(v:muTmpNative(str name, str fuid, NativeKind nkind), MuExp exp), JGenie jg)
+JCode trans(muAssign(v:muTmpNative(str name, loc fuid, NativeKind nkind), MuExp exp), JGenie jg)
     = jg.isRef(v) ? "<name>.setValue(<trans2Native(exp, nkind, jg)>);\n"
                   : "<name> = <trans2Native(exp, nkind, jg)>;\n";
 
@@ -975,19 +976,19 @@ JCode trans(muOCall(MuExp fun, AType ftype, list[MuExp] largs, lrel[str kwpName,
     argTypes = getFunctionOrConstructorArgumentTypes(ftype);
     actuals = getActuals(argTypes, largs, jg);
     cst = (getResult(ftype) == avoid()) ? "" : "(<atype2javatype(getResult(ftype))>)";
-    if(muOFun(list[loc] srcs, AType _) := fun){   
+    if(muOFun(list[FUNID] funIds, AType _) := fun){   
         kwactuals = hasKeywordParameters(ftype) ? getKwpActuals(ftype has kwFields ? ftype.kwFields : getFunctionOrConstructorKeywords(ftype), kwargs, jg) : [];
-        isInnerFunction = any( fsrc <- srcs, loc2muFunction[fsrc]?, !isEmpty(loc2muFunction[fsrc].scopeIn) );
+        isInnerFunction = any( funId <- funIds, muFunctions[funId]?, !isGlobalScope(muFunctions[funId].scopeIn) );
         externals = [];
         if(isInnerFunction){
-            externalRefs = { *jg.getExternalRefs(fsrc) | fsrc <- srcs };
+            externalRefs = { *jg.getExternalRefs(funId) | funId <- funIds };
             externals = [ varName(var, jg) | var <- sort(externalRefs)];
             kwParams = jg.collectKwpFormals(jg.getFunction());
             if(!isEmpty(kwParams) && isEmpty(kwactuals)){
                 externals = "$kwpActuals" + externals;
             }
         }
-        return "<jg.getAccessor(srcs)>(<intercalate(", ", actuals + kwactuals + externals)>)";
+        return "<jg.getAccessor(funIds)>(<intercalate(", ", actuals + kwactuals + externals)>)";
     }
     
     if(muFun(loc uid, _) := fun){
@@ -996,14 +997,14 @@ JCode trans(muOCall(MuExp fun, AType ftype, list[MuExp] largs, lrel[str kwpName,
         externals = [ varName(var, jg) | var <- sort(externalRefs), !isVarDeclaredInFun(var, jg.getFunction())/*, var notin fun.formals*/];
     
         if(jg.isContainedIn(uid, jg.getModuleLoc())){
-            fn = loc2muFunction[uid];
+            fn = muFunctions[uid];
             kwactuals1 = jg.collectKwpFormals(fn);
             if(isEmpty(kwactuals) && !isEmpty(kwactuals1)) kwactuals = ["$kwpActuals"];
             externalRefs -= fn.formals;
             externals = [ varName(var, jg) | var <- sort(externalRefs) ];
             arg_list = "(<intercalate(", ", actuals + kwactuals + externals)>)"; 
             
-            fun_name = isEmpty(fn.scopeIn) ? "$me.<asJavaName(getFunctionName(fn))>" : (isClosureName(fn.name) ? fn.name : "<fn.scopeIn>_<fn.name>");           
+            fun_name = isGlobalScope(fn.scopeIn) ? "$me.<asJavaName(getFunctionName(fn))>" : (isClosureName(fn.name) ? fn.name : "<fn.scopeIn>_<fn.name>");           
 
             result = "<asJavaName(fun_name)><arg_list>";
             
@@ -1066,6 +1067,11 @@ JCode trans(muGetKwField(AType resultType,  consType:acons(AType adt, list[AType
     return isConsKwField ? "<prefix(moduleName,jg)>$getkw_<adtName>_<asJavaName(consType.alabel,completeId=false)>_<asJavaName(fieldName,completeId=false)>(<transWithCast(consType, cons, jg)>)"
                          : "<prefix(moduleName,jg)>$getkw_<adtName>_<asJavaName(fieldName,completeId=false)>(<transWithCast(consType, cons, jg)>)";
 }
+
+JCode trans(muGetKwField(AType resultType,  aparameter(_, atp), MuExp cons, str fieldName, str moduleName), JGenie jg){
+    return trans(muGetKwField(resultType,  atp, cons, fieldName, moduleName), jg);
+}
+
 // ---- muGetField ---------------------------------------------------------
 
 JCode trans(muGetField(AType resultType, AType consType, MuExp cons, str fieldName), JGenie jg)
@@ -1196,7 +1202,7 @@ JCode trans(muPrim(str name, AType result, list[AType] details, list[MuExp] exps
     }
 }
 
-JCode trans(muCallJava(str name, str class, AType funType, list[MuExp] largs, str enclosingFun), JGenie jg){
+JCode trans(muCallJava(str name, str class, AType funType, list[MuExp] largs, FUNID enclosingFun), JGenie jg){
     jg.addImportedLibrary(class);
   
     actuals = [ trans(arg, jg) | arg <- largs ];
@@ -1338,14 +1344,14 @@ JCode trans(muKwpMap(lrel[str kwName, AType atype, MuExp defaultExp] kwpDefaults
 
 // ---- muVarKwp --------------------------------------------------------------
 
-JCode trans(var:muVarKwp(str name, str fuid, AType atype),  JGenie jg){
+JCode trans(var:muVarKwp(str name, loc fuid, AType atype),  JGenie jg){
     return "((<atype2javatype(atype)>) ($kwpActuals.containsKey(\"<unescape(name)>\") ? $kwpActuals.get(\"<unescape(name)>\") : $kwpDefaults.get(\"<unescape(name)>\")))";
 }
 
-JCode trans(muIsVarKwpDefined(muVarKwp(str name, str fuid, AType atype)),  JGenie jg)
+JCode trans(muIsVarKwpDefined(muVarKwp(str name, loc fuid, AType atype)),  JGenie jg)
     = "$kwpActuals.containsKey(\"<unescape(name)>\")";
     
-JCode trans(muAssign(muVarKwp(str name, str fuid, AType atype), MuExp exp), JGenie jg)
+JCode trans(muAssign(muVarKwp(str name, loc fuid, AType atype), MuExp exp), JGenie jg)
     = "$kwpActuals.put(\"<unescape(name)>\", <trans(exp, jg)>);\n";
 
 JCode trans(muIsKwpConstructorDefined(MuExp exp, str kwpName), JGenie jg)
@@ -1779,12 +1785,12 @@ JCode trans(muValueBlock(AType t, list[MuExp] exps), JGenie jg){
 
 // Exceptions
        
-JCode trans(muThrow(muTmpNative(str name, str fuid, nativeException()), loc src), JGenie jg){
+JCode trans(muThrow(muTmpNative(str name, loc fuid, nativeException()), loc src), JGenie jg){
     return "throw <name>;";
 }
 
 JCode trans(muThrow(MuExp exp, loc src), JGenie jg)
-    = muTmpNative(str name, str fuid, nativeException()) := exp 
+    = muTmpNative(str name, loc fuid, nativeException()) := exp 
       ? "throw <name>;" 
       : "throw new Throw(<trans(exp, jg)>);";
 
@@ -2132,5 +2138,6 @@ JCode trans(muTemplateClose(MuExp template), JGenie jg)
 // ---- Catch all ------------------------------------------------------------------
 
 default JCode trans(MuExp exp, JGenie jg){
+    iprintln(exp);
     throw "Cannot translate <exp>";
 }
\ No newline at end of file
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Interface.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Interface.rsc
index c6908c66a6f..56259b66245 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Interface.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Interface.rsc
@@ -44,24 +44,25 @@ import String;
 
 // Generate an interface for a Rascal module
 
-str generateInterface(str moduleName, str packageName, list[MuFunction] functions, set[str] imports, set[str] extends, map[str,TModel] tmodels, PathConfig pcfg, JGenie _jg){
+str generateInterface(str moduleName, str packageName, list[MuFunction] functions, set[str] imports, set[str] extends, map[str,TModel] tmodels, PathConfig pcfg, JGenie jg){
     return "<if(!isEmpty(packageName)){>package <packageName>;<}>
            'import io.usethesource.vallang.*;
            'import org.rascalmpl.runtime.function.*;
            '
            '@SuppressWarnings(\"unused\")
            'public interface <asBaseInterfaceName(moduleName)>  {
-           '    <generateInterfaceMethods(moduleName, functions, imports, extends, tmodels, pcfg)>
+           '    <generateInterfaceMethods(moduleName, functions, imports, extends, tmodels, pcfg, jg)>
            '}";
 }
 
-lrel[str, AType] getInterfaceSignature(str moduleName, list[MuFunction] functions, set[str]  _imports, set[str] extends, map[str,TModel] tmodels, PathConfig pcfg){
+lrel[str, AType] getInterfaceSignature(str moduleName, list[MuFunction] functions, set[str]  _imports, set[str] extends, map[str,TModel] tmodels, PathConfig pcfg, JGenie jg){
     lrel[str, AType] result = [];
     rel[str, int, AType] signatures = {};
-    mscope = tmodels[moduleName].moduleLocs[moduleName];
+    // mscope = tmodels[moduleName].moduleLocs[moduleName];
+    mscope = moduleName2moduleId(moduleName);
    
     
-    for(f <- functions, isEmpty(f.scopeIn), isContainedIn(f.src, mscope),
+    for(f <- functions, isGlobalScope(f.scopeIn), jg.isContainedIn(f.funId, mscope),
                                             !( //"test" in f.modifiers 
                                                 isSyntheticFunctionName(f.name) 
                                              || isMainName(f.name)
@@ -72,7 +73,8 @@ lrel[str, AType] getInterfaceSignature(str moduleName, list[MuFunction] function
     //iprintln(signatures);
     
     for(ext <- extends, ext in tmodels){
-        escope = tmodels[ext].moduleLocs[ext];
+        // escope = tmodels[ext].moduleLocs[ext];   
+        escope = moduleName2moduleId(ext);  
         for(def <- tmodels[ext].defines, defType(AType tp) := def.defInfo, 
             def.idRole == functionId() ,//|| def.idRole == constructorId(),
             getRascalModuleName(def.scope, pcfg) == ext,//def.scope == escope, //isContainedIn(def.defined, escope),
@@ -100,8 +102,8 @@ lrel[str, AType] getInterfaceSignature(str moduleName, list[MuFunction] function
     return sort(result);
 }
 
-str generateInterfaceMethods(str moduleName, list[MuFunction] functions, set[str] imports, set[str] extends, map[str,TModel] tmodels, PathConfig pcfg){
-    interface_signature = getInterfaceSignature(moduleName, functions, imports, extends, tmodels, pcfg);
+str generateInterfaceMethods(str moduleName, list[MuFunction] functions, set[str] imports, set[str] extends, map[str,TModel] tmodels, PathConfig pcfg, JGenie jg){
+    interface_signature = getInterfaceSignature(moduleName, functions, imports, extends, tmodels, pcfg, jg);
     methods = [generateInterfaceMethod(name, tp) | <name, tp> <- interface_signature];
     return intercalate("\n", methods);
 }
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
index 09099adbe7f..7b1466f8110 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
@@ -88,15 +88,14 @@ data JGenie
 JGenie makeJGenie(MuModule m, 
                   map[str,TModel] tmodels, 
                   map[str,loc] moduleLocs, 
-                  map[str, MuFunction] muFunctions){
+                  map[FUNID, MuFunction] muFunctions){
 
     // // temporary glue code
     // map[str,TModel] tmodels = (moduleId2moduleName(mid) : tmodels[mid] | mid <- tmodels0);
     // map[str,loc] moduleLocs = (moduleId2moduleName(mid) : moduleLocs[mid] | mid <- moduleLocs0);
     // map[str,loc] moduleLocs = (moduleId2moduleName(mid) : muFunctions0[mid] | mid <- muFunctions0);
 
-    map[str,loc] allModuleLocs = moduleLocs;
-    map[loc,str] allLocs2Module = invertUnique((mname : moduleLocs[mname].top | mname <- moduleLocs));
+    map[MODID,str] allLocs2Module = invertUnique((mname : moduleName2moduleId(mname) | mname <- moduleLocs));
     MuModule currentModule = m;
     str moduleName = m.name;
     MODID moduleId = moduleName2moduleId(moduleName);
@@ -123,13 +122,13 @@ JGenie makeJGenie(MuModule m,
     
     TModel currentTModel = tmodels[moduleName];
     checkAllTypesAvailable(currentTModel);  // TODO: remove
-    loc currentModuleScope = moduleLocs[moduleName];
+    MODID currentModuleScope = moduleName2moduleId(moduleName);
     str functionName = "$UNKNOWN";
-    MuFunction function = muFunction("", "*unknown", avalue(), [], [], [], "", false, true, false, {}, {}, {}, currentModuleScope, [], (), muBlock([]));               
+    MuFunction function = muFunction("", |unknown:///|, avalue(), [], [], [], |global-scopeInfo:///|, false, true, false, {}, {}, {}, currentModuleScope, [], (), muBlock([]));               
     
     
-    map[loc,set[MuExp]] fun2externals = (fun.src : fun.externalRefs | fun <- range(muFunctions), fun.scopeIn != "");
-    map[loc,MuFunction] muFunctionsByLoc = (f.src : f | fname <- muFunctions, f := muFunctions[fname]);
+    map[loc,set[MuExp]] fun2externals = (fun.src : fun.externalRefs | fun <- range(muFunctions), !isGlobalScope(fun.scopeIn));
+    // map[loc,MuFunction] muFunctionsByLoc = (f.src : f | fname <- muFunctions, f := muFunctions[fname]);
     
     allPaths = { *(tmodels[mname].paths) | mname <- tmodels};
     
@@ -173,7 +172,7 @@ JGenie makeJGenie(MuModule m,
         
     void _setFunction(MuFunction fun){
         function = fun;
-        functionName = fun.uniqueName;
+        functionName = fun.funId.path;
     }
     
     MuFunction _getFunction()
@@ -266,8 +265,8 @@ JGenie makeJGenie(MuModule m,
                         return baseName;
                     } else if(_isContainedIn(def.defined, currentModuleScope)){
                         if(def.scope != currentModuleScope){    // inner function
-                            fun = muFunctionsByLoc[def.defined];
-                            return isEmpty(fun.scopeIn) ? baseName : "<fun.scopeIn>_<baseName>";
+                            fun = muFunctions[def.defined];
+                            return isGlobalScope(fun.scopeIn) ? baseName : "<fun.scopeIn>_<baseName>";
                         }
                         return baseName;
                     } else {
@@ -317,7 +316,7 @@ JGenie makeJGenie(MuModule m,
         scopeIn = definedInInnerScope(srcs);
         jname = asJavaName(name);
         
-        if(scopeIn != ""){
+        if(!isGlobalScope(scopeIn)){
             return "<scopeIn>_<jname>";
         }
         
@@ -332,17 +331,17 @@ JGenie makeJGenie(MuModule m,
        return jname;
     }
     
-    str definedInInnerScope(list[loc] srcs){
-        scopeIn = "";
+    loc definedInInnerScope(list[loc] srcs){
+        scopeIn = |global-scope:///|;
         for(d <- srcs){
             if(_isContainedIn(d, currentModuleScope)){
-                if(muFunctionsByLoc[d]?){
-                    fun = muFunctionsByLoc[d];
-                    if(fun.scopeIn == "") return "";
+                if(muFunctions[d]?){
+                    fun = muFunctions[d];
+                    if(isGlobalScope(fun.scopeIn)) return fun.scopeIn;
                     scopeIn = fun.scopeIn;
                 }
             } else {
-                return "";
+                return |global-scope:///|;
             }
         }
         return scopeIn;
@@ -360,7 +359,7 @@ JGenie makeJGenie(MuModule m,
     
     list[MuExp] _getExternalRefs(loc src){
         if(fun2externals[src]?){
-            fun = muFunctionsByLoc[src];
+            fun = muFunctions[src];
             evars = _isContainedIn(src, currentModuleScope) ? fun2externals[src] : {};
             return sort([var | var <- evars, var.pos >= 0, var notin fun.formals, !isVarDeclaredInFun(var, fun) ]);
         }
@@ -379,11 +378,11 @@ JGenie makeJGenie(MuModule m,
         if(isSyntheticFunctionName(fun.name)) return []; // closures, function compositions ...
         Scopes scopes = currentTModel.scopes;
         kwFormals = fun.ftype.kwFormals;
-        outer = scopes[fun.src];
-        while (muFunctionsByLoc[outer]?){
-            fun1 = muFunctionsByLoc[outer];
+        outer = scopes[fun.funId];
+        while (muFunctions[outer]?){
+            fun1 = muFunctions[outer];
             kwFormals += fun1.ftype.kwFormals;
-            outer = scopes[fun1.src];
+            outer = scopes[fun1.funId];
         }
         return kwFormals;
     }
@@ -393,11 +392,11 @@ JGenie makeJGenie(MuModule m,
         scopes = currentTModel.scopes;
         defaults = fun.kwpDefaults;
         funKwps =  fun.kwpDefaults<0>;
-        outer = scopes[fun.src];
-        while (muFunctionsByLoc[outer]?){
-            fun1 = muFunctionsByLoc[outer];
+        outer = scopes[fun.funId];
+        while (muFunctions[outer]?){
+            fun1 = muFunctions[outer];
             defaults = [<name, atype, defaultExp> | <str name, AType atype, MuExp defaultExp> <- fun1.kwpDefaults, name notin funKwps] + defaults; // remove outer definitions
-            outer = scopes[fun1.src];
+            outer = scopes[fun1.funId];
         }
         return defaults;
     }
@@ -407,12 +406,12 @@ JGenie makeJGenie(MuModule m,
         scopes = currentTModel.scopes;
         funKwps = fun.kwpDefaults<0>;
         redeclared = [];
-        outer = scopes[fun.src];
-        while (muFunctionsByLoc[outer]?){
-            fun1 = muFunctionsByLoc[outer];
+        outer = scopes[fun.funId];
+        while (muFunctions[outer]?){
+            fun1 = muFunctions[outer];
             outerKwps = fun1.kwpDefaults<0>;
             redeclared += funKwps & outerKwps;
-            outer = scopes[fun1.src];
+            outer = scopes[fun1.funId];
         }
         return redeclared;
     }
@@ -422,12 +421,12 @@ JGenie makeJGenie(MuModule m,
         scopes = currentTModel.scopes;
         funKwps = fun.kwpDefaults<0>;
         declared = funKwps;
-        outer = scopes[fun.src];
-        while (muFunctionsByLoc[outer]?){
-            fun1 = muFunctionsByLoc[outer];
+        outer = scopes[fun.funId];
+        while (muFunctions[outer]?){
+            fun1 = muFunctions[outer];
             outerKwps = fun1.kwpDefaults<0>;
             declared += outerKwps;
-            outer = scopes[fun1.src];
+            outer = scopes[fun1.funId];
         }
         return declared;
     }
@@ -711,7 +710,7 @@ JGenie makeJGenie(MuModule m,
         return (varIn(var1, function.externalRefs) || varIn(var1, localRefs));
     }
     
-    bool _varHasLocalScope(MuExp var) = var.pos >= 0 && var.fuid == function.uniqueName;
+    bool _varHasLocalScope(MuExp var) = var.pos >= 0 && var.fuid == function.funId;
     bool _varHasGlobalScope(MuExp var) = var.pos < 0;
     
     str _newTmp(str prefix){
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Resolvers.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Resolvers.rsc
index d6d1f6b79c4..f90e7a9612b 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Resolvers.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Resolvers.rsc
@@ -52,7 +52,7 @@ alias Name_Arity = tuple[str name, int arity];
 
 // Get all functions and constructors from a given tmodel
 
-rel[Name_Arity, Define] getFunctionsAndConstructors(TModel tmodel, set[loc] module_and_extend_scopes, PathConfig pcfg, JGenie jg){
+rel[Name_Arity, Define] getFunctionsAndConstructors(TModel tmodel, set[MODID] module_and_extend_scopes, PathConfig pcfg, JGenie jg){
      if(!tmodel.moduleLocs[tmodel.modelName]?){
         iprintln(tmodel);
         throw "getFunctionsAndConstructors";
@@ -80,7 +80,7 @@ rel[Name_Arity, Define] getFunctionsAndConstructors(TModel tmodel, set[loc] modu
      return overloads_used_in_module + overloads_created_in_module;
 }
 
-str varName(muVar(str name, str _fuid, int pos, AType _, IdRole idRole)){ // duplicate, see CodeGen
+str varName(muVar(str name, loc _fuid, int pos, AType _, IdRole idRole)){ // duplicate, see CodeGen
 
     result = asJavaName(name);
     if(name[0] == "$") return result;
@@ -148,11 +148,12 @@ public set[set[Define]] mygroup(set[Define] input, bool (Define a, Define b) sim
 
 // Generate all resolvers for a given module
 
-str generateResolvers(str moduleName, map[loc, MuFunction] loc2muFunction, set[str] imports, set[str] extends, map[str,TModel] tmodels, map[str,loc] module2loc, PathConfig pcfg, JGenie jg){
-    module_scope = module2loc[moduleName];
+str generateResolvers(str moduleName, map[FUNID, MuFunction] loc2muFunction, set[str] imports, set[str] extends, map[str,TModel] tmodels, map[str,loc] module2loc, PathConfig pcfg, JGenie jg){
+    //module_scope = module2loc[moduleName];
+    module_scope = moduleName2moduleId(moduleName);
 
     loc2module = invertUnique(module2loc);
-    module_scopes = domain(loc2module);
+    module_scopes = range(module2loc);
     extend_scopes = { module2loc[ext] | ext <- extends, ext in module2loc};
     import_scopes = { module2loc[imp] | imp <- imports, imp in module2loc };
 
@@ -207,7 +208,7 @@ list[MuExp] getExternalRefs(set[Define] relevant_fun_defs, map[loc, MuFunction]
    return sort({ *getExternalRefs(fun_def, loc2muFunction) | fun_def <- relevant_fun_defs });
 }
 
-tuple[bool,loc] findImplementingModule(set[Define] fun_defs, set[loc] import_scopes, set[loc] extend_scopes, JGenie jg){
+tuple[bool,loc] findImplementingModule(set[Define] fun_defs, set[MODID] import_scopes, set[MODID] extend_scopes, JGenie jg){
     for(s <- import_scopes + extend_scopes){
         if(all(fd <- fun_defs, jg.isContainedIn(fd.defined, s))){
             return <true, s>;
@@ -377,23 +378,12 @@ str generateResolver(str moduleName, str functionName, set[Define] fun_defs, map
     map[int, lrel[str,str]] overload_table = ();
     lrel[str,str] defaults_and_constructors = [];
 
-    physical2logical = invertUnique(tm.logical2physical);
-
     // Handle a function or constructor defintion
 
     void handleDef(Define def){
         inner_scope = "";
-        uniqueName = "<inner_scope><asJavaName(def.id, completeId=false)>";
-        if(physical2logical[def.defined]?){
-          ph = physical2logical[def.defined];
-          path = ph.path;
-          if(path[0] == "/"){
-            path = path[1..];
-          }
-
-          name = replaceAll(path, "/", "_");
-          uniqueName = "<inner_scope><asJavaName(name, completeId=false)>";
-        }
+        uniqueName = def.idRole == functionId() ? asJavaName(def.defined)
+                                                : "<inner_scope><asJavaName(def.id, completeId=false)>";
         def_type = def.defInfo.atype;
 
         conds = [];
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Tests.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Tests.rsc
index d1211b2c3fe..2a6131a87fd 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Tests.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/Tests.rsc
@@ -99,8 +99,9 @@ str generateTestMethod(MuFunction f, str _className, JGenie jg){
    
     if("test" notin f.modifiers) return "";
     
-    test_name = asJavaName(f.uniqueName);
-    test_name_uniq = "<test_name>_<f.src.begin.line>";
+    test_name = asJavaName(f.name);
+    test_name_uniq = asJavaName(f.funId);
+    // test_name_uniq = "<test_name>_<f.src.begin.line>";
     formals = f.ftype.formals;
     expected = f.tags["expected"] ? "";
    
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/util/Names.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/util/Names.rsc
index 07de47545a2..bca7e05f0f6 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/util/Names.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/util/Names.rsc
@@ -30,6 +30,7 @@ import String;
 import List;
 import util::Reflective;
 import lang::rascalcore::CompilerPathConfig;
+import lang::rascalcore::check::LogicalLocations;
 
 public /*const*/ str compiled_rascal_package = "org.rascalmpl"; //"rascal";
 public /*const*/ str compiled_rascal_package_as_path = "org/rascalmpl"; //"rascal";
@@ -196,10 +197,19 @@ str asJavaName(str fname, bool completeId = true){
     return res == "_" ? "$_" : res; //single _ not allowed since Java9
 }
 
+str asJavaName(FUNID fuid, bool completeId = true){
+    return asJavaName(split("/", fuid.path)[-1]);
+}
+
 str module2class(str qname){
     return asBaseClassName(qname); //replaceAll(qname, "::", ".");
 }
 
+str module2field(MODID mid){
+    qname = replaceAll(mid.path, "/", "::");
+    return "M_" + replaceAll(normalizeQNameAndEscapeKeywords(qname), ".", "_");
+}
+
 str module2field(str qname){
     return "M_" + replaceAll(normalizeQNameAndEscapeKeywords(qname), ".", "_");
 }

From cd7e91d97bd55c7dcf55b3106cbe7ebf8441e23c Mon Sep 17 00:00:00 2001
From: paulklint <Paul.Klint@cwi.nl>
Date: Tue, 9 Jun 2026 13:25:56 +0200
Subject: [PATCH 2/3] Progress

---
 .../lang/rascalcore/compile/Examples/A.rsc         | 14 +++++++++++---
 .../rascalcore/compile/muRascal2Java/CodeGen.rsc   |  2 +-
 .../rascalcore/compile/muRascal2Java/JGenie.rsc    |  2 +-
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
index 792ba0b42cb..83aab1b6ad9 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
@@ -25,11 +25,19 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
 module  lang::rascalcore::compile::Examples::A
-              
 
+data Symbol 
+    = \sort(str name) 
+    | \adt(str name, list[Symbol] parameters)
+    ;
+bool subtype(Symbol::\sort(_), Symbol::\adt("Tree", _)) = true;
+
+
+// import List;
+
+// @javaClass{org.rascalmpl.library.Prelude}
+// public java map[&K, set[&V]] index(lrel[&K, &V] R);
 
-@javaClass{org.rascalmpl.library.Prelude}
-public java bool isEmpty(set[&T] st);
 
 
 // list[&T] sort(list[&T] lst) =
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
index 4e952581c48..92a948b8f34 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
@@ -512,7 +512,7 @@ tuple[str constantKwpDefaults, str constantKwpDefaultsInit, JCode jcode] trans(M
 }
 
 JCode call(MuFunction fun, list[str] actuals, JGenie _jg){
-    return "<asJaveName(fun.funId)>(<intercalate(", ", actuals)>)";
+    return "<asJavaName(fun.funId)>(<intercalate(", ", actuals)>)";
 }
 
 JCode trans(muComment(str text), JGenie jg)
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
index 7b1466f8110..36905e4e1f2 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
@@ -127,7 +127,7 @@ JGenie makeJGenie(MuModule m,
     MuFunction function = muFunction("", |unknown:///|, avalue(), [], [], [], |global-scopeInfo:///|, false, true, false, {}, {}, {}, currentModuleScope, [], (), muBlock([]));               
     
     
-    map[loc,set[MuExp]] fun2externals = (fun.src : fun.externalRefs | fun <- range(muFunctions), !isGlobalScope(fun.scopeIn));
+    map[FUNID,set[MuExp]] fun2externals = (fun.funId : fun.externalRefs | fun <- range(muFunctions), !isGlobalScope(fun.scopeIn));
     // map[loc,MuFunction] muFunctionsByLoc = (f.src : f | fname <- muFunctions, f := muFunctions[fname]);
     
     allPaths = { *(tmodels[mname].paths) | mname <- tmodels};

From d26830a1fcb5984613e6e87123819cefd73e714b Mon Sep 17 00:00:00 2001
From: paulklint <Paul.Klint@cwi.nl>
Date: Wed, 10 Jun 2026 13:23:25 +0200
Subject: [PATCH 3/3] Minor changes

---
 .../rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc   | 2 +-
 .../compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc  | 2 +-
 .../compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
index 83aab1b6ad9..04c52f957c9 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/A.rsc
@@ -25,7 +25,7 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 }
 module  lang::rascalcore::compile::Examples::A
-
+   
 data Symbol 
     = \sort(str name) 
     | \adt(str name, list[Symbol] parameters)
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
index 92a948b8f34..813f0fcb3a6 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/CodeGen.rsc
@@ -720,7 +720,7 @@ JCode trans(var:muVar(str name, loc fuid, int pos, AType atype, IdRole idRole),
     //println("muVar: fuid=<fuid>, functionName: <jg.getFunctionName()>, moduleName: <jg.getModuleName()>");
     return jg.isRef(var) ? "<varName(var, jg)>.getValue()" 
                          : ( pos >= 0 ? varName(var, jg)
-                                      : "<fuid == jg.getFunction().funId ? |global-scope:///| : (fuid == jg.getModuleLoc()) ? "" : "<module2field(fuid)>."><varName(var, jg)>"
+                                      : "<fuid == jg.getFunction().funId ? "" : (fuid == jg.getModuleLoc()) ? "" : "<module2field(fuid)>."><varName(var, jg)>"
                          );
 }
 
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
index 36905e4e1f2..206af84140d 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/muRascal2Java/JGenie.rsc
@@ -241,7 +241,7 @@ JGenie makeJGenie(MuModule m,
         //        return res;
         //    }
         //}
-        //println("getTypeAccessor(<t>) =\> \"\"");
+        if(b)println("getTypeAccessor(<t>) =\> \"\"");
         return ""; //throw "No accessor found for <t>";
     }