[NF] Improve performance of DAE conversion.

- Cache the conversion of complex types by replacing a converted
  INSTANCED_CLASS with a new DAE_TYPE class.

Belonging to [master]:
  - #2296

Author: perost

Compiler/NFFrontEnd/NFClass.mo

@@ -118,6 +118,10 @@ uniontype Class
     Restriction restriction;
   end INSTANCED_BUILTIN;
 
+  record DAE_TYPE
+    DAE.Type ty;
+  end DAE_TYPE;
+
   function fromSCode
     input list<SCode.Element> elements;
     input Boolean isClassExtends;

Compiler/NFFrontEnd/NFConvertDAE.mo

@@ -1045,17 +1045,15 @@ end convertExternalDeclOutput;
 
 public
 function makeTypesVars
-  input Type complex_ty;
-  output list<DAE.Var> type_vars;
+  input InstNode complexCls;
+  output list<DAE.Var> typeVars;
 protected
-  InstNode cls_node;
   Component comp;
   DAE.Var type_var;
 algorithm
-  Type.COMPLEX(cls = cls_node) := complex_ty;
-  type_vars := {};
+  typeVars := {};
 
-  () := match cls as InstNode.getClass(cls_node)
+  () := match cls as InstNode.getClass(complexCls)
     case Class.INSTANCED_CLASS(elements = ClassTree.FLAT_TREE()) algorithm
 
       for c in ClassTree.getComponents(cls.elements) loop
@@ -1072,10 +1070,10 @@ algorithm
                       , DAE.UNBOUND()
                       , NONE()
                      );
-        type_vars := type_var::type_vars;
+        typeVars := type_var::typeVars;
       end for;
 
-      type_vars := listReverse(type_vars);
+      typeVars := listReverse(typeVars);
     then ();
 
     else ();

Compiler/NFFrontEnd/NFInstNode.mo

@@ -43,9 +43,11 @@ import Prefixes = NFPrefixes;
 import Visibility = NFPrefixes.Visibility;
 import NFModifier.Modifier;
 import SCodeDump;
+import DAE;
 
 protected
 import List;
+import ConvertDAE = NFConvertDAE;
 
 public
 uniontype InstNodeType
@@ -1201,6 +1203,33 @@ uniontype InstNode
     end match;
   end setModifier;
 
+  function toDAEType
+    input InstNode clsNode;
+    output DAE.Type outType;
+  algorithm
+    outType := match clsNode
+      local
+        Class cls;
+
+      case CLASS_NODE()
+        algorithm
+          cls := Pointer.access(clsNode.cls);
+        then
+          match cls
+            case Class.DAE_TYPE() then cls.ty;
+            else
+              algorithm
+                // TODO: Use proper ClassInf.State here.
+                outType := DAE.Type.T_COMPLEX(ClassInf.MODEL(scopePath(clsNode)),
+                                              ConvertDAE.makeTypesVars(clsNode),
+                                              NONE());
+                Pointer.update(clsNode.cls, Class.DAE_TYPE(outType));
+              then
+                outType;
+          end match;
+    end match;
+  end toDAEType;
+
 end InstNode;
 
 annotation(__OpenModelica_Interface="frontend");

Compiler/NFFrontEnd/NFType.mo

@@ -514,9 +514,7 @@ public
         then DAE.T_FUNCTION({} /*TODO:FIXME*/, toDAE(ty.resultType), 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()
-        // TODO: Use proper ClassInf.State here.
-        then DAE.Type.T_COMPLEX(ClassInf.MODEL(InstNode.scopePath(ty.cls)), ConvertDAE.makeTypesVars(ty), NONE());
+      case Type.COMPLEX() then InstNode.toDAEType(ty.cls);
       case Type.POLYMORPHIC() then DAE.T_METAPOLYMORPHIC(ty.name);
       case Type.ANY() then DAE.T_ANYTYPE(NONE());
       else