[NF] Fix expansion of cref slices.

Belonging to [master]:
  - #2609
  - OpenModelica/OpenModelica-testsuite#1015

Author: perost

Compiler/NFFrontEnd/NFComponentRef.mo

@@ -690,7 +690,7 @@ public
       case CREF(ty = Type.ARRAY())
         algorithm
           dims := Type.arrayDims(cref.ty);
-          subs := Subscript.expandList(cref.subscripts, dims);
+          subs := Subscript.scalarizeList(cref.subscripts, dims);
           subs := List.combination(subs);
         then
           list(setSubscripts(s, cref) for s in subs);

Compiler/NFFrontEnd/NFExpandExp.mo

@@ -111,31 +111,34 @@ public
     output Expression arrayExp;
     output Boolean expanded;
   protected
-    list<list<list<Subscript>>> subs;
+    list<list<Subscript>> subs;
   algorithm
     (arrayExp, expanded) := match crefExp
       case Expression.CREF(cref = ComponentRef.CREF())
-        guard Type.hasKnownSize(crefExp.ty)
         algorithm
-          subs := expandCref2(crefExp.cref);
-
-          if listEmpty(subs) then
+          if Type.hasZeroDimension(crefExp.ty) then
             arrayExp := Expression.ARRAY(Type.ARRAY(Type.arrayElementType(crefExp.ty), {Dimension.fromInteger(0)}), {});
-          else
+            expanded := true;
+          elseif Type.hasKnownSize(crefExp.ty) then
+            subs := expandCref2(crefExp.cref);
             arrayExp := expandCref3(subs, crefExp.cref, Type.arrayElementType(crefExp.ty));
+            expanded := true;
+          else
+            arrayExp := crefExp;
+            expanded := false;
           end if;
         then
-          (arrayExp, true);
+          (arrayExp, expanded);
 
       else (crefExp, false);
     end match;
   end expandCref;
 
   function expandCref2
     input ComponentRef cref;
-    input output list<list<list<Subscript>>> subs = {};
+    input output list<list<Subscript>> subs = {};
   protected
-    list<list<Subscript>> cr_subs = {};
+    list<Subscript> cr_subs = {};
     list<Dimension> dims;
 
     import NFComponentRef.Origin;
@@ -154,7 +157,7 @@ public
   end expandCref2;
 
   function expandCref3
-    input list<list<list<Subscript>>> subs;
+    input list<list<Subscript>> subs;
     input ComponentRef cref;
     input Type crefType;
     input list<list<Subscript>> accum = {};
@@ -167,26 +170,29 @@ public
   end expandCref3;
 
   function expandCref4
-    input list<list<Subscript>> subs;
+    input list<Subscript> subs;
     input list<Subscript> comb = {};
     input list<list<Subscript>> accum = {};
-    input list<list<list<Subscript>>> restSubs;
+    input list<list<Subscript>> restSubs;
     input ComponentRef cref;
     input Type crefType;
     output Expression arrayExp;
   protected
     list<Expression> expl = {};
     Type arr_ty;
+    list<Subscript> slice, rest;
   algorithm
     arrayExp := match subs
       case {} then expandCref3(restSubs, cref, crefType, listReverse(comb) :: accum);
-      else
+
+      case Subscript.EXPANDED_SLICE(indices = slice) :: rest
         algorithm
-          expl := list(expandCref4(listRest(subs), sub :: comb, accum, restSubs, cref, crefType)
-            for sub in listHead(subs));
+          expl := list(expandCref4(rest, idx :: comb, accum, restSubs, cref, crefType) for idx in slice);
           arr_ty := Type.liftArrayLeft(Expression.typeOf(listHead(expl)), Dimension.fromExpList(expl));
         then
           Expression.ARRAY(arr_ty, expl);
+
+      else expandCref4(listRest(subs), listHead(subs) :: comb, accum, restSubs, cref, crefType);
     end match;
   end expandCref4;
 

Compiler/NFFrontEnd/NFSubscript.mo

@@ -63,6 +63,10 @@ public
     Expression slice;
   end SLICE;
 
+  record EXPANDED_SLICE
+    list<Subscript> indices;
+  end EXPANDED_SLICE;
+
   record WHOLE end WHOLE;
 
   function fromExp
@@ -295,6 +299,8 @@ public
       case UNTYPED() then Expression.toString(subscript.exp);
       case INDEX() then Expression.toString(subscript.index);
       case SLICE() then Expression.toString(subscript.slice);
+      case EXPANDED_SLICE()
+        then List.toString(subscript.indices, toString, "", "{", ", ", "}", false);
       case WHOLE() then ":";
     end match;
   end toString;
@@ -338,7 +344,7 @@ public
     end match;
   end toDimension;
 
-  function expand
+  function scalarize
     input Subscript subscript;
     input Dimension dimension;
     output list<Subscript> subscripts;
@@ -350,9 +356,9 @@ public
       case WHOLE()
         then RangeIterator.map(RangeIterator.fromDim(dimension), makeIndex);
     end match;
-  end expand;
+  end scalarize;
 
-  function expandList
+  function scalarizeList
     input list<Subscript> subscripts;
     input list<Dimension> dimensions;
     output list<list<Subscript>> outSubscripts = {};
@@ -363,7 +369,7 @@ public
   algorithm
     for s in subscripts loop
       dim :: rest_dims := rest_dims;
-      subs := expand(s, dim);
+      subs := scalarize(s, dim);
 
       if listEmpty(subs) then
         outSubscripts := {};
@@ -384,6 +390,42 @@ public
       end if;
     end for;
 
+    outSubscripts := listReverse(outSubscripts);
+  end scalarizeList;
+
+  function expand
+    input Subscript subscript;
+    input Dimension dimension;
+    output Subscript outSubscript;
+  algorithm
+    outSubscript := match subscript
+      case INDEX() then subscript;
+      case SLICE()
+        then EXPANDED_SLICE(list(INDEX(e) for e in Expression.arrayElements(ExpandExp.expand(subscript.slice))));
+      case WHOLE() then EXPANDED_SLICE(RangeIterator.map(RangeIterator.fromDim(dimension), makeIndex));
+    end match;
+  end expand;
+
+  function expandList
+    input list<Subscript> subscripts;
+    input list<Dimension> dimensions;
+    output list<Subscript> outSubscripts = {};
+  protected
+    Dimension dim;
+    list<Dimension> rest_dims = dimensions;
+    Subscript sub;
+  algorithm
+    for s in subscripts loop
+      dim :: rest_dims := rest_dims;
+      sub := expand(s, dim);
+      outSubscripts := sub :: outSubscripts;
+    end for;
+
+    for d in rest_dims loop
+      sub := EXPANDED_SLICE(RangeIterator.map(RangeIterator.fromDim(d), makeIndex));
+      outSubscripts := sub :: outSubscripts;
+    end for;
+
     outSubscripts := listReverse(outSubscripts);
   end expandList;
 

Compiler/NFFrontEnd/NFType.mo

@@ -539,6 +539,16 @@ public
     end match;
   end hasKnownSize;
 
+  function hasZeroDimension
+    input Type ty;
+    output Boolean hasZero;
+  algorithm
+    hasZero := match ty
+      case ARRAY() then List.exist(ty.dimensions, Dimension.isZero);
+      else false;
+    end match;
+  end hasZeroDimension;
+
   function mapDims
     input output Type ty;
     input FuncT func;