[NF] Fix default values in record constructors.

- Fix conversion of bindings for DAE.Var, since record constructors
  uses them for default values.
- Don't generate type variables when converting types of scope crefs,
  to avoid loops when converting complex types.

Belonging to [master]:
  - #2468
  - OpenModelica/OpenModelica-testsuite#962

Author: perost

Compiler/NFFrontEnd/NFBinding.mo

@@ -83,6 +83,7 @@ uniontype Binding
 
   record FLAT_BINDING
     Expression bindingExp;
+    Variability variability;
   end FLAT_BINDING;
 
   record CEVAL_BINDING
@@ -245,7 +246,15 @@ public
     input Binding binding;
     output Variability var;
   algorithm
-    TYPED_BINDING(variability = var) := binding;
+    var := match binding
+      case TYPED_BINDING() then binding.variability;
+      case FLAT_BINDING() then binding.variability;
+      else
+        algorithm
+          Error.assertion(false, getInstanceName() + " got unknown binding", sourceInfo());
+        then
+          fail();
+    end match;
   end variability;
 
   function getInfo
@@ -411,21 +420,46 @@ public
   algorithm
     outBinding := match binding
       case UNBOUND() then DAE.UNBOUND();
-      case TYPED_BINDING()
-        then DAE.EQBOUND(
-            Expression.toDAE(binding.bindingExp),
-            NONE(),
-            Variability.variabilityToDAEConst(binding.variability),
-            DAE.BINDING_FROM_DEFAULT_VALUE() // TODO: revise this.
-          );
-
+      case TYPED_BINDING() then makeDAEBinding(binding.bindingExp, binding.variability);
+      case FLAT_BINDING() then makeDAEBinding(binding.bindingExp, binding.variability);
+      case CEVAL_BINDING() then DAE.UNBOUND();
       else
         algorithm
-          Error.assertion(false, getInstanceName() + " got untyped binding.", sourceInfo());
+          Error.assertion(false, getInstanceName() + " got untyped binding", sourceInfo());
         then
           fail();
     end match;
   end toDAE;
+
+  function makeDAEBinding
+    input Expression exp;
+    input Variability var;
+    output DAE.Binding binding;
+  algorithm
+    binding := DAE.EQBOUND(
+      Expression.toDAE(exp),
+      NONE(),
+      Variability.variabilityToDAEConst(var),
+      DAE.BINDING_FROM_DEFAULT_VALUE() // TODO: revise this.
+    );
+  end makeDAEBinding;
+
+  function toDAEExp
+    input Binding binding;
+    output Option<DAE.Exp> bindingExp;
+  algorithm
+    bindingExp := match binding
+      case UNBOUND() then NONE();
+      case TYPED_BINDING() then SOME(Expression.toDAE(binding.bindingExp));
+      case FLAT_BINDING() then SOME(Expression.toDAE(binding.bindingExp));
+      case CEVAL_BINDING() then NONE();
+      else
+        algorithm
+          Error.assertion(false, getInstanceName() + " got untyped binding", sourceInfo());
+        then
+          fail();
+    end match;
+  end toDAEExp;
 end Binding;
 
 annotation(__OpenModelica_Interface="frontend");

Compiler/NFFrontEnd/NFComponentRef.mo

@@ -575,6 +575,7 @@ public
     dcref := match cref
       local
         Type ty;
+        DAE.Type dty;
 
       case EMPTY() then accumCref;
       case CREF()
@@ -585,7 +586,8 @@ public
           // 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),
+          dty := Type.toDAE(ty, makeTypeVars = false);
+          dcref := DAE.ComponentRef.CREF_QUAL(InstNode.name(cref.node), dty,
             list(Subscript.toDAE(s) for s in cref.subscripts), accumCref);
         then
           toDAE_impl(cref.restCref, dcref);

Compiler/NFFrontEnd/NFConvertDAE.mo

@@ -110,7 +110,7 @@ protected
   Option<DAE.VariableAttributes> var_attr;
   Option<DAE.Exp> binding_exp;
 algorithm
-  binding_exp := convertBinding(var.binding);
+  binding_exp := Binding.toDAEExp(var.binding);
   var_attr := convertVarAttributes(var.typeAttributes, var.ty, var.attributes);
   daeVar := makeDAEVar(var.name, var.ty, binding_exp, var.attributes,
     var.visibility, var_attr, var.comment, useLocalDir, false, var.info);
@@ -190,17 +190,6 @@ algorithm
   end match;
 end getComponentDirection;
 
-function convertBinding
-  input Binding binding;
-  output Option<DAE.Exp> bindingExp;
-algorithm
-  bindingExp := match binding
-    case Binding.UNBOUND() then NONE();
-    case Binding.TYPED_BINDING() then SOME(Expression.toDAE(binding.bindingExp));
-    case Binding.FLAT_BINDING() then SOME(Expression.toDAE(binding.bindingExp));
-  end match;
-end convertBinding;
-
 function convertVarAttributes
   input list<tuple<String, Binding>> attrs;
   input Type ty;
@@ -981,7 +970,7 @@ algorithm
     case Component.TYPED_COMPONENT(ty = ty, info = info)
       algorithm
         cref := ComponentRef.fromNode(node, ty);
-        binding := convertBinding(comp.binding);
+        binding := Binding.toDAEExp(comp.binding);
         cls := InstNode.getClass(comp.classInst);
         ty_attr := list((Modifier.name(m), Modifier.binding(m)) for m in Class.getTypeAttributes(cls));
         attr := comp.attributes;
@@ -1061,44 +1050,38 @@ algorithm
 end convertExternalDeclOutput;
 
 public
-function makeTypesVars
+function makeTypeVars
   input InstNode complexCls;
   output list<DAE.Var> typeVars;
 protected
   Component comp;
   DAE.Var type_var;
 algorithm
-  typeVars := {};
-
-  () := match cls as InstNode.getClass(complexCls)
-    case Class.INSTANCED_CLASS(elements = ClassTree.FLAT_TREE()) algorithm
-
-      for c in ClassTree.getComponents(cls.elements) loop
-        if InstNode.isOnlyOuter(c) or InstNode.isEmpty(c) then
-          continue;
-        end if;
-        comp := InstNode.component(InstNode.resolveOuter(c));
-
-        type_var := DAE.TYPES_VAR(InstNode.name(c)
-                      , Component.Attributes.toDAE(Component.getAttributes(comp))
-                      , Type.toDAE(Component.getType(comp))
-                      // Fix recursive bindings and update this
-                      // , Binding.toDAE(Component.getBinding(comp))
-                      , DAE.UNBOUND()
-                      , NONE()
-                     );
-        typeVars := type_var::typeVars;
-      end for;
-
-      typeVars := listReverse(typeVars);
-    then ();
-
-    else ();
+  typeVars := match cls as InstNode.getClass(complexCls)
+    case Class.INSTANCED_CLASS(elements = ClassTree.FLAT_TREE())
+      then list(makeTypeVar(c) for c guard not (InstNode.isOnlyOuter(c) or InstNode.isEmpty(c))
+             in ClassTree.getComponents(cls.elements));
 
+    else {};
   end match;
+end makeTypeVars;
 
-end makeTypesVars;
-
+function makeTypeVar
+  input InstNode component;
+  output DAE.Var typeVar;
+protected
+  Component comp;
+algorithm
+  comp := InstNode.component(InstNode.resolveOuter(component));
+
+  typeVar := DAE.TYPES_VAR(
+    InstNode.name(component),
+    Component.Attributes.toDAE(Component.getAttributes(comp)),
+    Type.toDAE(Component.getType(comp)),
+    Binding.toDAE(Component.getBinding(comp)),
+    NONE()
+  );
+end makeTypeVar;
 
 annotation(__OpenModelica_Interface="frontend");
 end NFConvertDAE;

Compiler/NFFrontEnd/NFFlatten.mo

@@ -344,11 +344,13 @@ function getRecordBindings
 protected
   Expression binding_exp;
   list<Expression> expl;
+  Variability var;
 algorithm
   binding_exp := Binding.getTypedExp(binding);
+  var := Binding.variability(binding);
 
   recordBindings := match binding_exp
-    case Expression.RECORD() then list(Binding.FLAT_BINDING(e) for e in binding_exp.elements);
+    case Expression.RECORD() then list(Binding.FLAT_BINDING(e, var) for e in binding_exp.elements);
     else
       algorithm
         Error.assertion(false, getInstanceName() + " got non-record binding " +

Compiler/NFFrontEnd/NFInstNode.mo

@@ -1242,32 +1242,76 @@ uniontype InstNode
     end match;
   end setModifier;
 
-  function toDAEType
+  function toPartialDAEType
+    "Returns the DAE type for a class, without the list of variables filled in."
     input InstNode clsNode;
     output DAE.Type outType;
   algorithm
     outType := match clsNode
       local
         Class cls;
+        ClassInf.State state;
+
+      case CLASS_NODE()
+        algorithm
+          cls := Pointer.access(clsNode.cls);
+        then
+          match cls
+            case Class.DAE_TYPE() then stripDAETypeVars(cls.ty);
+
+            else
+              algorithm
+                state := Restriction.toDAE(Class.restriction(cls), scopePath(clsNode));
+              then
+                DAE.Type.T_COMPLEX(state, {}, NONE());
+
+          end match;
+    end match;
+  end toPartialDAEType;
+
+  function stripDAETypeVars
+    input output DAE.Type ty;
+  algorithm
+    () := match ty
+      case DAE.Type.T_COMPLEX()
+        algorithm
+          ty.varLst := {};
+        then
+          ();
+
+      else ();
+    end match;
+  end stripDAETypeVars;
+
+  function toFullDAEType
+    "Returns the DAE type for a class, with the list of variables filled in."
+    input InstNode clsNode;
+    output DAE.Type outType;
+  algorithm
+    outType := match clsNode
+      local
+        Class cls;
+        list<DAE.Var> vars;
+        ClassInf.State state;
 
       case CLASS_NODE()
         algorithm
           cls := Pointer.access(clsNode.cls);
         then
           match cls
             case Class.DAE_TYPE() then cls.ty;
+
             else
               algorithm
-                outType := DAE.Type.T_COMPLEX(
-                  Restriction.toDAE(Class.restriction(cls), scopePath(clsNode)),
-                  ConvertDAE.makeTypesVars(clsNode),
-                  NONE());
+                state := Restriction.toDAE(Class.restriction(cls), scopePath(clsNode));
+                vars := ConvertDAE.makeTypeVars(clsNode);
+                outType := DAE.Type.T_COMPLEX(state, vars, NONE());
                 Pointer.update(clsNode.cls, Class.DAE_TYPE(outType));
               then
                 outType;
           end match;
     end match;
-  end toDAEType;
+  end toFullDAEType;
 
   function isBuiltin
     input InstNode node;

Compiler/NFFrontEnd/NFScalarize.mo

@@ -48,6 +48,7 @@ import MetaModelica.Dangerous.arrayCreateNoInit;
 import Variable = NFVariable;
 import NFComponent.Component;
 import NFPrefixes.Visibility;
+import NFPrefixes.Variability;
 import List;
 import ElementSource;
 import DAE;
@@ -96,6 +97,7 @@ protected
   Variable v;
   list<String> ty_attr_names;
   array<ExpressionIterator> ty_attr_iters;
+  Variability bind_var;
 algorithm
   if Type.isArray(var.ty) then
     Variable.VARIABLE(name, ty, binding, vis, attr, ty_attr, cmt, info) := var;
@@ -110,10 +112,11 @@ algorithm
 
     if Binding.isBound(binding) then
       binding_iter := ExpressionIterator.fromExp(Binding.getTypedExp(binding));
+      bind_var := Binding.variability(binding);
 
       for cr in crefs loop
         (binding_iter, exp) := ExpressionIterator.next(binding_iter);
-        binding := Binding.FLAT_BINDING(exp);
+        binding := Binding.FLAT_BINDING(exp, bind_var);
         ty_attr := nextTypeAttributes(ty_attr_names, ty_attr_iters);
         vars := Variable.VARIABLE(cr, ty, binding, vis, attr, ty_attr, cmt, info) :: vars;
       end for;
@@ -162,7 +165,7 @@ algorithm
     (iter, exp) := ExpressionIterator.next(iters[i]);
     arrayUpdate(iters, i, iter);
     i := i + 1;
-    attrs := (name, Binding.FLAT_BINDING(exp)) :: attrs;
+    attrs := (name, Binding.FLAT_BINDING(exp, Variability.PARAMETER)) :: attrs;
   end for;
 end nextTypeAttributes;
 

Compiler/NFFrontEnd/NFType.mo

@@ -628,6 +628,7 @@ public
 
   function toDAE
     input Type ty;
+    input Boolean makeTypeVars = true;
     output DAE.Type daeTy;
   algorithm
     daeTy := match ty
@@ -638,15 +639,16 @@ public
       case Type.ENUMERATION() then DAE.T_ENUMERATION(NONE(), ty.typePath, ty.literals, {}, {});
       case Type.CLOCK() then DAE.T_CLOCK_DEFAULT;
       case Type.ARRAY()
-        then DAE.T_ARRAY(toDAE(ty.elementType),
+        then DAE.T_ARRAY(toDAE(ty.elementType, makeTypeVars),
           list(Dimension.toDAE(d) for d in ty.dimensions));
       case Type.TUPLE()
         then DAE.T_TUPLE(list(toDAE(t) for t in ty.types), ty.names);
       case Type.FUNCTION()
-        then DAE.T_FUNCTION({} /*TODO:FIXME*/, toDAE(ty.resultType), ty.attributes, Absyn.IDENT("TODO:FIXME"));
+        then DAE.T_FUNCTION({} /*TODO:FIXME*/, toDAE(ty.resultType, makeTypeVars), ty.attributes, Absyn.IDENT("TODO:FIXME"));
       case Type.NORETCALL() then DAE.T_NORETCALL_DEFAULT;
       case Type.UNKNOWN() then DAE.T_UNKNOWN_DEFAULT;
-      case Type.COMPLEX() then InstNode.toDAEType(ty.cls);
+      case Type.COMPLEX()
+        then if makeTypeVars then InstNode.toFullDAEType(ty.cls) else InstNode.toPartialDAEType(ty.cls);
       case Type.POLYMORPHIC() then DAE.T_METAPOLYMORPHIC(ty.name);
       case Type.ANY() then DAE.T_ANYTYPE(NONE());
       else

Compiler/NFFrontEnd/NFTyping.mo

@@ -830,7 +830,7 @@ algorithm
 
         exp := Ceval.evalExp(exp, Ceval.EvalTarget.CONDITION(info));
       then
-        Binding.FLAT_BINDING(exp);
+        Binding.FLAT_BINDING(exp, var);
 
   end match;
 end typeComponentCondition;