[NF] Various fixes.

- Check that connector subscripts are parameter expressions.
- Split tuple equations when the call is evaluated into a tuple
  expression, same as tuple assigments.

Belonging to [master]:
  - OpenModelica/OpenModelica#126
  - #3035

Author: perost

Compiler/NFFrontEnd/NFEquation.mo

@@ -159,6 +159,17 @@ public
     DAE.ElementSource source;
   end NORETCALL;
 
+  function makeEquality
+    input Expression lhs;
+    input Expression rhs;
+    input Type ty;
+    input DAE.ElementSource src;
+    output Equation eq;
+  algorithm
+    eq := EQUALITY(lhs, rhs, ty, src);
+    annotation(__OpenModelica_EarlyInline=true);
+  end makeEquality;
+
   function makeBranch
     input Expression condition;
     input list<Equation> body;

Compiler/NFFrontEnd/NFSimplifyModel.mo

@@ -143,17 +143,7 @@ algorithm
       Expression e, lhs, rhs;
       Type ty;
 
-    case Equation.EQUALITY()
-      algorithm
-        ty := Type.mapDims(eq.ty, simplifyDimension);
-
-        if not Type.isEmptyArray(ty) then
-          lhs := removeEmptyTupleElements(SimplifyExp.simplify(eq.lhs));
-          rhs := removeEmptyFunctionArguments(SimplifyExp.simplify(eq.rhs));
-          equations := Equation.EQUALITY(lhs, rhs, ty, eq.source) :: equations;
-        end if;
-      then
-        equations;
+    case Equation.EQUALITY() then simplifyEqualityEquation(eq, equations);
 
     case Equation.ARRAY_EQUALITY()
       algorithm
@@ -211,6 +201,34 @@ algorithm
   end match;
 end simplifyEquation;
 
+function simplifyEqualityEquation
+  input Equation eq;
+  input output list<Equation> equations;
+protected
+  Expression lhs, rhs;
+  Type ty;
+  DAE.ElementSource src;
+algorithm
+  Equation.EQUALITY(lhs = lhs, rhs = rhs, ty = ty, source = src) := eq;
+  ty := Type.mapDims(ty, simplifyDimension);
+
+  if Type.isEmptyArray(ty) then
+    return;
+  end if;
+
+  lhs := SimplifyExp.simplify(lhs);
+  lhs := removeEmptyTupleElements(lhs);
+  rhs := SimplifyExp.simplify(rhs);
+  rhs := removeEmptyFunctionArguments(rhs);
+
+  equations := match (lhs, rhs)
+    case (Expression.TUPLE(), Expression.TUPLE())
+      then simplifyTupleElement(lhs.elements, rhs.elements, ty, src, Equation.makeEquality, equations);
+
+    else Equation.EQUALITY(lhs, rhs, ty, src) :: equations;
+  end match;
+end simplifyEqualityEquation;
+
 function simplifyAlgorithms
   input list<Algorithm> algs;
   output list<Algorithm> outAlgs = {};
@@ -325,21 +343,30 @@ algorithm
 
   statements := match (lhs, rhs)
     case (Expression.TUPLE(), Expression.TUPLE())
-      then simplifyTupleAssignment(lhs.elements, rhs.elements, ty, src, statements);
+      then simplifyTupleElement(lhs.elements, rhs.elements, ty, src, Statement.makeAssignment, statements);
 
     else Statement.ASSIGNMENT(lhs, rhs, ty, src) :: statements;
   end match;
 end simplifyAssignment;
 
-function simplifyTupleAssignment
-  "Helper function to simplifyAssignment.
+function simplifyTupleElement<ElementT>
+  "Helper function to simplifyEqualityEquation/simplifyAssignment.
    Handles Expression.TUPLE() := Expression.TUPLE() assignments by splitting
    them into a separate assignment statement for each pair of tuple elements."
   input list<Expression> lhsTuple;
   input list<Expression> rhsTuple;
   input Type ty;
   input DAE.ElementSource src;
-  input output list<Statement> statements;
+  input MakeElement makeFn;
+  input output list<ElementT> statements;
+
+  partial function MakeElement
+    input Expression lhs;
+    input Expression rhs;
+    input Type ty;
+    input DAE.ElementSource src;
+    output ElementT element;
+  end MakeElement;
 protected
   Expression rhs;
   list<Expression> rest_rhs = rhsTuple;
@@ -353,10 +380,10 @@ algorithm
     ety :: rest_ty := rest_ty;
 
     if not Expression.isWildCref(lhs) then
-      statements := Statement.ASSIGNMENT(lhs, rhs, ety, src) :: statements;
+      statements := makeFn(lhs, rhs, ety, src) :: statements;
     end if;
   end for;
-end simplifyTupleAssignment;
+end simplifyTupleElement;
 
 function removeEmptyTupleElements
   "Replaces tuple elements that has one or more zero dimension with _."

Compiler/NFFrontEnd/NFStatement.mo

@@ -111,6 +111,17 @@ public
     DAE.ElementSource source;
   end FAILURE;
 
+  function makeAssignment
+    input Expression lhs;
+    input Expression rhs;
+    input Type ty;
+    input DAE.ElementSource src;
+    output Statement stmt;
+  algorithm
+    stmt := ASSIGNMENT(lhs, rhs, ty, src);
+    annotation(__OpenModelica_EarlyInline=true);
+  end makeAssignment;
+
   function makeIf
     input list<tuple<Expression, list<Statement>>> branches;
     input DAE.ElementSource src;

Compiler/NFFrontEnd/NFTyping.mo

@@ -2468,6 +2468,7 @@ function checkConnector
   input SourceInfo info;
 protected
   ComponentRef cr;
+  list<Subscript> subs;
 algorithm
   () := match connExp
     case Expression.CREF(cref = cr as ComponentRef.CREF(origin = Origin.CREF))
@@ -2481,6 +2482,17 @@ algorithm
           Error.addSourceMessageAndFail(Error.INVALID_CONNECTOR_FORM,
             {ComponentRef.toString(cr)}, info);
         end if;
+
+        if ComponentRef.subscriptsVariability(cr) > Variability.PARAMETER then
+          subs := ComponentRef.subscriptsAllFlat(cr);
+          for sub in subs loop
+            if Subscript.variability(sub) > Variability.PARAMETER then
+              Error.addSourceMessage(Error.CONNECTOR_NON_PARAMETER_SUBSCRIPT,
+                {Expression.toString(connExp), Subscript.toString(sub)}, info);
+              fail();
+            end if;
+          end for;
+        end if;
       then
         ();
 

Compiler/Util/Error.mo

@@ -348,9 +348,8 @@ public constant Message NON_PARAMETER_ITERATOR_RANGE = MESSAGE(109, TRANSLATION(
   Util.gettext("The iteration range %s is not a constant or parameter expression."));
 public constant Message IMPLICIT_ITERATOR_NOT_FOUND_IN_LOOP_BODY = MESSAGE(110, TRANSLATION(), ERROR(),
   Util.gettext("Identifier %s of implicit for iterator must be present as array subscript in the loop body."));
-
-// UNUSED ID 111
-
+public constant Message CONNECTOR_NON_PARAMETER_SUBSCRIPT = MESSAGE(111, TRANSLATION(), ERROR(),
+  Util.gettext("Connector ‘%s‘ has non-parameter subscript ‘%s‘."));
 public constant Message LOOKUP_CLASS_VIA_COMP_COMP = MESSAGE(112, TRANSLATION(), ERROR(),
   Util.gettext("Illegal access of class '%s' via a component when looking for '%s'."));
 public constant Message SUBSCRIPTED_FUNCTION_CALL = MESSAGE(113, TRANSLATION(), ERROR(),