[NF] Record improvements.

- Fix evaluation of record field crefs so that getting the binding from
  the parent's parent (and so on) works properly.
- When determining the default argument for a function parameter of
  record type, try to create an argument from the record's fields if the
  parameter itself does not have a binding.

Author: perost

OMCompiler/Compiler/NFFrontEnd/NFCeval.mo

@@ -644,19 +644,43 @@ algorithm
 
     // A record field without an explicit binding, evaluate the parent's binding
     // if it has one and fetch the binding from it instead.
-    case (_, ComponentRef.CREF(restCref = rest_cr as ComponentRef.CREF(ty = ty)))
-      guard Type.isRecord(Type.arrayElementType(ty))
+    case (_, _)
       algorithm
-        exp := evalCref(rest_cr, Expression.EMPTY(ty), target);
-        exp := Expression.bindingExpMap(exp, function makeComponentBinding2(name = InstNode.name(node)));
+        exp := makeRecordFieldBindingFromParent(cref, target);
       then
         Binding.CEVAL_BINDING(exp);
 
     else NFBinding.EMPTY_BINDING;
   end matchcontinue;
 end makeComponentBinding;
 
-function makeComponentBinding2
+function makeRecordFieldBindingFromParent
+  input ComponentRef cref;
+  input EvalTarget target;
+  output Expression exp;
+protected
+  ComponentRef parent_cr;
+  Type parent_ty;
+algorithm
+  parent_cr := ComponentRef.rest(cref);
+  parent_ty := ComponentRef.nodeType(parent_cr);
+  true := Type.isRecord(Type.arrayElementType(parent_ty));
+
+  try
+    // Pass an EMPTY expression here as the default expression instead of the
+    // cref. Otherwise evalCref might attempt to make a binding for the parent
+    // from its children, which would create an evaluation loop.
+    exp := evalCref(parent_cr, Expression.EMPTY(parent_ty), target);
+  else
+    // If the parent didn't have a binding, try the parent's parent.
+    exp := makeRecordFieldBindingFromParent(parent_cr, target);
+  end try;
+
+  exp := Expression.bindingExpMap(exp,
+    function lookupRecordFieldInExp(name = ComponentRef.firstName(cref)));
+end makeRecordFieldBindingFromParent;
+
+function lookupRecordFieldInExp
   input Expression exp;
   input String name;
   output Expression result;
@@ -669,7 +693,7 @@ algorithm
 
     case Expression.RECORD() then Expression.recordElement(name, exp);
 
-    // An empty array of records will still be empty, only the type needs to be changed.
+    // An empty array of records will still be empty, but the type needs to be changed.
     case Expression.ARRAY(elements = {})
       algorithm
         exp.ty := Type.lookupRecordFieldType(name, exp.ty);
@@ -682,16 +706,16 @@ algorithm
     //       element of the array so we only need to do lookup once.
     case Expression.ARRAY(ty = Type.ARRAY(dimensions = dim :: _))
       algorithm
-        expl := list(makeComponentBinding2(e, name) for e in exp.elements);
+        expl := list(lookupRecordFieldInExp(e, name) for e in exp.elements);
         ty := Type.liftArrayLeft(Expression.typeOf(listHead(expl)), dim);
       then
         Expression.makeArray(ty, expl, literal = true);
 
     case Expression.SUBSCRIPTED_EXP()
-      then Expression.SUBSCRIPTED_EXP(makeComponentBinding2(exp.exp, name), exp.subscripts, exp.ty);
+      then Expression.SUBSCRIPTED_EXP(lookupRecordFieldInExp(exp.exp, name), exp.subscripts, exp.ty);
 
   end match;
-end makeComponentBinding2;
+end lookupRecordFieldInExp;
 
 function makeRecordBindingExp
   input InstNode typeNode;

OMCompiler/Compiler/NFFrontEnd/NFClass.mo

@@ -694,6 +694,23 @@ uniontype Class
     end if;
   end hasOperator;
 
+  function makeRecordExp
+    input InstNode clsNode;
+    output Expression exp;
+  protected
+    Class cls;
+    Type ty;
+    InstNode ty_node;
+    array<InstNode> fields;
+    list<Expression> args;
+  algorithm
+    cls := InstNode.getClass(clsNode);
+    ty as Type.COMPLEX(complexTy = ComplexType.RECORD(ty_node)) := getType(cls, clsNode);
+    fields := ClassTree.getComponents(classTree(cls));
+    args := list(Binding.getExp(Component.getImplicitBinding(InstNode.component(f))) for f in fields);
+    exp := Expression.makeRecord(InstNode.scopePath(ty_node), ty, args);
+  end makeRecordExp;
+
   function toFlatStream
     input Class cls;
     input InstNode clsNode;

OMCompiler/Compiler/NFFrontEnd/NFComponent.mo

@@ -453,6 +453,31 @@ uniontype Component
     end match;
   end getBinding;
 
+  function getImplicitBinding
+    "Returns the component's binding. If the component does not have a binding
+     and is a record instance it will try to create a binding from the
+     component's children."
+    input Component component;
+    output Binding binding;
+  protected
+    InstNode cls_node;
+    Expression record_exp;
+  algorithm
+    binding := getBinding(component);
+
+    if Binding.isUnbound(binding) then
+      cls_node := classInstance(component);
+
+      if InstNode.isRecord(cls_node) then
+        try
+          record_exp := Class.makeRecordExp(cls_node);
+          binding := Binding.FLAT_BINDING(record_exp, Expression.variability(record_exp));
+        else
+        end try;
+      end if;
+    end if;
+  end getImplicitBinding;
+
   function setBinding
     input Binding binding;
     input output Component component;

OMCompiler/Compiler/NFFrontEnd/NFFunction.mo

@@ -77,6 +77,7 @@ import Array;
 import ElementSource;
 import SCodeUtil;
 import IOStream;
+import ComplexType = NFComplexType;
 
 public
 type NamedArg = tuple<String, Expression>;
@@ -1969,7 +1970,7 @@ protected
   algorithm
     try
       comp := InstNode.component(component);
-      default := Binding.typedExp(Component.getBinding(comp));
+      default := Binding.typedExp(Component.getImplicitBinding(comp));
       name := InstNode.name(component);
 
       // Remove $in_ for OM input output arguments.

testsuite/flattening/modelica/scodeinst/Makefile

@@ -712,7 +712,9 @@ RecordBinding4.mo \
 RecordBinding5.mo \
 RecordBinding6.mo \
 RecordBinding7.mo \
+RecordBinding8.mo \
 RecordConstructor1.mo \
+RecordConstructor2.mo \
 RecordExtends1.mo \
 RecordExtends2.mo \
 RecordUnknownDim1.mo \
@@ -882,7 +884,6 @@ OCGTests.mos \
 # test that currently fail. Move up when fixed.
 # Run make testfailing
 FAILINGTESTFILES=\
-RecordConstructor2.mo \
 FinalParameter1.mo \
 FinalParameter2.mo \
 FinalParameter3.mo \

testsuite/flattening/modelica/scodeinst/RecordBinding8.mo

@@ -0,0 +1,32 @@
+// name: RecordBinding8
+// keywords:
+// status: correct
+// cflags: -d=newInst
+//
+
+record R1
+  Real x = 1.0;
+end R1;
+
+record R2
+  R1 r1;
+end R2;
+
+function f
+  input R2 r2;
+  output Real x = r2.r1.x;
+end f;
+
+model RecordBinding8
+  Real x;
+equation
+  x = f();
+end RecordBinding8;
+
+// Result:
+// class RecordBinding8
+//   Real x;
+// equation
+//   x = 1.0;
+// end RecordBinding8;
+// endResult

testsuite/flattening/modelica/scodeinst/RecordConstructor2.mo

@@ -29,6 +29,6 @@ end RecordConstructor2;
 //   Real r.x;
 //   constant Real r.y = 1.0;
 // algorithm
-//   r := R(time);
+//   r := R(time, 1.0);
 // end RecordConstructor2;
 // endResult