[NF] Improvements.

- Simplified the type checking of bindings, and made it work for
  binding on array types too.
- Added check that non-type classes shouldn't have dimensions.
- Fixed the check for 'each' being used correctly, and made it into
  a varning instead of an error.
- Fixed the typing of crefs so that it doesn't cause typing cycles.

Belonging to [master]:
  - #2370
  - OpenModelica/OpenModelica-testsuite#923

Author: perost

Compiler/NFFrontEnd/NFBinding.mo

@@ -43,28 +43,31 @@ protected
   import Binding = NFBinding;
 
 public
-  type Origin = enumeration(COMPONENT, EXTENDS, CLASS);
-
-  record UNBOUND end UNBOUND;
+  record UNBOUND
+    Option<NFBindingOrigin> origin;
+  end UNBOUND;
 
   record RAW_BINDING
     Absyn.Exp bindingExp;
     InstNode scope;
     BindingOrigin origin;
+    Boolean isEach;
   end RAW_BINDING;
 
   record UNTYPED_BINDING
     Expression bindingExp;
     Boolean isProcessing;
     InstNode scope;
     BindingOrigin origin;
+    Boolean isEach;
   end UNTYPED_BINDING;
 
   record TYPED_BINDING
     Expression bindingExp;
     Type bindingType;
     Variability variability;
     BindingOrigin origin;
+    Boolean isEach;
   end TYPED_BINDING;
 
   record FLAT_BINDING
@@ -86,9 +89,9 @@ public
         Absyn.Exp exp;
 
       case SOME(exp)
-        then RAW_BINDING(exp, scope, BindingOrigin.create(eachPrefix, level, ty, info));
+        then RAW_BINDING(exp, scope, BindingOrigin.create(level, ty, info), eachPrefix);
 
-      else UNBOUND();
+      else UNBOUND(if eachPrefix then SOME(BindingOrigin.create(level, ty, info)) else NONE());
     end match;
   end fromAbsyn;
 
@@ -178,10 +181,11 @@ public
     output SourceInfo info;
   algorithm
     info := match binding
-      case UNBOUND() then Absyn.dummyInfo;
+      case UNBOUND(origin = SOME(BindingOrigin.ORIGIN(info = info))) then info;
       case RAW_BINDING() then binding.origin.info;
       case UNTYPED_BINDING() then binding.origin.info;
       case TYPED_BINDING() then binding.origin.info;
+      else Absyn.dummyInfo;
     end match;
   end getInfo;
 
@@ -190,12 +194,32 @@ public
     output BindingOrigin origin;
   algorithm
     origin := match binding
+      case UNBOUND(origin = SOME(origin)) then origin;
       case RAW_BINDING() then binding.origin;
       case UNTYPED_BINDING() then binding.origin;
       case TYPED_BINDING() then binding.origin;
     end match;
   end getOrigin;
 
+  function setOrigin
+    input BindingOrigin origin;
+    input output Binding binding;
+  algorithm
+    () := match binding
+      case RAW_BINDING()     algorithm binding.origin := origin; then ();
+      case UNTYPED_BINDING() algorithm binding.origin := origin; then ();
+      case TYPED_BINDING()   algorithm binding.origin := origin; then ();
+      else ();
+    end match;
+  end setOrigin;
+
+  function setOriginNode
+    input InstNode node;
+    input output Binding binding;
+  algorithm
+    binding := setOrigin(BindingOrigin.setNode(node, getOrigin(binding)), binding);
+  end setOriginNode;
+
   function getType
     input Binding binding;
     output Type ty;
@@ -208,9 +232,10 @@ public
     output Boolean isEach;
   algorithm
     isEach := match binding
-      case RAW_BINDING() then BindingOrigin.isEach(binding.origin);
-      case UNTYPED_BINDING() then BindingOrigin.isEach(binding.origin);
-      case TYPED_BINDING() then BindingOrigin.isEach(binding.origin);
+      case UNBOUND(origin = SOME(_)) then true;
+      case RAW_BINDING() then binding.isEach;
+      case UNTYPED_BINDING() then binding.isEach;
+      case TYPED_BINDING() then binding.isEach;
       else false;
     end match;
   end isEach;

Compiler/NFFrontEnd/NFBindingOrigin.mo

@@ -31,6 +31,7 @@
 
 encapsulated uniontype NFBindingOrigin
   import NFModifier.ModifierScope;
+  import NFInstNode.InstNode;
 
 protected
   import BindingOrigin = NFBindingOrigin;
@@ -41,29 +42,24 @@ public
   record ORIGIN
     Integer level;
     ElementType ty;
+    Option<InstNode> node;
     SourceInfo info;
   end ORIGIN;
 
   function create
-    input Boolean eachPrefix;
     input Integer level;
     input ElementType ty;
     input SourceInfo info;
     output BindingOrigin origin;
   algorithm
-    origin := ORIGIN(if eachPrefix then -level else level, ty, info);
+    origin := ORIGIN(level, ty, NONE(), info);
   end create;
 
   function level
     input BindingOrigin origin;
     output Integer level = origin.level;
   end level;
 
-  function isEach
-    input BindingOrigin origin;
-    output Boolean isEach = origin.level < 0;
-  end isEach;
-
   function info
     input BindingOrigin origin;
     output SourceInfo info = origin.info;
@@ -78,5 +74,12 @@ public
     fromClass := ty == ElementType.CLASS;
   end isFromClass;
 
+  function setNode
+    input InstNode node;
+    input output BindingOrigin origin;
+  algorithm
+    origin.node := SOME(node);
+  end setNode;
+
   annotation(__OpenModelica_Interface="frontend");
 end NFBindingOrigin;

Compiler/NFFrontEnd/NFBuiltin.mo

@@ -44,7 +44,7 @@ public
 import Absyn;
 import SCode;
 import Binding = NFBinding;
-import BindingOrigin = NFBindingOrigin;
+import NFBindingOrigin;
 import NFClass.Class;
 import NFClassTree.ClassTree;
 import NFComponent.Component;
@@ -175,12 +175,11 @@ constant InstNode TIME =
     Pointer.createImmutable(Component.TYPED_COMPONENT(
       REAL_NODE,
       Type.REAL(),
-      Binding.UNBOUND(),
-      Binding.UNBOUND(),
+      Binding.UNBOUND(NONE()),
+      Binding.UNBOUND(NONE()),
       NFComponent.INPUT_ATTR,
       NONE(),
       Absyn.dummyInfo)),
-    0,
     InstNode.EMPTY_NODE());
 
 constant ComponentRef TIME_CREF = ComponentRef.CREF(TIME, {}, Type.REAL(), Origin.CREF, ComponentRef.EMPTY());

Compiler/NFFrontEnd/NFBuiltinFuncs.mo

@@ -75,43 +75,43 @@ constant SCode.Element DUMMY_ELEMENT = SCode.CLASS(
 
 // Default Integer parameter.
 constant Component INT_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.INTEGER(), Binding.UNBOUND(), Binding.UNBOUND(), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
+  Type.INTEGER(), Binding.UNBOUND(NONE()), Binding.UNBOUND(NONE()), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
 
 constant InstNode INT_PARAM = InstNode.COMPONENT_NODE("i",
   Visibility.PUBLIC,
-  Pointer.createImmutable(INT_COMPONENT), 0, InstNode.EMPTY_NODE());
+  Pointer.createImmutable(INT_COMPONENT), InstNode.EMPTY_NODE());
 
 // Default Real parameter.
 constant Component REAL_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.REAL(), Binding.UNBOUND(), Binding.UNBOUND(), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
+  Type.REAL(), Binding.UNBOUND(NONE()), Binding.UNBOUND(NONE()), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
 
 constant InstNode REAL_PARAM = InstNode.COMPONENT_NODE("r",
   Visibility.PUBLIC,
-  Pointer.createImmutable(REAL_COMPONENT), 0, InstNode.EMPTY_NODE());
+  Pointer.createImmutable(REAL_COMPONENT), InstNode.EMPTY_NODE());
 
 // Default Boolean parameter.
 constant Component BOOL_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.BOOLEAN(), Binding.UNBOUND(), Binding.UNBOUND(), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
+  Type.BOOLEAN(), Binding.UNBOUND(NONE()), Binding.UNBOUND(NONE()), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
 
 constant InstNode BOOL_PARAM = InstNode.COMPONENT_NODE("b",
   Visibility.PUBLIC,
-  Pointer.createImmutable(BOOL_COMPONENT), 0, InstNode.EMPTY_NODE());
+  Pointer.createImmutable(BOOL_COMPONENT), InstNode.EMPTY_NODE());
 
 // Default String parameter.
 constant Component STRING_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.STRING(), Binding.UNBOUND(), Binding.UNBOUND(), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
+  Type.STRING(), Binding.UNBOUND(NONE()), Binding.UNBOUND(NONE()), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
 
 constant InstNode STRING_PARAM = InstNode.COMPONENT_NODE("s",
   Visibility.PUBLIC,
-  Pointer.createImmutable(STRING_COMPONENT), 0, InstNode.EMPTY_NODE());
+  Pointer.createImmutable(STRING_COMPONENT), InstNode.EMPTY_NODE());
 
 // Default enumeration(:) parameter.
 constant Component ENUM_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.ENUMERATION_ANY(), Binding.UNBOUND(), Binding.UNBOUND(), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
+  Type.ENUMERATION_ANY(), Binding.UNBOUND(NONE()), Binding.UNBOUND(NONE()), NFComponent.DEFAULT_ATTR, NONE(), Absyn.dummyInfo);
 
 constant InstNode ENUM_PARAM = InstNode.COMPONENT_NODE("e",
   Visibility.PUBLIC,
-  Pointer.createImmutable(ENUM_COMPONENT), 0, InstNode.EMPTY_NODE());
+  Pointer.createImmutable(ENUM_COMPONENT), InstNode.EMPTY_NODE());
 
 // Integer(e)
 constant array<NFInstNode.CachedData> EMPTY_NODE_CACHE = listArrayLiteral({

Compiler/NFFrontEnd/NFCall.mo

@@ -668,8 +668,8 @@ uniontype Call
           // Create a range binding on which we will iterate to vectorize.
           ty := Type.ARRAY(Type.INTEGER(), {dim});
           exp := Expression.RANGE(ty, Expression.INTEGER(1), NONE(), Expression.INTEGER(Dimension.size(dim)));
-          origin := BindingOrigin.create(false, 0, NFBindingOrigin.ElementType.COMPONENT, info);
-          bind := Binding.TYPED_BINDING(exp, ty, Variability.CONSTANT, origin);
+          origin := BindingOrigin.create(0, NFBindingOrigin.ElementType.COMPONENT, info);
+          bind := Binding.TYPED_BINDING(exp, ty, Variability.CONSTANT, origin, false);
 
           // Add an iterator to the call scope.
           (iter_scope, iter) := Inst.addIteratorToScope("$i" + intString(i), bind, iter_scope, Type.INTEGER());

Compiler/NFFrontEnd/NFClass.mo

@@ -418,7 +418,10 @@ uniontype Class
     output Type ty;
   algorithm
     ty := match cls
-      case DERIVED_CLASS() then getType(InstNode.getClass(cls.baseClass), clsNode);
+      case DERIVED_CLASS()
+        then Type.liftArrayLeftList(
+               getType(InstNode.getClass(cls.baseClass), clsNode),
+               cls.dims);
       case INSTANCED_CLASS() then cls.ty;
       case PARTIAL_BUILTIN() then cls.ty;
       case INSTANCED_BUILTIN()

Compiler/NFFrontEnd/NFComponentRef.mo

@@ -490,10 +490,19 @@ public
     output DAE.ComponentRef dcref;
   algorithm
     dcref := match cref
+      local
+        Type ty;
+
       case EMPTY() then accumCref;
       case CREF()
         algorithm
-          dcref := DAE.ComponentRef.CREF_QUAL(InstNode.name(cref.node), Type.toDAE(cref.ty),
+          // If the type is unknown here it's likely because the cref part is
+          // from a scope prefix, which the typing doesn't bother typing since
+          // that introduces cycles in the typing. We could patch the crefs
+          // after the typing, but the new frontend doesn't use these types anyway.
+          // So instead we just fetch the type of the node if the type is unknown.
+          ty := if Type.isUnknown(cref.ty) then InstNode.getType(cref.node) else cref.ty;
+          dcref := DAE.ComponentRef.CREF_QUAL(InstNode.name(cref.node), Type.toDAE(ty),
             list(Subscript.toDAE(s) for s in cref.subscripts), accumCref);
         then
           toDAE_impl(cref.restCref, dcref);
@@ -566,7 +575,7 @@ public
         list<Dimension> dims;
         list<list<Subscript>> subs;
 
-      case CREF()
+      case CREF(ty = Type.ARRAY())
         algorithm
           dims := Type.arrayDims(cref.ty);
           subs := Subscript.expandList(cref.subscripts, dims);

Compiler/NFFrontEnd/NFExpressionIterator.mo

@@ -109,7 +109,7 @@ public
   algorithm
     iterator := match binding
       case Binding.TYPED_BINDING()
-        then if BindingOrigin.isEach(binding.origin) or BindingOrigin.isFromClass(binding.origin) then
+        then if Binding.isEach(binding) or BindingOrigin.isFromClass(binding.origin) then
           EACH_ITERATOR(binding.bindingExp) else fromExp(binding.bindingExp);
 
       case Binding.FLAT_BINDING()

Compiler/NFFrontEnd/NFFlatten.mo

@@ -295,10 +295,10 @@ algorithm
     eq := Equation.ARRAY_EQUALITY(Expression.CREF(ty, name), Binding.getTypedExp(binding), ty,
       ElementSource.createElementSource(info));
     sections := Sections.prependEquation(eq, sections);
-    binding := Binding.UNBOUND();
+    binding := Binding.UNBOUND(NONE());
   end if;
 
-  ty_attrs := list(flattenTypeAttribute(m, prefix, node) for m in typeAttrs);
+  ty_attrs := list(flattenTypeAttribute(m, name, node) for m in typeAttrs);
   vars := Variable.VARIABLE(name, ty, binding, visibility, comp_attr, ty_attrs, cmt, info) :: vars;
 end flattenSimpleComponent;
 
@@ -364,7 +364,7 @@ algorithm
       eq := Equation.EQUALITY(Expression.CREF(ty, name),  binding_exp, ty,
         ElementSource.createElementSource(InstNode.info(node)));
       sections := Sections.prependEquation(eq, sections);
-      opt_binding := SOME(Binding.UNBOUND());
+      opt_binding := SOME(Binding.UNBOUND(NONE()));
     else
       opt_binding := SOME(flattenBinding(binding, prefix, node));
     end if;
@@ -427,8 +427,8 @@ algorithm
       algorithm
         binding_level := BindingOrigin.level(binding.origin);
 
-        if binding_level > 0 then
-          subs := List.flatten(ComponentRef.subscriptsN(prefix, InstNode.level(component) - binding_level));
+        if not binding.isEach and binding_level > 0 then
+          subs := List.flatten(ComponentRef.subscriptsN(prefix, binding_level));
           binding.bindingExp := Expression.applySubscripts(subs, binding.bindingExp);
         end if;
       then