[NF][#4784] Fix conversion of complex types to old DAE.

  - Create proper DAE.TYPES_VAR for complex types.
  - create DAE complex equation for complex equations
    - until we start scalarizing complex equations.

Belonging to [master]:
  - #2266

Author: mahge

Compiler/NFFrontEnd/NFBinding.mo

@@ -250,5 +250,25 @@ public
     end match;
   end isEqual;
 
+  function toDAE
+    input Binding b;
+    output DAE.Binding outb;
+  algorithm
+    outb := match b
+      case UNBOUND() then DAE.UNBOUND();
+      case TYPED_BINDING()
+        then DAE.EQBOUND(Expression.toDAE(b.bindingExp)
+                         , NONE()
+                         , Variability.variabilityToDAEConst(b.variability)
+                         , DAE.BINDING_FROM_DEFAULT_VALUE() // TODO: revise this.
+                        );
+
+      else algorithm
+        Error.assertion(false, getInstanceName() + " got untyped binding.", sourceInfo());
+        then fail();
+
+    end match;
+  end toDAE;
+
 annotation(__OpenModelica_Interface="frontend");
 end NFBinding;

Compiler/NFFrontEnd/NFComponent.mo

@@ -95,6 +95,8 @@ constant Component.Attributes DISCRETE_ATTR =
 
 uniontype Component
   uniontype Attributes
+    import SCode;
+
     record ATTRIBUTES
       // adrpo: keep the order in DAE.ATTR
       ConnectorType connectorType;
@@ -103,6 +105,19 @@ uniontype Component
       Direction direction;
       InnerOuter innerOuter;
     end ATTRIBUTES;
+
+   function toDAE
+     input Attributes ina;
+     output DAE.Attributes outa;
+   algorithm
+     outa := DAE.ATTR(connectorTypeToDAE(ina.connectorType)
+                      , parallelismToSCode(ina.parallelism)
+                      , variabilityToSCode(ina.variability)
+                      , directionToAbsyn(ina.direction)
+                      , innerOuterToAbsyn(ina.innerOuter)
+                      , SCode.PUBLIC() // TODO: Use the actual visibility.
+                     );
+    end toDAE;
   end Attributes;
 
   record COMPONENT_DEF

Compiler/NFFrontEnd/NFConvertDAE.mo

@@ -57,7 +57,7 @@ import Util;
 import MetaModelica.Dangerous.listReverseInPlace;
 import Sections = NFSections;
 import Function = NFFunction.Function;
-import ClassTree = NFClassTree;
+import NFClassTree.ClassTree;
 import NFPrefixes.Visibility;
 import NFPrefixes.Direction;
 import Variable = NFVariable;
@@ -453,6 +453,13 @@ algorithm
       list<DAE.Dimension> dims;
       list<DAE.Element> body;
 
+    case Equation.EQUALITY() guard Type.isComplex(eq.ty)
+      algorithm
+        e1 := Expression.toDAE(eq.lhs);
+        e2 := Expression.toDAE(eq.rhs);
+      then
+        DAE.Element.COMPLEX_EQUATION(e1, e2, eq.source) :: elements;
+
     case Equation.EQUALITY()
       algorithm
         e1 := Expression.toDAE(eq.lhs);
@@ -1027,5 +1034,46 @@ algorithm
   end match;
 end convertExternalDeclOutput;
 
+public
+function makeTypesVars
+  input Type complex_ty;
+  output list<DAE.Var> type_vars;
+protected
+  InstNode cls_node;
+  Component comp;
+  DAE.Var type_var;
+algorithm
+  Type.COMPLEX(cls = cls_node) := complex_ty;
+  type_vars := {};
+
+  () := match cls as InstNode.getClass(cls_node)
+    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));
+        InstNode.name(c);
+
+        type_var := DAE.TYPES_VAR(InstNode.name(c)
+                      , Component.Attributes.toDAE(Component.getAttributes(comp))
+                      , Type.toDAE(Component.getType(comp))
+                      , Binding.toDAE(Component.getBinding(comp))
+                      ,NONE()
+                     );
+        type_vars := type_var::type_vars;
+      end for;
+
+      type_vars := listReverse(type_vars);
+    then ();
+
+    else ();
+
+  end match;
+
+end makeTypesVars;
+
+
 annotation(__OpenModelica_Interface="frontend");
 end NFConvertDAE;

Compiler/NFFrontEnd/NFPrefixes.mo

@@ -131,6 +131,17 @@ algorithm
   end match;
 end parallelismFromSCode;
 
+function parallelismToSCode
+  input Parallelism par;
+  output SCode.Parallelism scodePar;
+algorithm
+  scodePar := match par
+    case Parallelism.GLOBAL then SCode.Parallelism.PARGLOBAL();
+    case Parallelism.LOCAL then SCode.Parallelism.PARLOCAL() ;
+    case Parallelism.NON_PARALLEL then SCode.Parallelism.NON_PARALLEL() ;
+  end match;
+end parallelismToSCode;
+
 function parallelismToDAE
   input Parallelism par;
   output DAE.VarParallelism dpar;
@@ -182,6 +193,18 @@ algorithm
   end match;
 end variabilityFromSCode;
 
+function variabilityToSCode
+  input Variability var;
+  output SCode.Variability scodeVar;
+algorithm
+  scodeVar := match var
+    case Variability.CONSTANT then SCode.CONST();
+    case Variability.PARAMETER then SCode.PARAM();
+    case Variability.DISCRETE then SCode.DISCRETE();
+    case Variability.CONTINUOUS then SCode.VAR();
+  end match;
+end variabilityToSCode;
+
 function variabilityToDAE
   input Variability var;
   input Type ty;
@@ -318,6 +341,18 @@ algorithm
   end match;
 end innerOuterFromSCode;
 
+function innerOuterToAbsyn
+  input InnerOuter inIO;
+  output Absyn.InnerOuter outIO;
+algorithm
+  outIO := match inIO
+    case InnerOuter.NOT_INNER_OUTER then Absyn.NOT_INNER_OUTER();
+    case InnerOuter.INNER then Absyn.INNER();
+    case InnerOuter.OUTER then Absyn.OUTER();
+    case InnerOuter.INNER_OUTER then Absyn.INNER_OUTER();
+  end match;
+end innerOuterToAbsyn;
+
 function innerOuterString
   input InnerOuter io;
   output String str;

Compiler/NFFrontEnd/NFType.mo

@@ -39,6 +39,7 @@ public
   import NFInstNode.InstNode;
   import Subscript = NFSubscript;
   import ComplexType = NFComplexType;
+  import ConvertDAE = NFConvertDAE;
 
   record INTEGER
   end INTEGER;
@@ -515,7 +516,7 @@ public
       case Type.UNKNOWN() then DAE.T_UNKNOWN_DEFAULT;
       case Type.COMPLEX()
         // TODO: Use proper ClassInf.State here.
-        then DAE.Type.T_COMPLEX(ClassInf.MODEL(InstNode.scopePath(ty.cls)), {}, NONE());
+        then DAE.Type.T_COMPLEX(ClassInf.MODEL(InstNode.scopePath(ty.cls)), ConvertDAE.makeTypesVars(ty), NONE());
       case Type.POLYMORPHIC() then DAE.T_METAPOLYMORPHIC(ty.name);
       case Type.ANY() then DAE.T_ANYTYPE(NONE());
       else