NFInst improvements.

- Improved handling of class modifiers.
- Improved merging of redeclares with modifiers.
- Implemented basic type matching for complex types.

Author: perost

Compiler/NFFrontEnd/NFClassTree.mo

@@ -658,6 +658,17 @@ public
       element := resolveEntry(entry, tree);
     end lookupElement;
 
+    function lookupElementPtr
+      input String name;
+      input ClassTree tree;
+      output Mutable<InstNode> element;
+    protected
+      LookupTree.Entry entry;
+    algorithm
+      entry := LookupTree.get(lookupTree(tree), name);
+      element := resolveEntryPtr(entry, tree);
+    end lookupElementPtr;
+
     function applyExtends
       input ClassTree tree;
       input FuncT func;

Compiler/NFFrontEnd/NFInst.mo

@@ -532,7 +532,7 @@ algorithm
         end if;
 
         redecl_node := expand(cls_mod.element);
-        node := instClass(redecl_node, Modifier.NOMOD(), parent);
+        node := instClass(redecl_node, cls_mod.mod, parent);
       then
         ();
 
@@ -738,6 +738,7 @@ function applyModifier
   input String clsName;
 protected
   list<Modifier> mods;
+  Mutable<InstNode> node_ptr;
   InstNode node;
   Component comp;
 algorithm
@@ -749,18 +750,21 @@ algorithm
 
   for mod in mods loop
     try
-      node := ClassTree.lookupElement(Modifier.name(mod), cls);
+      node_ptr := ClassTree.lookupElementPtr(Modifier.name(mod), cls);
     else
       Error.addSourceMessage(Error.MISSING_MODIFIED_ELEMENT,
         {Modifier.name(mod), clsName}, Modifier.info(mod));
       fail();
     end try;
 
+    node := Mutable.access(node_ptr);
     if InstNode.isComponent(node) then
       InstNode.componentApply(node, Component.mergeModifier, mod);
     else
       partialInstClass(node);
-      InstNode.classApply(node, Class.mergeModifier, mod);
+      node := InstNode.replaceClass(Class.mergeModifier(mod, InstNode.getClass(node)), node);
+      node := InstNode.resetCache(node);
+      Mutable.update(node_ptr, node);
     end if;
   end for;
 
@@ -785,16 +789,19 @@ algorithm
   mod := Component.getModifier(comp);
 
   () := match (mod, comp)
-    case (Modifier.REDECLARE(), _)
+    case (Modifier.REDECLARE(), Component.COMPONENT_DEF(definition = def))
       algorithm
         if not InstNode.isComponent(mod.element) then
           Error.addMultiSourceMessage(Error.INVALID_REDECLARE_AS,
             {"component", InstNode.name(node), "class"},
             {InstNode.info(mod.element), InstNode.info(node)});
         end if;
 
-        comp := InstNode.component(mod.element);
-        InstNode.updateComponent(comp, node);
+        comp_mod := Modifier.fromElement(def, parent);
+        comp_mod := Modifier.merge(comp_mod, mod.mod);
+        inst_comp := InstNode.component(mod.element);
+        inst_comp := Component.setModifier(comp_mod, inst_comp);
+        InstNode.updateComponent(inst_comp, node);
         instComponent(node, parent, InstNode.parent(mod.element));
       then
         ();

Compiler/NFFrontEnd/NFInstNode.mo

@@ -686,6 +686,18 @@ uniontype InstNode
     end match;
   end setCachedData;
 
+  function resetCache
+    input output InstNode node;
+  algorithm
+    () := match node
+      case CLASS_NODE()
+        algorithm
+          node.cached := CachedData.empty();
+        then
+          ();
+    end match;
+  end resetCache;
+
   function cacheAddFunc
     input Function fn;
     input Boolean specialBuiltin;

Compiler/NFFrontEnd/NFMod.mo

@@ -130,6 +130,7 @@ uniontype Modifier
     SCode.Final finalPrefix;
     SCode.Each eachPrefix;
     InstNode element;
+    Modifier mod;
   end REDECLARE;
 
   record NOMOD end NOMOD;
@@ -160,7 +161,7 @@ public
           MODIFIER(name, mod.finalPrefix, mod.eachPrefix, binding, submod_table, mod.info);
 
       case SCode.REDECL()
-        then REDECLARE(mod.finalPrefix, mod.eachPrefix, InstNode.new(mod.element, scope));
+        then REDECLARE(mod.finalPrefix, mod.eachPrefix, InstNode.new(mod.element, scope), NOMOD());
 
     end match;
   end create;
@@ -271,6 +272,18 @@ public
         then
           MODIFIER(outerMod.name, outerMod.finalPrefix, outerMod.eachPrefix, binding, submods, outerMod.info);
 
+      case (REDECLARE(), MODIFIER())
+        algorithm
+          outerMod.mod := merge(outerMod.mod, innerMod);
+        then
+          outerMod;
+
+      case (MODIFIER(), REDECLARE())
+        algorithm
+          innerMod.mod := merge(outerMod, innerMod.mod);
+        then
+          innerMod;
+
       case (REDECLARE(), _) then outerMod;
       case (_, REDECLARE()) then innerMod;
 

Compiler/NFFrontEnd/NFTypeCheck.mo

@@ -53,6 +53,8 @@ import List;
 import Types;
 import Operator = NFOperator;
 import Type = NFType;
+import Class = NFClass.Class;
+import ClassTree = NFClassTree;
 
 public
 
@@ -1376,6 +1378,7 @@ algorithm
       Dimension dim1, dim2;
       Type ety1, ety2;
       Boolean compat;
+      InstNode cls;
 
     case Type.INTEGER() then actualType;
     case Type.REAL() then actualType;
@@ -1399,7 +1402,8 @@ algorithm
 
     case Type.COMPLEX()
       algorithm
-        assert(false, getInstanceName() + " IMPLEMENT ME.");
+        (expression, compatibleType, matchKind) :=
+          matchComplexTypes(actualType, expectedType, expression, allowUnknown);
       then
         actualType;
 
@@ -1412,6 +1416,84 @@ algorithm
   end match;
 end matchTypes;
 
+function matchComplexTypes
+  input Type actualType;
+  input Type expectedType;
+  input output Expression expression;
+  input Boolean allowUnknown;
+        output Type compatibleType = actualType;
+        output MatchKind matchKind = MatchKind.EXACT;
+protected
+  Class cls1, cls2;
+  InstNode anode, enode;
+  array<InstNode> comps1, comps2;
+  Absyn.Path path;
+  Type ty;
+  Expression e;
+  list<Expression> elements, matched_elements = {};
+  MatchKind mk;
+algorithm
+  Type.COMPLEX(cls = anode) := actualType;
+  Type.COMPLEX(cls = enode) := expectedType;
+  cls1 := InstNode.getClass(anode);
+  cls2 := InstNode.getClass(enode);
+
+  () := match (cls1, cls2, expression)
+    case (Class.INSTANCED_CLASS(elements = ClassTree.FLAT_TREE(components = comps1)),
+          Class.INSTANCED_CLASS(elements = ClassTree.FLAT_TREE(components = comps2)),
+          Expression.RECORD(elements = elements))
+      algorithm
+        if arrayLength(comps1) <> arrayLength(comps2) or
+           arrayLength(comps1) <> listLength(elements) then
+          matchKind := MatchKind.NOT_COMPATIBLE;
+        else
+          for i in 1:arrayLength(comps1) loop
+            e :: elements := elements;
+            (e, _, mk) := matchTypes(InstNode.getType(comps1[i]), InstNode.getType(comps2[i]), e, allowUnknown);
+            matched_elements := e :: matched_elements;
+
+            if mk == MatchKind.CAST then
+              matchKind := mk;
+            elseif mk <> MatchKind.EXACT then
+              matchKind := MatchKind.NOT_COMPATIBLE;
+              break;
+            end if;
+          end for;
+
+          if matchKind == MatchKind.CAST then
+            expression.elements := listReverse(matched_elements);
+          end if;
+        end if;
+      then
+        ();
+
+    case (Class.INSTANCED_CLASS(elements = ClassTree.FLAT_TREE(components = comps1)),
+          Class.INSTANCED_CLASS(elements = ClassTree.FLAT_TREE(components = comps2)), _)
+      algorithm
+        if arrayLength(comps1) <> arrayLength(comps2) then
+          matchKind := MatchKind.NOT_COMPATIBLE;
+        else
+          for i in 1:arrayLength(comps1) loop
+            (_, _, mk) := matchTypes(InstNode.getType(comps1[i]), InstNode.getType(comps2[i]), expression, allowUnknown);
+
+            if mk <> MatchKind.EXACT then
+              matchKind := MatchKind.NOT_COMPATIBLE;
+              break;
+            end if;
+          end for;
+        end if;
+      then
+        ();
+
+    else
+      algorithm
+        matchKind := MatchKind.NOT_COMPATIBLE;
+      then
+        ();
+
+  end match;
+end matchComplexTypes;
+
 function matchArrayTypes
   input Type arrayType1;
   input Type arrayType2;

Compiler/NFFrontEnd/NFTyping.mo

@@ -887,6 +887,7 @@ protected
   Type ty;
 algorithm
   for e in elements loop
+    // TODO: Type checking.
     (exp, ty, var) := typeExp(e, info);
     variability := Types.constAnd(var, variability);
     expl := exp :: expl;