[NF] Function evaluation improvements.

- Handle some subscripted expressions in EvalFunction.
- Fixed type of cat in Ceval.evalBuiltinCat.

Belonging to [master]:
  - OpenModelica/OMCompiler#2421
  - OpenModelica/OpenModelica-testsuite#942

Author: perost

Compiler/NFFrontEnd/NFCeval.mo

@@ -1394,7 +1394,7 @@ algorithm
     fail();
   end if;
   (es,dims) := ExpressionSimplify.evalCat(n, args, getArrayContents=Expression.arrayElements, toString=Expression.toString);
-  result := Expression.arrayFromList(es, Type.arrayElementType(ty), list(Dimension.fromInteger(d) for d in dims));
+  result := Expression.arrayFromList(es, Expression.typeOf(listHead(es)), list(Dimension.fromInteger(d) for d in dims));
 end evalBuiltinCat;
 
 function evalBuiltinCeil

Compiler/NFFrontEnd/NFComponentRef.mo

@@ -357,6 +357,16 @@ public
     end match;
   end applySubscript2;
 
+  function getSubscripts
+    input ComponentRef cref;
+    output list<Subscript> subscripts;
+  algorithm
+    subscripts := match cref
+      case CREF() then cref.subscripts;
+      else {};
+    end match;
+  end getSubscripts;
+
   function setSubscripts
     "Sets the subscripts of the first part of a cref."
     input list<Subscript> subscripts;

Compiler/NFFrontEnd/NFEvalFunction.mo

@@ -210,19 +210,32 @@ algorithm
   if Binding.isBound(binding) then
     bindingExp := Binding.getExp(binding);
   else
-    bindingExp := buildRecordBinding(node);
+    bindingExp := buildBinding(node);
   end if;
 end getBindingExp;
 
-function buildRecordBinding
+function buildBinding
   input InstNode node;
   output Expression result;
 protected
-  InstNode cls_node = InstNode.classScope(node);
-  Class cls = InstNode.getClass(cls_node);
+  Type ty;
+algorithm
+  ty := InstNode.getType(node);
+
+  result := match ty
+    case Type.ARRAY() guard Type.hasKnownSize(ty) then Expression.fillType(ty, Expression.EMPTY());
+    case Type.COMPLEX() then buildRecordBinding(ty.cls);
+    else Expression.EMPTY();
+  end match;
+end buildBinding;
+
+function buildRecordBinding
+  input InstNode recordNode;
+  output Expression result;
+protected
+  Class cls = InstNode.getClass(recordNode);
   array<InstNode> comps;
   list<Expression> bindings;
-  Component comp;
   Expression exp;
 algorithm
   result := match cls
@@ -231,13 +244,12 @@ algorithm
         bindings := {};
 
         for i in arrayLength(comps):-1:1 loop
-          bindings := getBindingExp(comps[i]) :: bindings;
+          bindings := Expression.makeMutable(getBindingExp(comps[i])) :: bindings;
         end for;
       then
-        Expression.RECORD(InstNode.scopePath(cls_node), cls.ty, bindings);
+        Expression.RECORD(InstNode.scopePath(recordNode), cls.ty, bindings);
 
     case Class.TYPED_DERIVED() then buildRecordBinding(cls.baseClass);
-    else Expression.makeMutable(Expression.EMPTY());
   end match;
 end buildRecordBinding;
 
@@ -266,12 +278,6 @@ algorithm
     local
       Option<Expression> repl_exp;
 
-    case Expression.CREF(cref = ComponentRef.CREF(subscripts = _ :: _))
-      algorithm
-        Error.assertion(false, getInstanceName() + ": missing handling of subscripts", sourceInfo());
-      then
-        fail();
-
     case Expression.CREF() then applyReplacementCref(repl, exp.cref, exp);
     else exp;
   end match;
@@ -305,14 +311,18 @@ algorithm
       return;
     end if;
 
+    outExp := Expression.applySubscripts(ComponentRef.getSubscripts(listHead(cref_parts)), outExp);
+    cref_parts := listRest(cref_parts);
+
     if not listEmpty(cref_parts) then
       try
         // If the cref consists of more than one identifier we need to look up
         // the corresponding record field in the expression.
-        for cr in listRest(cref_parts) loop
+        for cr in cref_parts loop
           node := ComponentRef.node(cr);
           outExp := Expression.makeImmutable(outExp);
           outExp := Expression.lookupRecordField(InstNode.name(node), outExp);
+          outExp := Expression.applySubscripts(ComponentRef.getSubscripts(cr), outExp);
         end for;
       else
         Error.assertion(false, getInstanceName() + " could not find replacement for " +
@@ -420,12 +430,13 @@ function assignVariable
 algorithm
   () := match (variable, value)
     local
-      Expression val;
+      Expression var, val;
       list<Expression> vals;
+      Mutable<Expression> var_ptr;
 
-    case (Expression.MUTABLE(), _)
+    case (Expression.MUTABLE(exp = var_ptr), _)
       algorithm
-        Mutable.update(variable.exp, assignExp(Mutable.access(variable.exp), value));
+        Mutable.update(var_ptr, assignExp(Mutable.access(var_ptr), value));
       then
         ();
 
@@ -438,6 +449,13 @@ algorithm
       then
         ();
 
+    case (Expression.SUBSCRIPTED_EXP(exp = Expression.MUTABLE(exp = var_ptr)), _)
+      algorithm
+        Error.assertion(false, getInstanceName() +
+          ": missing handling of subscripted assignment", sourceInfo());
+      then
+        ();
+
     else
       algorithm
         Error.assertion(false, getInstanceName() + " failed on " +

Compiler/NFFrontEnd/NFExpression.mo

@@ -553,6 +553,7 @@ public
       case SUBSCRIPTED_EXP() then exp.ty;
       case TUPLE_ELEMENT()   then exp.ty;
       case BOX()             then Type.METABOXED(typeOf(exp.exp));
+      case MUTABLE()         then typeOf(Mutable.access(exp.exp));
       else Type.UNKNOWN();
     end match;
   end typeOf;

Compiler/NFFrontEnd/NFFunction.mo

@@ -208,7 +208,7 @@ uniontype Function
     Type returnType;
     DAE.FunctionAttributes attributes;
     Pointer<Boolean> collected "Whether this function has already been added to the function tree or not.";
-    Pointer<Integer> callCounter "Used during function evaluation to avoid infinite loops.";
+    Pointer<Integer> callCounter "Used during function evaluation to limit recursion.";
   end FUNCTION;
 
   function new

Compiler/NFFrontEnd/NFType.mo

@@ -517,6 +517,17 @@ public
     end match;
   end dimensionCount;
 
+  function hasKnownSize
+    input Type ty;
+    output Boolean isKnown;
+  algorithm
+    isKnown := match ty
+      case ARRAY() then List.all(ty.dimensions, function Dimension.isKnown(allowExp = false));
+      case FUNCTION() then hasKnownSize(ty.resultType);
+      else true;
+    end match;
+  end hasKnownSize;
+
   function mapDims
     input output Type ty;
     input FuncT func;