Extend treatment of for-equations in backend

Basic assumption: one for-equation defines one array variable.
This makes sense along with -d=newInst,-nfScalarize.

Belonging to [master]:
  - #2692
  - OpenModelica/OpenModelica-testsuite#1044

Author: rfranke

Compiler/BackEnd/BackendDAETransform.mo

@@ -565,6 +565,7 @@ algorithm
   (outEquation, outTypeA) := matchcontinue (inEquation)
     local
       DAE.Exp e1_1, e2_1, e1, e2, cond;
+      DAE.Exp iter, start, stop;
       DAE.ComponentRef cr, cr1;
       Integer size;
       list<DAE.Exp> expl;
@@ -596,6 +597,12 @@ algorithm
       source = List.foldr(ops, ElementSource.addSymbolicTransformation, source);
     then (BackendDAE.ARRAY_EQUATION(dimSize, e1_1, e2_1, source, eqAttr), ext_arg_2);
 
+    case BackendDAE.FOR_EQUATION(iter = iter, start = start, stop = stop, left = e1, right = e2, source = source, attr = eqAttr) equation
+      (e1_1, (ops, ext_arg_1)) = func(e1, ({}, inTypeA));
+      (e2_1, (ops, ext_arg_2)) = func(e2, (ops, ext_arg_1));
+      source = List.foldr(ops, ElementSource.addSymbolicTransformation, source);
+    then (BackendDAE.FOR_EQUATION(iter, start, stop, e1_1, e2_1, source, eqAttr), ext_arg_2);
+
     case BackendDAE.SOLVED_EQUATION(componentRef = cr, exp = e2, source=source, attr=eqAttr) equation
       e1 = Expression.crefExp(cr);
       (DAE.CREF(cr1, _), (ops, ext_arg_1)) = func(e1, ({}, inTypeA));

Compiler/BackEnd/BackendDAEUtil.mo

@@ -2538,6 +2538,18 @@ algorithm
       then
         (res,size);
 
+    // FOR_EQUATION
+    case BackendDAE.FOR_EQUATION(left = e1, right = e2, start = e, stop = cond,
+             iter = DAE.CREF(componentRef = DAE.CREF_IDENT(ident = str)))
+      equation
+        // assume one equation defining a whole array var (no NF_SCALARIZE)
+        e1 = Expression.traverseExpTopDown(e1, stripIterSub, str);
+        e2 = Expression.traverseExpTopDown(e2, stripIterSub, str);
+        lst1 = incidenceRowExp(e1, vars, iRow, functionTree, inIndexType);
+        res = incidenceRowExp(e2, vars, lst1, functionTree, inIndexType);
+      then
+        (res,1);
+
     // SOLVED_EQUATION
     case BackendDAE.SOLVED_EQUATION(componentRef = cr,exp = e)
       equation
@@ -2585,14 +2597,35 @@ algorithm
     else
       equation
         eqnstr = BackendDump.equationString(inEquation);
-        str = "- BackendDAE.incidenceRow failed for equation: " + eqnstr;
+        str = "- BackendDAEUtil.incidenceRow failed for equation: " + eqnstr;
         Error.addMessage(Error.INTERNAL_ERROR, {str});
       then
         fail();
   end matchcontinue;
   outIntegerLst := AvlSetInt.addList(outIntegerLst, whenIntegerLst);
 end incidenceRow;
 
+protected
+function stripIterSub
+"Strips the last subscript if it is equal to given inIter ident.
+ This enables incicence analysis for array variables defined in for loops.
+ author: rfranke"
+  input DAE.Exp inExp;
+  input DAE.Ident inIter;
+  output DAE.Exp outExp;
+  output Boolean cont;
+  output DAE.Ident outIter = inIter;
+algorithm
+  (outExp, cont) := match inExp
+    local
+      DAE.ComponentRef cr;
+      DAE.Type ty;
+    case DAE.CREF(componentRef = cr, ty = ty)
+    then (DAE.CREF(ComponentReference.crefStripIterSub(cr, inIter), ty), false);
+    else (inExp, true);
+  end match;
+end stripIterSub;
+
 protected function incidenceRowLst
 "author: Frenkel TUD
   Helper function to incidenceMatrix. Calculates the indidence row

Compiler/BackEnd/BackendEquation.mo

@@ -283,6 +283,22 @@ algorithm
   end for;
 end traverseEquationArray_WithUpdate;
 
+public
+function getForEquationIterIdent
+ "Get the iterator of a for-equation
+  author: rfranke"
+  input BackendDAE.Equation inEquation;
+  output Option<DAE.Ident> forIter;
+algorithm
+  forIter := match inEquation
+    local
+      DAE.Ident iter;
+    case BackendDAE.FOR_EQUATION(iter = DAE.CREF(componentRef = DAE.CREF_IDENT(ident = iter)))
+    then SOME(iter);
+    else NONE();
+  end match;
+end getForEquationIterIdent;
+
 public function getWhenEquationExpr "Get the left and right hand parts from an equation appearing in a when clause"
   input BackendDAE.WhenEquation inWhenEquation;
   output DAE.ComponentRef outComponentRef;
@@ -1614,6 +1630,7 @@ algorithm
   source := match eq
     case BackendDAE.EQUATION(source=source) then source;
     case BackendDAE.ARRAY_EQUATION(source=source) then source;
+    case BackendDAE.FOR_EQUATION(source=source) then source;
     case BackendDAE.SOLVED_EQUATION(source=source) then source;
     case BackendDAE.RESIDUAL_EQUATION(source=source) then source;
     case BackendDAE.WHEN_EQUATION(source=source) then source;
@@ -1647,6 +1664,7 @@ algorithm
   osize := match eq
     local
       list<Integer> ds;
+      DAE.Exp e1, e2;
       Integer size, start, stop;
       list<BackendDAE.Equation> eqnsfalse;
 
@@ -1676,8 +1694,14 @@ algorithm
       size = equationLstSize(eqnsfalse);
     then size;
 
-    case BackendDAE.FOR_EQUATION(start=DAE.ICONST(start), stop=DAE.ICONST(stop)) equation
-      size = stop-start+1;
+    case BackendDAE.FOR_EQUATION(start = e1, stop = e2) equation
+      if Flags.isSet(Flags.NF_SCALARIZE) then
+        DAE.ICONST(start) = e1;
+        DAE.ICONST(stop) = e2;
+        size = stop - start + 1;
+      else
+        size = 1;
+      end if;
     then size;
 
     else equation
@@ -1774,6 +1798,7 @@ algorithm
 
     case BackendDAE.EQUATION(attr=BackendDAE.EQUATION_ATTRIBUTES(kind=kind)) then kind;
     case BackendDAE.ARRAY_EQUATION(attr=BackendDAE.EQUATION_ATTRIBUTES(kind=kind)) then kind;
+    case BackendDAE.FOR_EQUATION(attr=BackendDAE.EQUATION_ATTRIBUTES(kind=kind)) then kind;
     case BackendDAE.SOLVED_EQUATION(attr=BackendDAE.EQUATION_ATTRIBUTES(kind=kind)) then kind;
     case BackendDAE.RESIDUAL_EQUATION(attr=BackendDAE.EQUATION_ATTRIBUTES(kind=kind)) then kind;
     case BackendDAE.WHEN_EQUATION(attr=BackendDAE.EQUATION_ATTRIBUTES(kind=kind)) then kind;
@@ -1952,6 +1977,7 @@ algorithm
       list<Integer> dimSize;
       DAE.Exp lhs;
       DAE.Exp rhs;
+      DAE.Exp iter, start, stop;
       DAE.ComponentRef componentRef;
       Integer size;
       DAE.Algorithm alg;
@@ -1967,6 +1993,9 @@ algorithm
     case (BackendDAE.ARRAY_EQUATION(dimSize=dimSize, left=lhs, right=rhs, source=source), _)
     then BackendDAE.ARRAY_EQUATION(dimSize, lhs, rhs, source, inAttr);
 
+    case (BackendDAE.FOR_EQUATION(iter=iter, start=start, stop=stop, left=lhs, right=rhs, source=source), _)
+    then BackendDAE.FOR_EQUATION(iter, start, stop, lhs, rhs, source, inAttr);
+
     case (BackendDAE.SOLVED_EQUATION(componentRef=componentRef, exp=rhs, source=source), _)
     then BackendDAE.SOLVED_EQUATION(componentRef, rhs, source, inAttr);
 

Compiler/FrontEnd/ComponentReference.mo

@@ -2770,6 +2770,29 @@ algorithm
   end match;
 end crefStripLastSubs;
 
+public function crefStripIterSub
+  "Strips the last sub if it is equal to the given iter ident.
+   This gives an array variable that is defined in a for loop (no NF_SCALARIZE).
+   author: rfranke"
+  input DAE.ComponentRef inComponentRef;
+  input DAE.Ident iter;
+  output DAE.ComponentRef outComponentRef;
+protected
+  DAE.Ident index;
+algorithm
+  outComponentRef := match crefLastSubs(inComponentRef)
+    case {DAE.INDEX(exp = DAE.CREF(componentRef = DAE.CREF_IDENT(ident = index)))}
+    algorithm
+      if index == iter then
+        outComponentRef := crefStripLastSubs(inComponentRef);
+      else
+        outComponentRef := inComponentRef;
+      end if;
+    then outComponentRef;
+    else inComponentRef;
+  end match;
+end crefStripIterSub;
+
 public function crefStripFirstIdent
 "Strips the first part of a component reference,
 i.e the identifier and eventual subscripts"