[NF] Implementation of expandable connectors.

- Added new module ExpandableConnectors that handles expandable
  connections.
- Changed Prefixes.ConnectorType from an enumeration into a bit field,
  so that it also can keep track of whether something is a connector,
  expandable connector, or expandable connector element.
- Fixed connector form error message so that the whole connector name is
  printed out.
- Changed OCConnectionGraph.handleOverconstrainedConnections to take a
  Connections record, so it only needs to be created once and so that
  expandable connector can be handled first.

- Removed the list of broken equations from Equation.CONNECT since it
  wasn't used.

Belonging to [master]:
  - #2941
  - OpenModelica/OpenModelica-testsuite#1125

Author: perost

Compiler/NFFrontEnd/NFClass.mo

@@ -469,6 +469,45 @@ uniontype Class
     end match;
   end getType;
 
+  function setType
+    input Type ty;
+    input output Class cls;
+  algorithm
+    () := match cls
+      case PARTIAL_BUILTIN()
+        algorithm
+          cls.ty := ty;
+        then
+          ();
+
+      case EXPANDED_DERIVED()
+        algorithm
+          InstNode.classApply(cls.baseClass, setType, ty);
+        then
+          ();
+
+      case INSTANCED_CLASS()
+        algorithm
+          cls.ty := ty;
+        then
+          ();
+
+      case INSTANCED_BUILTIN()
+        algorithm
+          cls.ty := ty;
+        then
+          ();
+
+      case TYPED_DERIVED()
+        algorithm
+          cls.ty := ty;
+        then
+          ();
+
+      else ();
+    end match;
+  end setType;
+
   function restriction
     input Class cls;
     output Restriction res;
@@ -503,6 +542,11 @@ uniontype Class
     output Boolean isConnector = Restriction.isConnector(restriction(cls));
   end isConnectorClass;
 
+  function isNonexpandableConnectorClass
+    input Class cls;
+    output Boolean isConnector = Restriction.isNonexpandableConnector(restriction(cls));
+  end isNonexpandableConnectorClass;
+
   function isExpandableConnectorClass
     input Class cls;
     output Boolean isConnector = Restriction.isExpandableConnector(restriction(cls));

Compiler/NFFrontEnd/NFClassTree.mo

@@ -400,6 +400,45 @@ public
       tree := FLAT_TREE(ltree, listArray({}), comps, listArray({}), DuplicateTree.EMPTY());
     end fromEnumeration;
 
+    function addElementsToFlatTree
+      "Adds a list of class and/or component nodes as elements to a flat class
+       tree, in the same order as they are listed. Name conflicts will result in
+       an duplicate element error, and trying to add nodes that are not pure
+       class or component nodes will result in undefined behaviour."
+      input list<InstNode> elements;
+      input output ClassTree tree;
+    protected
+      LookupTree.Tree ltree;
+      array<InstNode> cls_arr, comp_arr;
+      list<InstNode> cls_lst = {}, comp_lst = {};
+      array<Import> imports;
+      DuplicateTree.Tree duplicates;
+      Integer cls_idx, comp_idx;
+      LookupTree.Entry lentry;
+    algorithm
+      FLAT_TREE(ltree, cls_arr, comp_arr, imports, duplicates) := tree;
+      cls_idx := arrayLength(cls_arr);
+      comp_idx := arrayLength(comp_arr);
+
+      for e in elements loop
+        if InstNode.isComponent(e) then
+          comp_idx := comp_idx + 1;
+          lentry := LookupTree.Entry.COMPONENT(comp_idx);
+          comp_lst := e :: comp_lst;
+        else
+          cls_idx := cls_idx + 1;
+          lentry := LookupTree.Entry.CLASS(cls_idx);
+          cls_lst := e :: cls_lst;
+        end if;
+
+        ltree := addLocalElement(InstNode.name(e), lentry, tree, ltree);
+      end for;
+
+      cls_arr := Array.appendList(cls_arr, listReverseInPlace(cls_lst));
+      comp_arr := Array.appendList(comp_arr, listReverseInPlace(comp_lst));
+      tree := FLAT_TREE(ltree, cls_arr, comp_arr, imports, duplicates);
+    end addElementsToFlatTree;
+
     function expand
       "This function adds all local and inherited class and component names to
        the lookup tree. Note that only their names are added, the elements

Compiler/NFFrontEnd/NFComplexType.mo

@@ -50,9 +50,13 @@ public
     list<InstNode> potentials;
     list<InstNode> flows;
     list<InstNode> streams;
-    Boolean isExpandable;
   end CONNECTOR;
 
+  record EXPANDABLE_CONNECTOR
+    list<InstNode> potentiallyPresents;
+    list<InstNode> expandableConnectors;
+  end EXPANDABLE_CONNECTOR;
+
   record RECORD
     InstNode constructor;
     list<String> fieldNames;

Compiler/NFFrontEnd/NFComponent.mo

@@ -51,7 +51,7 @@ import Prefixes = NFPrefixes;
 public
 constant Component.Attributes DEFAULT_ATTR =
   Component.Attributes.ATTRIBUTES(
-    ConnectorType.POTENTIAL,
+    ConnectorType.NON_CONNECTOR,
     Parallelism.NON_PARALLEL,
     Variability.CONTINUOUS,
     Direction.NONE,
@@ -98,7 +98,7 @@ constant Component.Attributes CONSTANT_ATTR =
 
 constant Component.Attributes IMPL_DISCRETE_ATTR =
   Component.Attributes.ATTRIBUTES(
-    ConnectorType.POTENTIAL,
+    ConnectorType.NON_CONNECTOR,
     Parallelism.NON_PARALLEL,
     Variability.IMPLICITLY_DISCRETE,
     Direction.NONE,
@@ -114,7 +114,7 @@ uniontype Component
 
     record ATTRIBUTES
       // adrpo: keep the order in DAE.ATTR
-      ConnectorType connectorType;
+      ConnectorType.Type connectorType;
       Parallelism parallelism;
       Variability variability;
       Direction direction;
@@ -130,7 +130,7 @@ uniontype Component
       output DAE.Attributes outa;
     algorithm
       outa := DAE.ATTR(
-        connectorTypeToDAE(ina.connectorType),
+        ConnectorType.toDAE(ina.connectorType),
         parallelismToSCode(ina.parallelism),
         variabilityToSCode(ina.variability),
         directionToAbsyn(ina.direction),
@@ -147,12 +147,11 @@ uniontype Component
       str := (if attr.isRedeclare then "redeclare " else "") +
              (if attr.isFinal then "final " else "") +
              Prefixes.unparseInnerOuter(attr.innerOuter) +
-             Prefixes.unparseConnectorType(attr.connectorType) +
              Prefixes.unparseReplaceable(attr.isReplaceable) +
              Prefixes.unparseParallelism(attr.parallelism) +
+             ConnectorType.unparse(attr.connectorType) +
              Prefixes.unparseVariability(attr.variability, ty) +
-             Prefixes.unparseDirection(attr.direction) +
-             Prefixes.unparseConnectorType(attr.connectorType);
+             Prefixes.unparseDirection(attr.direction);
     end toString;
   end Attributes;
 
@@ -647,7 +646,7 @@ uniontype Component
 
   function connectorType
     input Component component;
-    output ConnectorType cty;
+    output ConnectorType.Type cty;
   algorithm
     cty := match component
       case UNTYPED_COMPONENT(attributes = Attributes.ATTRIBUTES(connectorType = cty)) then cty;
@@ -657,21 +656,45 @@ uniontype Component
     end match;
   end connectorType;
 
+  function setConnectorType
+    input ConnectorType.Type cty;
+    input output Component component;
+  algorithm
+    () := match component
+      local
+        Attributes attr;
+
+      case UNTYPED_COMPONENT(attributes = attr)
+        algorithm
+          attr.connectorType := cty;
+          component.attributes := attr;
+        then
+          ();
+
+      case TYPED_COMPONENT(attributes = attr)
+        algorithm
+          attr.connectorType := cty;
+          component.attributes := attr;
+        then
+          ();
+
+      else ();
+    end match;
+  end setConnectorType;
+
   function isFlow
     input Component component;
-    output Boolean isFlow = connectorType(component) == ConnectorType.FLOW;
+    output Boolean isFlow = ConnectorType.isFlow(connectorType(component));
   end isFlow;
 
   function isConnector
     input Component component;
-    output Boolean isConnector =
-      Class.isConnectorClass(InstNode.getDerivedClass(classInstance(component)));
+    output Boolean isConnector = ConnectorType.isConnectorType(connectorType(component));
   end isConnector;
 
   function isExpandableConnector
     input Component component;
-    output Boolean isExpandableConnector =
-      Class.isExpandableConnectorClass(InstNode.getDerivedClass(classInstance(component)));
+    output Boolean isConnector = ConnectorType.isExpandable(connectorType(component));
   end isExpandableConnector;
 
   function isIdentical

Compiler/NFFrontEnd/NFComponentRef.mo

@@ -182,6 +182,20 @@ public
     CREF(ty = ty) := cref;
   end nodeType;
 
+  function updateNodeType
+    input output ComponentRef cref;
+  algorithm
+    () := match cref
+      case CREF()
+        algorithm
+          cref.ty := InstNode.getType(cref.node);
+        then
+          ();
+
+      else ();
+    end match;
+  end updateNodeType;
+
   function firstName
     input ComponentRef cref;
     output String name;

Compiler/NFFrontEnd/NFConnectEquations.mo

@@ -65,6 +65,7 @@ import Global;
 import BuiltinCall = NFBuiltinCall;
 import ComplexType = NFComplexType;
 import ExpandExp = NFExpandExp;
+import Prefixes = NFPrefixes;
 
 constant Expression EQ_ASSERT_STR =
   Expression.STRING("Connected constants/parameters must be equal");
@@ -82,6 +83,7 @@ protected
   list<Equation> set_eql;
   potFunc potfunc;
   Expression flowThreshold;
+  ConnectorType.Type cty;
 algorithm
   setGlobalRoot(Global.isInStream, NONE());
 
@@ -91,17 +93,20 @@ algorithm
   flowThreshold := Expression.REAL(Flags.getConfigReal(Flags.FLOW_THRESHOLD));
 
   for set in sets loop
-    set_eql := match getSetType(set)
-      case ConnectorType.POTENTIAL then potfunc(set);
-      case ConnectorType.FLOW then generateFlowEquations(set);
-      case ConnectorType.STREAM then generateStreamEquations(set, flowThreshold);
-      else
-        algorithm
-          Error.addInternalError("Invalid connector type on set "
-            + List.toString(set, Connector.toString, "", "{", ", ", "}", true), sourceInfo());
-        then
-          fail();
-    end match;
+    cty := getSetType(set);
+
+    if ConnectorType.isPotential(cty) then
+      set_eql := potfunc(set);
+    elseif ConnectorType.isFlow(cty) then
+      set_eql := generateFlowEquations(set);
+    elseif ConnectorType.isStream(cty) then
+      set_eql := generateStreamEquations(set, flowThreshold);
+    else
+      Error.addInternalError(getInstanceName() + " got connection set with invalid type '" +
+        ConnectorType.toDebugString(cty) + "': " +
+        List.toString(set, Connector.toString, "", "{", ", ", "}", true), sourceInfo());
+      fail();
+    end if;
 
     equations := listAppend(set_eql, equations);
   end for;
@@ -155,7 +160,7 @@ end evaluateOperators;
 protected
 function getSetType
   input list<Connector> set;
-  output ConnectorType cty;
+  output ConnectorType.Type cty;
 algorithm
   // All connectors in a set should have the same type, so pick the first.
   Connector.CONNECTOR(cty = cty) :: _ := set;

Compiler/NFFrontEnd/NFConnection.mo

@@ -41,5 +41,12 @@ public
     NFConnector rhs;
   end CONNECTION;
 
+  function toString
+    input Connection conn;
+    output String str;
+  algorithm
+    str := "connect(" + Connector.toString(conn.lhs) + ", " + Connector.toString(conn.rhs) + ")";
+  end toString;
+
   annotation(__OpenModelica_Interface="frontend");
 end NFConnection;

Compiler/NFFrontEnd/NFConnectionSets.mo

@@ -132,6 +132,9 @@ package ConnectionSets
       // when collecting the connections, but if the connectors themselves
       // contain connectors that have been deleted we need to remove them here.
       if not (Connector.isDeleted(c1) or Connector.isDeleted(c2)) then
+        // TODO: Check variability of connectors. It's an error if either
+        //       connector is constant/parameter while the other isn't.
+
         if listEmpty(broken) then
           sets := merge(c1, c2, sets);
         elseif isBroken(c1, c2, broken) then

Compiler/NFFrontEnd/NFConnections.mo

@@ -60,6 +60,13 @@ public
     output Connections conns = CONNECTIONS({}, {}, {});
   end new;
 
+  function fromConnectionList
+    input list<Connection> connl;
+    output Connections conns;
+  algorithm
+    conns := CONNECTIONS(connl, {}, {});
+  end fromConnectionList;
+
   function addConnection
     input Connection conn;
     input output Connections conns;