diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/check/AType.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/check/AType.rsc
index 860229ac..4f3b1380 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/check/AType.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/check/AType.rsc
@@ -2,10 +2,9 @@
 module lang::rascalcore::check::AType
 
 /*
-    Every needed to operate on ATypes, including asubtype, alub, 
+    Every needed to operate on ATypes, including asubtype, alub,
 */
 
-
 extend lang::rascalcore::check::ATypeBase;
 extend lang::rascalcore::grammar::definition::Characters;
 
@@ -18,23 +17,23 @@ import Set;
 @doc{
 .Synopsis
 Subtype on types.
-}       
+}
 //bool asubtype(type[&T] t, type[&U] u) { throw "asubtype not yet implemented on <t> and <u>"; } //asubtype(t.symbol, u.symbol);
 
 @doc{
 .Synopsis
-This function documents and implements the subtype relation of Rascal's type system. 
+This function documents and implements the subtype relation of Rascal's type system.
 }
 
-bool asubtype(tvar(s), AType r) { 
-    throw TypeUnavailable(); 
+bool asubtype(tvar(s), AType r) {
+    throw TypeUnavailable();
 }
 default bool asubtype(AType l, AType r){
     switch(r){
-        case l:     
+        case l:
             return true;
         case tvar(_):
-            throw TypeUnavailable(); 
+            throw TypeUnavailable();
         case overloadedAType(overloads):
             //TODO: Alternative: return asubtype(l, (\avoid() | alub(it, tp) | <_, _, tp> <- overloads));
            return isEmpty(overloads) ? asubtype(l, avoid()) : any(<_, _, tp> <- overloads, asubtype(l, tp));
@@ -44,7 +43,7 @@ default bool asubtype(AType l, AType r){
             return l is aint || l is areal || l is arat || l is anum;
         case aalias(str _, list[AType] _, AType aliased):
             return asubtype(l, aliased);
-        case \start(AType t): 
+        case \start(AType t):
             return asubtype(l, t);
         case aprod(p):
             return asubtype(l, p.def);
@@ -73,15 +72,15 @@ default bool asubtype(AType l, AType r){
         case areified(AType t):
             return asubtype(l, t);
     }
-    if(l.alabel? || r.alabel?) 
-        return asubtype(unset(l, "alabel") , unset(r, "alabel")); 
-    else 
+    if(l.alabel? || r.alabel?)
+        return asubtype(unset(l, "alabel") , unset(r, "alabel"));
+    else
         return l == r;
 }
 
 bool asubtype(p1:aparameter(str n1, AType b1), AType r)
     = asubtypeParam(p1, r);
-    
+
 // From "Exploring Type Parameters:
 // aparameter, open
 bool asubtypeParam(p1:aparameter(str n1, AType b1, closed=false), AType r) {
@@ -89,23 +88,23 @@ bool asubtypeParam(p1:aparameter(str n1, AType b1, closed=false), AType r) {
      if(aparameter(str _, AType _, closed=false) := r){                 // [S1]
         res = true;
      } else if(aparameter(str _, AType b2, closed=true) := r){          // [S3]
-        res = asubtype(p1, b2); 
+        res = asubtype(p1, b2);
       } else {                                                          // [S5]
-        res = asubtype(b1, r);   
+        res = asubtype(b1, r);
      }
      //println("asubtype(<p1>, <r>) =\> <res>");
      return res;
- } 
-   
+ }
+
 // aparameter, closed
 bool asubtypeParam(p1:aparameter(str n1, AType b1, closed=true), AType r) {
     res = false;
     if(aparameter(str n2, AType _, closed=true) := r ){                  // [S2]
         res = n1 == n2;
     } else if(p2:aparameter(str _, AType _,closed=false) := r){// [S4]
-        res = asubtype(b1, p2);  
+        res = asubtype(b1, p2);
     } else {                                                              // [S7]
-        res = asubtype(b1, r);  
+        res = asubtype(b1, r);
     }
     //println("asubtype(<p1>, <r>) =\> <res>");
     return res;
@@ -117,7 +116,7 @@ bool asubtype(overloadedAType(overloads), AType r)
 
 bool asubtype(avoid(), AType _) = true;
 default bool asubtype(AType _, avalue()) = true;
- 
+
 bool asubtype(ac:acons(AType a, list[AType] ap, list[Keyword] _), AType b){
     switch(b){
         case acons(a,list[AType] bp, list[Keyword] _):
@@ -202,9 +201,9 @@ bool asubtype(i:\iter-seps(AType s, list[AType] seps), AType b){
             return true;
         case anode(_):
             return true;
-        case \iter-seps(AType t, list[AType] seps2): 
+        case \iter-seps(AType t, list[AType] seps2):
             return asubtype(s,t) && asubtypeList(removeLayout(seps), removeLayout(seps2));
-        case \iter(AType t): 
+        case \iter(AType t):
             return asubtype(s,t) && isEmpty(removeLayout(seps));
         case  \iter-star(AType t):
             return asubtype(s,t) && isEmpty(removeLayout(seps));
@@ -285,7 +284,7 @@ bool asubtype(alist(AType a), AType b){
     switch(b){
         case alist(AType t):
             return asubtype(a, t);
-        case alrel(AType t): 
+        case alrel(AType t):
             return asubtype(a, atuple(t));
         case avalue():
             return true;
@@ -311,7 +310,7 @@ bool asubtype(aset(AType a),  AType b){
     switch(b){
         case aset(AType t):
             return asubtype(a, t);
-        case arel(AType t): 
+        case arel(AType t):
             return asubtype(a, atuple(t));
         case avalue():
             return true;
@@ -321,7 +320,7 @@ bool asubtype(aset(AType a),  AType b){
 
 bool asubtype(arel(AType a), AType b){
     switch(b){
-        case arel(AType t): 
+        case arel(AType t):
             return  asubtype(a,t);
         case aset(AType t):
             return asubtype(atuple(a), t);
@@ -331,9 +330,9 @@ bool asubtype(arel(AType a), AType b){
     fail;
 }
 
-bool asubtype(abag(AType s), abag(AType t)) = asubtype(s, t);  
+bool asubtype(abag(AType s), abag(AType t)) = asubtype(s, t);
 
-bool asubtype(amap(AType from1, AType to1), amap(AType from2, AType to2)) 
+bool asubtype(amap(AType from1, AType to1), amap(AType from2, AType to2))
     = asubtype(from1, from2) && asubtype(to1, to2);
 
 bool asubtype(AType l:afunc(AType a, list[AType] ap, list[Keyword] _), AType r){
@@ -356,7 +355,7 @@ bool asubtype(AType l:afunc(AType a, list[AType] ap, list[Keyword] _), AType r){
 // areified
 bool asubtype(areified(AType s), AType b){
     switch(b){
-        case areified(AType t): 
+        case areified(AType t):
             return asubtype(s,t);
         case anode(_):
             return true;
@@ -370,7 +369,7 @@ bool asubtype(a:anode(list[AType] l), AType b){
     switch(b){
         case anode(_):
             return true;
-        case anode(list[AType] r): 
+        case anode(list[AType] r):
             return l <= r;
         case \start(t):
             return asubtype(a, t);
@@ -395,7 +394,7 @@ bool asubtype(l:\achar-class(_), AType r){
             return true;
         }
         case aadt("Tree", _, _):
-            return true; // characters are Tree instances 
+            return true; // characters are Tree instances
         case \start(t):
             return asubtype(l, t);
         case avalue():
@@ -477,14 +476,14 @@ bool outerComparable1(f1:afunc(AType r1, list[AType] p1, list[Keyword] _), f2:af
     = outerComparable(r1, r2) && (f1.varArgs ? (f2.varArgs ? outerComparable(p1, p2)
                                                            : outerComparable(p1[0..-1], p2))
                                              : (f2.varArgs ? outerComparable(p1, p2[0..-1])
-                                                           : outerComparable(p1, p2)));              
-    
+                                                           : outerComparable(p1, p2)));
+
 bool outerComparable1(afunc(AType r1, list[AType] p1, list[Keyword] _), acons(AType r2, list[AType] p2, list[Keyword] _))
     = outerComparable(r1, r2) && outerComparable(p1, p2);
 bool outerComparable1(acons(AType r1, list[AType] p1, list[Keyword] _), afunc(AType r2, list[AType] p2, list[Keyword] _))
     = outerComparable(r1, r2) && outerComparable(p1, p2);
 
-bool outerComparable1(aparameter(str pname1, AType bound1), aparameter(str pname2, AType bound2)) 
+bool outerComparable1(aparameter(str pname1, AType bound1), aparameter(str pname2, AType bound2))
     = outerComparable(bound1, bound2);
 
 bool outerComparable1(aadt(str adtName1, list[AType] parameters1, SyntaxRole syntaxRole1),  areified(_)) = true;
@@ -507,7 +506,7 @@ bool equivalent(AType s, AType t) = asubtype(s,t) && asubtype(t,s);
 
 @doc{
 .Synopsis
-Structural equality between values. 
+Structural equality between values.
 
 .Description
 The difference is that no implicit coercions are done between values of incomparable types, such as == does for
@@ -534,13 +533,13 @@ public java bool eq(value x, value y);
 The least-upperbound (lub) between two types.
 
 .Description
-This function documents and implements the lub operation in Rascal's type system. 
+This function documents and implements the lub operation in Rascal's type system.
 }
-AType alub(tvar(s), AType r) { 
-    throw TypeUnavailable(); 
-} 
-AType alub(AType l, tvar(s)) { 
-     throw TypeUnavailable(); 
+AType alub(tvar(s), AType r) {
+    throw TypeUnavailable();
+}
+AType alub(AType l, tvar(s)) {
+     throw TypeUnavailable();
 }
 
 AType alub(AType s, s) = s;
@@ -558,7 +557,7 @@ AType alub(overloadedAType(overloads), AType t2)
 AType alub(AType t1, overloadedAType(overloads))
     //TODO: Alternative: = alub(t1, (\avoid() | alub(it, tp) | <_, _, tp> <- overloads));
     = isEmpty(overloads) ? t1 : alub(t1, (avalue() | aglb(it, tp)  | <_, _, tp> <- overloads));
-    
+
 AType alub(avalue(), AType t) = avalue();
 AType alub(AType s, avalue()) = avalue();
 AType alub(avoid(), AType t)  = t;
@@ -576,37 +575,37 @@ AType alub(anum(), aint())    = anum();
 AType alub(anum(), areal())   = anum();
 AType alub(anum(), arat())    = anum();
 
-AType alub(aset(AType s), aset(AType t)) = aset(alub(s, t)); 
- 
-AType alub(aset(AType s), arel(AType t)) = aset(alub(s,atuple(t)));  
+AType alub(aset(AType s), aset(AType t)) = aset(alub(s, t));
+
+AType alub(aset(AType s), arel(AType t)) = aset(alub(s,atuple(t)));
 AType alub(arel(AType s), aset(AType t)) = aset(alub(atuple(s), t));
 
 AType alub(arel(atypeList(list[AType] l)), arel(atypeList(list[AType] r)))  = size(l) == size(r) ? arel(atypeList(alubList(l, r))) : aset(avalue());
 
-AType alub(alist(AType s), alist(AType t)) = alist(alub(s, t));  
-AType alub(alist(AType s), alrel(AType t)) = alist(alub(s,atuple(t)));  
+AType alub(alist(AType s), alist(AType t)) = alist(alub(s, t));
+AType alub(alist(AType s), alrel(AType t)) = alist(alub(s,atuple(t)));
 AType alub(alrel(AType s), alist(AType t)) = alist(alub(atuple(s),t));
 
 AType alub(alrel(atypeList(list[AType] l)), alrel(atypeList(list[AType] r)))  = size(l) == size(r) ? alrel(atypeList(alubList(l, r))) : alist(avalue());
 
 AType alub(atuple(atypeList(list[AType] l)), atuple(atypeList(list[AType] r))) = size(l) == size(r) ? atuple(atypeList(alubList(l, r))) : avalue();
 
-AType alub(amap(ld, lr), amap(rd, rr)) = amap(alub(ld, rd), alub(lr, rr));  
+AType alub(amap(ld, lr), amap(rd, rr)) = amap(alub(ld, rd), alub(lr, rr));
 
 AType alub(abag(AType s), abag(AType t)) = abag(alub(s, t));
 
 AType alub(aadt(str n, list[AType] _, SyntaxRole_), anode(_))  = anode([]);
 AType alub(anode(_), aadt(str n, list[AType] _, SyntaxRole _)) = anode([]);
 
-AType alub(a1:aadt(str n, list[AType] lp, SyntaxRole lsr), a2:aadt(n, list[AType] rp, SyntaxRole rsr)) 
+AType alub(a1:aadt(str n, list[AType] lp, SyntaxRole lsr), a2:aadt(n, list[AType] rp, SyntaxRole rsr))
                                                 = addADTLabel(a1, a2, aadt(n, alubList(lp,rp), sr))
                                                   when size(lp) == size(rp) && getTypeParamNames(lp) == getTypeParamNames(rp) && size(getTypeParamNames(lp)) > 0 &&
                                                        sr := overloadSyntaxRole({lsr, rsr}) && sr != illegalSyntax();
-                                                                         
-AType alub(a1:aadt(str n, list[AType] lp, SyntaxRole lsr), a2:aadt(n, list[AType] rp, SyntaxRole rsr)) 
+
+AType alub(a1:aadt(str n, list[AType] lp, SyntaxRole lsr), a2:aadt(n, list[AType] rp, SyntaxRole rsr))
                                                 = addADTLabel(a1, a2, aadt(n, alubList(lp,rp), sr))
                                                   when size(lp) == size(rp) && size(getTypeParamNames(lp)) == 0 && sr := overloadSyntaxRole({lsr, rsr}) && sr != illegalSyntax();
-                                                                         
+
 AType alub(aadt(str n, list[AType] lp, SyntaxRole _), aadt(str m, list[AType] rp,SyntaxRole _)) = anode([]) when n != m;
 AType alub(a1: aadt(str ln, list[AType] lp,SyntaxRole  _), acons(AType b, _, _)) = alub(a1,b);
 
@@ -647,7 +646,7 @@ AType alub(AType l, aalias(str _, list[AType] _, AType aliased)) = alub(l, alias
 
 // From "Exploring Type Parameters (adapted to keep aparameter as long as possible)
 AType alub(p1:aparameter(n1, b1,closed=false), aparameter(n2, b2,closed=false)) = n1 == n2 && b1 == gl ? p1 : gl when gl := aglb(b1, b2);
-AType alub(p:aparameter(n1, b1,closed=true), aparameter(n2, b2, closed=true)) = n1 == n2 ? aparameter(n1, aglb(b1, b2),closed=true) 
+AType alub(p:aparameter(n1, b1,closed=true), aparameter(n2, b2, closed=true)) = n1 == n2 ? aparameter(n1, aglb(b1, b2),closed=true)
                                                               : lb == b1 ? p : lb when lb := alub(b1, b2);
 
 AType alub(p1:aparameter(n1, b1,closed=false), p2:aparameter(n2, b2,closed=true)) = n1 == n2 && lb == b1 ? p1 : lb when lb := alub(b1, p2);
@@ -699,8 +698,8 @@ AType alub(afunc(AType lr, list[AType] lp, list[Keyword] lkw), afunc(AType rr, l
         return avalue();
 }
 
-public list[AType] alubList(list[AType] l, list[AType] r) = [alub(l[idx],r[idx]) | idx <- index(l)] when size(l) == size(r); 
-default list[AType] alubList(list[AType] l, list[AType] r) = [avalue()]; 
+public list[AType] alubList(list[AType] l, list[AType] r) = [alub(l[idx],r[idx]) | idx <- index(l)] when size(l) == size(r);
+default list[AType] alubList(list[AType] l, list[AType] r) = [avalue()];
 
 private list[str] getTypeParamNames(list[AType] l) = [ s | li <- l, aparameter(s,_) := li];
 
@@ -719,13 +718,13 @@ public bool comparableOrNum(AType l, AType r) {
         case areal() => anum()
         case arat() => anum()
     };
-    
+
     rightAsNum = visit(r) {
         case aint() => anum()
         case areal() => anum()
         case arat() => anum()
     };
-    
+
     return comparable(l, r) || comparable(leftAsNum,rightAsNum);
 }
 
@@ -750,8 +749,8 @@ public AType aglb(anum(), arat())    = arat();
 public AType aglb(areal(), anum())   = areal();
 public AType aglb(anum(), areal())   = areal();
 
-public AType aglb(aset(AType s), aset(AType t)) = aset(aglb(s, t));  
-public AType aglb(aset(AType s), arel(AType t)) = aset(aglb(s,atuple(t)));  
+public AType aglb(aset(AType s), aset(AType t)) = aset(aglb(s, t));
+public AType aglb(aset(AType s), arel(AType t)) = aset(aglb(s,atuple(t)));
 public AType aglb(arel(AType s), aset(AType t)) = aset(aglb(atuple(s), t));
 
 AType aglb(arel(atypeList(list[AType] l)), arel(atypeList(list[AType] r)))  = size(l) == size(r) ? arel(atypeList(aglbList(l, r))) : aset(avalue());
@@ -763,9 +762,9 @@ AType aglb(overloadedAType(overloads), AType t2)
 AType aglb(AType t1, overloadedAType(overloads))
     //TODO: Alternative: = aglb(t1, (\avoid() | alub(it, tp) | <_, _, tp> <- overloads));
     = isEmpty(overloads) ? t1 : aglb(t1, (avoid() | alub(it, tp)  | <_, _, tp> <- overloads));
-    
-public AType aglb(alist(AType s), alist(AType t)) = alist(aglb(s, t));  
-public AType aglb(alist(AType s), alrel(AType t)) = alist(aglb(s,atuple(t)));  
+
+public AType aglb(alist(AType s), alist(AType t)) = alist(aglb(s, t));
+public AType aglb(alist(AType s), alrel(AType t)) = alist(aglb(s,atuple(t)));
 public AType aglb(alrel(AType s), alist(AType t)) = alist(aglb(atuple(s), t));
 
 AType aglb(alrel(atypeList(list[AType] l)), alrel(atypeList(list[AType] r))) = size(l) == size(r) ? alrel(atypeList(aglbList(l, r))) : alist(avalue());
@@ -779,16 +778,16 @@ public AType aglb(abag(AType s), abag(AType t)) = abag(aglb(s, t));
 public AType aglb(anode(list[AType] l), aadt(str _, list[AType] _, SyntaxRole _), SyntaxRole _) = anode(l);
 public AType aglb(aadt(str _, list[AType] _, SyntaxRole _), anode(list[AType] r)) = anode(r);
 
-AType aglb(a1:aadt(str n, list[AType] lp, SyntaxRole lsr), a2:aadt(n, list[AType] rp, SyntaxRole rsr)) 
+AType aglb(a1:aadt(str n, list[AType] lp, SyntaxRole lsr), a2:aadt(n, list[AType] rp, SyntaxRole rsr))
     = addADTLabel(a1, a2, aadt(n, aglbList(lp,rp), sr))
       when size(lp) == size(rp) && getTypeParamNames(lp) == getTypeParamNames(rp) && size(getTypeParamNames(lp)) > 0 &&
            sr := overloadSyntaxRole({lsr, rsr}) && sr != illegalSyntax();
-                                                                         
-AType aglb(a1:aadt(str n, list[AType] lp, SyntaxRole lsr), a2:aadt(n, list[AType] rp, SyntaxRole rsr)) 
+
+AType aglb(a1:aadt(str n, list[AType] lp, SyntaxRole lsr), a2:aadt(n, list[AType] rp, SyntaxRole rsr))
     = addADTLabel(a1, a2, aadt(n, aglbList(lp,rp), sr))
-      when size(lp) == size(rp) && size(getTypeParamNames(lp)) == 0 && 
+      when size(lp) == size(rp) && size(getTypeParamNames(lp)) == 0 &&
            sr := overloadSyntaxRole({lsr, rsr}) && sr != illegalSyntax();
-                                                                         
+
 AType aglb(aadt(str n, list[AType] lp, SyntaxRole _), aadt(str m, list[AType] rp,SyntaxRole _)) = anode([]) when n != m;
 AType aglb(a1: aadt(str ln, list[AType] lp,SyntaxRole  _), acons(AType b, _, _)) = aglb(a1,b);
 
@@ -826,5 +825,5 @@ public AType aglb(afunc(AType lr, list[AType] lp, list[Keyword] kwl), afunc(ATyp
         return avalue();
 }
 
-public list[AType] aglbList(list[AType] l, list[AType] r) = [aglb(l[idx],r[idx]) | idx <- index(l)] when size(l) == size(r); 
-public default list[AType] aglbList(list[AType] l, list[AType] r) = [avalue()]; 
+public list[AType] aglbList(list[AType] l, list[AType] r) = [aglb(l[idx],r[idx]) | idx <- index(l)] when size(l) == size(r);
+public default list[AType] aglbList(list[AType] l, list[AType] r) = [avalue()];
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/check/Checker.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/check/Checker.rsc
index f3475648..4e975e66 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/check/Checker.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/check/Checker.rsc
@@ -144,7 +144,8 @@ ModuleStatus rascalTModelForLocs(
         ms = getImportAndExtendGraph(topModuleNames, compilerConfig);
 
         if(/error(_,_) := ms.messages){
-            return ms;
+
+            return clearTModelCache(ms);
         }
 
         if(compilerConfig.forceCompilationTopModule){
@@ -153,8 +154,8 @@ ModuleStatus rascalTModelForLocs(
             }
         }
 
-        imports_and_extends = ms.strPaths<0,2>;
 
+        imports_and_extends = ms.strPaths<0,2>;
         <components, sorted> = stronglyConnectedComponentsAndTopSort(imports_and_extends);
 
         map[str, set[str]] module2component = (m : c | c <- components, m <- c);
@@ -187,7 +188,7 @@ ModuleStatus rascalTModelForLocs(
             component = module2component[ordered[mi]];
             jobStep(jobName, intercalate(" + ", [*component]), work=size(component));
 
-            recheck = !all(m <- component, (tpl_uptodate() in ms.status[m] || checked() in ms.status[m]));
+            recheck = !all(m <- component, ms.status[m]?, (tpl_uptodate() in ms.status[m] || checked() in ms.status[m]));
             for(m <- component){
                 mi += 1;
                 if(!recheck){
@@ -199,7 +200,34 @@ ModuleStatus rascalTModelForLocs(
                     }
                }
             }
-            if(!all(m <- component, tpl_uptodate() in ms.status[m] || checked() in ms.status[m])){
+
+            compatible_with_all_imports = true;
+            for(m <- component){
+                m_compatible = false;
+                <found, tm, ms> = getTModelForModule(m, ms);
+                if(found){
+                    imports_extends_m = imports_and_extends[m];
+                    <m_compatible, ms> = importsAndExtendsAreBinaryCompatible(tm, imports_extends_m, ms);
+                    if(m_compatible){
+                        ms.status[m] += {tpl_uptodate(), checked()};
+                    }
+                }
+                compatible_with_all_imports = compatible_with_all_imports && m_compatible;
+            }
+
+            any_rsc_changed = any(m <- component, rsc_changed() in ms.status[m]);
+            all_tmodels_uptodate = true;
+            for(m <- component){
+                if(tpl_uptodate() notin ms.status[m] && checked() notin ms.status[m])
+                    all_tmodels_uptodate = false;
+            }
+            recheckCond = !compatible_with_all_imports || any_rsc_changed || !all_tmodels_uptodate;
+
+             if(recheckCond){
+                if(ms.compilerConfig.verbose){
+                    println("recheck <component>: compatible_with_all_imports: <compatible_with_all_imports>, any_rsc_changed: <any_rsc_changed>, all_tmodels_uptodate: <all_tmodels_uptodate>");
+                }
+
                 <tm, ms> = rascalTModelComponent(component, ms);
                 moduleScopes += getModuleScopes(tm);
                 map[str,TModel] tmodels_for_component = ();
@@ -218,6 +246,7 @@ ModuleStatus rascalTModelForLocs(
                         msgs = [];
                         <success, pt, ms> = getModuleParseTree(m, ms);
                         if(success){
+                            msgs += [info("Checked <m>", pt.header.name@\loc)];
                             check_imports:
                             for(imod <- pt.header.imports, imod has \module){
                                 iname = unescape("<imod.\module.name>");
@@ -228,10 +257,10 @@ ModuleStatus rascalTModelForLocs(
                                    if(iname == "ParseTree" && implicitlyUsesParseTree(ms.moduleLocs[m].path, tm)){
                                      continue check_imports;
                                    }
-                                   if(ms.moduleLocs[iname]? && implicitlyUsesLayoutOrLexical(ms.moduleLocs[m].path, ms.moduleLocs[iname].path, tm)){
+                                   if(ms.moduleLocs[iname]? && ms.moduleLocs[m]? && implicitlyUsesLayoutOrLexical(ms.moduleLocs[m].path, ms.moduleLocs[iname].path, tm)){
                                     continue check_imports;
                                    }
-                                   if(ms.moduleLocs[iname]? && usesOrExtendsADT(ms.moduleLocs[m].path, ms.moduleLocs[iname].path, tm)){
+                                   if(ms.moduleLocs[iname]? && ms.moduleLocs[m]? && usesOrExtendsADT(ms.moduleLocs[m].path, ms.moduleLocs[iname].path, tm)){
                                     continue check_imports;
                                    }
                                    if(checked() in ms.status[iname] && rsc_not_found() notin ms.status[iname]){
@@ -271,6 +300,16 @@ ModuleStatus rascalTModelForLocs(
                     }
                 }
                 ms = doSaveModule(component, m_imports, m_extends, ms, moduleScopes, transient_tms, compilerConfig);
+                for(m <- component){
+                    ms.status[m] -= {rsc_changed()};
+                    ms.status[m] += {tpl_uptodate()};
+                }
+            } else {
+                 for(m <- component){
+                    imports =  { imp | <m1, importPath(), imp> <- ms.strPaths, m1 == m };
+                    extends = { ext | <m1, extendPath(), ext > <- ms.strPaths, m1 == m };
+                    updateBOM(m, imports, extends, ms);
+                 }
             }
         }
     } catch ParseError(loc src): {
@@ -292,7 +331,7 @@ ModuleStatus rascalTModelForLocs(
     }
 
     jobEnd(jobName);
-    return ms;
+    return clearTModelCache(ms);
 }
 
 bool implicitlyUsesParseTree(str modulePath, TModel tm){
@@ -440,9 +479,21 @@ list[ModuleMessages] checkAll(loc root, RascalCompilerConfig compilerConfig){
 
 // ---- Convenience check function during development -------------------------
 
+void find(str s, ModuleStatus ms){
+    if(ms.moduleLocs[s]?) println("moduleLocs[<s>] = <ms.moduleLocs[s]>");
+    for(mname <- ms.tmodels){
+        tm = ms.tmodels[mname];
+        for(d <- tm.definitions){
+            def = tm.definitions[d];
+            if(contains("<def>", s)) {println("<mname>: <def>"); }
+        }
+    }
+}
+
 map[str, list[Message]] checkModules(list[str] moduleNames, RascalCompilerConfig compilerConfig) {
     ModuleStatus ms = rascalTModelForNames(moduleNames, compilerConfig, dummy_compile1);
     tmodels = ms.tmodels;
+    //find("Exception.rsc|(0,", ms);
     tmMsgs = (mname : tmodels[mname].messages | mname <- tmodels, !isEmpty(tmodels[mname].messages));
     return //(mname : tmodels[mname].messages | mname <- tmodels, !isEmpty(tmodels[mname].messages))
          (mname : ms.messages[mname] + (tmMsgs[mname] ? []) | mname <- ms.messages, !isEmpty(ms.messages[mname]));
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/check/CheckerCommon.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/check/CheckerCommon.rsc
index 82c585f3..9e0d37cc 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/check/CheckerCommon.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/check/CheckerCommon.rsc
@@ -43,6 +43,7 @@ void checkSupportedByParserGenerator(Tree t, Collector c){
 data MStatus =
       rsc_not_found()
     | tpl_not_found()
+    | rsc_changed()
     | parsed()
     | parse_error()
     | module_dependencies_extracted()
@@ -178,9 +179,21 @@ tuple[bool, Module, ModuleStatus] getModuleParseTree(str qualifiedModuleName, Mo
    }
 }
 
+/*
+ * We implement a caching mechanism for TModels with the following properties:
+ * - tmodelCacheSize tmodels are cached.
+ * - The most frequently uses modules are hardwired and are never removed.
+     They are determined by static analysis of the import/extend graph.
+ * - TModels on file (.tpl) physical locations have been replaced by logical locations where possible.
+ * - When a TModel is read in, physical locations are converted by logical logical locations
+ * - The policy is to keep TModels in the cache in this physical form as long as possible.
+ * - During its presence in the cache, the BOM of a TModel may get updated.
+ * - When a TModel has to be removed from the cache, it is converted back to the logical form and written back to file.
+ */
+
 set[str] hardwired = {};
 
-int tmodelCacheSize = 4; // should be > 0
+int tmodelCacheSize = 12; // should be > 0
 
 int maxHardwired = tmodelCacheSize/4;
 
@@ -202,25 +215,54 @@ void analyzeTModels(ModuleStatus ms){
     hardwired = toSet(domain(hardwire));
 }
 
+ModuleStatus clearTModelCache(ModuleStatus ms){
+    for(candidate <- ms.tmodelLIFO){
+        ms = removeOldestTModelFromCache(ms);
+    }
+    for(candidate <- hardwired){
+        ms = removeTModel(candidate, ms);
+    }
+    return ms;
+}
+
+ModuleStatus removeTModel(str candidate, ModuleStatus ms){
+    if(tpl_saved() notin ms.status[candidate]){
+        pcfg = ms.pathConfig;
+        if(ms.compilerConfig.verbose) println("Save <candidate> before removing from cache <ms.status[candidate]>");
+        tm = ms.tmodels[candidate];
+        <found, tplLoc> = getTPLWriteLoc(candidate, pcfg);
+        tm = convertTModel2LogicalLocs(tm, ms.tmodels);
+        ms.status[candidate] += tpl_saved();
+        try {
+            writeBinaryValueFile(tplLoc, tm);
+            if(traceTPL) println("Written <tplLoc>");
+        } catch value e: {
+            throw "Cannot write TPL file <tplLoc>, reason: <e>";
+        }
+    }
+    ms.tmodels = delete(ms.tmodels, candidate);
+    return ms;
+}
+
+ModuleStatus removeOldestTModelFromCache(ModuleStatus ms){
+    if(size(ms.tmodelLIFO) > 0){
+        candidate = ms.tmodelLIFO[-1];
+        ms = removeTModel(candidate, ms);
+        if(traceTModelCache) println("*** deleting tmodel <candidate>, tmodels: <size(ms.tmodels)>, lifo: <size(ms.tmodelLIFO)>");
+        ms.tmodelLIFO = ms.tmodelLIFO[..-1];
+    }
+    return ms;
+}
+
 ModuleStatus  addTModel (str qualifiedModuleName, TModel tm, ModuleStatus ms){
     if(traceTModelCache) println("addTModel: <qualifiedModuleName>");
     if(tmodelCacheSize > 0){
-        if(tpl_saved() notin ms.status[qualifiedModuleName]){
-            iprintln(ms.status);
-            throw "Cannot add module <qualifiedModuleName> with unsaved tpl";
-        }
         ms.tmodels[qualifiedModuleName] = tm;
         if(qualifiedModuleName notin hardwired){
             if(qualifiedModuleName notin ms.tmodelLIFO){
                 ms.tmodelLIFO = [qualifiedModuleName, *ms.tmodelLIFO];
                 while(size(ms.tmodels) >= tmodelCacheSize && size(ms.tmodelLIFO) > 0 && ms.tmodelLIFO[-1] != qualifiedModuleName){
-                    if(tpl_saved() notin ms.status[ms.tmodelLIFO[-1]]){
-                        iprintln(ms.status);
-                        throw "Cannot remove unsaved tpl <ms.tmodelLIFO[-1]>, <ms.status[ms.tmodelLIFO[-1]]>";
-                    }
-                    ms.tmodels = delete(ms.tmodels, ms.tmodelLIFO[-1]);
-                    if(traceTModelCache) println("*** deleting tmodel <ms.tmodelLIFO[-1]>, tmodels: <size(ms.tmodels)>, lifo: <size(ms.tmodelLIFO)>");
-                    ms.tmodelLIFO = ms.tmodelLIFO[..-1];
+                    ms = removeOldestTModelFromCache(ms);
                 }
             }
         }
@@ -231,16 +273,11 @@ ModuleStatus  addTModel (str qualifiedModuleName, TModel tm, ModuleStatus ms){
 tuple[bool, TModel, ModuleStatus] getTModelForModule(str qualifiedModuleName, ModuleStatus ms){
     if(traceTModelCache) println("getTModelForModule: <qualifiedModuleName>");
     pcfg = ms.pathConfig;
-    if(ms.tmodels[qualifiedModuleName]?){
-        if(tpl_saved() notin ms.status[qualifiedModuleName]){
-            throw "Unsaved tmodel for <qualifiedModuleName> in cache";
-        }
+    if(ms.tmodels[qualifiedModuleName]? /*&& tpl_uptodate() in ms.status[qualifiedModuleName]*/){
         return <true, ms.tmodels[qualifiedModuleName], ms>;
     }
     while(size(ms.tmodels) >= tmodelCacheSize && size(ms.tmodelLIFO) > 0 && ms.tmodelLIFO[-1] != qualifiedModuleName){
-        ms.tmodels = delete(ms.tmodels, ms.tmodelLIFO[-1]);
-        if(traceTModelCache) println("*** deleting tmodel <ms.tmodelLIFO[-1]>, tmodels: <size(ms.tmodels)>, lifo: <size(ms.tmodelLIFO)>");
-        ms.tmodelLIFO = ms.tmodelLIFO[..-1];
+        ms = removeOldestTModelFromCache(ms);
     }
 
     <found, tplLoc> = getTPLReadLoc(qualifiedModuleName, pcfg);
@@ -252,7 +289,7 @@ tuple[bool, TModel, ModuleStatus] getTModelForModule(str qualifiedModuleName, Mo
                 tpl = convertTModel2PhysicalLocs(tpl);
 
                 ms.tmodels[qualifiedModuleName] = tpl;
-                ms.status[qualifiedModuleName] += {tpl_uptodate(), tpl_saved()};
+                ms.status[qualifiedModuleName] ? {} += {tpl_uptodate(), tpl_saved()};
                 if(qualifiedModuleName notin hardwired){
                     ms.tmodelLIFO = [qualifiedModuleName, *ms.tmodelLIFO];
                 }
@@ -285,4 +322,4 @@ int nextClosure(){
 
 void resetClosureCounter(){
     closureCounter = 0;
-}
\ No newline at end of file
+}
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/check/CollectType.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/check/CollectType.rsc
index 1db9b133..317ad79d 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/check/CollectType.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/check/CollectType.rsc
@@ -99,8 +99,8 @@ void collect(current: (TypeArg) `<Type tp> <Name name>`, Collector c){
 }
 // ---- structured types ------------------------------------------------------
 
-@doc{Convert structured types, such as list<<int>>. Check here for certain syntactical 
-conditions, such as: all field names must be distinct in a given type; lists require 
+@doc{Convert structured types, such as list<<int>>. Check here for certain syntactical
+conditions, such as: all field names must be distinct in a given type; lists require
 exactly one type argument; etc.}
 
 public list[&T] dup(list[&T] lst) {
@@ -115,7 +115,7 @@ public list[&T] dup(list[&T] lst) {
 
 void collect(current:(Type)`list [ < {TypeArg ","}+ tas > ]`, Collector c){
    targs = [ta | ta <- tas];
-    
+
    collect(targs[0], c);
    try {
         dt = c.getType(targs[0]);
@@ -124,8 +124,8 @@ void collect(current:(Type)`list [ < {TypeArg ","}+ tas > ]`, Collector c){
         }
         c.fact(current, makeListType(dt));
    } catch TypeUnavailable():{
-        c.calculate("list type", current, targs, 
-            AType(Solver s){ 
+        c.calculate("list type", current, targs,
+            AType(Solver s){
                 dt = s.getType(targs[0]);
                 if (!isEmpty(dt.alabel)) {
                     s.report(warning(tas, "Element name `<dt.alabel>` ignored"));
@@ -143,7 +143,7 @@ void collect(current:(Type)`list [ < {TypeArg ","}+ tas > ]`, Collector c){
 void collect(current:(Type)`set [ < {TypeArg ","}+ tas > ]`, Collector c){
     targs = [ta | ta <- tas];
     collect(targs[0], c);
-  
+
     try {
         dt = c.getType(targs[0]);
         if (!isEmpty(dt.alabel)) {
@@ -151,13 +151,13 @@ void collect(current:(Type)`set [ < {TypeArg ","}+ tas > ]`, Collector c){
         }
         c.fact(current, makeSetType(dt));
     } catch TypeUnavailable():{
-        c.calculate("set type", current, targs, 
-            AType(Solver s){ 
+        c.calculate("set type", current, targs,
+            AType(Solver s){
                 dt = s.getType(targs[0]);
                 if (!isEmpty(dt.alabel)) {
                     s.report(warning(tas, "Element name `<dt.alabel>` ignored"));
                 }
-                return makeSetType(dt); 
+                return makeSetType(dt);
             });
     }
     if(size(targs) != 1){
@@ -169,7 +169,7 @@ void collect(current:(Type)`set [ < {TypeArg ","}+ tas > ]`, Collector c){
 
 void collect(current:(Type)`bag [ < {TypeArg ","}+ tas > ]`, Collector c){
     targs = [ta | ta <- tas];
-    collect(targs[0], c); 
+    collect(targs[0], c);
     try {
         c.fact(current, makeBagType(c.getType(targs[0])));
     } catch TypeUnavailable(): {
@@ -183,7 +183,7 @@ void collect(current:(Type)`bag [ < {TypeArg ","}+ tas > ]`, Collector c){
 // ---- map
 
 tuple[list[FailMessage] msgs, AType atype] handleMapFields({TypeArg ","}+ tas, AType dt, AType rt){
-    if (!isEmpty(dt.alabel) && !isEmpty(rt.alabel) && dt.alabel != rt.alabel) { 
+    if (!isEmpty(dt.alabel) && !isEmpty(rt.alabel) && dt.alabel != rt.alabel) {
         return <[], makeMapType(dt, rt)>;
     } else if (!isEmpty(dt.alabel) && !isEmpty(rt.alabel) && dt.alabel == rt.alabel) {
         return <[error(tas,"Non-well-formed map type, labels must be distinct")], makeMapType(unset(dt, "alabel"),unset(rt,"alabel"))>;
@@ -198,7 +198,7 @@ tuple[list[FailMessage] msgs, AType atype] handleMapFields({TypeArg ","}+ tas, A
 
 void collect(current:(Type)`map [ < {TypeArg ","}+ tas > ]`, Collector c){
     targs = [ta | ta <- tas];
-    
+
     if(size(targs) != 2){
         c.report(error(current, "Type `map` should have two type arguments"));
         c.fact(current, amap(avalue(), avalue()));
@@ -207,20 +207,20 @@ void collect(current:(Type)`map [ < {TypeArg ","}+ tas > ]`, Collector c){
     //c.push(currentAdt, <current, targs, c.getScope()>);
         collect(targs, c);
     //c.pop(currentAdt);
-   
+
     try {
         <msgs, result> = handleMapFields(tas, c.getType(targs[0]), c.getType(targs[1]));
         for(m <- msgs) c.report(m);
         c.fact(current, result);
     } catch TypeUnavailable(): {
-        c.calculate("map type", current, targs[0..2], 
+        c.calculate("map type", current, targs[0..2],
             AType(Solver s){
                 <msgs, result> = handleMapFields(tas, s.getType(targs[0]), s.getType(targs[1]));
                 for(m <- msgs) s.report(m);
-                return result;                    
+                return result;
         });
     }
-    
+
 }
 
 // ---- rel
@@ -249,7 +249,7 @@ void collect(current:(Type)`rel [ < {TypeArg ","}+ tas > ]`, Collector c){
         for(m <- msgs) c.report(m);
         c.fact(current, result);
     } catch TypeUnavailable(): {
-        c.calculate("rel type", current, targs, 
+        c.calculate("rel type", current, targs,
             AType(Solver s){
                  <msgs, result> = handleRelFields(tas,  [s.getType(ta) | ta <- targs]);
                  for(m <- msgs) s.report(m);
@@ -284,7 +284,7 @@ void collect(current:(Type)`lrel [ < {TypeArg ","}+ tas > ]`, Collector c){
         for(m <- msgs) c.report(m);
         c.fact(current, result);
     } catch TypeUnavailable(): {
-        c.calculate("lrel type", current, targs, 
+        c.calculate("lrel type", current, targs,
             AType(Solver s){
                  <msgs, result> = handleListRelFields(tas,  [s.getType(ta) | ta <- targs]);
                  for(m <- msgs) s.report(m);
@@ -313,82 +313,82 @@ tuple[list[FailMessage] msgs, AType atype] handleTupleFields({TypeArg ","}+ tas,
         return <msgs+[error(tas, "Non-well-formed tuple type, labels must be distinct")], makeTupleType([unset(tp, "alabel") | tp <- fieldTypes])>;
     } else if (size(distinctLabels) > 0) {
         return <msgs+[warning(tas, "Field name ignored, field names must be provided for all fields or for none")], makeTupleType([unset(tp, "alabel") | tp <- fieldTypes])>;
-    } 
-    return <[], avoid()>; 
+    }
+    return <[], avoid()>;
 }
 
 void collect(current:(Type)`tuple [ < {TypeArg ","}+ tas > ]`, Collector c){
     targs = [ta | ta <- tas];
-    collect(tas, c);  
+    collect(tas, c);
     try {
         <msgs, result> = handleTupleFields(tas, [c.getType(ta) | ta <- targs]);
         for(m <- msgs) c.report(m);
         c.fact(current, result);
     } catch TypeUnavailable():{
-        c.calculate("tuple type", current, targs, 
+        c.calculate("tuple type", current, targs,
             AType(Solver s){
                 <msgs, result> = handleTupleFields(tas, [s.getType(ta) | ta <- targs]);
                 for(m <- msgs) s.report(m);
                 return result;
             });
     }
-} 
+}
 
 // ---- type
 
-tuple[list[FailMessage] msgs, AType atype] handleTypeField({TypeArg ","}+ tas, AType fieldType){  
+tuple[list[FailMessage] msgs, AType atype] handleTypeField({TypeArg ","}+ tas, AType fieldType){
     if (!isEmpty(fieldType.alabel)) {
         return <[warning(tas, "Field name `<fieldType.alabel>` ignored")], areified(fieldType)>;
     } else {
         return <[], areified(fieldType)>;
-    } 
+    }
 }
 
 void collect(current:(Type)`type [ < {TypeArg ","}+ tas > ]`, Collector c){
     targs = [ta | ta <- tas];
     collect(targs[0], c);
-   
+
     try {
         <msgs, result> = handleTypeField(tas, c.getType(targs[0]));
         for(m <- msgs) c.report(m);
         c.fact(current, result);
     } catch TypeUnavailable(): {
-        c.calculate("type type", current, targs[0..1], 
+        c.calculate("type type", current, targs[0..1],
             AType(Solver s){
                 <msgs, result> = handleTypeField(tas,  s.getType(targs[0]));
                 for(m <- msgs) s.report(m);
                 return result;
              });
-    }  
+    }
     if(size(targs) != 1){
         c.report(error(current, "Non-well-formed type, type should have one type argument"));
     }
-}      
+}
 
 // ---- function type ---------------------------------------------------------
-    
-tuple[list[FailMessage] msgs, AType atype] handleFunctionType({TypeArg ","}* _, AType returnType, list[AType] argTypes){  
+
+tuple[list[FailMessage] msgs, AType atype] handleFunctionType({TypeArg ","}* _, AType returnType, list[AType] argTypes){
     return <[], afunc(returnType, argTypes, [])>;
 }
 
 @doc{Convert Rascal function types into their abstract representation.}
 void collect(current: (FunctionType) `<Type t> ( <{TypeArg ","}* tas> )`, Collector c) {
-    
+
     //println("collect: <current>");
     // return type, any type parameters should be closed
     beginUseTypeParameters(c, closed=true);
         collect(t, c);
     endUseTypeParameters(c);
-    
+
     targs = [ta | ta <- tas];
-   
+
     // When a function type occurs in a body, just use closed type parameters
     beginDefineOrReuseTypeParameters(c,closed=false);
         for(targ <- targs){
             collect(targ, c);
         }
     endDefineOrReuseTypeParameters(c);
-    
+
     c.calculate("function type", current, t + targs,
         AType(Solver s){
             <msgs, result> = handleFunctionType(tas, s.getType(t), [s.getType(ta) | ta <- targs]);
@@ -400,7 +400,7 @@ void collect(current: (FunctionType) `<Type t> ( <{TypeArg ","}* tas> )`, Collec
 
 // ---- user defined type -----------------------------------------------------
 
-tuple[list[FailMessage] msgs, AType atype] handleUserType(QualifiedName n, AType baseType){  
+tuple[list[FailMessage] msgs, AType atype] handleUserType(QualifiedName n, AType baseType){
     if(aadt(adtName, _, _) := baseType){
         nformals = size(baseType.parameters);
         if(nformals > 0) return <[error(n, "Expected %v type parameter(s) for %q, found 0", nformals, adtName)], baseType>;
@@ -426,13 +426,13 @@ void collect(current:(UserType) `<QualifiedName n>`, Collector c){
     } else {
         c.useQualified([qualifier, base], n, {dataId(), aliasId(), lexicalId(), nonterminalId(), keywordId(), layoutId()}, dataOrSyntaxRoles + {moduleId()});
     }
-    
+
     try {
         <msgs, result> = handleUserType(n,  c.getType(n));
         for(m <- msgs) c.report(m);
         c.fact(current, result);
-    } catch TypeUnavailable(): 
-    
+    } catch TypeUnavailable():
+
     c.calculate("type without parameters", current, [n],
         AType(Solver s){
             <msgs, result> = handleUserType(n, s.getType(n));
@@ -449,7 +449,7 @@ void collect(current:(UserType) `<QualifiedName n>[ <{Type ","}+ ts> ]`, Collect
         c.useQualified([qualifier, base], n, {dataId(), aliasId(), lexicalId(), nonterminalId(), keywordId(), layoutId()}, dataOrSyntaxRoles + {moduleId()});
     }
     actuals = [t | t <- ts];
-    
+
     c.calculate("parameterized type with parameters", current, n + actuals,
         AType(Solver s){
             nactuals = size(actuals);
@@ -462,7 +462,7 @@ void collect(current:(UserType) `<QualifiedName n>[ <{Type ","}+ ts> ]`, Collect
             } else if(aalias(aname, params, aliased) := baseType){
                 nformals = size(baseType.parameters);
                 if(nactuals != nformals) s.report(error(ts, "Expected %v type parameter(s) for %v, found %v", nformals, aname, nactuals));
-                
+
                 bindings = (params[i].pname : s.getType(actuals[i]) | i <- index(params));
                 return instantiateRascalTypeParameters(ts, aliased, bindings, s);
             }
@@ -492,7 +492,7 @@ str md5ContribSym(Nonterminal n) = "<n>";
 
 void collect(current:(Sym) `& <Nonterminal n>`, Collector c){
     pname = prettyPrintName("<n>");
-    
+
     if(<true, bool closed> := defineOrReuseTypeParameters(c)){
         if(c.isAlreadyDefined(pname, n)){
             c.use(n, {typeVarId() });
@@ -509,8 +509,8 @@ void collect(current:(Sym) `& <Nonterminal n>`, Collector c){
         //println("Use <pname> at <current@\loc>");
         c.fact(current, n);
         return;
-    }     
-   
+    }
+
     c.fact(current, aparameter(prettyPrintName("<n>"),treeType,closed=true));
 }
 
@@ -520,9 +520,9 @@ str md5ContribSym((Sym) `& <Nonterminal n>`)
 void collect(current:(Sym) `<Nonterminal n>[ <{Sym ","}+ parameters> ]`, Collector c){
     params = [p | p <- parameters];
     c.use(n, syntaxRoles);
-    c.calculate("parameterized <n>", current, n + params, 
-        AType(Solver s) { 
-            base = getSyntaxType(n, s); 
+    c.calculate("parameterized <n>", current, n + params,
+        AType(Solver s) {
+            base = getSyntaxType(n, s);
             s.requireTrue(isParameterizedNonTerminalType(base), error(current, "Expected a non-terminal type, found %t", base));
             nexpected = size(getADTTypeParameters(base)); nparams = size(params);
             s.requireTrue(nexpected == nparams, error(current, "Expected %v type parameter(s) for %q, found %v", nexpected, getADTName(base), nparams));
@@ -561,21 +561,21 @@ void collect(current:(Sym) `<Sym symbol> <NonterminalLabel n>`, Collector c){
     } else {
         throw "Cannot compute md5 for <current>";
     }
-    
+
     // TODO require symbol is nonterminal
-    c.define(un, fieldId(), n, defType([symbol], 
-        AType(Solver s){ 
-            res = s.getType(symbol)[alabel=un]; 
+    c.define(un, fieldId(), n, defType([symbol],
+        AType(Solver s){
+            res = s.getType(symbol)[alabel=un];
           return res;
         })[md5=md5Hash("<md5Contrib><unparseNoLayout(current)>")]);
-      
+
     c.fact(current, n);
     collect(symbol, c);
 }
 
 str md5ContribSym((Sym) `<Sym symbol> <NonterminalLabel n>`)
     = "<md5ContribSym(symbol)><unescape("<n>")>";
-    
+
 // ---- literals
 
 void collect(current:(Sym) `<Class cc>`, Collector c){
@@ -607,15 +607,15 @@ bool isLexicalContext(Collector c){
     adtStack = c.getStack(currentAdt);
     if(!isEmpty(adtStack) && <Tree adt, list[KeywordFormal] _, _, _> := adtStack[0]){
         return !(adt is language);
-    } 
+    }
     return false;
 }
 
 void collect(current:(Sym) `<Sym symbol>+`, Collector c){
     if(isIterSym(symbol)) c.report(warning(current, "Nested iteration"));
     isLexical = isLexicalContext(c);
-    c.calculate("iter", current, [symbol], AType(Solver s) { 
-        symbol_type = s.getType(symbol); 
+    c.calculate("iter", current, [symbol], AType(Solver s) {
+        symbol_type = s.getType(symbol);
         return isLexical ? \iter(symbol_type, isLexical=true) : \iter(symbol_type);
         //return isLexical ? \iter(getSyntaxType(symbol, s), isLexical=true) : \iter(getSyntaxType(symbol, s));
     });
@@ -624,11 +624,11 @@ void collect(current:(Sym) `<Sym symbol>+`, Collector c){
 
 str md5ContribSym((Sym) `<Sym symbol>+`)
     = "<md5ContribSym(symbol)>PLUS";
-    
+
 void collect(current:(Sym) `<Sym symbol>*`, Collector c) {
     if(isIterSym(symbol)) c.report(warning(current, "Nested iteration"));
     isLexical = isLexicalContext(c);
-    c.calculate("iterStar", current, [symbol], AType(Solver s) { 
+    c.calculate("iterStar", current, [symbol], AType(Solver s) {
         symbol_type = s.getType(symbol);
         return isLexical ? \iter-star(symbol_type, isLexical=true) : \iter-star(symbol_type);
         //return isLexical ? \iter-star(getSyntaxType(symbol, s), isLexical=true) : \iter-star(getSyntaxType(symbol, s));
@@ -638,12 +638,12 @@ void collect(current:(Sym) `<Sym symbol>*`, Collector c) {
 
 str md5ContribSym((Sym) `<Sym symbol>*`)
     = "<md5ContribSym(symbol)>STAR";
-    
+
 void collect(current:(Sym) `{ <Sym symbol> <Sym sep> }+`, Collector c){
     if(isIterSym(symbol)) c.report(warning(current, "Nested iteration"));
     isLexical = isLexicalContext(c);
-    c.calculate("iterSep", current, [symbol, sep], 
-        AType(Solver s) { 
+    c.calculate("iterSep", current, [symbol, sep],
+        AType(Solver s) {
             seps = [s.getType(sep)];
             validateSeparators(current, seps, s);
             symbol_type = s.getType(symbol);
@@ -661,8 +661,8 @@ str md5ContribSym((Sym) `{ <Sym symbol> <Sym sep> }+`){
 void collect(current:(Sym) `{ <Sym symbol> <Sym sep> }*`, Collector c){
     if(isIterSym(symbol)) c.report(warning(current, "Nested iteration"));
     isLexical = isLexicalContext(c);
-    c.calculate("iterStarSep", current, [symbol, sep], 
-        AType(Solver s) { 
+    c.calculate("iterStarSep", current, [symbol, sep],
+        AType(Solver s) {
             seps = [s.getType(sep)];
             validateSeparators(current, seps, s);
             symbol_type = s.getType(symbol);
@@ -676,7 +676,7 @@ str md5ContribSym((Sym) `{ <Sym symbol> <Sym sep> }*`){
     res = "LC<md5ContribSym(symbol)><md5ContribSym(sep)>RCSTAR";
     return res;
 }
-    
+
 void validateSeparators(Tree current, list[AType] separators, Solver s){
     if(all(sep <- separators, isLayoutAType(sep)))
         s.report(warning(current, "At least one element of separators should be non-layout")); // TODO make error
@@ -708,11 +708,11 @@ str md5ContribSym((Sym) `( <Sym first> | <{Sym "|"}+ alternatives> )`)
 
 void collect(current:(Sym) `( <Sym first> <Sym+ sequence> )`, Collector c){
     seqs = first + [seq | seq <- sequence];
-    c.calculate("sequence", current, seqs, 
-        AType(Solver s) { 
+    c.calculate("sequence", current, seqs,
+        AType(Solver s) {
             symbols = [s.getType(seq) | seq <- seqs];
             forbidConsecutiveLayout(current, symbols, s);
-            return AType::seq(symbols); 
+            return AType::seq(symbols);
         });
     collect(seqs, c);
 }
@@ -752,12 +752,12 @@ void collect(current:(Sym) `^ <Sym symbol>`, Collector c){
 
 str md5ContribSym((Sym) `^ <Sym symbol>`)
     = "BEGIN<md5ContribSym(symbol)>";
-    
+
 void collect(current:(Sym) `<Sym symbol> ! <NonterminalLabel n>`, Collector c){
     // TODO: c.use(n, {productionId()});
     un = unescape("<n>");
-    c.calculate("except", current, [symbol], AType(Solver s) { 
-        res = AType::conditional(s.getType(symbol), {ACondition::\a-except(un) }); 
+    c.calculate("except", current, [symbol], AType(Solver s) {
+        res = AType::conditional(s.getType(symbol), {ACondition::\a-except(un) });
         return res;
     });
     collect(symbol, c);
@@ -765,7 +765,7 @@ void collect(current:(Sym) `<Sym symbol> ! <NonterminalLabel n>`, Collector c){
 
 str md5ContribSym((Sym) `<Sym symbol> ! <NonterminalLabel n>`)
     = "<md5ContribSym(symbol)>EXCEPT<unescape("<n>")>";
-    
+
 bool isTerminal((Sym) `<Sym symbol> @ <IntegerLiteral _>`) = isTerminal(symbol);
 bool isTerminal((Sym) `<Sym symbol> $`) = isTerminal(symbol);
 bool isTerminal((Sym) `^ <Sym symbol>`) = isTerminal(symbol);
@@ -775,10 +775,10 @@ default bool isTerminal(Sym s)
     = s is literal || s is caseInsensitiveLiteral || s is characterClass;
 
 void collect(current:(Sym) `<Sym symbol>  \>\> <Sym match>`, Collector c){
-   c.calculate("follow", current, [symbol, match], 
-        AType(Solver s) { 
+   c.calculate("follow", current, [symbol, match],
+        AType(Solver s) {
             s.requireTrue(isTerminal(match), warning(match, "Followed By (`\>\>`) requires literal or character class, found %v", match));
-            return AType::conditional(s.getType(symbol), {ACondition::\follow(s.getType(match)) }); 
+            return AType::conditional(s.getType(symbol), {ACondition::\follow(s.getType(match)) });
         });
    collect(symbol, match, c);
 }
@@ -787,10 +787,10 @@ str md5ContribSym((Sym) `<Sym symbol>  \>\> <Sym match>`)
     = "<md5ContribSym(symbol)>FOLLOW<md5ContribSym(match)>";
 
 void collect(current:(Sym) `<Sym symbol>  !\>\> <Sym match>`, Collector c){
-   c.calculate("notFollow", current, [symbol, match], 
-        AType(Solver s) { 
+   c.calculate("notFollow", current, [symbol, match],
+        AType(Solver s) {
             s.requireTrue(isTerminal(match), warning(match, "Not Followed By (`!\>\>`) requires literal or character class, found %v", match));
-            res = AType::conditional(s.getType(symbol), {ACondition::\not-follow(s.getType(match)) }); 
+            res = AType::conditional(s.getType(symbol), {ACondition::\not-follow(s.getType(match)) });
             return res;
         });
    collect(symbol, match, c);
@@ -798,12 +798,12 @@ void collect(current:(Sym) `<Sym symbol>  !\>\> <Sym match>`, Collector c){
 
 str md5ContribSym((Sym) `<Sym symbol>  !\>\> <Sym match>`)
     = "<md5ContribSym(symbol)>NOTFOLLOW<md5ContribSym(match)>";
-    
+
 void collect(current:(Sym) `<Sym match>  \<\< <Sym symbol>`, Collector c){
-   c.calculate("precede", current, [match, symbol], 
-        AType(Solver s) { 
+   c.calculate("precede", current, [match, symbol],
+        AType(Solver s) {
             s.requireTrue(isTerminal(match), warning(match, "Preceded By (`\<\<`) requires literal or character class, found %v", match));
-            return AType::conditional(s.getType(symbol), {ACondition::\precede(s.getType(match)) }); 
+            return AType::conditional(s.getType(symbol), {ACondition::\precede(s.getType(match)) });
         });
    collect(match, symbol, c);
 }
@@ -812,20 +812,20 @@ str md5ContribSym((Sym) `<Sym match>  \<\< <Sym symbol>`)
     = "<md5ContribSym(match)>PRECEDE<md5ContribSym(symbol)>";
 
 void collect(current:(Sym) `<Sym match>  !\<\< <Sym symbol>`, Collector c){
-   c.calculate("notPrecede", current, [match, symbol], 
-        AType(Solver s) { 
+   c.calculate("notPrecede", current, [match, symbol],
+        AType(Solver s) {
             s.requireTrue(isTerminal(match), warning(match, "Not Preceded By (`!\<\<`) requires literal or character class, found %v", match));
-            return AType::conditional(s.getType(symbol), {ACondition::\not-precede(s.getType(match)) }); 
+            return AType::conditional(s.getType(symbol), {ACondition::\not-precede(s.getType(match)) });
         });
    collect(match, symbol, c);
 }
 
 str md5ContribSym((Sym) `<Sym match>  !\<\< <Sym symbol>`)
     = "<md5ContribSym(match)>NOTPRECEDE<md5ContribSym(symbol)>";
-    
+
 void collect(current:(Sym) `<Sym symbol> \\ <Sym match>`, Collector c){
-   c.calculate("exclude", current, [symbol, match], 
-        AType(Solver s) { 
+   c.calculate("exclude", current, [symbol, match],
+        AType(Solver s) {
             t = s.getType(match);
             if(alit(_) !:= t && (t has syntaxRole && t.syntaxRole != keywordSyntax())){
                 s.report(error(match, "Exclude (`\\`) requires keywords as right argument, found %t", match));
@@ -847,7 +847,7 @@ void collect(Sym current, Collector c){
 
 void collect(current:(TypeVar) `& <Name n>`, Collector c){
     pname = prettyPrintName(n);
-    
+
     if(<true, bool closed> := defineOrReuseTypeParameters(c)){
         if(c.isAlreadyDefined(pname, n)){
             c.use(n, {typeVarId() });
@@ -865,22 +865,22 @@ void collect(current:(TypeVar) `& <Name n>`, Collector c){
         }
         c.calculate("xxx", current, [n], AType (Solver s) { return s.getType(n)[closed=closed]; });
         return;
-      
+
     } else if(<true, bool closed> := useTypeParameters(c)){
         c.use(n, {typeVarId() });
         //if(debugTP)println("Use <pname> at <current@\loc>, closed=<closed>");
         c.calculate("xxx", current, [n], AType (Solver s) { return s.getType(n)[closed=closed]; });
         return;
-    } else {        
+    } else {
         if(<true, rel[str, Type] tpbounds> := useBoundedTypeParameters(c)){
             if(tpbounds[pname]?){
                 bnds = toList(tpbounds[pname]);
                 //if(debugTP)println("collect: Adding calculator for <pname>");
                 c.calculate("type parameter with bound", current, bnds,
-                    AType(Solver s){ 
+                    AType(Solver s){
                         new_bnd = (avalue() | aglb(it, s.getType(bnd)) | bnd <- bnds);
                         return  aparameter(pname, new_bnd, closed=true);
-                    });  
+                    });
             } else {
                 //if(debugTP)println("collect: fact for <pname>, closed=<closed>");
                 c.fact(current, aparameter(pname, avalue(), closed=true));
@@ -893,12 +893,12 @@ void collect(current:(TypeVar) `& <Name n>`, Collector c){
 
 void collect(current: (TypeVar) `& <Name n> \<: <Type tp>`, Collector c){
     pname = prettyPrintName(n);
-    
+
     if(<true, bool closed> := defineOrReuseTypeParameters(c)){
         if(c.isAlreadyDefined(pname, n)){
             c.use(n, {typeVarId() });
             //if(debugTP)println("Use <pname> at <current@\loc>");
-        } else { 
+        } else {
             c.define(pname, typeVarId(), n, defTypeCall([getLoc(tp)], AType(Solver s) {return aparameter(pname,s.getType(tp), closed=closed); }));
             //if(debugTP)println("Define <pname> at <current@\loc>");
         }
@@ -910,21 +910,21 @@ void collect(current: (TypeVar) `& <Name n> \<: <Type tp>`, Collector c){
     } else if(<true, rel[str, Type] tpbounds> := useBoundedTypeParameters(c)){
         if(!isEmpty(tpbounds[pname])){
             bnds = toList(tpbounds[pname]);
-            c.calculate("type parameter with bound", n, bnds, 
-                AType(Solver s){ 
+            c.calculate("type parameter with bound", n, bnds,
+                AType(Solver s){
                     new_bnd = (avalue() | aglb(it, s.getType(bnd)) | bnd <- bnds);
                     return  aparameter(prettyPrintName(n), s.getType(new_bnd), closed=true);
-                });  
+                });
         } else {
             c.calculate("type parameter with bound", n, [tp], AType(Solver s){ return  aparameter(prettyPrintName(n), s.getType(tp), closed=true); });
-        }  
+        }
         c.fact(current, n);
     }
-    
+
     collect(tp, c);
 }
 
 @doc{A parsing function, useful for generating test cases.}
 public Type parseType(str s) {
     return parse(#Type, s);
-}
\ No newline at end of file
+}
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/check/Import.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/check/Import.rsc
index 5275bd5e..2abfeda4 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/check/Import.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/check/Import.rsc
@@ -117,7 +117,9 @@ ModuleStatus getImportAndExtendGraph(str qualifiedModuleName, ModuleStatus ms){
                lm = getLastModified(m, ms.moduleLastModified, pcfg);
                if(lm == startOfEpoch || lm > timestampInBom) {
                     allImportsAndExtendsValid = false;
-                    if(tpl_uptodate() notin ms.status[m] && lm != timestampInBom && ms.compilerConfig.verbose){
+                    ms.status[m] += rsc_changed();
+                    ms.status[m] -= {tpl_uptodate(), checked()};
+                    if(ms.compilerConfig.verbose){
                         println("--- using <lm> (most recent) version of <m>,
                                 '    older <timestampInBom> version was used in previous check of <qualifiedModuleName>");
                     }
@@ -132,7 +134,8 @@ ModuleStatus getImportAndExtendGraph(str qualifiedModuleName, ModuleStatus ms){
                 mloc = getModuleLocation(qualifiedModuleName, pcfg);
                 if(mloc.extension != "rsc" || isModuleLocationInLibs(mloc, pcfg)) throw "No src or library module 1"; //There is only a tpl file available
             } catch value _:{
-                if(!isCompatibleBinary(tm, domain(localImportsAndExtends), ms)){
+                <compatible, ms> = isCompatibleBinaryLibrary(tm, domain(localImportsAndExtends), ms);
+                if(!compatible){
                     msg = error("Binary module `qualifiedModuleName` needs recompilation", |unknown:///|);
                     tm.messages += [msg];
                     ms.messages[qualifiedModuleName] ? [] += [msg];
@@ -147,12 +150,11 @@ ModuleStatus getImportAndExtendGraph(str qualifiedModuleName, ModuleStatus ms){
         }
         if(allImportsAndExtendsValid){
             ms.status[qualifiedModuleName] += {tpl_uptodate(), checked()}; //TODO: maybe check existence of generated java files
-
             ms.moduleLocs += tm.moduleLocs;
             ms.paths += tm.paths;
             ms.strPaths += {<qualifiedModuleName, pathRole, imp> | <str imp, PathRole pathRole> <- localImportsAndExtends };
             ms.status[qualifiedModuleName] += module_dependencies_extracted();
-            for(imp <- localImportsAndExtends<0>, module_dependencies_extracted() notin ms.status[imp]  ){
+            for(imp <- localImportsAndExtends<0>, isEmpty({module_dependencies_extracted()} & ms.status[imp])  ){
                 ms = getImportAndExtendGraph(imp, ms);
             }
             return ms;
@@ -172,9 +174,7 @@ ModuleStatus getImportAndExtendGraph(str qualifiedModuleName, ModuleStatus ms){
             ms = getImportAndExtendGraph(imp, ms);
         }
     } else {
-        if(rsc_not_found() notin ms.status[qualifiedModuleName]){
-            ms.status[qualifiedModuleName] += rsc_not_found();
-        }
+         ms.status[qualifiedModuleName] += rsc_not_found();
     }
 
     return ms;
@@ -192,27 +192,61 @@ ModuleStatus getInlineImportAndExtendGraph(Tree pt, RascalCompilerConfig ccfg){
     return complete(ms);
 }
 
+// Example: |rascal+function:///util/Math/round$d80e373d64c01979| ==> util::Math
 str getModuleFromLogical(loc l){
-    i = findFirst(l.path[1..], "/");
-    return i >= 0 ? l.path[1..i+1] : l.path[1..];
+    i = findLast(l.path[1..], "/");
+    res = i >= 0 ? l.path[1..i+1] : l.path[1..];
+    return replaceAll(res, "/", "::");
 }
 
-bool isCompatibleBinary(TModel lib, set[str] otherImportsAndExtends, ModuleStatus ms){
-
-    provides = {<m , l> | l <- domain(lib.logical2physical), m := getModuleFromLogical(l) };
-    requires = {};
-    for(m <- otherImportsAndExtends){
+// Is what library module lib provides compatible with all uses in the modules libUsers?
+tuple[bool, ModuleStatus] isCompatibleBinaryLibrary(TModel lib, set[str] libUsers, ModuleStatus ms){
+    libName = lib.modelName;
+    libProvides = domain(lib.logical2physical);
+    libProvidesModules = { getModuleFromLogical(l) | l <- libProvides };
+    usersRequire = {};
+    for(m <- libUsers){
        <found, tm, ms> = getTModelForModule(m, ms);
        if(found){
-           requires += {<m , l> | l <- domain(tm.logical2physical), m := getModuleFromLogical(l) };
+           usersRequire += domain(tm.logical2physical);
        }
     }
+    usersRequireFromLib = { l | l <- usersRequire, getModuleFromLogical(l) in libProvidesModules };
+
+    if(usersRequireFromLib <= libProvides){
+        //println("isCompatibleBinaryLibrary <libName>: satisfied");
+        return <true, ms>;
+    } else {
+        //println("isCompatibleBinaryLibrary, <libName> unsatisfied: <usersRequireFromLib - libProvides>");
+        return <false, ms>;
+    }
+}
 
-    if(isEmpty(requires - provides)){
-        return true;
+tuple[bool, ModuleStatus] importsAndExtendsAreBinaryCompatible(TModel tm, set[str] importsAndExtends, ModuleStatus ms){
+    moduleName = tm.modelName;
+    physical2logical = invertUnique(tm.logical2physical);
+
+    modRequires = { lg | l <- range(tm.useDef),
+                        physical2logical[l]?, lg := physical2logical[l],
+                        moduleName !:= getModuleFromLogical(lg) };
+    provided = {};
+    if(!isEmpty(modRequires)){
+        for(m <- importsAndExtends){
+            <found, tm, ms> = getTModelForModule(m, ms);
+            if(found){
+                provided += domain(tm.logical2physical);
+            }
+        }
+    }
+
+    //println("<moduleName> requires <modRequires>");
+
+    if(isEmpty(modRequires - provided)){
+        //println("importsAndExtendsAreBinaryCompatible <moduleName>: satisfied");
+        return <true, ms>;
     } else {
-        println("isCompatibleBinary, unsatisfied: <requires - provides>");
-        return false;
+        //println("importsAndExtendsAreBinaryCompatible, <moduleName> unsatisfied: <modRequires - provided>");
+        return <false, ms>;
     }
 }
 
@@ -290,6 +324,28 @@ tuple[map[str,TModel], ModuleStatus] prepareForCompilation(set[str] component, m
     }
     return <transient_tms, ms>;
 }
+rel[str,datetime,PathRole] makeBom(str qualifiedModuleName, set[str] imports, set[str] extends,  ModuleStatus ms){
+    map[str,datetime] moduleLastModified = ms.moduleLastModified;
+    pcfg = ms.pathConfig;
+    return   { < m, getLastModified(m, moduleLastModified, pcfg), importPath() > | m <- imports }
+           + { < m, getLastModified(m, moduleLastModified, pcfg), extendPath() > | m <- extends }
+           + { <qualifiedModuleName, getLastModified(qualifiedModuleName, moduleLastModified, pcfg), importPath() > };
+}
+void updateBOM(str qualifiedModuleName, set[str] imports, set[str] extends,  ModuleStatus ms){
+    <found, tm, ms> = getTModelForModule(qualifiedModuleName, ms);
+    if(found){
+        newBom = makeBom(qualifiedModuleName, imports, extends, ms);
+        if(newBom != tm.store[key_bom]){
+            tm.store[key_bom] = newBom;
+            ms.status[qualifiedModuleName] -= tpl_saved();
+            addTModel(qualifiedModuleName, tm, ms);
+
+            if(ms.compilerConfig.logWrittenFiles) println("Updated BOM: <qualifiedModuleName>");
+        }
+    } else{
+        println("Could not update BOM of <qualifiedModuleName>");
+    }
+}
 
 ModuleStatus doSaveModule(set[str] component, map[str,set[str]] m_imports, map[str,set[str]] m_extends, ModuleStatus ms, map[str,loc] moduleScopes, map[str, TModel] transient_tms, RascalCompilerConfig compilerConfig){
     map[str,datetime] moduleLastModified = ms.moduleLastModified;
@@ -315,15 +371,14 @@ ModuleStatus doSaveModule(set[str] component, map[str,set[str]] m_imports, map[s
     for(qualifiedModuleName <- component){
         start_save = cpuTime();
         tm = transient_tms[qualifiedModuleName];
-        try {
+        //try {
             mscope = getModuleScope(qualifiedModuleName, moduleScopes, pcfg);
             <found, tplLoc> = getTPLWriteLoc(qualifiedModuleName, pcfg);
+
             imports = m_imports[qualifiedModuleName];
             extends = m_extends[qualifiedModuleName];
 
-            bom = { < m, getLastModified(m, moduleLastModified, pcfg), importPath() > | m <- imports }
-                + { < m, getLastModified(m, moduleLastModified, pcfg), extendPath() > | m <- extends }
-                + { <qualifiedModuleName, getLastModified(qualifiedModuleName, moduleLastModified, pcfg), importPath() > };
+            bom = makeBom(qualifiedModuleName, imports, extends, ms);
 
             extendedModuleScopes = {getModuleScope(m, moduleScopes, pcfg) | str m <- extends, checked() in ms.status[m]};
             extendedModuleScopes += {*tm.paths[ems,importPath()] | ems <- extendedModuleScopes}; // add imports of extended modules
@@ -395,57 +450,15 @@ ModuleStatus doSaveModule(set[str] component, map[str,set[str]] m_imports, map[s
                     case kwField(AType atype, str fieldName, str definingModule, Expression _defaultExp) => kwField(atype, fieldName, definingModule)
                     case loc l : if(!isEmpty(l.fragment)) insert l[fragment=""];
                  };
-            m1.logical2physical = tm.logical2physical;
-            //println("Import, tmodel:"); iprintln(m1);
-            m1 = convertTModel2LogicalLocs(m1, ms.tmodels);
-
-            ////TODO temporary check: are external locations present in the TModel? If so, throw exception
-            //
-            //result = "";
-            //
-            //void checkPhysical(value v, str label){
-            //    visit(v){
-            //        case loc l:
-            //                if(!(isContainedInComponentScopes(l) || l == |global-scope:///| || contains(l.scheme, "rascal+")))
-            //                    result += "<label>, outside <qualifiedModuleName>: <l>\n";
-            //    }
-            //}
-            //checkPhysical(m1.moduleLocs, "moduleLocs");
-            //checkPhysical(m1.facts, "facts");
-            //checkPhysical(m1.specializedFacts, "specializedFacts");
-            //checkPhysical(m1.defines, "defines");
-            //checkPhysical(m1.definitions, "definitions");
-            //checkPhysical(m1.scopes, "scopes");
-            //checkPhysical(m1.store, "store");
-            //checkPhysical(m1.paths, "paths");
-            //checkPhysical(m1.useDef, "useDef");
-            //
-            //if(!isEmpty(result)){
-            //    println("------------- <qualifiedModuleName>:
-            //            '<result>");
-            //    iprintln(m1, lineLimit=10000);
-            //    throw "checkPhysical failed, see above";
-            //}
-
-            ms.status[qualifiedModuleName] += tpl_saved();
-            try {
-                writeBinaryValueFile(tplLoc, m1);
-                if(compilerConfig.logWrittenFiles) println("Written: <tplLoc>");
-                save_time = (cpuTime() - start_save)/1000000;
-                if(compilerConfig.verbose) {
-                    save_time = (cpuTime() - start_save)/1000000;
-                    println("Saved TPL .. <qualifiedModuleName> in <save_time> ms");
-                }
-            } catch value e: {
-                throw "Cannot write TPL file <tplLoc>, reason: <e>";
-            }
+
+            ms.status[qualifiedModuleName] -= {tpl_saved()};
             ms = addTModel(qualifiedModuleName, m1, ms);
-            //println("doSaveModule"); iprintln(m1);
+            //println("doSaveModule"); iprintln(m1.logical2physical);
 
-        } catch value e: {
-            ms.messages[qualifiedModuleName] ? [] += tm.messages + [error("Could not save .tpl file for `<qualifiedModuleName>`, reason: <e>", |unknown:///|(0,0,<0,0>,<0,0>))];
-            return ms;
-        }
+        // } catch value e: {
+        //     ms.messages[qualifiedModuleName] ? [] += tm.messages + [error("Could not save .tpl file for `<qualifiedModuleName>`, reason: <e>", |unknown:///|(0,0,<0,0>,<0,0>))];
+        //     return ms;
+        // }
     }
     return ms;
 }
\ No newline at end of file
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/check/tests/ChangeScenarioTests.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/check/tests/ChangeScenarioTests.rsc
index 7ed330a5..9b17ef4c 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/check/tests/ChangeScenarioTests.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/check/tests/ChangeScenarioTests.rsc
@@ -2,6 +2,12 @@
 module lang::rascalcore::check::tests::ChangeScenarioTests
 
 import lang::rascalcore::check::tests::StaticTestingUtils;
+import lang::rascalcore::check::TestConfigs;
+import util::Reflective;
+import util::Benchmark;
+import IO;
+import List;
+import ListRelation;
 
 test bool fixMissingImport(){
     clearMemory();
@@ -20,119 +26,498 @@ test bool fixMissingExtend(){
 test bool fixErrorInImport(){
     clearMemory();
     assert checkModuleOK("module A public bool b = false;");
-    moduleB = "module B import A; int n = b + 1;";
-    assert unexpectedTypeInModule(moduleB);
+    B = "module B import A; int n = b + 1;";
+    assert unexpectedTypeInModule(B);
     assert checkModuleOK("module A public int b = 0;"); // change b to type int
-    return checkModuleOK(moduleB);
+    return checkModuleOK(B);
 }
 
 test bool fixErrorInExtend(){
     clearMemory();
     assert checkModuleOK("module A bool b = false;");
-    moduleB = "module B extend A; int n = b + 1;";
-    assert unexpectedTypeInModule(moduleB);
+    B = "module B extend A; int n = b + 1;";
+    assert unexpectedTypeInModule(B);
     assert checkModuleOK("module A int b = 0;"); // change b to type int
-    return checkModuleOK(moduleB);
+    return checkModuleOK(B);
 }
 
 test bool introduceErrorInImport(){
     clearMemory();
     assert checkModuleOK("module A public int b = 0;");
-    moduleB = "module B import A; int n = b + 1;";
-    assert checkModuleOK(moduleB);
+    B = "module B import A; int n = b + 1;";
+    assert checkModuleOK(B);
     assert checkModuleOK("module A public bool b = false;");
-    return unexpectedTypeInModule(moduleB);
+    return unexpectedTypeInModule(B);
 }
 
 test bool introduceErrorInExtend(){
     clearMemory();
     assert checkModuleOK("module A int b = 0;");
-    moduleB = "module B extend A; int n = b + 1;";
-    assert checkModuleOK(moduleB);
+    B = "module B extend A; int n = b + 1;";
+    assert checkModuleOK(B);
     assert checkModuleOK("module A bool b = false;");
-    return unexpectedTypeInModule(moduleB);
+    return unexpectedTypeInModule(B);
 }
 
-test bool removeImportedModuleAndRestoreIt1(){
+test bool removeImportedAndRestoreIt1(){
     clearMemory();
     assert checkModuleOK("module A");
-    moduleB = "module B import A;";
-    assert checkModuleOK(moduleB);
+    B = "module B import A;";
+    assert checkModuleOK(B);
     removeModule("A");
-    assert missingModuleInModule(moduleB);
+    assert missingModuleInModule(B);
     assert checkModuleOK("module A");
-    return checkModuleOK(moduleB);
+    return checkModuleOK(B);
 }
 
-test bool removeImportedModuleAndRestoreIt2(){
+test bool removeImportedAndRestoreIt2(){
     clearMemory();
-    moduleA = "module A int twice(int n) = n * n;";
-    assert checkModuleOK(moduleA);
-    moduleB = "module B import A; int quad(int n) = twice(twice(n));";
-    assert checkModuleOK(moduleB);
+    A = "module A int twice(int n) = n * n;";
+    assert checkModuleOK(A);
+    B = "module B import A; int quad(int n) = twice(twice(n));";
+    assert checkModuleOK(B);
     removeModule("A");
-    assert missingModuleInModule(moduleB);
-    assert checkModuleOK(moduleA);
-    return checkModuleOK(moduleB);
+    assert missingModuleInModule(B);
+    assert checkModuleOK(A);
+    return checkModuleOK(B);
 }
 
-test bool removeExtendedModuleAndRestoreIt1(){
+test bool removeExtendedAndRestoreIt1(){
     clearMemory();
-    moduleA = "module A";
-    assert checkModuleOK(moduleA);
-    moduleB = "module B extend A;";
-    assert checkModuleOK(moduleB);
+    A = "module A";
+    assert checkModuleOK(A);
+    B = "module B extend A;";
+    assert checkModuleOK(B);
     removeModule("A");
-    assert missingModuleInModule(moduleB);
-    assert checkModuleOK(moduleA);
-    return checkModuleOK(moduleB);
+    assert missingModuleInModule(B);
+    assert checkModuleOK(A);
+    return checkModuleOK(B);
 }
 
-test bool removeExtendedModuleAndRestoreIt2(){
+test bool removeExtendedAndRestoreIt2(){
     clearMemory();
-    moduleA = "module A int twice(int n) = n * n;";
-    assert checkModuleOK(moduleA);
-    moduleB = "module B extend A; int quad(int n) = twice(twice(n));";
-    assert checkModuleOK(moduleB);
+    A = "module A int twice(int n) = n * n;";
+    assert checkModuleOK(A);
+    B = "module B extend A; int quad(int n) = twice(twice(n));";
+    assert checkModuleOK(B);
     removeModule("A");
-    assert missingModuleInModule(moduleB);
-    assert checkModuleOK(moduleA);
-    return checkModuleOK(moduleB);
+    assert missingModuleInModule(B);
+    assert checkModuleOK(A);
+    return checkModuleOK(B);
 }
 
 test bool removeOverloadAndRestoreIt(){
     clearMemory();
-    moduleA1 = "module A
-                int dup(int n) = n + n;
-                str dup(str s) = s + s;";
-    moduleA2 = "module A
-                int dup(int n) = n + n;";
-    assert checkModuleOK(moduleA1);
-    moduleB = "module B import A;  str f(str s) = dup(s);";
-    assert checkModuleOK(moduleB);
+    A1 = "module A
+            int dup(int n) = n + n;
+            str dup(str s) = s + s;";
+    A2 = "module A
+            int dup(int n) = n + n;";
+    assert checkModuleOK(A1);
+    B = "module B import A;  str f(str s) = dup(s);";
+    assert checkModuleOK(B);
     removeModule("A");
-    assert missingModuleInModule(moduleB);
+    assert missingModuleInModule(B);
 
-    assert checkModuleOK(moduleA2);
-    assert argumentMismatchInModule(moduleB);
-    assert checkModuleOK(moduleA1);
-    return checkModuleOK(moduleB);
+    assert checkModuleOK(A2);
+    assert argumentMismatchInModule(B);
+    assert checkModuleOK(A1);
+    return checkModuleOK(B);
 }
 
 test bool removeConstructorAndRestoreIt(){
     clearMemory();
-    moduleA1 = "module A
-                data D = d(int n) | d(str s);";
-    moduleA2 = "module A
-                data D = d(int n);";
-    assert checkModuleOK(moduleA1);
-    moduleB = "module B import A;  D f(str s) = d(s);";
-    assert checkModuleOK(moduleB);
+    A1 = "module A
+            data D = d(int n) | d(str s);";
+    A2 = "module A
+            data D = d(int n);";
+    assert checkModuleOK(A1);
+    B = "module B import A;  D f(str s) = d(s);";
+    assert checkModuleOK(B);
     removeModule("A");
-    assert missingModuleInModule(moduleB);
+    assert missingModuleInModule(B);
 
-    assert checkModuleOK(moduleA2);
-    assert argumentMismatchInModule(moduleB);
-    assert checkModuleOK(moduleA1);
-    return checkModuleOK(moduleB);
+    assert checkModuleOK(A2);
+    assert argumentMismatchInModule(B);
+    assert checkModuleOK(A1);
+    return checkModuleOK(B);
+}
+
+// ---- incremental type checking ---------------------------------------------
+
+// Legend:
+//      X --> Y: X import Y
+//      X ==> Y: X extends Y
+//      X >>> Y: replace X by Y
+//      *X     : check starts at X
+//      X!     : X is (re)checked
+//      X?     : X contains error
+
+// Scenarios:
+//     I        II      III     IV      V       VI
+//
+//     *A1!     A1  >>> A2!     A2  >>> A3!     A3
+//              ^       ^       ^       ^       ^
+//              |       |       |       |       |
+//             *B1!     B1      B1      B1 >>>  B2!
+//                              ^       ^       ^
+//                              |       |       |
+//                             *C1!    *C1     *C1
+
+test bool nobreakingChange1(){
+    clearMemory();
+    A1 = "module A";
+    A2 = "module A
+            public int n = 3;";
+    A3 = "module A
+            public int n = 3;
+            data D = d1();";
+
+    assert expectReChecks(A1, ["A"]);    // I
+
+    B1 = "module B
+            import A;";
+    B2 = "module B
+            import A;
+            public int m = n + 1;";
+    assert expectReChecks(B1, ["B"]);    // II
+
+    writeModule(A2);
+    assert expectReChecks(B1, ["A"]);    // III
+
+    C1 = "module C
+            import B;
+            int f() = 2;";
+    assert expectReChecks(C1, ["C"]);    // IV
+
+    writeModule(A3);
+
+    assert expectReChecks(C1, ["A"]);    // V
+
+    writeModule(B2);
+    return expectReChecks(C1, ["B"]);    // VI
+}
+
+
+//      I                   II
+//
+//      A1!<-----+          A1<-------+
+//      ^        |          |         |
+//      |        |          |         |
+//      B1!<-+   |    >>>   B2!<-+    |
+//      ^    |   |          |    |    |
+//      |    |   |          |    |    |
+//      C1!  +---D1!        C1   +----D1
+//      ^        ^          ^         ^
+//      |        |          |         |
+//      +--*E!---+          +---*E----+
+
+test bool nobreakingChange2(){
+    clearMemory();
+    A1 = "module A";
+    B1 = "module B import A;";
+    C1 = "module C import B;";
+    D1 = "module D import A; import B;";
+    E1 = "module E import C; import D;";
+
+    B2 = "module B import A; int n = 0;";
+
+    writeModules(A1, B1, C1, D1, E1);
+
+    assert expectReChecks(E1, ["A", "B", "C", "D", "E"]);    // I
+
+    writeModule(B2);
+    return expectReChecks(C1, ["B"]);                        // II
+}
+
+//      I                   II
+//
+//      A1!<-----+          A1<-------+
+//      ^        |          ^         |
+//      |        |          |         |
+//      B1!<-+   |    >>>   B2!<-+    |
+//      |    |   |          |    |    |
+//      C1!  +---D1!        C1!  +----D1
+//      ^        ^          ^         ^
+//      |        |          |         |
+//      +--*E!---+          +---*E----+
+
+test bool noBreakingChange3(){
+    clearMemory();
+    A1 = "module A";
+    B1 = "module B import A; int b() = 1;";
+    C1 = "module C import B; int c() = b();";
+    D1 = "module D import A; import B;";
+    E1 = "module E import C; import D;";
+
+    B2 = "module B import A; int b(int n) = n;";
+
+    writeModules(A1, B1, C1, D1, E1);
+
+    assert expectReChecks(E1, ["A", "B", "C", "D", "E"]);   // I
+
+    writeModule(B2);
+    return expectReChecksWithErrors(C1, ["B", "C"]);        // II
+}
+
+//      I       II             III       IV
+//
+//      A1!     A1<----+  >>>  A2!       A2<------+
+//      ^       ^      |       ^         ^        |
+//      |       |      |       |         |        |
+//      B1!     B1    *D1!     B1        B1       D1!
+//      ^       |              ^         ^        ^
+//      |       |              |         |        |
+//     *C1!     C1            *C1   ==> *C2! -----+
+//
+test bool noBreakingChange4(){
+    clearMemory();
+    A1 = "module A";
+    A2 = "module A int a() = 0;";
+    B1 = "module B import A; int b() = 1;";
+    C1 = "module C import B; int c() = b();";
+    C2 = "module C import B; import D; int c() = b();";
+    D1 = "module D import A;";
+
+    writeModules(A1, B1, C1);
+
+    assert expectReChecks(C1, ["A", "B", "C"]);  // I
+
+    writeModule(D1);
+    assert expectReChecks(D1, ["D"]);            // II
+
+    writeModule(A2);
+    assert expectReChecks(C1, ["A"]);            // III
+
+     writeModule(C2);
+     return expectReChecks(C2, ["C", "D"]);      // IV
+}
+
+//          Math---------->Exception
+//           | ^             ^  ^
+//           |  \           /   |
+//           |    \        /    |
+//           |      \     /     |
+//           |        Set       |
+//           |      /  ^        |
+//           |    /    |        |
+//           |  /      |        |
+//           v v       |        |
+//  Map <----List<----Top       |
+//            |                 |
+//            +-----------------+
+
+test bool noBreakingChange5(){
+    Exception1 = "module Exception";
+    Exception2 = "module Exception
+                            int n = 0;";
+    Math = "module Math import Exception; import List; ";
+    List = "module List import Map; import Exception; ";
+    Map  = "module Map";
+    Set1 = "module Set import List; import Exception; import Math;";
+    Set2 = "module Set import List; import Exception; import Math;
+                        int m = 0;";
+    Top  = "module Top  import List; import Set; ";
+
+    writeModules(Exception1, Math, List, Map, Set1, Top);
+
+    assert expectReChecks(Top, ["Exception", "Math", "List", "Map", "Set", "Top"]);
+
+    writeModule(Exception2);
+    assert expectReChecks(Top, ["Exception"]);
+
+    writeModule(Set2);
+    assert expectReChecks(Top, ["Set"]);
+
+    writeModule(Exception1);
+    writeModule(Set1);
+    return expectReChecks(Top, ["Exception", "Set"]);
+}
+
+//   +-->A1!<-+  >>>  +-->A2!<-+         +-->A2<--+
+//   |        |       |        |         |        |
+//   B!       C1!     B!       C1!?  >>> B        C2!
+//   ^        ^       ^        ^         ^        ^
+//   |        |       |        |         |        |
+//   +---D!---+       +----D---+         +----D---+
+
+test bool breakingChange1(){
+    clearMemory();
+    A1 = "module A int f(int n) = n; int g() = 42;";
+    A2 = "module A int f(int n) = n;";
+    B  = "module B import A; int ff(int n) = f(n);";
+    C1 = "module C import A; int fff(int n) = f(n); int gg() = g();";
+    C2 = "module C import A; int fff(int n) = f(n);";
+    D  = "module D import B; import C;";
+
+    writeModules(A1, B, C1, D);
+
+    assert expectReChecks(D, ["A", "B", "C", "D"]);
+    writeModule(A2);
+    assert expectReChecksWithErrors(D, ["A", "B", "C"]);
+    writeModule(C2);
+    return expectReChecks(D, ["C", "D"]);
+}
+
+// ---- touch and recheck modules ---------------------------------------------
+
+bool touchAndCheck(loc Top, list[str] moduleNames, PathConfig pcfg){
+    println("TOUCH <moduleNames>");
+    for(mname <- moduleNames){
+        touch(getModuleLocation(mname, pcfg));
+    }
+    return expectReChecks(Top, moduleNames, pathConfig=pcfg);
+}
+
+test bool onlyTouchedModulesAreReChecked1(){
+    pcfg = getAllSrcPathConfig();
+    remove(pcfg.resources, recursive=true);
+    Top = getModuleLocation("analysis::grammars::Ambiguity", pcfg);
+    assert checkModuleOK(Top, pathConfig = pcfg);
+
+    assert touchAndCheck(Top, ["Exception"], pcfg);
+    assert touchAndCheck(Top, ["Set"], pcfg);
+    assert touchAndCheck(Top, ["Grammar"], pcfg);
+    return touchAndCheck(Top, ["Exception", "Set", "Grammar"], pcfg);
+}
+
+@ignore{Very expensive test}
+test bool onlyTouchedModulesAreReChecked2(){
+    pcfg = getAllSrcPathConfig();
+    remove(pcfg.resources, recursive=true);
+    Top = getModuleLocation("lang::rascalcore::check::Checker", pcfg);
+    assert checkModuleOK(Top, pathConfig = pcfg);
+
+    assert touchAndCheck(Top, ["Exception"], pcfg);
+    assert touchAndCheck(Top, ["Set"], pcfg);
+    assert touchAndCheck(Top, ["Exception", "Set"], pcfg);
+    assert touchAndCheck(Top, ["lang::rascalcore::check::CollectType"], pcfg);
+    return touchAndCheck(Top, ["Exception", "Set", "ParseTree", "analysis::typepal::TypePal", "lang::rascalcore::check::CollectType"], pcfg);
+}
+
+// ---- change and recheck modules --------------------------------------------
+
+str MARKER = "//TEMPORARILY ADDED FOR TESTING";
+
+void changeModules(list[str] moduleNames, PathConfig pcfg){
+    for(moduleName <- moduleNames){
+        mloc = getModuleLocation(moduleName, pcfg);
+        lines = readFileLines(mloc);
+        lines += MARKER;
+        writeFileLines(mloc, lines);
+    }
+}
+
+void restoreModules(list[str] moduleNames, PathConfig pcfg){
+    for(moduleName <- moduleNames){
+        mloc = getModuleLocation(moduleName, pcfg);
+        lines = readFileLines(mloc);
+        for(int i <- index(lines)){
+            if(lines[i] == MARKER){
+                writeFileLines(mloc, lines[..i]);
+                break;
+            }
+        }
+    }
+}
+
+bool changeAndCheck(loc Top, list[str] moduleNames, PathConfig pcfg){
+    println("CHANGE <moduleNames>");
+    changeModules(moduleNames, pcfg);
+    return expectReChecks(Top, moduleNames, pathConfig=pcfg);
+}
+
+test bool onlyChangedModulesAreReChecked1(){
+    pcfg = getAllSrcPathConfig();
+    remove(pcfg.resources, recursive=true);
+    Top = getModuleLocation("analysis::grammars::Ambiguity", pcfg);
+    assert checkModuleOK(Top, pathConfig = pcfg);
+
+    assert changeAndCheck(Top, ["Exception"], pcfg);
+    assert changeAndCheck(Top, ["Set"], pcfg);
+    assert changeAndCheck(Top, ["Grammar"], pcfg);
+    assert changeAndCheck(Top, ["Exception", "Set", "Grammar"], pcfg);
+
+    restoreModules(["Exception", "Set", "Grammar"], pcfg);
+    return true;
+}
+
+@ignore{Very expensive test}
+test bool onlyChangedModulesAreReChecked2(){
+    pcfg = getAllSrcPathConfig();
+    remove(pcfg.resources, recursive=true);
+    Top = getModuleLocation("lang::rascalcore::check::Checker", pcfg);
+    assert checkModuleOK(Top, pathConfig = pcfg);
+
+    assert changeAndCheck(Top, ["Exception"], pcfg);
+    assert changeAndCheck(Top, ["Set"], pcfg);
+    assert changeAndCheck(Top, ["Exception", "Set"], pcfg);
+    assert changeAndCheck(Top, ["lang::rascalcore::check::CollectType"], pcfg);
+    assert changeAndCheck(Top, ["Exception", "Set", "ParseTree", "analysis::typepal::TypePal",
+                                      "lang::rascalcore::check::CollectType"], pcfg);
+    restoreModules(["Exception", "Set", "ParseTree", "analysis::typepal::TypePal",
+                    "lang::rascalcore::check::CollectType"], pcfg);
+    return true;
+}
+
+// Benchmarks for incremental type checking
+
+void benchmark(str title, lrel[str, void()] cases){
+    measurements = [];
+	for (<str Name, runCase> <- cases) {
+		measurements+= <Name, realTimeOf(runCase)>;
+	}
+    sum(range(measurements));
+    println(title);
+    iprintln(measurements);
+    println("Total: <sum(range(measurements))>");
+}
+
+void miniBenchmarkRechecking(){
+    pcfg = getAllSrcPathConfig();
+    remove(pcfg.resources, recursive=true);
+    Top = getModuleLocation("ParseTree", pcfg);
+
+    cases =
+        [<"ParseTree, first", void(){ checkModuleOK(Top, pathConfig = pcfg); }>,
+         <"ParseTree, nochange", void(){ checkModuleOK(Top, pathConfig = pcfg); }>,
+         <"Exception", void(){ touchAndCheck(Top, ["Exception"], pcfg); }>,
+         <"Set", void(){ touchAndCheck(Top, ["Set"], pcfg); }>,
+         <"Exception+Set", void(){ touchAndCheck(Top, ["Exception", "Set"], pcfg); }>
+        ];
+    benchmark("miniBenchmarkRechecking", cases);
+}
+
+void mediumBenchmarkRechecking(){
+    pcfg = getAllSrcPathConfig();
+    remove(pcfg.resources, recursive=true);
+    Top = getModuleLocation("analysis::grammars::Ambiguity", pcfg);
+
+    cases =
+        [<"analysis::grammars::Ambiguity, first", void(){ checkModuleOK(Top, pathConfig = pcfg); }>,
+         <"analysis::grammars::Ambiguity, nochange", void(){ checkModuleOK(Top, pathConfig = pcfg); }>,
+         <"Exception", void(){ touchAndCheck(Top, ["Exception"], pcfg); }>,
+         <"Set", void(){ touchAndCheck(Top, ["Set"], pcfg); }>,
+         <"Grammar", void(){ touchAndCheck(Top, ["Grammar"], pcfg); }>,
+         <"Exception+Set+Grammar", void(){ touchAndCheck(Top, ["Exception", "Set", "Grammar"], pcfg); }>
+        ];
+
+    benchmark("mediumBenchmarkRechecking", cases);
+}
+
+void largeBenchmarkRechecking(){
+    pcfg = getAllSrcPathConfig();
+    remove(pcfg.resources, recursive=true);
+    Top = getModuleLocation("lang::rascalcore::check::Checker", pcfg);
+
+    cases =
+        [<"lang::rascalcore::check::Checker", void(){ checkModuleOK(Top, pathConfig = pcfg); }>,
+         <"Exception", void(){ touchAndCheck(Top, ["Exception"], pcfg); }>,
+         <"Set", void(){ touchAndCheck(Top, ["Set"], pcfg); }>,
+         <"Exception+Set", void(){ touchAndCheck(Top, ["Exception", "Set"], pcfg); }>,
+         <"lang::rascalcore::check::CollectType", void(){ touchAndCheck(Top, ["lang::rascalcore::check::CollectType"], pcfg); }>,
+         <"5 modules changed", void(){ touchAndCheck(Top, ["Exception", "Set", "ParseTree", "analysis::typepal::TypePal", "lang::rascalcore::check::CollectType"], pcfg); }>
+        ];
+
+    benchmark("largeBenchmarkRechecking", cases);
 }
\ No newline at end of file
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/check/tests/StaticTestingUtils.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/check/tests/StaticTestingUtils.rsc
index 3f28e3e8..2c6a0473 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/check/tests/StaticTestingUtils.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/check/tests/StaticTestingUtils.rsc
@@ -18,6 +18,8 @@ import lang::rascalcore::check::RascalConfig;
 
 import lang::rascalcore::check::Checker;
 
+bool verbose = false;
+
 PathConfig pathConfigForTesting() {
   return getDefaultTestingPathConfig();
 }
@@ -32,7 +34,7 @@ bool matches(str subject, str pat){
 
 tuple[str,str] extractModuleNameAndBody(str moduleText){
 	txt = trim(moduleText);
-	if(/module\s*<nm:[A-Z][A-Za-z0-9]*>\s*<body:.*$>/s := txt){
+	if(/module\s*<nm:[A-Z][A-Za-z0-9:]*>\s*<body:.*$>/s := txt){
 		return <nm, body>;
 	}
 	throw "Cannot extract module name from <moduleText>";
@@ -60,6 +62,12 @@ loc writeModule(str moduleText){
     return mloc;
 }
 
+void writeModules(str modules...){
+	for(mname <- modules){
+		writeModule(mname);
+	}
+}
+
 void removeModule(str mname){
 	pcfg = getDefaultTestingPathConfig();
 	name = cleanName(mname);
@@ -82,7 +90,6 @@ ModuleStatus checkStatements(str stmts) {
 }
 
 bool checkStatementsAndFilter(str stmts, list[str] expected) {
-	bool verbose=false;
      msgs = getAllMessages(checkStatements(stmts));
 	 if (verbose) {
      	println(msgs);
@@ -93,18 +100,28 @@ bool checkStatementsAndFilter(str stmts, list[str] expected) {
      }
      throw abbrev("<msgs>");
 }
-
-bool checkModuleAndFilter(str moduleText, list[str] expected) {
-	bool verbose=false;
+bool checkModuleAndFilter(str moduleText, list[str] expected, bool matchAll = false, bool errorsAllowed = true, PathConfig pathConfig = pathConfigForTesting()) {
 	mloc = writeModule(moduleText);
-    msgs = getAllMessages(rascalTModelForLocs([mloc], rascalCompilerConfig(pathConfigForTesting()), dummy_compile1));
+	return checkModuleAndFilter(mloc, expected, matchAll=matchAll, errorsAllowed=errorsAllowed, pathConfig=pathConfig);
+}
+bool checkModuleAndFilter(loc mloc, list[str] expected, bool matchAll = false, bool errorsAllowed = true, PathConfig pathConfig = pathConfigForTesting()) {
+    msgs = getAllMessages(rascalTModelForLocs([mloc], rascalCompilerConfig(pathConfig), dummy_compile1));
 	if (verbose) {
      	println(msgs);
 	 }
+	 if(!errorsAllowed && !isEmpty(msgs) && any(error(_,_) <- msgs)) return false;
+	 matched = {};
      for(eitem <- msgs, str exp <- expected){
-         if(matches(eitem.msg, exp))
+         if(matches(eitem.msg, exp)){
+		 	if(matchAll){
+				matched += eitem.msg;
+			} else
                return true;
+		 }
      }
+	 if(matchAll) {
+		return all(e <- expected, e in matched);
+	 }
      throw abbrev("<msgs>");
 }
 
@@ -115,17 +132,18 @@ bool checkOK(str stmts) {
      throw errors;
 }
 
-bool checkModuleOK(loc moduleToCheck) {
-     errors = getErrorMessages(rascalTModelForLocs([moduleToCheck], rascalCompilerConfig(pathConfigForTesting()), dummy_compile1));
+bool checkModuleOK(loc moduleToCheck, PathConfig pathConfig = pathConfigForTesting()) {
+     errors = getErrorMessages(rascalTModelForLocs([moduleToCheck], rascalCompilerConfig(pathConfig), dummy_compile1));
      if(size(errors) == 0)
         return true;
      throw abbrev("<errors>");
 }
 
-bool checkModuleOK(str moduleText){
+bool checkModuleOK(str moduleText, PathConfig pathConfig = pathConfigForTesting()){
 	<mname, mbody> = extractModuleNameAndBody(moduleText);
+	pathConfig.srcs += pathConfigForTesting().srcs;
 	mloc = writeModule(moduleText);
-	return checkModuleOK(mloc);
+	return checkModuleOK(mloc, pathConfig=pathConfig);
 }
 
 // bool checkModuleOK(str mbody){
@@ -367,3 +385,26 @@ bool unsupportedInModule(str moduleText)
 
 bool unsupported(str stmts) =
     checkStatementsAndFilter(stmts, unsupportedMsgs);
+
+// ---- expectChecks ----------------------------------------------------------
+
+bool expectReChecks(str moduleText, list[str] moduleNames, PathConfig pathConfig = pathConfigForTesting()){
+	mloc = writeModule(moduleText);
+	pathConfig.srcs +=  pathConfigForTesting().srcs;
+	return expectReChecks(mloc, moduleNames, pathConfig=pathConfig);
+}
+
+bool expectReChecks(loc mloc, list[str] moduleNames, PathConfig pathConfig = pathConfigForTesting()){
+	msgs = [ "Checked <nm>" | nm <- moduleNames ];
+	return checkModuleAndFilter(mloc, msgs, matchAll=true, errorsAllowed=false, pathConfig = pathConfig);
+}
+
+bool expectReChecksWithErrors(str moduleText, list[str] moduleNames, PathConfig pathConfig = pathConfigForTesting()){
+	mloc = writeModule(moduleText);
+	return return expectReChecksWithErrors(mloc, moduleNames, pathConfig=pathConfig);
+}
+
+bool expectReChecksWithErrors(loc mloc, list[str] moduleNames, PathConfig pathConfig = pathConfigForTesting()){
+	msgs = [ "Checked <nm>" | nm <- moduleNames ];
+	return checkModuleAndFilter(mloc, msgs, matchAll=true, errorsAllowed=true, pathConfig=pathConfig);
+}
\ No newline at end of file
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst0.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst0.rsc
index 43c69c2a..7ff08ee1 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst0.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst0.rsc
@@ -1 +1,14 @@
 module lang::rascalcore::compile::Examples::Tst0
+
+
+
+
+
+
+
+
+
+
+public int f(int n) = n;
+
+public int g() = 42;
\ No newline at end of file
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst1.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst1.rsc
index f92dab98..ef4f37c8 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst1.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst1.rsc
@@ -1,29 +1,12 @@
 module lang::rascalcore::compile::Examples::Tst1
-import IO;
-import util::Reflective;
-import lang::rascalcore::check::Checker;
-import util::Benchmark;
-
-void main() {
-    start_time = cpuTime();  
-    input_module = "B";
-    
-    pcfg = pathConfig(
-                    bin=|project://rascal-core/target/generated-test-sources2|,
-                    generatedSources=|project://rascal-core/target/generated-test-sources2|,
-                    resources = |project://rascal-core/target/generated-test-resources2|,
-                    srcs=[ //|project://rascal/src/org/rascalmpl/library|, 
-                           //|std:///|,  
-                           |project://rascal-core/src/org/rascalmpl/core/library|,
-                           |project://typepal/src|,
-                           |project://rascal-tutor/src|],
-                     libs=[|jar+file:///Users/paulklint/.m2/repository/org/rascalmpl/rascal/0.39.5-BOOT2/rascal-0.39.5-BOOT2.jar!|]
-                );
-    ModuleStatus result =  rascalTModelForNames([input_module],
-                                                  rascalCompilerConfig(pcfg),
-                                                  dummy_compile1
-                                                 );
-    iprintln(result.tmodels, lineLimit=10000);
-    //iprintln(result.tmodels[input_module].messages);
-    println("Total time for checker: <(cpuTime() - start_time)/1000000> ms");
-}
\ No newline at end of file
+
+import lang::rascalcore::compile::Examples::Tst0;
+
+
+
+
+
+
+
+
+public int T1 = f(3);
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst2.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst2.rsc
index c54aa646..850a1e91 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst2.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Examples/Tst2.rsc
@@ -1,22 +1,9 @@
 //@bootstrapParser
 module lang::rascalcore::compile::Examples::Tst2
 
-import util::Reflective;
-import  lang::rascalcore::compile::Compile;
+import lang::rascalcore::compile::Examples::Tst1;
 
-value main() {
-    pcfg = getRascalCorePathConfig();
-    input ="lang::rascalcore::check::Summary";
-    testConfig = pathConfig(
-                    bin=|project://rascal-core/target|,
-                    generatedSources=|project://rascal-core/target/generated-test-sources2|,
-                    resources = |project://rascal-core/target/generated-test-resources2|,
-                    srcs=[ |project://rascal/src/org/rascalmpl/library|, 
-                           |std:///|,  
-                           |project://rascal-core/src/org/rascalmpl/core/library|,
-                           |project://typepal/src|],
-                    libs = [|lib:///| ]
-                );
-    msgs = compile(input, getRascalCoreCompilerConfig());
-    return msgs;
-}
\ No newline at end of file
+
+
+
+public int T2 = T1 + 2;
\ No newline at end of file
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Rascal2muRascal/RascalExpression.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Rascal2muRascal/RascalExpression.rsc
index caefd584..c6f223b6 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Rascal2muRascal/RascalExpression.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Rascal2muRascal/RascalExpression.rsc
@@ -39,20 +39,20 @@ import lang::rascalcore::compile::Rascal2muRascal::RascalConstantCall;
 //import lang::rascalcore::compile::RVM::Interpreter::ParsingTools;
 
 /*
- * Translate a Rascal expression to muRascal using the function: 
+ * Translate a Rascal expression to muRascal using the function:
  * - MuExp translate(Expression e).
  */
- 
+
 /*********************************************************************/
 /*                  Auxiliary functions                              */
 /*********************************************************************/
 
 // Generate code for completely type-resolved operators
 
-private MuExp infix(str op, Expression e) { 
+private MuExp infix(str op, Expression e) {
     return muPrim(op, getType(e), [getType(e.lhs), getType(e.rhs)], [translate(e.lhs), translate(e.rhs)], e@\loc);
-}    
-private MuExp unary(str op, Expression e, Expression arg) = 
+}
+private MuExp unary(str op, Expression e, Expression arg) =
     muPrim(op, getType(e), [getType(arg)], [translate(arg)], e@\loc);
 
 // ----------- compose: exp o exp ----------------
@@ -74,19 +74,19 @@ private MuExp translateComposeFunction(Expression e){
   resType = getType(e);
   //if(overloadedAType(rel[loc, IdRole, AType] lhsOverloads) := lhsType){
   //  if(overloadedAType(rel[loc, IdRole, AType] rhsOverloads) := rhsType){
-  //      lhsType = overloadedAType({ltup | ltup:<loc ll, IdRole lidr, AType latype> <- lhsOverloads, 
-  //                                        any(rtup:<loc rl, IdRole ridr, AType ratype> <- rhsOverloads, 
-  //                                            comparable(getFunctionArgumentTypes(latype)[0], getResult(ratype)))}); 
+  //      lhsType = overloadedAType({ltup | ltup:<loc ll, IdRole lidr, AType latype> <- lhsOverloads,
+  //                                        any(rtup:<loc rl, IdRole ridr, AType ratype> <- rhsOverloads,
+  //                                            comparable(getFunctionArgumentTypes(latype)[0], getResult(ratype)))});
   //  } else {
   //      rhsResult = getResult(lhsType);
-  //      lhsType = overloadedAType({ltup | ltup:<loc ll, IdRole lidr, AType latype> <- lhsOverloads, 
-  //                                        comparable(getFunctionArgumentTypes(latype)[0], rhsResult)}); 
+  //      lhsType = overloadedAType({ltup | ltup:<loc ll, IdRole lidr, AType latype> <- lhsOverloads,
+  //                                        comparable(getFunctionArgumentTypes(latype)[0], rhsResult)});
   //  }
   //} else if(overloadedAType(rel[loc, IdRole, AType] overloads) := rhsType){
   //  leftArgType = getFunctionArgumentTypes(lhsType)[0];
-  //  rhsType = overloadedAType({tup | tup:<loc l, IdRole idr, AType atype> <- overloads, comparable(leftArgType, getResult(atype))}); 
+  //  rhsType = overloadedAType({tup | tup:<loc l, IdRole idr, AType atype> <- overloads, comparable(leftArgType, getResult(atype))});
   //}
-  
+
   return muComposedFun(translate(e.lhs), translate(e.rhs), lhsType, rhsType, resType);
 }
 
@@ -108,7 +108,7 @@ private MuExp translateAddFunction(Expression e){
   str add_name = "$ADD<e@\loc.begin.line>A<e@\loc.offset>L<e@\loc.length>";
   str add_fuid = scopeId + "_" + add_name;
 
-  MuExp lhsReceiver = translate(e.lhs); 
+  MuExp lhsReceiver = translate(e.lhs);
   MuExp rhsReceiver = translate(e.rhs);
 
   enterFunctionScope(add_fuid);
@@ -116,21 +116,21 @@ private MuExp translateAddFunction(Expression e){
   nargs = size(lhsFormals);
   lactuals = [muVar("$<j>", add_fuid, j, lhsFormals[j], formalId()) | int j <- [0 .. nargs]];
   lhsCall = muOCall(lhsReceiver, lhsType, lactuals, [], e.lhs@\loc);
-  
+
   rhsFormals = getFormals(rhsType);
   nargs = size(rhsFormals);
   ractuals = [muVar("$<j>" , add_fuid, j, rhsFormals[j], formalId()) | int j <- [0 .. nargs]];
   rhsCall = muOCall(rhsReceiver, rhsType, ractuals, [], e.rhs@\loc);
-  
+
   body = muReturnFirstSucceeds(["$<i>" | int i <- [0 .. nargs]], [muReturn1(resType, lhsCall), muReturn1(resType, rhsCall)]);
- 
+
   leaveFunctionScope();
   funType = afunc(resType, lhsFormals, []);
   fun = muFunction(add_name, add_name, funType, lactuals, [], [], scopeId, false, false, false, getExternalRefs(body, add_fuid, []), {}, {}, e@\loc, [], (), body);
   loc uid = declareGeneratedFunction(add_name, add_fuid, funType, e@\loc);
-  addFunctionToModule(fun);  
+  addFunctionToModule(fun);
   addDefineAndType(<currentFunctionDeclaration(), add_name, add_name, functionId(), /*1000+e@\loc.offset,*/ e@\loc, defType(funType)>, funType); // TODO: replace arbitrary number
- 
+
   return muOFun([uid], funType);
 }
 
@@ -143,21 +143,21 @@ MuExp translate(Literal lit)
 
 // -- boolean literal  -----------------------------------------------
 
-MuExp translate((Literal) `<BooleanLiteral b>`, BTSCOPES _btscopes) = 
+MuExp translate((Literal) `<BooleanLiteral b>`, BTSCOPES _btscopes) =
     "<b>" == "true" ? muCon(true) : muCon(false);
-    
-MuExp translateBool((Literal) `<BooleanLiteral b>`, BTSCOPES _btscopes, MuExp trueCont, MuExp falseCont) = 
+
+MuExp translateBool((Literal) `<BooleanLiteral b>`, BTSCOPES _btscopes, MuExp trueCont, MuExp falseCont) =
     "<b>" == "true" ? trueCont : falseCont;
 
 // -- integer literal  -----------------------------------------------
- 
-MuExp translateLiteral((Literal) `<IntegerLiteral n>`) = 
+
+MuExp translateLiteral((Literal) `<IntegerLiteral n>`) =
     muCon(toInt("<n>"));
 
 // -- regular expression literal  ------------------------------------
 
-MuExp translateLiteral((Literal) `<RegExpLiteral r>`) { 
-    throw "RexExpLiteral `<r>` cannot occur in expression"; 
+MuExp translateLiteral((Literal) `<RegExpLiteral r>`) {
+    throw "RexExpLiteral `<r>` cannot occur in expression";
 }
 
 // -- string literal  ------------------------------------------------
@@ -169,19 +169,19 @@ MuExp translateLiteral((Literal) `<StringLiteral n>`) {
 /* Recap of relevant rules from Rascal grammar:
 
    syntax StringLiteral
-        = template: PreStringChars pre StringTemplate template StringTail tail 
-	   | interpolated: PreStringChars pre Expression expression StringTail tail 
+        = template: PreStringChars pre StringTemplate template StringTail tail
+	   | interpolated: PreStringChars pre Expression expression StringTail tail
 	   | nonInterpolated: StringConstant constant ;
-	
+
    lexical PreStringChars
 	   = [\"] StringCharacter* [\<] ;
-	
+
    lexical MidStringChars
 	   =  [\>] StringCharacter* [\<] ;
-	
+
    lexical PostStringChars
 	   = @category="Constant" [\>] StringCharacter* [\"] ;
-*/	
+*/
 
 // -- translateStringLiteral
 
@@ -196,7 +196,7 @@ private MuExp translateStringLiteral(s: (StringLiteral) `<PreStringChars pre> <S
                            muTemplateClose(template)
                          ]);
 }
-    
+
 private MuExp translateStringLiteral(s: (StringLiteral) `<PreStringChars pre> <Expression expression> <StringTail tail>`) {
     preIndent = computeIndent(pre);
     str fuid = topFunctionScope();
@@ -208,7 +208,7 @@ private MuExp translateStringLiteral(s: (StringLiteral) `<PreStringChars pre> <E
     				       muTemplateClose(template)
 					     ]);
 }
-                    
+
 private MuExp translateStringLiteral(s: (StringLiteral)`<StringConstant constant>`) {
     return muCon(/*deescape(*/readTextValueString(removeMargins("<constant>"))/*)*/);
 }
@@ -218,7 +218,7 @@ private MuExp translateStringLiteral(s: (StringLiteral)`<StringConstant constant
 private MuExp translateExpOrTemplateInStringLiteral(MuExp template, str indent, Expression expression){    /* Expression | StringTemplate */
     if(indent == ""){
     	return muBlock([ muTemplateAdd(template, getType(expression), translate(expression)) ]);
-    }	
+    }
 	return muBlock([ muTemplateBeginIndent(template, indent),
     	             muTemplateAdd(template, getType(expression), translate(expression)),
     		         muTemplateEndIndent(template, indent)
@@ -228,7 +228,7 @@ private MuExp translateExpOrTemplateInStringLiteral(MuExp template, str indent,
 private MuExp translateExpOrTemplateInStringLiteral(MuExp template, str indent, StringTemplate stemplate){    /* Expression | StringTemplate */
     if(indent == ""){
         return muBlock([ muTemplateAdd(template, astr(), translate(stemplate)) ]);
-    }   
+    }
     return muBlock([ muTemplateBeginIndent(template, indent),
                      muTemplateAdd(template, astr(), translate(stemplate)),
                      muTemplateEndIndent(template, indent)
@@ -246,16 +246,16 @@ private str removeMargins(str s) {
 	}
 }
 
-// --- computeIndent 
+// --- computeIndent
 
 private str computeIndent(str s) {
    removed = removeMargins(s);
    if(endsWith(s, "\n")){
       return "";
    }
-   lines = split("\n", removed); 
+   lines = split("\n", removed);
    return isEmpty(lines) ? "" : left("", size(lines[-1]));
-} 
+}
 
 private str computeIndent(PreStringChars pre) = computeIndent(removeMargins(/*deescape(*/"<pre>"[1..-1]/*)*/));
 private str computeIndent(MidStringChars mid) = computeIndent(removeMargins(/*deescape(*/"<mid>"[1..-1]/*)*/));
@@ -263,30 +263,30 @@ private str computeIndent(MidStringChars mid) = computeIndent(removeMargins(/*de
 private str translatePreChars(PreStringChars pre) {
    spre = removeMargins("<pre>"[1..-1]);
    return "<spre>" == "" ? "" : deescape(spre);
-}	
+}
 
 private MuExp translateMidChars(MuExp template, MidStringChars mid) {
   smid = removeMargins("<mid>"[1..-1]);
   return "<mid>" == "" ? muBlock([]) : muTemplateAdd(template, astr(), deescape(smid));	//?
 }
-                     
+
 /* Recap of relevant rules from Rascal grammar:
 
    syntax StringTemplate
-	   = ifThen    : "if"    "(" {Expression ","}+ conditions ")" "{" Statement* preStats StringMiddle body Statement* postStats "}" 
-	   | ifThenElse: "if"    "(" {Expression ","}+ conditions ")" "{" Statement* preStatsThen StringMiddle thenString Statement* postStatsThen "}" "else" "{" Statement* preStatsElse StringMiddle elseString Statement* postStatsElse "}" 
-	   | \for       : "for"   "(" {Expression ","}+ generators ")" "{" Statement* preStats StringMiddle body Statement* postStats "}" 
-	   | doWhile   : "do"    "{" Statement* preStats StringMiddle body Statement* postStats "}" "while" "(" Expression condition ")" 
+	   = ifThen    : "if"    "(" {Expression ","}+ conditions ")" "{" Statement* preStats StringMiddle body Statement* postStats "}"
+	   | ifThenElse: "if"    "(" {Expression ","}+ conditions ")" "{" Statement* preStatsThen StringMiddle thenString Statement* postStatsThen "}" "else" "{" Statement* preStatsElse StringMiddle elseString Statement* postStatsElse "}"
+	   | \for       : "for"   "(" {Expression ","}+ generators ")" "{" Statement* preStats StringMiddle body Statement* postStats "}"
+	   | doWhile   : "do"    "{" Statement* preStats StringMiddle body Statement* postStats "}" "while" "(" Expression condition ")"
 	   | \while     : "while" "(" Expression condition ")" "{" Statement* preStats StringMiddle body Statement* postStats "}" ;
-	
+
    syntax StringMiddle
-	   = mid: MidStringChars mid 
-	   | template: MidStringChars mid StringTemplate template StringMiddle tail 
+	   = mid: MidStringChars mid
+	   | template: MidStringChars mid StringTemplate template StringMiddle tail
 	   | interpolated: MidStringChars mid Expression expression StringMiddle tail ;
-	
+
    syntax StringTail
-        = midInterpolated: MidStringChars mid Expression expression StringTail tail 
-        | post: PostStringChars post 
+        = midInterpolated: MidStringChars mid Expression expression StringTail tail
+        | post: PostStringChars post
         | midTemplate: MidStringChars mid StringTemplate template StringTail tail ;
 */
 
@@ -322,7 +322,7 @@ private MuExp translateTail(MuExp template, str indent, s: (StringTail) `<MidStr
                      translateTail(template, indent + midIndent, tail)
                    ]);
 }
-	
+
 private MuExp translateTail(MuExp template, str indent, (StringTail) `<PostStringChars post>`) {
   content = removeMargins("<post>"[1..-1]);
   return size(content) == 0 ? muBlock([]) : muTemplateAdd(template, astr(), deescape(content));
@@ -334,56 +334,56 @@ private MuExp translateTail(MuExp template, str indent, s: (StringTail) `<MidStr
                      translateTemplate(template, indent + midIndent, stemplate),
                      translateTail(template, indent + midIndent,tail)
                    ]);
- } 
- 
- // --- translateTemplate 
- 
+ }
+
+ // --- translateTemplate
+
  private default MuExp translateTemplate(MuExp template, str indent, StringTemplate stemplate){
     return translateExpOrTemplateInStringLiteral(template, indent, stemplate);
  }
- 
+
  private default MuExp translateTemplate(MuExp template, str indent, Expression expression){
     return translateExpOrTemplateInStringLiteral(template, indent, expression);
  }
- 
+
 // -- location literal  ----------------------------------------------
 
-MuExp translateLiteral((Literal) `<LocationLiteral src>`) = 
+MuExp translateLiteral((Literal) `<LocationLiteral src>`) =
     translateLocationLiteral(src);
- 
+
 /* Recap of relevant rules from Rascal grammar:
    syntax LocationLiteral
 	   = \default: ProtocolPart protocolPart PathPart pathPart ;
-	
+
    syntax ProtocolPart
-        = nonInterpolated: ProtocolChars protocolChars 
+        = nonInterpolated: ProtocolChars protocolChars
         | interpolated: PreProtocolChars pre Expression expression ProtocolTail tail ;
-    
+
    lexical PreProtocolChars
         = "|" URLChars "\<" ;
-    
+
    lexical MidProtocolChars
         = "\>" URLChars "\<" ;
-    
+
    lexical ProtocolChars
         = [|] URLChars "://" !>> [\t-\n \r \ \u00A0 \u1680 \u2000-\u200A \u202F \u205F \u3000];
 
    syntax ProtocolTail
-        = mid: MidProtocolChars mid Expression expression ProtocolTail tail 
+        = mid: MidProtocolChars mid Expression expression ProtocolTail tail
         | post: PostProtocolChars post ;
 
    lexical PostProtocolChars
-        = "\>" URLChars "://" ; 
-    
+        = "\>" URLChars "://" ;
+
    syntax PathPart
-        = nonInterpolated: PathChars pathChars 
+        = nonInterpolated: PathChars pathChars
         | interpolated: PrePathChars pre Expression expression PathTail tail ;
 
    lexical PathChars
         = URLChars [|] ;
-        
+
    syntax PathTail
-        = mid: MidPathChars mid Expression expression PathTail tail 
+        = mid: MidPathChars mid Expression expression PathTail tail
         | post: PostPathChars post ;
 
    lexical PrePathChars
@@ -391,7 +391,7 @@ MuExp translateLiteral((Literal) `<LocationLiteral src>`) =
 
    lexical MidPathChars
         = "\>" URLChars "\<" ;
-    
+
    lexical PostPathChars
         = "\>" URLChars "|" ;
  */
@@ -402,25 +402,25 @@ private MuExp toIString(MuExp e, loc src)
 private MuExp translateToIString(Expression e)
     = isStrAType(getType(e)) ? translate(e)
                              : muPrim("toIString", astr(), [avalue()], [translate(e)], e@\loc);
-    
+
 private MuExp translateLocationLiteral(l: (LocationLiteral) `<ProtocolPart protocolPart> <PathPart pathPart>`) =
-     muPrim("create_loc", aloc(), [astr()], 
-            [muPrim("add", astr(), [astr(), astr()], 
+     muPrim("create_loc", aloc(), [astr()],
+            [muPrim("add", astr(), [astr(), astr()],
                 [ translateProtocolPart(protocolPart),
                   translatePathPart(pathPart)
                 ],
                 l@\loc)
             ],
             l@\loc);
- 
+
 private MuExp translateProtocolPart((ProtocolPart) `<ProtocolChars protocolChars>`) = muCon("<protocolChars>"[1..]);
- 
+
 private MuExp translateProtocolPart(p: (ProtocolPart) `<PreProtocolChars pre> <Expression expression> <ProtocolTail tail>`) =
     muPrim("add", astr(), [astr(), astr(), astr()], [muCon("<pre>"[1..-1]), translateToIString(expression), translateProtocolTail(tail)], p@\loc);
- 
+
 private MuExp  translateProtocolTail(p: (ProtocolTail) `<MidProtocolChars mid> <Expression expression> <ProtocolTail tail>`) =
    muPrim("add", astr(), [astr(), astr(), astr()], [muCon("<mid>"[1..-1]), translateToIString(expression), translateProtocolTail(tail)], p@\loc);
-   
+
 private MuExp translateProtocolTail((ProtocolTail) `<PostProtocolChars post>`) = muCon("<post>"[1 ..]);
 
 private MuExp translatePathPart((PathPart) `<PathChars pathChars>`) = muCon("<pathChars>"[..-1]);
@@ -430,7 +430,7 @@ private MuExp translatePathPart(p: (PathPart) `<PrePathChars pre> <Expression ex
 
 private MuExp translatePathTail(p: (PathTail) `<MidPathChars mid> <Expression expression> <PathTail tail>`) =
    muPrim("add", astr(), [astr(), astr(), astr()], [ muCon("<mid>"[1..-1]), translateToIString(expression), translatePathTail(tail)], p@\loc);
-   
+
 private MuExp translatePathTail((PathTail) `<PostPathChars post>`) = muCon("<post>"[1..-1]);
 
 // -- all other literals  --------------------------------------------
@@ -449,35 +449,35 @@ default MuExp translateLiteral((Literal) `<Literal s>`) {
 
 // -- literal expression ---------------------------------------------
 
-MuExp translate(e:(Expression)  `<Literal s>`) = 
+MuExp translate(e:(Expression)  `<Literal s>`) =
     translateLiteral(s);
-    
-MuExp translateBool(e:(Expression)  `<Literal s>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) = 
+
+MuExp translateBool(e:(Expression)  `<Literal s>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) =
     translateBool(s, btscopes, trueCont, falseCont);
 
 // -- concrete syntax expression  ------------------------------------
 
-// this detects that the concrete string has been parsed correctly and we can 
+// this detects that the concrete string has been parsed correctly and we can
 // switch to compiling the tree values to muRascal expressions:
 MuExp translate(e:appl(prod(Symbol::label("parsed",Symbol::lex("Concrete")), [_],_),[Tree concrete])){
   return translateConcreteExpression(concrete);
-}  
-  
-// this detects that a parse error has occurred earlier and we generate an exception here:  
+}
+
+// this detects that a parse error has occurred earlier and we generate an exception here:
 MuExp translate(e:appl(prod(label("typed",lex("Concrete")), [_],_),_))
-  = muValueBlock(avalue(), [muThrow(muCon("(compile-time) parse error in concrete syntax"), e@\loc)]);   
+  = muValueBlock(avalue(), [muThrow(muCon("(compile-time) parse error in concrete syntax"), e@\loc)]);
 
 // these three constant parts of trees are directly mapped to constants:
 private MuExp translateConcreteExpression(t:appl(prod(lit(_),_, _), _)) = muCon(t);
 private MuExp translateConcreteExpression(t:appl(prod(cilit(_),_, _), _)) = muCon(t);
 private MuExp translateConcreteExpression(t:appl(prod(layouts(_),_, _), _)) = muCon(t);
-  
-// this is a pattern variable, which we substitute with a reference to a muVariable:  
+
+// this is a pattern variable, which we substitute with a reference to a muVariable:
 private MuExp translateConcreteExpression(t:appl(prod(Symbol::label("$MetaHole", Symbol _),[_], _), [ConcreteHole hole])) {
     <fuid, pos> = getVariableScope("<hole.name>", getConcreteHoleVarLoc(t));
-    
+
     return mkVar(unescape("<hole.name>"), hole.name@\loc);
-    //return muVar("<hole.name>", fuid, pos, getType(hole.symbol@\loc));    
+    //return muVar("<hole.name>", fuid, pos, getType(hole.symbol@\loc));
 }
 
 // Four cases of lists are detected to be able to implement splicing
@@ -486,18 +486,18 @@ private MuExp translateConcreteExpression(t:appl(p:Production::regular(s:Symbol:
   = muTreeAppl(muCon(p), translateConcreteExpressionList(elem, args, t@\loc), t@\loc);
 
 private MuExp translateConcreteExpression(t:appl(p:Production::regular(s:Symbol::\iter-star(Symbol elem)), list[Tree] args))
-  = muTreeAppl(muCon(p), translateConcreteExpressionList(elem, args, t@\loc), t@\loc); 
-   
+  = muTreeAppl(muCon(p), translateConcreteExpressionList(elem, args, t@\loc), t@\loc);
+
 private MuExp translateConcreteExpression(t:appl(p:Production::regular(s:Symbol::\iter-seps(Symbol elem, list[Symbol] seps)), list[Tree] args))
   = muTreeAppl(muCon(p), translateConcreteExpressionSeparatedList(elem, seps, args, t@\loc), t@\loc);
 
 private MuExp translateConcreteExpression(t:appl(p:Production::regular(s:Symbol::\iter-star-seps(Symbol elem, list[Symbol] seps)), list[Tree] args))
-  = muTreeAppl(muCon(p), translateConcreteExpressionSeparatedList(elem, seps, args, t@\loc), t@\loc); 
+  = muTreeAppl(muCon(p), translateConcreteExpressionSeparatedList(elem, seps, args, t@\loc), t@\loc);
 
 private MuExp translateConcreteExpression(char(int i)) =  muTreeChar(i);
 
 // this is a normal parse tree node:
-private default MuExp translateConcreteExpression(t:appl(Production p, list[Tree] args)) 
+private default MuExp translateConcreteExpression(t:appl(Production p, list[Tree] args))
   = muTreeAppl(muCon(p), [translateConcreteExpression(a) | a <- args], (t@\loc?) ? t@\loc : |unknown:///|); // TODO: t@\loc does not work here, why?????
 
 
@@ -516,11 +516,11 @@ private MuExp translateConcreteExpressionList(Symbol eltType, list[Tree] elems,
         return muCon([]);
     } else {
         str fuid = topFunctionScope();
-           
-        writer = muTmpListWriter(nextTmp("writer"), fuid);   
-        
+
+        writer = muTmpListWriter(nextTmp("writer"), fuid);
+
         enterWriter(writer.name);
-        
+
         code = for (Tree elem <- elems) {
            if (isListVar(eltType, elem)) {
               append muPrim("splice_list", avoid(), [avalue(), treeType], [writer, muTreeGetArgs(translateConcreteExpression(elem))], src);
@@ -529,10 +529,10 @@ private MuExp translateConcreteExpressionList(Symbol eltType, list[Tree] elems,
               append muPrim("add_list_writer", avoid(), [avalue(), treeType], [writer, translateConcreteExpression(elem)], src);
            }
         }
-       
+
         code = [muConInit(writer, muPrim("open_list_writer", avalue(), [], [], src)), *code];
         leaveWriter();
-       
+
         return muValueBlock(\alist(treeType), [*code, muPrim("close_list_writer", alist(treeType), [avalue()], [writer], src)]);
     }
 }
@@ -541,13 +541,13 @@ private MuExp translateConcreteExpressionSeparatedList(Symbol _, list[Symbol] _,
 
 private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symbol] _, [Tree single], loc src) {
     str fuid = topFunctionScope();
-       
-    writer = muTmpListWriter(nextTmp("writer"), fuid);   
-    
+
+    writer = muTmpListWriter(nextTmp("writer"), fuid);
+
     enterWriter(writer.name);
-    
+
     code = [muConInit(writer, muPrim("open_list_writer", avalue(), [], [], src))];
-       
+
     if (isListVar(eltType, single)) {
        varExp = muTreeGetArgs(translateConcreteExpression(single));
        code += [muPrim("splice_list", avoid(), [avalue(), treeType], [writer, varExp], src)];
@@ -556,19 +556,19 @@ private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symb
        code += [muPrim("add_list_writer", avoid(), [avalue(), treeType], [writer, translateConcreteExpression(single/*elem*/)], src)];
     }
     leaveWriter();
-        
-    return muValueBlock(\alist(treeType), [*code, muPrim("close_list_writer", alist(treeType), [avalue()], [writer], src)]);    
+
+    return muValueBlock(\alist(treeType), [*code, muPrim("close_list_writer", alist(treeType), [avalue()], [writer], src)]);
 }
 
 private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symbol] sepTypes, list[Tree] elems:[_,_,*_], loc src) {
     str fuid = topFunctionScope();
-       
-    writer = muTmpListWriter(nextTmp("writer"), fuid);   
-    
+
+    writer = muTmpListWriter(nextTmp("writer"), fuid);
+
     enterWriter(writer.name);
-    
+
     code = [muConInit(writer, muPrim("open_list_writer", avalue(), [], [], src))];
-    
+
     // first we compile all element except the final separators and the final element:
     while ([Tree first, *Tree sepTrees, Tree second, *Tree more] := elems && size(sepTypes) == size(sepTrees)) {
       varExp = translateConcreteExpression(first);
@@ -580,19 +580,19 @@ private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symb
       else {
         code += [muPrim("add_list_writer", avoid(), [avalue(), treeType], [writer, varExp], first@\loc?|unknown:///|)];
       }
-      
+
       sepCode    = [muPrim("add_list_writer", avoid(), [avalue(), treeType], [writer, muCon(e)], e@\loc?|unknown:///|) | e <- sepTrees];
       secondVarExp = translateConcreteExpression(second);
-       
-      // then separators are optionally added:  
+
+      // then separators are optionally added:
       if (isListStarVar(eltType, first) && isListStarVar(eltType, second)) {
-           
+
             if (more == []) {
               // if they are both star variables, and this is the last element then they both must be non-empty:
               sepCode = [muIfExp(muNotNativeBool(muEqual(muTreeGetArgs(varExp), muCon([]))),
                          muValueBlock(avoid(), sepCode),
                          muBlock([]))];
-            
+
               sepCode = [muIfExp(muNotNativeBool(muEqual(muTreeGetArgs(secondVarExp), muCon([]))),
                           muValueBlock(avoid(), sepCode),
                           muBlock([]))];
@@ -603,14 +603,14 @@ private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symb
                          muValueBlock(avoid(), sepCode),
                          muBlock([]))];
             }
-              
+
             code += sepCode;
       }
       else {
         // one of first or second is not a star var, so we always need the separators
         code += sepCode;
-      }    
-       
+      }
+
       if (more == []) {
         // the last element must be printed, or sliced now:
         if (isListVar(eltType, second)) {
@@ -622,17 +622,17 @@ private MuExp translateConcreteExpressionSeparatedList(Symbol eltType, list[Symb
       }
       elems = [second, *more];
     }
-     
-   
+
+
     leaveWriter();
-   
-    return muValueBlock(\alist(treeType), [*code, muPrim("close_list_writer", alist(treeType), [avalue()], [writer], src)]);   
+
+    return muValueBlock(\alist(treeType), [*code, muPrim("close_list_writer", alist(treeType), [avalue()], [writer], src)]);
 }
 
 
 // -- block expression ----------------------------------------------
 
-MuExp translate(e:(Expression) `{ <Statement+ statements> }`) = 
+MuExp translate(e:(Expression) `{ <Statement+ statements> }`) =
     muBlock([translate(stat, ()) | Statement stat <- statements]);
 
 // -- parenthesized expression --------------------------------------
@@ -645,7 +645,7 @@ BTINFO getBTInfo(e: (Expression) `(<Expression expression>)`, BTSCOPE btscope, B
 MuExp translate((Expression) `(<Expression expression>)`) {
     return translate(expression);
 }
-     
+
 MuExp translateBool((Expression) `(<Expression expression>)`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) =
      translateBool(expression, btscopes, trueCont, falseCont);
 
@@ -657,36 +657,37 @@ MuExp translate (e:(Expression) `<Type tp> <Parameters parameters> { <Statement+
 MuExp translate (e:(Expression) `<Parameters parameters> { <Statement* statements> }`) =
     translateClosure(e, parameters, [stat | stat <- statements]);
 
-// Translate a closure   
- 
+// Translate a closure
+
  private MuExp translateClosure(Expression e, Parameters parameters, list[Statement] cbody) {
  	uid = e@\loc;
 	fuid = convert2fuid(uid);
 	surrounding = topFunctionScope();
-	
+
 	enterFunctionScope(fuid);
-	
+
     ftype = getClosureType(e@\loc);
 	nformals = size(ftype.formals);
 	bool isVarArgs = ftype.varArgs;
-  	
+
   	// Keyword parameters
      lrel[str name, AType atype, MuExp defaultExp]  kwps = translateKeywordParameters(parameters);
-    
+
     enterSignatureSection();
     // TODO: we plan to introduce keyword patterns as formal parameters
     <formalVars, funBody> = translateFunction(fuid, parameters.formals.formals, ftype, muBlock([translate(stat, ()) | stat <- cbody]), false, []);
     typeVarsInParams = getFunctionTypeParameters(ftype);
-      
+
     leaveSignatureSection();
-    addFunctionToModule(muFunction("$CLOSURE_<uid.begin.line>A<uid.offset>", 
-                                   fuid, //"$CLOSURE_<uid.begin.line>A<uid.offset>", 
-                                   ftype, 
+    cname = "$CLOSURE_<getNextClosure()>";
+    addFunctionToModule(muFunction(cname, //"$CLOSURE_<uid.begin.line>A<uid.offset>",
+                                   cname, //fuid, //"$CLOSURE_<uid.begin.line>A<uid.offset>",
+                                   ftype,
                                    formalVars,
                                    [],
                                    kwps,
-                                   surrounding, 
-  								   isVarArgs, 
+                                   surrounding,
+  								   isVarArgs,
   								   false,
   								   false,
   								   getExternalRefs(funBody, fuid, formalVars),  // << TODO
@@ -696,9 +697,9 @@ MuExp translate (e:(Expression) `<Parameters parameters> { <Statement* statement
   								   [],
   								   (),
   								   funBody));
-  	
-  	leaveFunctionScope();								  
-  	return muFun(uid, ftype); // TODO!
+
+  	leaveFunctionScope();
+  	return muFun(cname, ftype); // TODO!
 }
 
 // -- range expression ----------------------------------------------
@@ -709,7 +710,7 @@ MuExp translate (e:(Expression) `[ <Expression first> .. <Expression last> ]`) {
   elemType = alub(getType(first), getType(last));
   elem = muTmpIValue(nextTmp("range_elem"), fuid,elemType);
   resultType = getType(e);
-  
+
   return
     muValueBlock(resultType,
                  [ muConInit(writer, muPrim("open_list_writer", avalue(), [], [], e@\loc)),
@@ -725,7 +726,7 @@ MuExp translate (e:(Expression) `[ <Expression first> , <Expression second> .. <
   writer = muTmpListWriter(nextTmp("range_writer"), fuid);
   elemType = lubList([getType(first), getType(second), getType(last)]);
   elem = muTmpIValue(nextTmp("range_elem"), fuid, elemType);
-  
+
   return
     muValueBlock(getType(e),
                  [ muConInit(writer, muPrim("open_list_writer", alist(elemType), [], [], e@\loc)),
@@ -738,25 +739,25 @@ 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) {	
+public MuExp translateVisit(Label label, lang::rascal::\syntax::Rascal::Visit \visit, BTSCOPES btscopes) {
     str fuid = topFunctionScope();
     subjectType = getType(\visit.subject);
     enterVisit(subjectType);
-   
+
     visitName = getLabel(label, "VISIT");
-    visitSubject = muTmpIValue("$<visitName>_subject", fuid, avalue());    
-	visitResult = muTmpIValue("$<visitName>_result", fuid, avalue());    
-    
+    visitSubject = muTmpIValue("$<visitName>_subject", fuid, avalue());
+	visitResult = muTmpIValue("$<visitName>_result", fuid, avalue());
+
 	bool isStringSubject = false; //subjectType == \str();
-	
+
 	cases = [ c | Case c <- \visit.cases ];
-	
-	useConcreteFingerprint = hasConcretePatternsOnly(cases) 
+
+	useConcreteFingerprint = hasConcretePatternsOnly(cases)
 	                         && isConcreteType(subjectType); // || subjectType == adt("Tree",[],_));
-	
+
 	reachable_syms = { avalue() };
 	reachable_prods = {};
-	
+
 	if(optimizeVisit()){
 	   tc = getTypesAndConstructorsInVisit(cases);
 	   <reachable_syms1, reachable_prods1> = getReachableTypes(subjectType, tc.constructors, tc.types, useConcreteFingerprint);
@@ -764,21 +765,21 @@ public MuExp translateVisit(Label label, lang::rascal::\syntax::Rascal::Visit \v
 	   reachable_prods = reachable_prods1;
 	   //println("reachableTypesInVisit, <size(reachable_syms)>: <reachable_syms>, <size(reachable_prods)>: <reachable_prods>");
 	}
-	
+
 	ddescriptor = descendantDescriptor(useConcreteFingerprint, reachable_syms, reachable_prods, getReifiedDefinitions());
-		
+
 	bool direction = true;
 	bool progress = true;
 	bool fixedpoint = true;
 	bool rebuild = false;
-	
-	if( Case c <- \visit.cases, (c is patternWithAction && c.patternWithAction is replacing 
+
+	if( Case c <- \visit.cases, (c is patternWithAction && c.patternWithAction is replacing
 									|| hasTopLevelInsert(c)) ) {
 		rebuild = true;
 	}
-	
+
 	if(\visit is defaultStrategy) {
-		                              direction = true;  progress = true;  fixedpoint = false; 
+		                              direction = true;  progress = true;  fixedpoint = false;
 	} else {
 		switch("<\visit.strategy>") {
 			case "bottom-up"      : { direction = true;  progress = true;  fixedpoint = false; }
@@ -789,10 +790,10 @@ public MuExp translateVisit(Label label, lang::rascal::\syntax::Rascal::Visit \v
 			case "outermost"      : { direction = false; progress = true;  fixedpoint = true;  }
 		}
 	}
-	
+
 	vdescriptor = visitDescriptor(direction, fixedpoint, progress, rebuild, ddescriptor);
 	<case_code, default_code> = translateSwitchCases(visitName, visitSubject, fuid, useConcreteFingerprint, cases, muSucceedVisitCase(visitName), btscopes);
-    
+
     visitCode = muVisit(visitName, muConInit(visitSubject, translate(\visit.subject)), case_code, default_code, vdescriptor);
     leaveVisit();
     return visit(visitCode) { case muReturn0() => muReturn0FromVisit() case muReturn1(AType t, MuExp e) => muReturn1FromVisit(t, e) };
@@ -841,13 +842,13 @@ MuExp translate (e:(Expression) `( <Expression init> | <Expression result> | <{E
 private MuExp translateReducer(Expression e){
     redName = nextTmp("REDUCER");
     str fuid = topFunctionScope();
-    
+
     //btfree = all(Expression c <- e.generators, backtrackFree(c));
     //enterBacktrackingScope(redName);
-    
+
     conds = normalizeAnd([g | g <- e.generators]);
     btscopes = getBTScopesAnd(conds, redName, ());
-    
+
     reducerTmp = muTmpIValue(nextTmp("reducer"), fuid, getType(e));
     pushIt(reducerTmp);
     code =  muValueBlock(getType(e), [ muVarInit(reducerTmp, translate(e.init)), translateAndConds(btscopes, conds, muAssign(reducerTmp, translate(e.result)), muBlock([])),  reducerTmp ]);
@@ -863,12 +864,12 @@ private MuExp translateReducer(Expression e){
 // -- reified type expression ---------------------------------------
 
 MuExp translate (e:(Expression) `type ( <Expression symbol> , <Expression definitions >)`) {
-    return muPrim("create_reifiedType", avalue(), [avalue(), avalue()], [translate(symbol), translate(definitions)], e@\loc);   
+    return muPrim("create_reifiedType", avalue(), [avalue(), avalue()], [translate(symbol), translate(definitions)], e@\loc);
 }
 
 // -- call expression -----------------------------------------------
 
-MuExp translate(e:(Expression) `<Expression expression> ( <{Expression ","}* arguments> <KeywordArguments[Expression] keywordArguments>)`){  
+MuExp translate(e:(Expression) `<Expression expression> ( <{Expression ","}* arguments> <KeywordArguments[Expression] keywordArguments>)`){
    lrel[str,MuExp] kwargs = translateKeywordArguments(keywordArguments);
    ftype = getType(expression); // Get the type of a receiver
    MuExp receiver = translate(expression);
@@ -877,7 +878,7 @@ MuExp translate(e:(Expression) `<Expression expression> ( <{Expression ","}* arg
    if(exp_type == "astr"){
    		return muPrim("create_node", getType(e), [ getType(arg) | arg <- arguments ], [receiver, *args, muKwpActuals(kwargs)], e@\loc);
    }
-  
+
    if(exp_type == "aloc"){
        if(size(args) == 2){
             return muPrim("create_loc_with_offset", aloc(), [aloc(), aint(), aint()], [receiver, *args], e@\loc);
@@ -890,7 +891,7 @@ MuExp translate(e:(Expression) `<Expression expression> ( <{Expression ","}* arg
         // Try to reduce non-overloaded function call (and three selected overloaded ones) to a constant
    		try {
    			return translateConstantCall(fname, args); //TODO: kwargs?
-   		} 
+   		}
    		catch "NotConstant":  /* not a constant, generate an ordinary call instead */;
    }
    return muOCall(receiver, ftype, args, kwargs, e@\loc);
@@ -898,7 +899,7 @@ MuExp translate(e:(Expression) `<Expression expression> ( <{Expression ","}* arg
 
 private lrel[str,MuExp] translateKeywordArguments((KeywordArguments[Expression]) `<KeywordArguments[Expression] keywordArguments>`) {
    // Version that does not propagates values of set keyword parameters downwards and is compatible with the interpreter
-    
+
    kwargs = [];
    if(keywordArguments is \default){
       kwargs = [ <unescape("<kwarg.name>"), translate(kwarg.expression)>  | kwarg <- keywordArguments.keywordArgumentList ];
@@ -908,7 +909,7 @@ private lrel[str,MuExp] translateKeywordArguments((KeywordArguments[Expression])
 
 MuExp translateBool(e:(Expression) `<Expression expression> ( <{Expression ","}* arguments> <KeywordArguments[Expression] keywordArguments>)`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
    = muIfExp(translate(e), trueCont, falseCont);
-   
+
 // -- any expression ------------------------------------------------
 
 BTINFO getBTInfo(e:(Expression) `any ( <{Expression ","}+ generators> )`, BTSCOPE btscope, BTSCOPES btscopes){
@@ -919,7 +920,7 @@ BTINFO getBTInfo(e:(Expression) `any ( <{Expression ","}+ generators> )`, BTSCOP
     }
     return registerBTScope(e, <btscope1.enter, btscope1.resume, btscope.resume>, btscopes);
 }
-    
+
 MuExp translate (e:(Expression) `any ( <{Expression ","}+ generators> )`){
     gens = normalizeAnd([ g | g <- generators ]);
     return translateQuantor(gens, quantorAll = false);
@@ -957,10 +958,10 @@ MuExp translateQuantor(list[Expression] generators, bool quantorAll = true, bool
     enter_quantor = nextTmp(quantorAll ? "ALL" : "ANY");
     my_btscopes = getBTScopesAnd(conds, enter_quantor, ());
     if(quantorAll){
-     return negateGenerators ? translateQuantorNotAll(conds, my_btscopes, done) 
+     return negateGenerators ? translateQuantorNotAll(conds, my_btscopes, done)
                              : translateQuantorAll(conds, my_btscopes, done);
     }
-    return negateGenerators ? translateQuantorNotAny(conds, my_btscopes, done) 
+    return negateGenerators ? translateQuantorNotAny(conds, my_btscopes, done)
                             : translateQuantorAny(conds, my_btscopes, done);
 }
 
@@ -968,7 +969,7 @@ MuExp translateQuantorAll(list[Expression] conds, BTSCOPES my_btscopes, MuExp do
     enter_gen = getEnter(conds[0], my_btscopes);
     trueCont = muContinue(enter_gen);
     falseCont = muBlock([]);
-    
+
     if(all(cond <- conds, backtrackFree(cond))){
         for(cond <- reverse(conds)){
             trueCont = translateBool(cond, my_btscopes, trueCont, falseCont);
@@ -979,14 +980,14 @@ MuExp translateQuantorAll(list[Expression] conds, BTSCOPES my_btscopes, MuExp do
         cont = i == 0 ? falseCont : muBlock([ muAssign(done, muCon(false)), muBreak(getFail(conds[i-1], my_btscopes))]);
         trueCont = translateBool(conds[i], my_btscopes, trueCont, cont);
     }
-    
+
     return muValueBlock(abool(), [ muVarInit(done, muCon(true)), muExists(enter_gen, trueCont), done ]);
 }
 
 MuExp translateQuantorNotAll(list[Expression] conds, BTSCOPES my_btscopes, MuExp done){
     enter_gen = getEnter(conds[0], my_btscopes);
-    trueCont = falseCont = muBlock([]); 
-    
+    trueCont = falseCont = muBlock([]);
+
     if(all(cond <- conds, backtrackFree(cond))){
         for(cond <- reverse(conds)){
             trueCont = translateBool(cond, my_btscopes, trueCont, falseCont);
@@ -997,7 +998,7 @@ MuExp translateQuantorNotAll(list[Expression] conds, BTSCOPES my_btscopes, MuExp
         cont = i == 0 ? falseCont : muBlock([ muAssign(done, muCon(true)), muSucceed(enter_gen)]);
         trueCont = translateBool(conds[i], my_btscopes, trueCont, cont);
     }
-    
+
     return muValueBlock(abool(), [ muVarInit(done, muCon(false)), muExists(enter_gen, trueCont), done ]);
 }
 
@@ -1005,7 +1006,7 @@ MuExp translateQuantorAny(list[Expression] conds, BTSCOPES my_btscopes, MuExp do
     enter_gen = getEnter(conds[0], my_btscopes);
     trueCont = muBlock([ muAssign(done, muCon(true)), muSucceed(enter_gen) ]);
     falseCont = muBlock([]);
-    
+
     if(all(cond <- conds, backtrackFree(cond))){
         for(cond <- reverse(conds)){
             trueCont = translateBool(cond, my_btscopes, trueCont, falseCont);
@@ -1013,10 +1014,10 @@ MuExp translateQuantorAny(list[Expression] conds, BTSCOPES my_btscopes, MuExp do
         return muValueBlock(abool(), [ muVarInit(done, muCon(true)), trueCont ]);
     }
     for(i <- reverse(index(conds))){
-        cont = i == 0 ? falseCont : muFail(getFail(conds[i-1], my_btscopes), comment="any quantor"); 
+        cont = i == 0 ? falseCont : muFail(getFail(conds[i-1], my_btscopes), comment="any quantor");
         trueCont = translateBool(conds[i], my_btscopes, trueCont, cont);
     }
-    
+
     return muValueBlock(abool(), [ muVarInit(done, muCon(false)), muExists(enter_gen, trueCont), done ]);
 }
 
@@ -1024,7 +1025,7 @@ MuExp translateQuantorNotAny(list[Expression] conds, BTSCOPES my_btscopes, MuExp
     enter_gen = getEnter(conds[0], my_btscopes);
     trueCont = muBlock([ muAssign(done, muCon(false)), muSucceed(enter_gen) ]);
     falseCont = muBlock([]);
-    
+
     if(all(cond <- conds, backtrackFree(cond))){
         for(cond <- reverse(conds)){
             trueCont = translateBool(cond, my_btscopes, trueCont, falseCont);
@@ -1035,7 +1036,7 @@ MuExp translateQuantorNotAny(list[Expression] conds, BTSCOPES my_btscopes, MuExp
         cont = i == 0 ? falseCont : muFail(getFail(conds[i-1], my_btscopes), comment="not any");
         trueCont = translateBool(conds[i], my_btscopes, trueCont, cont);
     }
-    
+
     return muValueBlock(abool(), [ muVarInit(done, muCon(true)), muExists(enter_gen, trueCont), done ]);
 }
 
@@ -1044,7 +1045,7 @@ MuExp translateQuantorNotAny(list[Expression] conds, BTSCOPES my_btscopes, MuExp
 MuExp translate ((Expression) `<Comprehension comprehension>`) = translateComprehension(comprehension);
 
 private list[MuExp] translateComprehensionContribution(str kind, AType resultType, MuExp writer, list[Expression] results){
-  return 
+  return
 	  for( r <- results){
 	    if((Expression) `* <Expression exp>` := r){
 	       append muPrim("splice_<kind>", resultType, [avalue(), getType(r)], [writer, translate(exp)], exp@\loc);
@@ -1052,7 +1053,7 @@ private list[MuExp] translateComprehensionContribution(str kind, AType resultTyp
 	      append muPrim("add_<kind>_writer", resultType, [avalue(), getType(r)], [writer, translate(r)], r@\loc);
 	    }
 	  }
-} 
+}
 
 private MuExp translateComprehension(c: (Comprehension) `[ <{Expression ","}+ results> | <{Expression ","}+ generators> ]`) {
     //println("translateComprehension (list): <generators>");
@@ -1062,11 +1063,11 @@ private MuExp translateComprehension(c: (Comprehension) `[ <{Expression ","}+ re
     conds = normalizeAnd([ g | Expression g <- generators ]);
     btscopes = getBTScopesAnd(conds, nextTmp("LCOMP"), ());
     //iprintln(btscopes);
-    return 
+    return
         muValueBlock(resultType,
                      [ muConInit(writer, muPrim("open_list_writer", avalue(), [], [], c@\loc)),
                        translateAndConds(btscopes, conds, muBlock(translateComprehensionContribution("list", resultType, writer, [r | r <- results])), muBlock([])),
-                       muPrim("close_list_writer", getType(c), [avalue()], [writer], c@\loc) 
+                       muPrim("close_list_writer", getType(c), [avalue()], [writer], c@\loc)
                      ]);
 }
 
@@ -1082,7 +1083,7 @@ private MuExp translateComprehension(c: (Comprehension) `{ <{Expression ","}+ re
         muValueBlock(resultType,
                      [ muConInit(writer, muPrim("open_set_writer", avalue(), [], [], c@\loc)),
                       translateAndConds(btscopes, conds, muBlock(translateComprehensionContribution("set", resultType, writer, [r | r <- results])), muBlock([])),
-                      muPrim("close_set_writer", getType(c), [avalue()], [writer], c@\loc) 
+                      muPrim("close_set_writer", getType(c), [avalue()], [writer], c@\loc)
                     ]);
 }
 
@@ -1097,7 +1098,7 @@ private MuExp translateComprehension(c: (Comprehension) `(<Expression from> : <E
         muValueBlock(resultType,
                      [ muConInit(writer, muPrim("open_map_writer", avalue(), [], [], c@\loc)),
                        translateAndConds(btscopes, conds, muPrim("add_map_writer", avoid(), [getType(from), getType(to)], [writer] + [ translate(from), translate(to)], c@\loc), muBlock([])),
-                       muPrim("close_map_writer", resultType, [avalue()], [writer], c@\loc) 
+                       muPrim("close_map_writer", resultType, [avalue()], [writer], c@\loc)
                      ]);
 }
 
@@ -1108,7 +1109,7 @@ MuExp translate(Expression e:(Expression)`{ <{Expression ","}* es> }`) =
 
 // -- list expression -----------------------------------------------
 
-MuExp translate(Expression e:(Expression)`[ <{Expression ","}* es> ]`) = 
+MuExp translate(Expression e:(Expression)`[ <{Expression ","}* es> ]`) =
     translateSetOrList(e, es, "list");
 
 // Translate SetOrList including spliced elements
@@ -1121,10 +1122,10 @@ private MuExp translateSetOrList(Expression e, {Expression ","}* es, str kind){
  if(containsSplices(es)){
        str fuid = topFunctionScope();
        writer = kind == "list" ? muTmpListWriter(nextTmp("writer"), fuid) : muTmpSetWriter(nextTmp("writer"), fuid);;
-      
-       
+
+
        kindwriter_open_code = muPrim("open_<kind>_writer", avalue(), [], [], e@\loc);
-       
+
        enterWriter(writer.name);
        code = [ muConInit(writer, kindwriter_open_code) ];
        for(elem <- es){
@@ -1140,7 +1141,7 @@ private MuExp translateSetOrList(Expression e, {Expression ","}* es, str kind){
     } else {
       //if(size(es) == 0 || all(elm <- es, isConstant(elm))){
       //   return kind == "list" ? muCon([getConstantValue(elm) | elm <- es]) : muCon({getConstantValue(elm) | elm <- es});
-      //} else 
+      //} else
         return muPrim("create_<kind>", getType(e), [elmType], [ translate(elem) | Expression elem <- es ], e@\loc);
     }
 }
@@ -1152,7 +1153,7 @@ MuExp translate (e: (Expression) `# <Type tp>`) {
 	res = muATypeCon(t, collectNeededDefs(t));
 	//println("<e> ==\>"); iprintln(res);
 	return res;
-}	
+}
 
 // -- tuple expression ----------------------------------------------
 
@@ -1168,27 +1169,27 @@ MuExp translate (e:(Expression) `\< <{Expression ","}+ elements> \>`) {
 MuExp translate (e:(Expression) `( <{Mapping[Expression] ","}* mappings> )`) {
    //if(isConstant(e)){
    //  return muCon(readTextValueString("<e>"));
-   //} else 
+   //} else
    mapType = getType(e);
    return muPrim("create_map", mapType, [mapType.keyType, mapType.valType], [ translate(m.from), translate(m.to) | m <- mappings ], e@\loc);
-}   
+}
 
 // -- it expression (in reducer) ------------------------------------
 
-MuExp translate (e:(Expression) `it`) = 
+MuExp translate (e:(Expression) `it`) =
     muTmpIValue(topIt().name,topIt().fuid, getType(e));
-    
-MuExp translateBool(e:(Expression) `it`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) = 
+
+MuExp translateBool(e:(Expression) `it`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) =
     muTmpIValue(topIt().name,topIt().fuid, getType(e));
- 
+
 // -- qualified name expression -------------------------------------
- 
-MuExp translate((Expression) `<QualifiedName v>`) = 
+
+MuExp translate((Expression) `<QualifiedName v>`) =
     translate(v);
-    
-MuExp translateBool((Expression) `<QualifiedName v>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) = 
+
+MuExp translateBool((Expression) `<QualifiedName v>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) =
     translateBool(v, btscopes, trueCont, falseCont);
- 
+
 MuExp translate((QualifiedName) `<QualifiedName v>`) =
     mkVar(prettyPrintName(v), v@\loc);
 
@@ -1213,7 +1214,7 @@ private MuExp translateSubscript(Expression e:(Expression) `<Expression exp> [ <
    op = isGuarded ? "guarded_subscript" : "subscript";
    access = muPrim(op, avalue() /*getType(e)*/, getType(exp) + [getType(s) | s <- subscripts],
                        translate(exp) + [isWildCard("<s>") ? muCon("_") : translate(s) | Expression s <- subscripts], e@\loc);
-   
+
    return access;
 }
 
@@ -1251,24 +1252,24 @@ MuExp translate (e:(Expression) `<Expression expression> . <Name field>`) {
    tp = stripStart(orgtp);
    fieldType = getType(field);
    ufield = unescape("<field>");
-   
+
    if(isTupleAType(tp) || isRelAType(tp) || isListRelAType(tp) || isMapAType(tp)) {
        return translateProject(e, expression, [(Field)`<Name field>`], e@\loc, false);
    }
-   
+
    if(isADTAType(tp)){
         <definingModule, consType, isKwp> = getConstructorInfo(orgtp, fieldType, ufield);
         return isKwp ? muGetKwField(consType, tp, translate(expression), ufield, definingModule)
                      : muGetField(getType(e), consType, translate(expression), ufield);
-    } else 
+    } else
     if(asubtype(tp, treeType)){
         <definingModule, consType, isKwp> = getConstructorInfo(treeType, fieldType, ufield);
         return isKwp ? muGetKwField(consType, treeType, translate(expression), ufield, definingModule)
                      : muGetField(getType(e), treeType, translate(expression), ufield); // Can this ever happen?
     }
-    
-    
-    return muGetField(getType(e), getType(expression), translate(expression), ufield);   
+
+
+    return muGetField(getType(e), getType(expression), translate(expression), ufield);
 }
 
 MuExp translateBool(e:(Expression) `<Expression expression> . <Name field>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
@@ -1278,7 +1279,7 @@ MuExp translateBool(e:(Expression) `<Expression expression> . <Name field>`, BTS
 // -- field update expression ---------------------------------------
 
 MuExp translate ((Expression) `<Expression expression> [ <Name key> = <Expression replacement> ]`) {
-    tp = getType(expression);  
+    tp = getType(expression);
     list[str] fieldNames = [];
     if(isRelAType(tp)){
        tp = getSetElementType(tp);
@@ -1297,7 +1298,7 @@ MuExp translate ((Expression) `<Expression expression> [ <Name key> = <Expressio
     }
     if(isTupleAType(tp) && tupleHasFieldNames(tp)){
     	  fieldNames = getTupleFieldNames(tp);
-    }	
+    }
     //TODO
     return muSetField(tp, getType(expression), translate(expression), indexOf(fieldNames, unescape("<key>")), translate(replacement));
 }
@@ -1308,8 +1309,8 @@ MuExp translate (e:(Expression) `<Expression expression> \< <{Field ","}+ fields
   translateProject(e, expression, [f | f <- fields], e@\loc, false);
 
 MuExp translateProject(Expression e, Expression base, list[Field] fields, loc src, bool isGuarded){
-    tp = getType(base); 
- 
+    tp = getType(base);
+
     if(isNodeAType(tp)){
         fieldName = ["<f>" | f <- fields][0];
         if(isGuarded){
@@ -1318,7 +1319,7 @@ MuExp translateProject(Expression e, Expression base, list[Field] fields, loc sr
            return muGetField(avalue(), tp, translate(base), fieldName);
          }
     }
-    
+
     list[str] fieldNames = [];
     if(isRelAType(tp)){
        tp = getSetElementType(tp);
@@ -1335,7 +1336,7 @@ MuExp translateProject(Expression e, Expression base, list[Field] fields, loc sr
        	fieldNames = getTupleFieldNames(tp);
     }
     fcode = [(f is index) ? muCon(toInt("<f>")) : muCon(indexOf(fieldNames, unescape("<f>"))) | f <- fields];
-      
+
     return muPrim((isGuarded ? "guarded_" : "") + "field_project", getType(e), [getType(base)], [ translate(base), *fcode], src);
 }
 
@@ -1343,7 +1344,7 @@ MuExp translateProject(Expression e, Expression base, list[Field] fields, loc sr
 
 // TODO: Deprecated
 MuExp translate (e:(Expression) `<Expression expression> [ @ <Name name> = <Expression val> ]`) {
-    tp = getType(expression);  
+    tp = getType(expression);
     list[str] fieldNames = [];
     uname = unescape("<name>");
     if(isRelAType(tp)){
@@ -1364,21 +1365,21 @@ MuExp translate (e:(Expression) `<Expression expression> [ @ <Name name> = <Expr
     }
     if(tupleHasFieldNames(tp)){
           fieldNames = getTupleFieldNames(tp);
-    }   
+    }
     //TODO
     return muSetField(tp, getType(expression), translate(expression), indexOf(fieldNames, uname), translate(val));
-    
+
 }
 
 // -- get annotation expression -------------------------------------
 //TODO: Deprecated
 MuExp translate (e:(Expression) `<Expression expression>@<Name name>`) {
-    tp = getType(expression);  
+    tp = getType(expression);
     uname = unescape("<name>");
     //if(asubtype(tp, treeType) && uname == "loc"){ //TODO: remove when loc anno has been removed
     //    uname = "src"; // rename loc to src
     //}
-    //return muGetField(getType(e), tp, translate(expression), uname);   
+    //return muGetField(getType(e), tp, translate(expression), uname);
     return muGetAnno(translate(expression), getType(e), uname);
 }
 
@@ -1389,21 +1390,21 @@ MuExp translate (e:(Expression) `<Expression expression> is <Name name>`) =
 
 MuExp translateBool(e:(Expression) `<Expression expression> is <Name name>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
     = muIfExp(translate(e),  trueCont, falseCont);
-    
+
 // -- has expression -----------------------------------------------
 
 MuExp translate ((Expression) `<Expression expression> has <Name name>`) {
     uname = unescape("<name>");
     tp = getType(expression);
     if(isSyntaxType(tp)){
-        return muHasField(translate(expression), tp, uname, {}); 
+        return muHasField(translate(expression), tp, uname, {});
     } else if (isADTAType(tp)){
-        commonKwFields = getCommonKeywordFieldsNameAndType()[tp] ? ();  
+        commonKwFields = getCommonKeywordFieldsNameAndType()[tp] ? ();
         if(commonKwFields[uname]?){
             return muCon(true); // If desired field is a common keyword field, all constructors have it
         }
-        
-        // Determine set of constructors with the desired field                                    
+
+        // Determine set of constructors with the desired field
         constructors = getConstructorsMap()[tp] ? {};
         consesWithField = {c | c:acons(AType _adt, list[AType] fields, list[Keyword] kwFields) <- constructors,
                                (!isEmpty(fields) && any(f <- fields, f.alabel == uname)) ||
@@ -1414,14 +1415,14 @@ MuExp translate ((Expression) `<Expression expression> has <Name name>`) {
         //}
 
         // Compute result at runtime, guided by the set of constructors that do have the desired field
-        return muHasField(translate(expression), tp, uname, consesWithField); 
-        
+        return muHasField(translate(expression), tp, uname, consesWithField);
+
      } else if(isNodeAType(tp)){
       // Always compute existence of field at run time
-      return muHasField(translate(expression), tp, uname, {}); 
+      return muHasField(translate(expression), tp, uname, {});
     } else { // all other cases: compute result statically
         return muCon(hasField(tp, uname));
-    }		    
+    }
 }
 
 MuExp translateBool(e: (Expression) `<Expression expression> has <Name name>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
@@ -1434,11 +1435,11 @@ MuExp translate(e:(Expression) `<Expression argument> +`) =
 
 // -- transitive reflexive closure expression -----------------------
 
-MuExp translate(e:(Expression) `<Expression argument> *`) = 
+MuExp translate(e:(Expression) `<Expression argument> *`) =
     unary("transitive_reflexive_closure", e, argument);
 
 // -- isDefined expression ------------------------------------------
-    
+
 // The isDefined and isDefinedElse expression are implemented using the following strategy:
 // - try to avoid recomputation
 // - try to avoid throwing exceptions
@@ -1449,15 +1450,15 @@ MuExp translate((Expression) `<Expression argument> ?`) {
 
 MuExp translateBool((Expression) `<Expression argument> ?`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
     = muIfExp(translateIsDefined(argument), trueCont, falseCont);
-	
+
 private MuExp translateIsDefined(Expression exp){
     tg = translateGuarded(exp);
-    return muIsVarKwpDefined(_) := tg ? tg : muIsDefinedValue(tg);  
+    return muIsVarKwpDefined(_) := tg ? tg : muIsDefinedValue(tg);
 }
 
 MuExp translateGuarded((Expression) `( <Expression exp1> )`)
     = translateGuarded(exp1);
- 
+
 MuExp translateGuarded(exp: (Expression) `<Expression exp1> [ <{Expression ","}+ subscripts> ]`)
     = translateSubscript(exp, true);
 
@@ -1481,7 +1482,7 @@ MuExp translateGuarded(exp: (Expression) `<Expression expression> . <Name field>
 MuExp translateGuarded(exp: (Expression) `<Name name>`)
     = muIsVarKwpDefined(mkVar("<name>", name@\loc));
 
-    
+
 // -- isDefinedOtherwise expression ---------------------------------
 
 MuExp translate(e: (Expression) `<Expression lhs> ? <Expression rhs>`) {
@@ -1495,7 +1496,7 @@ MuExp translate(e: (Expression) `<Expression lhs> ? <Expression rhs>`) {
 
 MuExp translateBool(e:(Expression) `<Expression lhs> ? <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
     = translateIfDefinedOtherwise(muBlock([translate(lhs), trueCont]), muBlock([translate(rhs), falseCont]), e@\loc);
-    
+
 
 public MuExp translateIfDefinedOtherwise(MuExp muLHS, MuExp muRHS, loc _src) {
     str fuid = topFunctionScope();
@@ -1510,12 +1511,12 @@ public MuExp translateIfDefinedOtherwise(MuExp muLHS, MuExp muRHS, loc _src) {
     } else if(muPrim("subscript", AType result, list[AType] details, list[MuExp] exps, loc src) := muLHS){
         muLHS = muPrim("guarded_subscript", result, details, exps, src);
         lhsType = result;
-    } 
+    }
     else if(muGetAnno(MuExp exp, AType resultType, str annoName) := muLHS){ // TODO remove when annos are gone
         muLHS = muGuardedGetAnno(exp, resultType, annoName);
         lhsType = resultType;
     }
-    
+
     return muValueBlock(lhsType,
                         [ muVarInit(guarded, muLHS),
                           muIfExp(muIsDefinedValue(guarded),  muGetDefinedValue(guarded, lhsType), muRHS)
@@ -1548,20 +1549,20 @@ MuExp translate(e:(Expression) `!<Expression exp>`) {
         case (Expression) `<Pattern pat> := <Expression exp2>`:
             return translateNoMatchOp(exp1, pat, exp2,  getBTScopes(exp1, nextTmp("MATCH")));
         case (Expression) `<Pattern pat> !:= <Expression exp2>`:
-            return translateMatchOp(exp1, pat, exp2,  getBTScopes(exp1, nextTmp("NOMATCH")));  
+            return translateMatchOp(exp1, pat, exp2,  getBTScopes(exp1, nextTmp("NOMATCH")));
         case (Expression) `<Pattern pat> \<- <Expression exp2>`:{
             my_btscopes = getBTScopes(exp1, nextTmp("NOGEN"));
-            return translateNoGenOp(exp1, pat, exp2, my_btscopes);  
+            return translateNoGenOp(exp1, pat, exp2, my_btscopes);
             }
         case (Expression) `any ( <{Expression ","}+ generators> )`:
             return translateQuantor([ g | g <- generators ], quantorAll = false, negateGenerators = true);
         case (Expression) `all ( <{Expression ","}+ generators> )`:
             return translateQuantor([ g | g <- generators ], quantorAll = true, negateGenerators = true);
         default:
-            return muNot(translate(exp1));    
+            return muNot(translate(exp1));
     }
 }
-    
+
 MuExp translateBool((Expression) `!<Expression exp>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) {
     exp1 = stripParens(exp);
     switch(exp1){
@@ -1578,21 +1579,21 @@ MuExp translateBool((Expression) `!<Expression exp>`, BTSCOPES btscopes, MuExp t
         case (Expression) `<Pattern pat> := <Expression exp2>`:
             return muIfExp(translateNoMatchOp(exp1, pat, exp2,  btscopes), trueCont, falseCont);
         case (Expression) `<Pattern pat> !:= <Expression exp2>`:
-            return muIfExp(translateMatchOp(exp1, pat, exp2,  btscopes), trueCont, falseCont);  
+            return muIfExp(translateMatchOp(exp1, pat, exp2,  btscopes), trueCont, falseCont);
         case (Expression) `<Pattern pat> \<- <Expression exp2>`:
-            return translateNoGenOp(exp1, pat, exp2, btscopes, trueCont, falseCont); 
+            return translateNoGenOp(exp1, pat, exp2, btscopes, trueCont, falseCont);
         case (Expression) `any ( <{Expression ","}+ generators> )`:
             return muIfExp(translateQuantor([ g | g <- generators ], quantorAll = false, negateGenerators = true), trueCont, falseCont);
         case (Expression) `all ( <{Expression ","}+ generators> )`:
             return muIfExp(translateQuantor([ g | g <- generators ], quantorAll = true, negateGenerators = true), trueCont, falseCont);
         default:
-            return muIfExp(translate(exp1), falseCont, trueCont); 
+            return muIfExp(translate(exp1), falseCont, trueCont);
     }
 }
 
 // -- negate expression ---------------------------------------------
 
-MuExp translate(e:(Expression) `-<Expression argument>`) 
+MuExp translate(e:(Expression) `-<Expression argument>`)
     = unary("negative", e, argument);
 
 // -- splice expression ---------------------------------------------
@@ -1600,28 +1601,28 @@ MuExp translate(e:(Expression) `-<Expression argument>`)
 MuExp translate(e:(Expression) `*<Expression argument>`) {
     throw "Splice `<e>` cannot occur outside set or list at <e@\loc>";
 }
-   
+
 // -- asType expression ---------------------------------------------
 
 MuExp translate(e:(Expression) `[ <Type typ> ] <Expression argument>`)  {
-    resultType = translateType(typ);  
+    resultType = translateType(typ);
     return muPrim("parse", resultType,
                                 [ avalue(), astr(), aloc()],
                                 [ muATypeCon(resultType, collectNeededDefs(resultType)),
    					              translate(argument),
    					              muCon(argument@\loc)
-   					            ], 
+   					            ],
    					            argument@\loc);
 }
 
 // -- composition expression ----------------------------------------
 
-MuExp translate(e: (Expression) `<Expression lhs> o <Expression rhs>`) 
+MuExp translate(e: (Expression) `<Expression lhs> o <Expression rhs>`)
     = compose(e);
 
 // -- product expression --------------------------------------------
 
-MuExp translate(e:(Expression) `<Expression lhs> * <Expression rhs>`) 
+MuExp translate(e:(Expression) `<Expression lhs> * <Expression rhs>`)
     = infix("product", e);
 
 // -- join expression -----------------------------------------------
@@ -1641,7 +1642,7 @@ MuExp translate(e:(Expression) `<Expression lhs> / <Expression rhs>`)
 
 // -- intersection expression ---------------------------------------
 
-MuExp translate(e:(Expression) `<Expression lhs> & <Expression rhs>`) 
+MuExp translate(e:(Expression) `<Expression lhs> & <Expression rhs>`)
     = infix("intersect", e);
 
 // -- addition expression -------------------------------------------
@@ -1673,13 +1674,13 @@ MuExp translate(e:(Expression) `<Expression lhs> mod <Expression rhs>`)
 
 MuExp translate(e:(Expression) `<Expression lhs> notin <Expression rhs>`)
     = infix("notin", e);
-    
-MuExp translateBool(e:(Expression) `<Expression lhs> notin <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) 
+
+MuExp translateBool(e:(Expression) `<Expression lhs> notin <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
     = muIfExp(infix("notin", e),  trueCont, falseCont);
 
 // -- in expression -------------------------------------------------
-    
-MuExp translate(e:(Expression) `<Expression lhs> in <Expression rhs>`) 
+
+MuExp translate(e:(Expression) `<Expression lhs> in <Expression rhs>`)
     = infix("in", e);
 
 MuExp translateBool(e:(Expression) `<Expression lhs> in <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
@@ -1689,7 +1690,7 @@ MuExp translateBool(e:(Expression) `<Expression lhs> in <Expression rhs>`, BTSCO
 
 MuExp translate(e:(Expression) `<Expression lhs> \>= <Expression rhs>`)
     = infix("greaterequal", e);
- 
+
  MuExp translateBool(e:(Expression) `<Expression lhs> \>= <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
     = muIfExp(infix("greaterequal", e),  trueCont, falseCont);
 
@@ -1702,10 +1703,10 @@ MuExp translateBool(e:(Expression) `<Expression lhs> \<= <Expression rhs>`, BTSC
     = muIfExp(infix("lessequal", e), trueCont, falseCont);
 
 // -- less expression ----------------------------------------------
-    
+
 MuExp translate(e:(Expression) `<Expression lhs> \< <Expression rhs>`)
     = infix("less", e);
-    
+
 MuExp translateBool(e:(Expression) `<Expression lhs> \< <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
     = muIfExp(infix("less", e),  trueCont, falseCont);
 
@@ -1713,7 +1714,7 @@ MuExp translateBool(e:(Expression) `<Expression lhs> \< <Expression rhs>`, BTSCO
 
 MuExp translate(e:(Expression) `<Expression lhs> \> <Expression rhs>`)
     = infix("greater", e);
-    
+
 MuExp translateBool(e:(Expression) `<Expression lhs> \> <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
     = muIfExp(infix("greater", e),  trueCont, falseCont);
 
@@ -1734,7 +1735,7 @@ MuExp translate(e:(Expression) `<Expression lhs> != <Expression rhs>`)
 
 MuExp translateBool(e:(Expression) `<Expression lhs> != <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont)
     = muIfExp(infix("notequal", e),  trueCont, falseCont);
- 
+
 // -- match expression --------------------------------------------------------
 
 BTINFO getBTInfo(e:(Expression) `<Pattern pat> := <Expression exp>`, BTSCOPE btscope, BTSCOPES btscopes){
@@ -1751,14 +1752,14 @@ MuExp translateMatchOp(Expression e, Pattern pat, Expression exp, BTSCOPES btsco
     my_btscope = btscopes[getLoc(e)];
     //if(backtrackFree(pat))
     //    return translateMatch(pat, exp, btscopes, muSucceed(my_btscope.enter), muFail(my_btscope.\fail));
-    //else 
+    //else
         return muExists(my_btscope.enter, translateMatch(pat, exp, btscopes, muSucceed(my_btscope.enter, comment="match operator"), muFail(my_btscope.\fail, comment="match operator")));
 }
-    
+
 MuExp translateBool(e:(Expression) `<Pattern pat> := <Expression exp>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
     return translateMatch(pat, exp, btscopes, trueCont, falseCont);
 }
-    
+
 // -- no match expression -------------------------------------------
 
 BTINFO getBTInfo(e:(Expression) `<Pattern pat> !:= <Expression exp>`, BTSCOPE btscope, BTSCOPES btscopes){
@@ -1770,18 +1771,18 @@ BTINFO getBTInfo(e:(Expression) `<Pattern pat> !:= <Expression exp>`, BTSCOPE bt
 
 MuExp translate(e:(Expression) `<Pattern pat> !:= <Expression exp>`, BTSCOPES btscopes)
     = translateNoMatchOp(e, pat, exp, btscopes);
-    
-MuExp translateNoMatchOp(Expression e, Pattern pat, Expression exp,  BTSCOPES btscopes) { 
-    my_btscope = btscopes[getLoc(e)];     
+
+MuExp translateNoMatchOp(Expression e, Pattern pat, Expression exp,  BTSCOPES btscopes) {
+    my_btscope = btscopes[getLoc(e)];
     return muNot(muExists(my_btscope.enter, translateMatch(pat, exp, btscopes, muSucceed(my_btscope.enter), muFail(my_btscope.\fail))));
 }
-    
+
 MuExp translateBool(e:(Expression) `<Pattern pat> !:= <Expression exp>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
     my_btscope = btscopes[getLoc(e)];
     return muNot(translateMatch(pat, exp, btscopes, trueCont, falseCont));
     //return muNot(muExists(my_btscope.enter, translateMatch(pat, exp, btscopes, trueCont, falseCont)));
 }
-    
+
 // -- generator expression ----------------------------------------------------
 
 BTINFO getBTInfo(e:(Expression) `<Pattern pat> \<- <Expression exp>`, BTSCOPE btscope, BTSCOPES btscopes){
@@ -1790,15 +1791,15 @@ BTINFO getBTInfo(e:(Expression) `<Pattern pat> \<- <Expression exp>`, BTSCOPE bt
     <btscope_pat, btscopes> = getBTInfo(pat, "<btscope.enter>_GEN<getLoc(e).offset>", btscopes);
     return registerBTScope(e, btscope_pat, btscopes);
 }
-    
+
 MuExp translateGenerator(Expression current, Pattern pat, Expression exp, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
     expType = getType(exp);
     elemType = getElementType(expType);
     if(isVoidAType(elemType)) return falseCont;
-    
+
     str fuid = topFunctionScope();
     elem = muTmpIValue(nextTmp("elem"), fuid, elemType);
-    
+
     l = getLoc(current).offset;
     enterGen = getEnter(pat, "GEN<l>", btscopes);
     resumeGen = getResume(pat, "GEN<l>", btscopes);
@@ -1811,7 +1812,7 @@ MuExp translateGenerator(Expression current, Pattern pat, Expression exp, BTSCOP
     // -- enumerator with range and step expression
     if((Expression) `[ <Expression first> , <Expression second> .. <Expression last> ]` := exp){
        code = muForRange(enterGen, elem, translate(first), translate(second), translate(last), translatePat(pat, alub(alub(getType(first), getType(second)), getType(last)), elem, btscopes, trueCont, muFail(resumeGen)/*falseCont*/), falseCont);
-    } else 
+    } else
     // -- a syntactic list or optional
     if(isIterType(expType) || isOptType(expType)){
         delta = getIterOrOptDelta(expType); // take care of skipping layout and separators
@@ -1855,7 +1856,7 @@ MuExp translateNoGenOp(Expression e, Pattern pat, Expression exp, BTSCOPES btsco
 MuExp translateNoGenOp(Expression e, Pattern pat, Expression exp, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
     return translateGenerator(e, pat, exp, btscopes, falseCont, trueCont);
 }
-    
+
 /*****************************************************************************/
 /*                  Boolean Operators                                        */
 /*****************************************************************************/
@@ -1890,11 +1891,11 @@ MuExp translateNoGenOp(Expression e, Pattern pat, Expression exp, BTSCOPES btsco
 //        |               |        +----------+  |  |
 //        |               +----------------------+  |
 //        |                                         |
-//        +-----------------------------------------+                                      
+//        +-----------------------------------------+
 
 // ---- getBTInfo
 
-BTINFO getBTInfo(Expression e:(Expression) `<Expression lhs> && <Expression rhs>`, BTSCOPE btscope, BTSCOPES btscopes){     
+BTINFO getBTInfo(Expression e:(Expression) `<Expression lhs> && <Expression rhs>`, BTSCOPE btscope, BTSCOPES btscopes){
     <lhs_btscope, btscopes1> = getBTInfo(lhs, btscope, btscopes);
     <rhs_btscope, btscopes2> = getBTInfo(rhs, lhs_btscope, btscopes1);
     return registerBTScope(e, <btscope.enter, rhs_btscope.resume, lhs_btscope.\fail>, btscopes2);
@@ -1919,9 +1920,9 @@ BTSCOPES getBTScopesParams(list[Pattern] args, str enter){
     return btscopes;
 }
 
-// ---- translate and 
+// ---- translate and
 
-MuExp translate(Expression e:(Expression) `<Expression lhs> && <Expression rhs>`){ 
+MuExp translate(Expression e:(Expression) `<Expression lhs> && <Expression rhs>`){
     return translate(e, getBTScopes(e, nextTmp("AND")));
 }
 
@@ -1931,9 +1932,9 @@ MuExp translate(Expression e:(Expression) `<Expression lhs> && <Expression rhs>`
     }
     enterLhs = getEnter(e, btscopes);
     failLhs = getFail(e, btscopes);
-  
+
     code = muExists(enterLhs, translateAndConds(btscopes, [lhs, rhs], muSucceed(enterLhs), muFail(enterLhs)));// <<<<
-    return code;    
+    return code;
 }
 
 MuExp translateBool(Expression e: (Expression) `<Expression lhs> && <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
@@ -1954,12 +1955,12 @@ MuExp identity(MuExp exp) = exp;
 
 MuExp translateAndConds(BTSCOPES btscopes, list[Expression] conds, MuExp trueCont, MuExp falseCont, MuExp(MuExp) normalize = identity){
     //pretty(btscopes);
-    
+
     if(isEmpty(conds)) return normalize(trueCont);
     conds = normalizeAnd(conds);
-  
+
     falseCont = normalize(falseCont);
-    
+
     if(all(cond <- conds, backtrackFree(cond))){
         for(cond <- reverse(conds)){
             trueCont = translateBool(cond, btscopes, trueCont, falseCont);
@@ -1968,7 +1969,7 @@ MuExp translateAndConds(BTSCOPES btscopes, list[Expression] conds, MuExp trueCon
     }
     for(i <- reverse(index(conds))){
          //cont = i == 0 ? falseCont : computeFail(conds, i-1, btscopes, falseCont);   // <<<
-        //altCont = i == 0 ? falseCont : computeFail(conds, i-1, btscopes, falseCont); 
+        //altCont = i == 0 ? falseCont : computeFail(conds, i-1, btscopes, falseCont);
         cont = i == 0 ? falseCont : muFail(getResume(conds[i-1], btscopes));   // <<<
         //if(altCont != cont){
         //    println("<i>: <conds[i]>
@@ -1978,7 +1979,7 @@ MuExp translateAndConds(BTSCOPES btscopes, list[Expression] conds, MuExp trueCon
         //cont = altCont;
         trueCont = normalize(translateBool(conds[i], btscopes, trueCont, cont));
     }
-    
+
     enter = getEnter(conds[0], btscopes);
     res = muExists(getEnter(conds[0], btscopes), trueCont);
     //iprintln(res);
@@ -1988,12 +1989,12 @@ MuExp translateAndConds(BTSCOPES btscopes, list[Expression] conds, MuExp trueCon
 MuExp computeFail(list[Expression] conds, int i, btscopes, MuExp falseCont){
     //iprintln(btscopes);
     if(i < 0) return falseCont;
-    
+
     resume_0 = getResume(conds[0], btscopes);
     enter_0 = getEnter(conds[0], btscopes);
     fail_0 = getFail(conds[0], btscopes);
-    
-    
+
+
     resume_i = getResume(conds[i], btscopes);
     enter_i = getEnter(conds[i], btscopes);
     fail_i = getFail(conds[i], btscopes);
@@ -2010,8 +2011,8 @@ MuExp computeFail(list[Expression] conds, int i, btscopes, MuExp falseCont){
 //    false | true  | true
 //    false | false | false
 //
-//                                                                   +-----------+ 
-//           +-------------------------------+        +------------->| falseCont |                              
+//                                                                   +-----------+
+//           +-------------------------------+        +------------->| falseCont |
 //           |                               |        |              +-----------+
 //           |                               |        |
 //        +--F--+-----------------------+    |     +--F--+-----------------------+
@@ -2025,19 +2026,19 @@ MuExp computeFail(list[Expression] conds, int i, btscopes, MuExp falseCont){
 //        |              |           |  |          |              |           |  |
 //        |              +-----------+  |          |              +-----------+  |
 //        +-----------------------------+          +-----------------------------+
-//                     
+//
 
 // ---- getBTInfo
 
 BTINFO getBTInfo(Expression e:(Expression) `<Expression lhs> || <Expression rhs>`, BTSCOPE btscope, BTSCOPES btscopes){
     conds = normalizeOr(e);
     BTSCOPE c_btscope = btscope;
-    
+
     for(c <- conds){
         <c_btscope, btscopes> = getBTInfo(c, btscope, btscopes);
     }
     res = registerBTScope(e, <btscope.enter, c_btscope.resume, btscope.\fail>, btscopes);
-    return res;    
+    return res;
 }
 
 // ---- translate or expression
@@ -2052,16 +2053,16 @@ MuExp translate(Expression e:(Expression) `<Expression lhs> || <Expression rhs>`
    if(backtrackFree(lhs)){
         return muIfExp(translate(lhs), muCon(true), translate(rhs));
    }
-   code = muExists(getEnter(e, btscopes), translateOrConds(btscopes, [lhs, rhs], muSucceed(getResume(lhs, btscopes)), muFail(getFail(rhs, btscopes))));                                                                 
-   return code;                                                                               
+   code = muExists(getEnter(e, btscopes), translateOrConds(btscopes, [lhs, rhs], muSucceed(getResume(lhs, btscopes)), muFail(getFail(rhs, btscopes))));
+   return code;
 }
-    
+
 MuExp translateBool((Expression) `<Expression lhs> || <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
    if(backtrackFree(lhs) && backtrackFree(rhs)){
         return muIfExp(translate(lhs), trueCont, muIfExp(translate(rhs), trueCont, falseCont));
    }
     return translateOrConds(btscopes, [lhs, rhs], trueCont, falseCont);
-}  
+}
 
 // ---- translateOrConds
 
@@ -2072,16 +2073,16 @@ default list[Expression] normalizeOr(Expression e) = [e];
 
 list[Expression] normalizeOr(list[Expression] exps)
     = [ *normalizeOr(e) | e <- exps ];
-    
+
 MuExp translateOrConds(BTSCOPES btscopes, list[Expression] conds, MuExp trueCont, MuExp falseCont, MuExp(MuExp) normalize = identity){
     //iprintln(btscopes);
     if(isEmpty(conds)) return normalize(trueCont);
     conds = normalizeOr(conds);
-    
+
     falseCont = normalize(falseCont);
-    
+
     nconds = size(conds);
-    
+
     result = falseCont;
     failTrueCont = getFailScope(trueCont);
     for(i <- reverse(index(conds))){
@@ -2099,7 +2100,7 @@ MuExp translateOrConds(BTSCOPES btscopes, list[Expression] conds, MuExp trueCont
             falseCont1 = result; // i < nconds - 1 ? result : muFail(getEnter(conds[i+1], btscopes), comment="translateOrConds, i==nconds-1");   // <<<
             trueCont1 = visit(trueCont) { case muFail(failTrueCont) => muBlock([]) };
             trueCont1  = redirect(trueCont, getFailScope(trueCont), getResume(conds[i], btscopes));
-            
+
             code = normalize(translateBool(conds[i], btscopes, trueCont1, falseCont1));
             result = code;
         }
@@ -2123,7 +2124,7 @@ MuExp redirect(MuExp exp, from, to){
            case mc: muContinue(from) =>  muContinue(to)
     };
 }
-  
+
 // ==== implies expression ====================================================
 
 //    Truth table
@@ -2154,7 +2155,7 @@ MuExp redirect(MuExp exp, from, to){
 //        |               |        +----------+  |  |
 //        |               +----------------------+  |
 //        |                                         |
-//        +-----------------------------------------+     
+//        +-----------------------------------------+
 
 // ---- getBTInfo
 
@@ -2168,7 +2169,7 @@ BTINFO getBTInfo(Expression e:(Expression) `<Expression lhs> ==\> <Expression rh
 
 // ---- translate implies expression
 
-MuExp translate(Expression e:(Expression) `<Expression lhs> ==\> <Expression rhs>`){ 
+MuExp translate(Expression e:(Expression) `<Expression lhs> ==\> <Expression rhs>`){
     return translate(e, getBTScopes(e, nextTmp("IMPLIES")));
 }
 
@@ -2180,18 +2181,18 @@ MuExp translate(e:(Expression) `<Expression lhs> ==\> <Expression rhs>`, BTSCOPE
     trueCont2 = muBlock([muComment("trueCont2"), muFail(getResume(rhs, btscopes))]);
     enterLhs = getEnter(lhs, "IMPLIES", btscopes);
     enterRhs = getEnter(rhs, "IMPLIES", btscopes);
-    
+
     code = translateBool(lhs, btscopes, translateBool(rhs, btscopes, muBlock([muComment("falseCont rhs"), muFail(getResume(rhs, btscopes))]), trueCont1),
-                                                           muBlock([muComment("falseCont lhs"), muFail(getResume(rhs, btscopes))])); 
- 
- 
+                                                           muBlock([muComment("falseCont lhs"), muFail(getResume(rhs, btscopes))]));
+
+
     //code = muExists(enterLhs, translateBool(lhs, btscopes, translateBool(rhs, btscopes, muSucceed(enterLhs), muFail(getResume(e, "IMPLIES", btscopes))),
-    //                                                                      muSucceed(enterLhs))); 
-    
-    
-    return code;  
+    //                                                                      muSucceed(enterLhs)));
+
+
+    return code;
 }
-    
+
 MuExp translateBool(e:(Expression) `<Expression lhs> ==\> <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
     trueCont2 = redirect(trueCont, getResume(lhs, btscopes), getResume(rhs, btscopes));
     falseCont2 = redirect(falseCont, getResume(rhs, btscopes), getResume(e, btscopes));
@@ -2228,7 +2229,7 @@ MuExp translateBool(e:(Expression) `<Expression lhs> ==\> <Expression rhs>`, BTS
 //        |               |        +----------+  |  |
 //        |               +----------------------+  |
 //        |                                         |
-//        +-----------------------------------------+     
+//        +-----------------------------------------+
 
 BTINFO getBTInfo(Expression e:(Expression) `<Expression lhs> \<==\> <Expression rhs>`, BTSCOPE btscope, BTSCOPES btscopes){
     <lhs_btscope, btscopes1> = getBTInfo(lhs, btscope, btscopes);
@@ -2236,32 +2237,32 @@ BTINFO getBTInfo(Expression e:(Expression) `<Expression lhs> \<==\> <Expression
     return registerBTScope(e, <btscope.enter, rhs_btscope.resume, lhs_btscope.\fail>, btscopes2);
 }
 
-MuExp translate(Expression e:(Expression) `<Expression lhs> \<==\> <Expression rhs>`){ 
+MuExp translate(Expression e:(Expression) `<Expression lhs> \<==\> <Expression rhs>`){
     return translate(e, getBTScopes(e, nextTmp("EQUIV")));
 }
-   
+
 MuExp translate(e:(Expression) `<Expression lhs> \<==\> <Expression rhs>`, BTSCOPES btscopes) {
     if(backtrackFree(e)){
         str fuid = topFunctionScope();
         rhs_val = muTmpIValue(nextTmp("rhs_val"), fuid, abool());
         return muValueBlock(abool(), [ muConInit(rhs_val, translate(rhs)),
-                                       muIfExp(translate(lhs), 
+                                       muIfExp(translate(lhs),
                                                rhs_val,
                                                muPrim("not", abool(), [abool()], [rhs_val], e@\loc))
                                      ]);
-   }  
-   
+   }
+
    enterLhs = getEnter(lhs, "EQUIV", btscopes);
    code = muExists(enterLhs, translateBool(lhs, btscopes, translateBool(rhs, btscopes, muSucceed(getResume(rhs, btscopes)), muFail(getFail(rhs, btscopes))),
-                                                          translateBool(rhs, btscopes, muFail(enterLhs), muSucceed(enterLhs)))); 
-                                                         
+                                                          translateBool(rhs, btscopes, muFail(enterLhs), muSucceed(enterLhs))));
+
    return code;
 }
 
-MuExp translateBool((Expression) `<Expression lhs> \<==\> <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) { 
-    return translateBool(lhs, btscopes, translateBool(rhs, btscopes, trueCont, falseCont), translateBool(rhs, btscopes, trueCont, falseCont));  
+MuExp translateBool((Expression) `<Expression lhs> \<==\> <Expression rhs>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont) {
+    return translateBool(lhs, btscopes, translateBool(rhs, btscopes, trueCont, falseCont), translateBool(rhs, btscopes, trueCont, falseCont));
 }
- 
+
 // -- conditional expression ----------------------------------------
 
 BTINFO getBTInfo(Expression e:(Expression) `<Expression condition> ? <Expression thenExp> : <Expression elseExp>`, BTSCOPE btscope, BTSCOPES btscopes){
@@ -2280,13 +2281,13 @@ bool isConditional((Expression) `( <Expression exp> )`) = isConditional(exp);
 default bool isConditional(Expression e) = false;
 
 MuExp translateBool((Expression) `<Expression condition> ? <Expression thenExp> : <Expression elseExp>`, BTSCOPES btscopes, MuExp trueCont, MuExp falseCont){
-    return translateBool(condition, btscopes, translateBool(thenExp, btscopes, trueCont, translateBool(elseExp, btscopes, trueCont, falseCont)), 
+    return translateBool(condition, btscopes, translateBool(thenExp, btscopes, trueCont, translateBool(elseExp, btscopes, trueCont, falseCont)),
                                               translateBool(elseExp, btscopes, trueCont, falseCont));
 }
 
 // -- concrete syntax
 
-MuExp translate((Expression) `<Concrete con>`) { 
+MuExp translate((Expression) `<Concrete con>`) {
     return translateConcreteExpression(con.args[0]);
 }
 
diff --git a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Rascal2muRascal/TmpAndLabel.rsc b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Rascal2muRascal/TmpAndLabel.rsc
index 0143e300..546146c1 100644
--- a/src/org/rascalmpl/core/library/lang/rascalcore/compile/Rascal2muRascal/TmpAndLabel.rsc
+++ b/src/org/rascalmpl/core/library/lang/rascalcore/compile/Rascal2muRascal/TmpAndLabel.rsc
@@ -13,7 +13,7 @@ import lang::rascalcore::compile::muRascal::AST;
 /*
  * Management of temporaries and labels.
  */
- 
+
 public void resetTmpAndLabel(){
     currentModule = |unknown:///|;
 	tmpVar = -1;
@@ -29,13 +29,14 @@ public void resetTmpAndLabel(){
 	resetOrCounter();
 	functionScopes = [];
 	functionDeclarations = [];
+    resetClosureCounter();
 }
 
 private loc currentModuleScope = |unknown:///|;
 
 void setModuleScope(loc l){
     currentModuleScope = l;
-}  
+}
 
 loc getModuleScope()
     = currentModuleScope;
@@ -106,7 +107,7 @@ void leaveLoop(){
   loops = tail(loops);
 }
 
-// labelled statements (if, while, 
+// labelled statements (if, while,
 
 private lrel[str label, str resume] labelledStats = [];               // *** state
 
@@ -157,7 +158,7 @@ str getLabel(Label label) =
 
 str getLabel(Label label, str alt) =
   (label is \default) ? "<label.name>" : nextLabel(alt);
-  
+
 str asTmp(str name) = "TMP<name>";
 
 // Keep track of possibly nested "it" variables in reducers
@@ -217,7 +218,7 @@ loc currentFunctionDeclaration(){
     return top(functionDeclarations);
 }
 
-// Administration of function scopes; 
+// Administration of function scopes;
 // needed to translate 'visit' expressions and generate function declarations for 'visit' cases
 
 private lrel[str scope,int counter] functionScopes = []; // *** state
@@ -230,12 +231,12 @@ int nextVisit() {
 	return counter;
 }
 
-void enterFunctionScope(str fuid) { 
-	functionScopes = <fuid,0> + functionScopes; 
+void enterFunctionScope(str fuid) {
+	functionScopes = <fuid,0> + functionScopes;
 }
 
-void leaveFunctionScope() { 
-	functionScopes = tail(functionScopes); 
+void leaveFunctionScope() {
+	functionScopes = tail(functionScopes);
 }
 
 private list[AType] visits = [];		// *** state
@@ -285,3 +286,15 @@ int getNextOr() {
 void resetOrCounter() {
     orCounter = 0;
 }
+
+private int closureCounter = 0;
+
+int getNextClosure(){
+    int counter = closureCounter;
+    closureCounter += 1;
+    return counter;
+}
+
+void resetClosureCounter(){
+    closureCounter = 0;
+}