[NF] Expandable Connectors [ticket:5015]

- partial implementation
- during lookup create virtual crefs
- during typing, type virtual crefs

Short on what remains:
Not sure how/when to add the virtual crefs as components in the ClassTree.
We need to collect all connects, do the union of expandable connectors and
then add all the virtual components to the FLAT_TREE before we do the
flattening.

Belonging to [master]:
  - #2608

Author: adrpo

Compiler/NFFrontEnd/NFClass.mo

@@ -469,6 +469,11 @@ uniontype Class
     output Boolean isConnector = Restriction.isConnector(restriction(cls));
   end isConnectorClass;
 
+  function isExpandableConnectorClass
+    input Class cls;
+    output Boolean isConnector = Restriction.isExpandableConnector(restriction(cls));
+  end isExpandableConnectorClass;
+
   function isExternalObject
     input Class cls;
     output Boolean isExternalObject = Restriction.isExternalObject(restriction(cls));

Compiler/NFFrontEnd/NFComponent.mo

@@ -659,6 +659,12 @@ uniontype Component
       Class.isConnectorClass(InstNode.getDerivedClass(classInstance(component)));
   end isConnector;
 
+  function isExpandableConnector
+    input Component component;
+    output Boolean isExpandableConnector =
+      Class.isExpandableConnectorClass(InstNode.getDerivedClass(classInstance(component)));
+  end isExpandableConnector;
+
   function isIdentical
     input Component comp1;
     input Component comp2;

Compiler/NFFrontEnd/NFInstNode.mo

@@ -398,6 +398,34 @@ uniontype InstNode
     end match;
   end isConnector;
 
+  function isExpandableConnector
+    input InstNode node;
+    output Boolean isConnector;
+  algorithm
+    isConnector := match node
+      case COMPONENT_NODE() then Component.isExpandableConnector(component(node));
+      else false;
+    end match;
+  end isExpandableConnector;
+
+  function hasParentExpandableConnector
+  "@author: adrpo
+   returns true if itself or any of the parents are expandable connectors"
+    input InstNode node;
+    output Boolean b = isExpandableConnector(node);
+  protected
+    InstNode p;
+  algorithm
+    p := node;
+    while not isEmpty(p) loop
+      p := parent(p);
+      b := boolOr(b, isExpandableConnector(p));
+      if b then
+        break;
+      end if;
+    end while;
+  end hasParentExpandableConnector;
+
   function name
     input InstNode node;
     output String name;

Compiler/NFFrontEnd/NFLookup.mo

@@ -36,6 +36,7 @@ encapsulated package NFLookup
 "
 
 import Absyn;
+import SCode;
 import Dump;
 import Error;
 import Global;
@@ -261,8 +262,18 @@ algorithm
       algorithm
         (node, foundCref, foundScope, state) :=
           lookupSimpleCref(cref.name, cref.subscripts, scope);
+        if InstNode.isExpandableConnector(ComponentRef.node(foundCref)) then
+          try // it migth not be there!
+            (foundCref, foundScope, state) := lookupCrefInNode(cref.componentRef, node, foundCref, foundScope, state);
+          else
+            // add it if is not there, fake crefs
+             (foundCref, foundScope, state) := createVirtualCrefs(cref.componentRef, node, foundCref, foundScope, state);
+          end try;
+        else
+          (foundCref, foundScope, state) := lookupCrefInNode(cref.componentRef, node, foundCref, foundScope, state);
+        end if;
       then
-        lookupCrefInNode(cref.componentRef, node, foundCref, foundScope, state);
+        (foundCref, foundScope, state);
 
     case Absyn.ComponentRef.CREF_FULLYQUALIFIED()
       then lookupCref(cref.componentRef, InstNode.topScope(scope));
@@ -275,6 +286,58 @@ algorithm
   end match;
 end lookupCref;
 
+function createVirtualCrefs
+  "This function will create virtual crefs for the expandable connectors"
+  input Absyn.ComponentRef cref;
+  input InstNode node;
+  input output ComponentRef foundCref;
+  input output InstNode foundScope;
+  input output LookupState state;
+protected
+  SCode.Element definition;
+  InstNode crefNode;
+algorithm
+  (foundCref, foundScope, state) := match cref
+    case Absyn.ComponentRef.CREF_IDENT()
+      algorithm
+        definition :=
+          SCode.COMPONENT(
+            cref.name,
+            SCode.defaultPrefixes,
+            SCode.defaultVarAttr,
+            Absyn.TPATH(Absyn.IDENT("Any"), NONE()),
+            SCode.NOMOD(),
+            SCode.COMMENT(NONE(), SOME("virtual expandable component")),
+            NONE(),
+            Absyn.dummyInfo);
+        crefNode := InstNode.newComponent(definition, node);
+        foundCref := ComponentRef.fromAbsyn(crefNode, cref.subscripts, foundCref);
+        state := LookupState.nodeState(crefNode);
+      then
+        (foundCref, foundScope, state);
+
+    case Absyn.ComponentRef.CREF_QUAL()
+      algorithm
+        definition :=
+          SCode.COMPONENT(
+            cref.name,
+            SCode.defaultPrefixes,
+            SCode.defaultVarAttr,
+            Absyn.TPATH(Absyn.IDENT("Any"), NONE()),
+            SCode.NOMOD(),
+            SCode.COMMENT(NONE(), SOME("virtual expandable component")),
+            NONE(),
+            Absyn.dummyInfo);
+        crefNode := InstNode.newComponent(definition, node);
+        foundCref := ComponentRef.fromAbsyn(crefNode, cref.subscripts, foundCref);
+        state := LookupState.nodeState(crefNode);
+        (foundCref, foundScope, state) :=
+           createVirtualCrefs(cref.componentRef, node, foundCref, foundScope, state);
+      then
+        (foundCref, foundScope, state);
+  end match;
+end createVirtualCrefs;
+
 function lookupLocalCref
   "Looks up a cref in the local scope without going into any enclosing scopes."
   input Absyn.ComponentRef cref;

Compiler/NFFrontEnd/NFRestriction.mo

@@ -103,6 +103,16 @@ public
     end match;
   end isConnector;
 
+  function isExpandableConnector
+    input Restriction res;
+    output Boolean isConnector;
+  algorithm
+    isConnector := match res
+      case CONNECTOR() then res.isExpandable;
+      else false;
+    end match;
+  end isExpandableConnector;
+
   function isExternalObject
     input Restriction res;
     output Boolean isExternalObject;

Compiler/NFFrontEnd/NFTyping.mo

@@ -87,6 +87,7 @@ import Direction = NFPrefixes.Direction;
 import ElementSource;
 import StringUtil;
 import NFOCConnectionGraph;
+import System;
 
 uniontype TypingError
   record NO_ERROR end NO_ERROR;
@@ -2006,6 +2007,14 @@ algorithm
           typeComponentSections(InstNode.resolveOuter(c), origin);
         end for;
 
+        // we need to update the ClassTree and add the expandable virtual components from the connects
+        if System.getHasExpandableConnectors() then
+          // collect the expandable virtual components from the connect equations
+
+          // create the components inside the existing expandable connectors
+        end if;
+
+
         InstNode.updateClass(typed_cls, classNode);
       then
         ();
@@ -2378,8 +2387,18 @@ algorithm
   end if;
 
   next_origin := intBitOr(origin, ExpOrigin.CONNECT);
-  (lhs, lhs_ty, lhs_var) := typeExp(lhsConn, next_origin, info, replaceConstants = false);
-  (rhs, rhs_ty, rhs_var) := typeExp(rhsConn, next_origin, info, replaceConstants = false);
+
+  try // try the normal stuff first!
+    (lhs, lhs_ty, lhs_var) := typeExp(lhsConn, next_origin, info, replaceConstants = false);
+    (rhs, rhs_ty, rhs_var) := typeExp(rhsConn, next_origin, info, replaceConstants = false);
+  else // either is an error or there are expandable connectors in there
+    // check if any of them are expandable connectors!
+    if InstNode.hasParentExpandableConnector(ComponentRef.node(Expression.toCref(lhsConn))) or
+       InstNode.hasParentExpandableConnector(ComponentRef.node(Expression.toCref(rhsConn)))
+    then // handle expandable
+      (lhs, rhs, lhs_ty, lhs_var, rhs_ty, rhs_var) := typeExpandableConnectors(lhsConn, rhsConn, next_origin, info, replaceConstants = false);
+    end if;
+  end try;
 
   checkConnector(lhs, info);
   checkConnector(rhs, info);
@@ -2416,6 +2435,82 @@ algorithm
   connEq := Equation.CONNECT(lhs, rhs, eql, source);
 end typeConnect;
 
+function typeExpandableConnectors
+  input output Expression lhs;
+  input output Expression rhs;
+  input ExpOrigin.Type origin;
+  input SourceInfo info;
+  input Boolean replaceConstants = true;
+        output Type tyLHS;
+        output Variability variabilityLHS;
+        output Type tyRHS;
+        output Variability variabilityRHS;
+algorithm
+  // first, try to type both of them, they might already exist
+  try
+    (lhs, tyLHS, variabilityLHS) := typeExp(lhs, origin, info, replaceConstants = false);
+    (rhs, tyRHS, variabilityRHS) := typeExp(rhs, origin, info, replaceConstants = false);
+    return;
+  else
+    // do nothing, continue
+  end try;
+
+  // lhs existing, type it and use it!
+  if InstNode.isConnector(ComponentRef.node(Expression.toCref(lhs))) then
+    (lhs, tyLHS, variabilityLHS) := typeExp(lhs, origin, info, replaceConstants = false);
+    tyRHS := tyLHS;
+    variabilityRHS := variabilityLHS;
+    rhs := updateVirtualCrefExp(rhs, lhs, tyLHS, variabilityLHS);
+    return;
+  end if;
+
+  // rhs existing, reuse the case above
+  (rhs, lhs, tyRHS, variabilityRHS, tyLHS, variabilityLHS) := typeExpandableConnectors(rhs, lhs, origin, info, replaceConstants = false);
+
+  if InstNode.hasParentExpandableConnector(ComponentRef.node(Expression.toCref(rhs))) or
+     InstNode.hasParentExpandableConnector(ComponentRef.node(Expression.toCref(rhs)))
+  then
+    // error, we don't handle this case yet!
+  end if;
+end typeExpandableConnectors;
+
+function updateVirtualCrefExp
+  input output Expression virtual;
+  input Expression existing;
+  input Type ty;
+  input Variability var;
+protected
+  ComponentRef v, e;
+algorithm
+  virtual := match(virtual, existing)
+    case (Expression.CREF(_, v), Expression.CREF(_, e)) then Expression.CREF(ty, updateVirtualCref(v, e, ty, var));
+  end match;
+end updateVirtualCrefExp;
+
+function updateVirtualCref
+  input output ComponentRef virtual;
+  input ComponentRef existing;
+  input Type ty;
+  input Variability var;
+protected
+  InstNode e;
+algorithm
+ virtual := match (virtual, existing)
+      case (ComponentRef.CREF(), ComponentRef.CREF())
+        algorithm
+          virtual.ty := existing.ty;
+          // set the correct parrent
+          e := InstNode.setParent(existing.node, ComponentRef.node(virtual.restCref));
+          // change the name!
+          e := InstNode.rename(InstNode.name(virtual.node), e);
+          virtual.node := e;
+          virtual.origin := existing.origin;
+        then
+          virtual;
+
+    end match;
+end updateVirtualCref;
+
 function checkConnector
   input Expression connExp;
   input SourceInfo info;
@@ -2426,12 +2521,17 @@ algorithm
     case Expression.CREF(cref = cr as ComponentRef.CREF(origin = Origin.CREF))
       algorithm
         if not InstNode.isConnector(cr.node) then
-          Error.addSourceMessage(Error.INVALID_CONNECTOR_TYPE,
-            {ComponentRef.toString(cr)}, info);
-          fail();
+          if not InstNode.hasParentExpandableConnector(cr.node) then
+            Error.addSourceMessage(Error.INVALID_CONNECTOR_TYPE,
+              {ComponentRef.toString(cr)}, info);
+            fail();
+          end if;
         end if;
 
-        checkConnectorForm(cr, info);
+        // expandable connectors can have the form eC.C.m, eC.m
+        if not InstNode.hasParentExpandableConnector(cr.node) then
+          checkConnectorForm(cr, info);
+        end if;
       then
         ();