[NF] Function evaluation improvements for records.

- Build a record expression from the child nodes if a record output
  doesn't have an explicit binding.
- Evaluate expressions in function outputs and local variables too
  (currently in order of declaration, needs to be dependency sorted).
- Added check that the outputs are assigned a value when evaluation a
  function (by adding Expression.EMPTY() and using it as the initial
  value if an output has no binding).
- Always evaluate complex bindings on parameters, even if they aren't
  structural, since they need to be split into their component values.

Belonging to [master]:
  - #2414
  - OpenModelica/OpenModelica-testsuite#940

Author: perost

Compiler/NFFrontEnd/NFBinding.mo

@@ -156,6 +156,12 @@ public
           binding.bindingExp := exp;
         then
           ();
+
+      case FLAT_BINDING()
+        algorithm
+          binding.bindingExp := exp;
+        then
+          ();
     end match;
   end setTypedExp;
 

Compiler/NFFrontEnd/NFEvalFunction.mo

@@ -42,6 +42,7 @@ import Binding = NFBinding;
 import NFComponent.Component;
 import Type = NFType;
 import Dimension = NFDimension;
+import NFClassTree.ClassTree;
 
 protected
 import Ceval = NFCeval;
@@ -191,20 +192,54 @@ function addMutableReplacement
 protected
   Binding binding;
   Expression repl_exp;
+algorithm
+  repl_exp := getBindingExp(node);
+  repl_exp := Expression.map(repl_exp, function applyReplacements2(repl = repl));
+  repl_exp := Expression.makeMutable(repl_exp);
+  repl := ReplTree.add(repl, prefix + InstNode.name(node), repl_exp);
+end addMutableReplacement;
+
+function getBindingExp
+  input InstNode node;
+  output Expression bindingExp;
+protected
+  Binding binding;
 algorithm
   binding := Component.getBinding(InstNode.component(node));
 
-  // TODO: Handle records.
   if Binding.isBound(binding) then
-    repl_exp := Binding.getExp(binding);
+    bindingExp := Binding.getExp(binding);
   else
-    // TODO: Replace with something more suitable, Expression.EMPTY?
-    repl_exp := Expression.INTEGER(0);
+    bindingExp := buildRecordBinding(node);
   end if;
+end getBindingExp;
 
-  repl_exp := Expression.makeMutable(repl_exp);
-  repl := ReplTree.add(repl, prefix + InstNode.name(node), repl_exp);
-end addMutableReplacement;
+function buildRecordBinding
+  input InstNode node;
+  output Expression result;
+protected
+  InstNode cls_node = InstNode.classScope(node);
+  Class cls = InstNode.getClass(cls_node);
+  array<InstNode> comps;
+  list<Expression> bindings;
+  Component comp;
+  Expression exp;
+algorithm
+  result := match cls
+    case Class.INSTANCED_CLASS(elements = ClassTree.FLAT_TREE(components = comps))
+      algorithm
+        bindings := {};
+
+        for i in arrayLength(comps):-1:1 loop
+          bindings := getBindingExp(comps[i]) :: bindings;
+        end for;
+      then
+        Expression.RECORD(InstNode.scopePath(cls_node), cls.ty, bindings);
+
+    case Class.TYPED_DERIVED() then buildRecordBinding(cls.baseClass);
+    else Expression.EMPTY();
+  end match;
+end buildRecordBinding;
 
 function addInputReplacement
   input InstNode node;
@@ -255,15 +290,19 @@ function createResult
 protected
   list<Expression> expl;
   list<Type> types;
+  Expression e;
 algorithm
   if listLength(outputs) == 1 then
     exp := Expression.makeImmutable(ReplTree.get(repl, InstNode.name(listHead(outputs))));
+    assertAssignedOutput(listHead(outputs), exp);
   else
     expl := {};
     types := {};
 
     for o in outputs loop
-      expl := Expression.makeImmutable(ReplTree.get(repl, InstNode.name(o))) :: expl;
+      e := Expression.makeImmutable(ReplTree.get(repl, InstNode.name(o)));
+      assertAssignedOutput(o, e);
+      expl := e :: expl;
     end for;
 
     expl := listReverseInPlace(expl);
@@ -272,6 +311,22 @@ algorithm
   end if;
 end createResult;
 
+function assertAssignedOutput
+  input InstNode outputNode;
+  input Expression value;
+algorithm
+  () := match value
+    case Expression.EMPTY()
+      algorithm
+        Error.addSourceMessage(Error.UNASSIGNED_FUNCTION_OUTPUT,
+          {InstNode.name(outputNode)}, InstNode.info(outputNode));
+      then
+        fail();
+
+    else ();
+  end match;
+end assertAssignedOutput;
+
 function evaluateStatements
   input list<Statement> stmts;
   output FlowControl ctrl = FlowControl.NEXT;

Compiler/NFFrontEnd/NFExpression.mo

@@ -192,6 +192,9 @@ public
     Mutable<Expression> exp;
   end MUTABLE;
 
+  record EMPTY
+  end EMPTY;
+
   function isCref
     input Expression exp;
     output Boolean isTrue;
@@ -976,6 +979,7 @@ public
       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) + "]";
       case MUTABLE() then toString(Mutable.access(exp.exp));
+      case EMPTY() then "#EMPTY#";
 
       else anyString(exp);
     end match;

Compiler/NFFrontEnd/NFFlatten.mo

@@ -79,6 +79,7 @@ import NFPrefixes.Variability;
 import Variable = NFVariable;
 import BindingOrigin = NFBindingOrigin;
 import ElementSource;
+import Ceval = NFCeval;
 
 public
 type FunctionTree = FunctionTreeImpl.Tree;
@@ -378,15 +379,21 @@ algorithm
 
   // Create an equation if there's a binding on a complex component.
   if Binding.isBound(binding) then
+    binding := flattenBinding(binding, prefix, node);
     binding_exp := Binding.getTypedExp(binding);
 
+    if Component.variability(comp) <= Variability.PARAMETER then
+      binding_exp := Ceval.evalExp(binding_exp);
+    end if;
+
     if not Expression.isRecord(binding_exp) then
       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(NONE()));
     else
-      opt_binding := SOME(flattenBinding(binding, prefix, node));
+      binding := Binding.setTypedExp(binding_exp, binding);
+      opt_binding := SOME(binding);
     end if;
   else
     opt_binding := NONE();

Compiler/Util/Error.mo

@@ -795,6 +795,8 @@ public constant Message TERMINATE_TRIGGERED = MESSAGE(333, TRANSLATION(), ERROR(
   Util.gettext("terminate triggered: %s"));
 public constant Message EVAL_RECURSION_LIMIT_REACHED = MESSAGE(334, TRANSLATION(), ERROR(),
   Util.gettext("The recursion limit (--evalRecursionLimit=%s) was exceeded during evaluation of %s."));
+public constant Message UNASSIGNED_FUNCTION_OUTPUT = MESSAGE(335, TRANSLATION(), ERROR(),
+  Util.gettext("Output parameter %s was not assigned a value"));
 public constant Message INITIALIZATION_NOT_FULLY_SPECIFIED = MESSAGE(496, TRANSLATION(), WARNING(),
   Util.gettext("The initial conditions are not fully specified. %s."));
 public constant Message INITIALIZATION_OVER_SPECIFIED = MESSAGE(497, TRANSLATION(), WARNING(),