NFInst improvements.

- Implemented handling of array classes.
- Improved typing of dimensions, including detection of dependency
  loops and inferring unknown dimensions from bindings.
- Improved type matching of arrays and component bindings.
- Improved typing of size expressions.

Author: perost

Compiler/NFFrontEnd/NFCeval.mo

@@ -61,6 +61,16 @@ uniontype EvalTarget
   end RANGE;
 
   record IGNORE_ERRORS end IGNORE_ERRORS;
+
+  function isRange
+    input EvalTarget target;
+    output Boolean isRange;
+  algorithm
+    isRange := match target
+      case RANGE() then true;
+      else false;
+    end match;
+  end isRange;
 end EvalTarget;
 
 function evalExp
@@ -76,13 +86,15 @@ algorithm
       Call call;
       Component comp;
       Option<Expression> oexp;
+      ComponentRef cref;
 
-    case Expression.CREF(cref=ComponentRef.CREF(node = c as InstNode.COMPONENT_NODE()))
+    case Expression.CREF(cref = cref as ComponentRef.CREF(node = c as InstNode.COMPONENT_NODE()))
       algorithm
         Typing.typeComponentBinding(c);
         binding := Component.getBinding(InstNode.component(c));
+        exp1 := evalBinding(binding, exp, target);
       then
-        evalBinding(binding, exp, target);
+        Expression.subscript(exp1, cref.subscripts);
 
     case Expression.TYPENAME()
       then evalTypename(exp.ty, exp, target);
@@ -231,23 +243,29 @@ function evalTypename
 protected
   list<Expression> lits;
 algorithm
-  exp := match ty
-    case Type.ARRAY(elementType = Type.BOOLEAN())
-      then Expression.ARRAY(ty, {Expression.BOOLEAN(false), Expression.BOOLEAN(true)});
-
-    case Type.ARRAY(elementType = Type.ENUMERATION())
-      algorithm
-        lits := Expression.makeEnumLiterals(ty.elementType);
-      then
-        Expression.ARRAY(ty, lits);
-
-    else
-      algorithm
-        assert(false, getInstanceName() + " got invalid typename");
-      then
-        fail();
-
-  end match;
+  // Only expand the typename into an array if it's used as a range, and keep
+  // them as typenames when used as e.g. dimensions.
+  if not EvalTarget.isRange(target) then
+    exp := originExp;
+  else
+    exp := match ty
+      case Type.ARRAY(elementType = Type.BOOLEAN())
+        then Expression.ARRAY(ty, {Expression.BOOLEAN(false), Expression.BOOLEAN(true)});
+
+      case Type.ARRAY(elementType = Type.ENUMERATION())
+        algorithm
+          lits := Expression.makeEnumLiterals(ty.elementType);
+        then
+          Expression.ARRAY(ty, lits);
+
+      else
+        algorithm
+          assert(false, getInstanceName() + " got invalid typename");
+        then
+          fail();
+
+    end match;
+  end if;
 end evalTypename;
 
 annotation(__OpenModelica_Interface="frontend");

Compiler/NFFrontEnd/NFClass.mo

@@ -268,6 +268,18 @@ uniontype Class
       else true;
     end match;
   end isIdentical;
+
+  function getDimensions
+    input Class cls;
+    output list<Dimension> dims;
+  algorithm
+    dims := match cls
+      case DERIVED_CLASS()
+        then listAppend(cls.dims, getDimensions(InstNode.getClass(cls.baseClass)));
+      else {};
+    end match;
+  end getDimensions;
+
 end Class;
 
 annotation(__OpenModelica_Interface="frontend");

Compiler/NFFrontEnd/NFComponent.mo

@@ -457,7 +457,6 @@ uniontype Component
       else false;
     end match;
   end isRedeclare;
-
 end Component;
 
 annotation(__OpenModelica_Interface="frontend");

Compiler/NFFrontEnd/NFComponentRef.mo

@@ -115,7 +115,7 @@ public
     () := match cref
       case CREF()
         algorithm
-          cref.subscripts := subscript :: cref.subscripts;
+          cref.subscripts := listAppend(cref.subscripts, {subscript});
         then
           ();
     end match;

Compiler/NFFrontEnd/NFExpression.mo

@@ -711,5 +711,21 @@ public
     end match;
   end toDAE;
 
+  function dimensionCount
+    input Expression exp;
+    output Integer dimCount;
+  algorithm
+    dimCount := match exp
+      case ARRAY(ty = Type.UNKNOWN())
+        then 1 + dimensionCount(listHead(exp.elements));
+      case ARRAY() then Type.dimensionCount(exp.ty);
+      case RANGE() then Type.dimensionCount(exp.ty);
+      case SIZE(dimIndex = NONE()) then dimensionCount(exp.exp);
+      case CAST() then dimensionCount(exp.exp);
+      // TODO: Add more expressions.
+      else 0;
+    end match;
+  end dimensionCount;
+
 annotation(__OpenModelica_Interface="frontend");
 end NFExpression;

Compiler/NFFrontEnd/NFInst.mo

@@ -300,7 +300,7 @@ algorithm
 
         // Fetch the needed information from the class definition and construct a DERIVED_CLASS.
         prefs := instClassPrefixes(def);
-        dims := list(Dimension.RAW_DIM(d) for d in cdef.attributes.arrayDims);
+        dims := list(Dimension.RAW_DIM(d) for d in Absyn.typeSpecDimensions(ty));
         mod := Class.getModifier(InstNode.getClass(node));
         c := Class.DERIVED_CLASS(ext_node, mod, dims, prefs, cdef.attributes.direction);
         node := InstNode.updateClass(c, node);
@@ -516,6 +516,7 @@ protected
   ClassTree cls_tree;
   Modifier cls_mod, mod;
   list<Modifier> type_attr;
+  list<Dimension> dims;
 algorithm
   cls := InstNode.getClass(node);
   cls_mod := Class.getModifier(cls);
@@ -568,7 +569,8 @@ algorithm
       algorithm
         mod := Modifier.fromElement(InstNode.definition(node), InstNode.parent(node));
         mod := Modifier.merge(cls_mod, mod);
-        node := instClass(cls.baseClass, mod, parent);
+        cls.baseClass := instClass(cls.baseClass, mod, parent);
+        node := InstNode.replaceClass(cls, node);
       then
         ();
 
@@ -923,6 +925,18 @@ algorithm
       then
         ();
 
+    case Class.DERIVED_CLASS()
+      algorithm
+        sections := instExpressions(cls.baseClass, scope, sections);
+
+        if not listEmpty(cls.dims) then
+          cls.dims := list(instDimension(d, InstNode.parent(node), InstNode.info(node))
+            for d in cls.dims);
+          InstNode.updateClass(cls, node);
+        end if;
+      then
+        ();
+
     case Class.INSTANCED_BUILTIN()
       algorithm
         cls.attributes := list(instBuiltinAttribute(a) for a in cls.attributes);
@@ -958,18 +972,45 @@ function instComponentExpressions
   input InstNode scope;
 protected
   Component c = InstNode.component(component);
-  array<Dimension> dims;
+  array<Dimension> dims, all_dims;
+  list<Dimension> cls_dims;
+  Integer len;
 algorithm
   () := match c
     case Component.UNTYPED_COMPONENT(dimensions = dims)
       algorithm
         c.binding := instBinding(c.binding);
+        instExpressions(c.classInst, component);
 
-        for i in 1:arrayLength(dims) loop
-          dims[i] := instDimension(dims[i], scope, c.info);
-        end for;
+        cls_dims := Class.getDimensions(InstNode.getClass(c.classInst));
+        len := arrayLength(dims);
+
+        if listEmpty(cls_dims) then
+          // If we have no type dimensions, simply instantiate the component's dimensions.
+          for i in 1:len loop
+            dims[i] := instDimension(dims[i], scope, c.info);
+          end for;
+        else
+          // If we have type dimensions, allocate space for them and add them to
+          // the component's dimensions.
+          all_dims := Dangerous.arrayCreateNoInit(len + listLength(cls_dims), Dimension.UNKNOWN());
+
+          // Instantiate the component's dimensions.
+          for i in 1:len loop
+            all_dims[i] := instDimension(dims[i], scope, c.info);
+          end for;
+
+          // Add the already instantiated dimensions from the type.
+          len := len + 1;
+          for e in cls_dims loop
+            all_dims[len] := e;
+            len := len + 1;
+          end for;
+
+          // Update the dimensions in the component.
+          c.dimensions := all_dims;
+        end if;
 
-        instExpressions(c.classInst, component);
         InstNode.updateComponent(c, component);
       then
         ();

Compiler/NFFrontEnd/NFType.mo

@@ -335,6 +335,17 @@ public
     end try;
   end getTypeDims;
 
+  function nthDimension
+    input Type ty;
+    input Integer index;
+    output Dimension dim;
+  algorithm
+    dim := match ty
+      case ARRAY() then listGet(ty.dimensions, index);
+      case FUNCTION() then nthDimension(ty.resultType, index);
+    end match;
+  end nthDimension;
+
   function dimensionCount
     input Type ty;
     output Integer dimCount;
@@ -370,7 +381,7 @@ public
       case Type.REAL() then "Real";
       case Type.STRING() then "String";
       case Type.BOOLEAN() then "Boolean";
-      case Type.ENUMERATION() then "enumeration()";
+      case Type.ENUMERATION() then "enumeration(" + stringDelimitList(ty.literals, ", ") + ")";
       case Type.ENUMERATION_ANY() then "enumeration(:)";
       case Type.CLOCK() then "Clock";
       case Type.ARRAY() then toString(ty.elementType) + "[" + stringDelimitList(List.map(ty.dimensions, Dimension.toString), ", ") + "]";