[NB] update cat() call handling (#15075)

 - Inline: fix inlining of arrays of literals as input to cat() calls
 - Slice/Adjacency: Allow for skips that skip an array only partially (not all dimensions)
 - Replacements: use full subscript list (whith wholedim) when replacing a cref by an expression

Author: kabdelhak

OMCompiler/Compiler/NBackEnd/Modules/2_Pre/NBInline.mo

@@ -672,7 +672,7 @@ protected
     subscript_exp := Expression.fromCref(iterator_name);
 
     for arg in rest loop
-      _ := match arg
+      failed := match arg
         case Expression.CREF(cref = rhs) guard(not failed) algorithm
           ty  := Expression.typeOf(arg);
           sz  := Type.sizeOf(ty);
@@ -728,34 +728,14 @@ protected
           if Flags.isSet(Flags.DUMPBACKENDINLINE) then
             print("-- Result: " + Equation.pointerToString(new_eqn) + "\n");
           end if;
-        then ();
+        then false;
 
+        // inline for literals down to element, nested arrays possible
         case Expression.ARRAY() guard(not failed and Expression.isLiteral(arg)) algorithm
-          // a literal expression, does not need subscripting
-          for elem in arg.elements loop
-            ty          := Expression.typeOf(elem);
-            sz          := Type.sizeOf(ty);
-            // properly subscript LHS with shift
-            lhs_sub     := Expression.INTEGER(shift+1);
-            lhs         := ComponentRef.mergeSubscripts(Subscript.fillWithWholeLeft({Subscript.INDEX(lhs_sub)}, n), cref);
-            lhs_exp     := Expression.fromCref(lhs);
+          (eqns, shift) := inlineCatCallLiterals(arg, cref, iter, attr, n, index, failed, eqns, shift);
+        then false;
 
-            // create the new equation
-            new_eqn     := Equation.makeAssignment(lhs_exp, elem, index, NBEquation.SIMULATION_STR, iter, attr);
-
-            // bump the shift adding the size of this last equation
-            shift := shift + sz;
-
-            eqns := new_eqn :: eqns;
-            if Flags.isSet(Flags.DUMPBACKENDINLINE) then
-              print("-- Result: " + Equation.pointerToString(new_eqn) + "\n");
-            end if;
-          end for;
-        then ();
-
-        else algorithm
-          failed := true;
-        then ();
+        else true;
       end match;
     end for;
 
@@ -765,6 +745,53 @@ protected
     end if;
   end inlineCatCall;
 
+  function inlineCatCallLiterals
+    "recursively inlines arrays of literal expressions that were an argument to a cat() call"
+    input Expression exp;
+    input ComponentRef cref;
+    input Iterator iter;
+    input EquationAttributes attr;
+    input Integer n;
+    input Pointer<Integer> index;
+    input Boolean failed;
+    input output list<Pointer<Equation>> eqns;
+    input output Integer shift;
+  algorithm
+    _ := match exp
+      local
+        Integer sz;
+        ComponentRef lhs;
+        Expression lhs_sub, lhs_exp;
+        Pointer<Equation> new_eqn;
+
+      case Expression.ARRAY() guard(not failed and Expression.isLiteral(exp)) algorithm
+        // a literal expression, does not need subscripting
+        for elem in exp.elements loop
+          (eqns, shift) := inlineCatCallLiterals(elem, cref, iter, attr, n, index, failed, eqns, shift);
+        end for;
+      then ();
+
+      else algorithm
+        sz          := Type.sizeOf(Expression.typeOf(exp));
+        // properly subscript LHS with shift
+        lhs_sub     := Expression.INTEGER(shift+1);
+        lhs         := ComponentRef.mergeSubscripts(Subscript.fillWithWholeLeft({Subscript.INDEX(lhs_sub)}, n), cref);
+        lhs_exp     := Expression.fromCref(lhs);
+
+        // create the new equation
+        new_eqn     := Equation.makeAssignment(lhs_exp, exp, index, NBEquation.SIMULATION_STR, iter, attr);
+
+        // bump the shift adding the size of this last equation
+        shift := shift + sz;
+
+        eqns := new_eqn :: eqns;
+        if Flags.isSet(Flags.DUMPBACKENDINLINE) then
+          print("-- Result: " + Equation.pointerToString(new_eqn) + "\n");
+        end if;
+      then ();
+    end match;
+  end inlineCatCallLiterals;
+
   function createInlinedEquation
     "used for inlining record, tuple and array equations.
     tries to create new equation from lhs and rhs and applying

OMCompiler/Compiler/NBackEnd/Util/NBReplacements.mo

@@ -203,8 +203,7 @@ public
           // try to strip the subscripts and see if that cref occurs
           stripped := ComponentRef.stripSubscriptsAll(exp.cref);
           if UnorderedMap.contains(stripped, replacements) then
-            subs  := ComponentRef.subscriptsAllFlat(exp.cref);
-            subs  := list(s for s guard(not Subscript.isWhole(s)) in subs);
+            subs  := ComponentRef.subscriptsAllWithWholeFlat(exp.cref);
             res   := UnorderedMap.getOrFail(stripped, replacements);
             res   := Expression.applySubscripts(subs, res, true);
           else

OMCompiler/Compiler/NBackEnd/Util/NBSlice.mo

@@ -1208,6 +1208,7 @@ protected
       local
         Integer skip;
         list<Integer> rest, tail;
+        list<Dimension> rest_dim, tail_dim;
         Type sub_ty;
         list<Type> rest_ty;
         Pointer<Variable> parent;
@@ -1263,12 +1264,19 @@ protected
       case (Type.ARRAY(), rest) guard(Dimension.sizesProduct(ty.dimensions, true) == 1) algorithm
       then resolveSkips(index, ty.elementType, rest, cref, fullmap);
 
-      // skip to an array element
+      // skip to an array element with more or equal skips to dimensions
       case (Type.ARRAY(), rest) guard List.compareLength(rest, ty.dimensions) >= 0 algorithm
         (rest, tail) := List.split(rest, listLength(ty.dimensions));
         index := locationToIndex(list(Dimension.size(dim, true) for dim in ty.dimensions), rest, index);
       then resolveSkips(index, ty.elementType, tail, cref, fullmap);
 
+      // skip to an array with less skips then dimensions
+      case (Type.ARRAY(), rest) algorithm
+        (rest_dim, tail_dim) := List.split(ty.dimensions, listLength(rest));
+        index := locationToIndex(list(Dimension.size(dim, true) for dim in rest_dim), rest, index);
+        ty.dimensions := tail_dim;
+      then (index, ty);
+
       // skip for tuple or array, but the skip is too large
       case (_, skip::_) guard(Type.isTuple(ty) or Type.isArray(ty)) algorithm
         Error.addMessage(Error.INTERNAL_ERROR,{getInstanceName() + " failed because skip of " + intString(skip)