NFInst improvements.

Compiler/NFFrontEnd/NFBinding.mo

@@ -47,23 +47,23 @@ public
   record RAW_BINDING
     Absyn.Exp bindingExp;
     InstNode scope;
-    Integer propagatedLevels;
+    Integer originLevel;
     SourceInfo info;
   end RAW_BINDING;
 
   record UNTYPED_BINDING
     Expression bindingExp;
     Boolean isProcessing;
     InstNode scope;
-    Integer propagatedLevels;
+    Integer originLevel;
     SourceInfo info;
   end UNTYPED_BINDING;
 
   record TYPED_BINDING
     Expression bindingExp;
     Type bindingType;
     Variability variability;
-    Integer propagatedLevels;
+    Integer originLevel;
     SourceInfo info;
   end TYPED_BINDING;
 
@@ -75,20 +75,21 @@ public
   function fromAbsyn
     input Option<Absyn.Exp> bindingExp;
     input SCode.Each eachPrefix;
+    input Integer level;
     input InstNode scope;
     input SourceInfo info;
     output Binding binding;
   algorithm
     binding := match bindingExp
       local
         Absyn.Exp exp;
-        Integer pd;
+        Integer lvl;
 
       case SOME(exp)
         algorithm
-          pd := if SCode.eachBool(eachPrefix) then -1 else 0;
+          lvl := if SCode.eachBool(eachPrefix) then -level else level;
         then
-          RAW_BINDING(exp, scope, pd, info);
+          RAW_BINDING(exp, scope, lvl, info);
 
       else UNBOUND();
     end match;
@@ -189,9 +190,9 @@ public
     output Boolean isEach;
   algorithm
     isEach := match binding
-      case RAW_BINDING() then binding.propagatedLevels == -1;
-      case UNTYPED_BINDING() then binding.propagatedLevels == -1;
-      case TYPED_BINDING() then binding.propagatedLevels == -1;
+      case RAW_BINDING() then binding.originLevel < 0;
+      case UNTYPED_BINDING() then binding.originLevel < 0;
+      case TYPED_BINDING() then binding.originLevel < 0;
       else false;
     end match;
   end isEach;

Compiler/NFFrontEnd/NFBuiltin.mo

@@ -50,7 +50,7 @@ import NFComponent.Component;
 import Expression = NFExpression;
 import NFInstNode.InstNode;
 import NFInstNode.InstNodeType;
-import NFMod.Modifier;
+import NFModifier.Modifier;
 import Type = NFType;
 import BuiltinFuncs = NFBuiltinFuncs;
 import Pointer;
@@ -237,6 +237,7 @@ constant InstNode STATESELECT_NEVER =
       STATESELECT_NEVER_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
+    0,
     STATESELECT_NODE);
 
 constant ComponentRef STATESELECT_NEVER_CREF =
@@ -252,6 +253,7 @@ constant InstNode STATESELECT_AVOID =
       STATESELECT_AVOID_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
+    0,
     STATESELECT_NODE);
 
 constant ComponentRef STATESELECT_AVOID_CREF =
@@ -267,6 +269,7 @@ constant InstNode STATESELECT_DEFAULT =
       STATESELECT_DEFAULT_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
+    0,
     STATESELECT_NODE);
 
 constant ComponentRef STATESELECT_DEFAULT_CREF =
@@ -282,6 +285,7 @@ constant InstNode STATESELECT_PREFER =
       STATESELECT_PREFER_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
+    0,
     STATESELECT_NODE);
 
 constant ComponentRef STATESELECT_PREFER_CREF =
@@ -297,6 +301,7 @@ constant InstNode STATESELECT_ALWAYS =
       STATESELECT_ALWAYS_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
+    0,
     STATESELECT_NODE);
 
 constant ComponentRef STATESELECT_ALWAYS_CREF =
@@ -321,6 +326,7 @@ constant InstNode TIME =
       Binding.UNBOUND(),
       NFComponent.INPUT_ATTR,
       Absyn.dummyInfo)),
+    0,
     InstNode.EMPTY_NODE());
 
 constant ComponentRef TIME_CREF = ComponentRef.CREF(TIME, {}, Type.REAL(), Origin.CREF, ComponentRef.EMPTY());

Compiler/NFFrontEnd/NFBuiltinFuncs.mo

@@ -64,39 +64,39 @@ constant Component INT_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NO
 
 constant InstNode INT_PARAM = InstNode.COMPONENT_NODE("i",
   Visibility.PUBLIC,
-  Pointer.createImmutable(INT_COMPONENT), InstNode.EMPTY_NODE());
+  Pointer.createImmutable(INT_COMPONENT), 0, InstNode.EMPTY_NODE());
 
 // Default Real parameter.
 constant Component REAL_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
   Type.REAL(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode REAL_PARAM = InstNode.COMPONENT_NODE("r",
   Visibility.PUBLIC,
-  Pointer.createImmutable(REAL_COMPONENT), InstNode.EMPTY_NODE());
+  Pointer.createImmutable(REAL_COMPONENT), 0, InstNode.EMPTY_NODE());
 
 // Default Boolean parameter.
 constant Component BOOL_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
   Type.BOOLEAN(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode BOOL_PARAM = InstNode.COMPONENT_NODE("b",
   Visibility.PUBLIC,
-  Pointer.createImmutable(BOOL_COMPONENT), InstNode.EMPTY_NODE());
+  Pointer.createImmutable(BOOL_COMPONENT), 0, InstNode.EMPTY_NODE());
 
 // Default String parameter.
 constant Component STRING_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
   Type.STRING(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode STRING_PARAM = InstNode.COMPONENT_NODE("s",
   Visibility.PUBLIC,
-  Pointer.createImmutable(STRING_COMPONENT), InstNode.EMPTY_NODE());
+  Pointer.createImmutable(STRING_COMPONENT), 0, InstNode.EMPTY_NODE());
 
 // Default enumeration(:) parameter.
 constant Component ENUM_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
   Type.ENUMERATION_ANY(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode ENUM_PARAM = InstNode.COMPONENT_NODE("e",
   Visibility.PUBLIC,
-  Pointer.createImmutable(ENUM_COMPONENT), InstNode.EMPTY_NODE());
+  Pointer.createImmutable(ENUM_COMPONENT), 0, InstNode.EMPTY_NODE());
 
 // Integer(e)
 constant Function INTEGER = Function.FUNCTION(Path.IDENT("Integer"),

Compiler/NFFrontEnd/NFCall.mo

@@ -293,7 +293,7 @@ uniontype Call
     outIters := {};
     iter_scope := scope;
     for Absiter in inIters loop
-      binding := Binding.fromAbsyn(Absiter.range, SCode.NOT_EACH(), iter_scope, info);
+      binding := Binding.fromAbsyn(Absiter.range, SCode.NOT_EACH(), 0, iter_scope, info);
       binding := Inst.instBinding(binding);
       (iter_scope, iter) := Inst.addIteratorToScope(Absiter.name, binding, info, iter_scope);
       outIters := iter::outIters;
@@ -646,6 +646,7 @@ uniontype Call
   algorithm
     ty := match call
       case TYPED_CALL(attributes = CallAttributes.CALL_ATTR(ty = ty)) then ty;
+      case TYPED_MAP_CALL() then call.ty;
       else Type.UNKNOWN();
     end match;
   end typeOf;

Compiler/NFFrontEnd/NFClass.mo

@@ -32,7 +32,7 @@
 encapsulated package NFClass
 
 import NFInstNode.InstNode;
-import NFMod.Modifier;
+import NFModifier.Modifier;
 import NFStatement.Statement;
 import SCode.Element;
 import Type = NFType;

Compiler/NFFrontEnd/NFComponent.mo

@@ -36,7 +36,7 @@ import Binding = NFBinding;
 import NFClass.Class;
 import Dimension = NFDimension;
 import NFInstNode.InstNode;
-import NFMod.Modifier;
+import NFModifier.Modifier;
 import SCode.Element;
 import SCode;
 import Type = NFType;

Compiler/NFFrontEnd/NFConvertDAE.mo

@@ -44,7 +44,7 @@ import ExecStat.execStat;
 import ElementSource;
 import ComponentRef = NFComponentRef;
 import Type = NFType;
-import NFMod.Modifier;
+import NFModifier.Modifier;
 import Expression = NFExpression;
 import NFComponent.Component;
 import Prefixes = NFPrefixes;

Compiler/NFFrontEnd/NFExpression.mo

@@ -161,6 +161,12 @@ public
     Type ty;
   end UNBOX;
 
+  record SUBSCRIPTED_EXP
+    Expression exp;
+    list<Expression> subscripts;
+    Type ty;
+  end SUBSCRIPTED_EXP;
+
   record TUPLE_ELEMENT
     Expression tupleExp;
     Integer index;
@@ -393,6 +399,17 @@ public
         then
           compare(exp1.exp, e1);
 
+      case SUBSCRIPTED_EXP()
+        algorithm
+          SUBSCRIPTED_EXP(exp = e1, subscripts = expl) := exp2;
+          comp := compare(exp1.exp, e1);
+
+          if comp == 0 then
+            comp := compareList(exp1.subscripts, expl);
+          end if;
+        then
+          comp;
+
       case TUPLE_ELEMENT()
         algorithm
           TUPLE_ELEMENT(tupleExp = e1, index = i) := exp2;
@@ -482,6 +499,7 @@ public
       case IF() then typeOf(exp.trueBranch);
       case CAST() then exp.ty;
       case UNBOX() then exp.ty;
+      case SUBSCRIPTED_EXP() then exp.ty;
       case TUPLE_ELEMENT() then exp.ty;
       else Type.UNKNOWN();
     end match;
@@ -564,6 +582,10 @@ public
         then
           CREF(Type.unliftArray(array.ty), cref);
 
+      case SUBSCRIPTED_EXP()
+        then SUBSCRIPTED_EXP(array.exp, listAppend(array.subscripts, {INTEGER(index)}), Type.unliftArray(array.ty));
+
+      else SUBSCRIPTED_EXP(array, {INTEGER(index)}, Type.unliftArray(typeOf(array)));
     end match;
   end arrayElement;
 
@@ -689,6 +711,7 @@ public
 
       case UNBOX() then "UNBOX(" + toString(exp.exp) + ")";
       case CAST() then "CAST(" + Type.toString(exp.ty) + ", " + toString(exp.exp) + ")";
+      case SUBSCRIPTED_EXP() then toString(exp.exp) + "[" + stringDelimitList(list(toString(e) for e in exp.subscripts), ", ") + "]";
       case TUPLE_ELEMENT() then toString(exp.tupleExp) + "[" + intString(exp.index) + "]";
 
       else anyString(exp);
@@ -769,6 +792,9 @@ public
       case UNBOX()
         then DAE.UNBOX(toDAE(exp.exp), Type.toDAE(exp.ty));
 
+      case SUBSCRIPTED_EXP()
+        then DAE.ASUB(toDAE(exp.exp), list(toDAE(s) for s in exp.subscripts));
+
       case TUPLE_ELEMENT()
         then DAE.TSUB(toDAE(exp.tupleExp), exp.index, Type.toDAE(exp.ty));
 
@@ -792,6 +818,7 @@ public
       case RANGE() then Type.dimensionCount(exp.ty);
       case SIZE(dimIndex = NONE()) then dimensionCount(exp.exp);
       case CAST() then dimensionCount(exp.exp);
+      case SUBSCRIPTED_EXP() then Type.dimensionCount(exp.ty);
       case TUPLE_ELEMENT() then Type.dimensionCount(exp.ty);
       // TODO: Add more expressions.
       else 0;
@@ -908,6 +935,9 @@ public
         then
           if referenceEq(exp.exp, e1) then exp else UNBOX(e1, exp.ty);
 
+      case SUBSCRIPTED_EXP()
+        then SUBSCRIPTED_EXP(map(exp.exp, func), list(map(e, func) for e in exp.subscripts), exp.ty);
+
       case TUPLE_ELEMENT()
         algorithm
           e1 := map(exp.tupleExp, func);
@@ -995,6 +1025,18 @@ public
         then
           Call.TYPED_CALL(call.fn, args, call.attributes);
 
+      case Call.UNTYPED_MAP_CALL()
+        algorithm
+          e := map(call.exp, func);
+        then
+          Call.UNTYPED_MAP_CALL(call.ref, e, call.iters);
+
+      case Call.TYPED_MAP_CALL()
+        algorithm
+          e := map(call.exp, func);
+        then
+          Call.TYPED_MAP_CALL(call.fn, call.ty, e, call.iters);
+
     end match;
   end mapCall;
 
@@ -1114,6 +1156,13 @@ public
 
       case CAST() then fold(exp.exp, func, arg);
       case UNBOX() then fold(exp.exp, func, arg);
+
+      case SUBSCRIPTED_EXP()
+        algorithm
+          result := fold(exp.exp, func, arg);
+        then
+          List.fold(exp.subscripts, func, result);
+
       case TUPLE_ELEMENT() then fold(exp.tupleExp, func, arg);
 
       else arg;
@@ -1167,6 +1216,18 @@ public
         then
           ();
 
+      case Call.UNTYPED_MAP_CALL()
+        algorithm
+          arg := fold(call.exp, func, arg);
+        then
+          ();
+
+      case Call.TYPED_MAP_CALL()
+        algorithm
+          arg := fold(call.exp, func, arg);
+        then
+          ();
+
     end match;
   end foldCall;
 
@@ -1345,6 +1406,13 @@ public
         then
           if referenceEq(exp.exp, e1) then exp else UNBOX(e1, exp.ty);
 
+      case SUBSCRIPTED_EXP()
+        algorithm
+          (e1, arg) := mapFold(exp.exp, func, arg);
+          (expl, arg) := List.map1Fold(exp.subscripts, mapFold, func, arg);
+        then
+          SUBSCRIPTED_EXP(e1, expl, exp.ty);
+
       case TUPLE_ELEMENT()
         algorithm
           (e1, arg) := mapFold(exp.tupleExp, func, arg);
@@ -1437,6 +1505,18 @@ public
         then
           Call.TYPED_CALL(call.fn, args, call.attributes);
 
+      case Call.UNTYPED_MAP_CALL()
+        algorithm
+          (e, foldArg) := mapFold(call.exp, func, foldArg);
+        then
+          Call.UNTYPED_MAP_CALL(call.ref, e, call.iters);
+
+      case Call.TYPED_MAP_CALL()
+        algorithm
+          (e, foldArg) := mapFold(call.exp, func, foldArg);
+        then
+          Call.TYPED_MAP_CALL(call.fn, call.ty, e, call.iters);
+
     end match;
   end mapFoldCall;