[NF] Subscripting improvements.

- Implemented basic handling of slices in Expression.applySubscript.
- Implemented missing cases for Real ranges in RangeIterator.
- Added the concept of invalid ranges to RangeIterator to allow it to
  fail gracefully on non-expandable ranges.
- Improved detection of too small step size in Real ranges.

Belonging to [master]:
  - #2308
  - OpenModelica/OpenModelica-testsuite#892

Author: perost

Compiler/NFFrontEnd/NFCall.mo

@@ -684,7 +684,7 @@ uniontype Call
             b::b_list := b_list;
             // If the argument is supposed to be vectorized
             if b then
-              vect_args := Expression.applySubscript(arg, Subscript.INDEX(exp))::vect_args;
+              vect_args := Expression.applyIndexSubscript(exp, arg)::vect_args;
             else
               vect_args := arg::vect_args;
             end if;

Compiler/NFFrontEnd/NFCeval.mo

@@ -137,7 +137,7 @@ algorithm
         binding := Component.getBinding(InstNode.component(c));
         exp1 := evalBinding(binding, exp, target);
       then
-        Expression.applySubscripts(exp1, cref.subscripts);
+        Expression.applySubscripts(cref.subscripts, exp1);
 
     case Expression.TYPENAME()
       then evalTypename(exp.ty, exp, target);

Compiler/NFFrontEnd/NFExpression.mo

@@ -41,6 +41,7 @@ protected
   import RangeIterator = NFRangeIterator;
   import NFPrefixes.Variability;
   import Prefixes = NFPrefixes;
+  import MetaModelica.Dangerous.listReverseInPlace;
 
 public
   import Absyn.Path;
@@ -574,42 +575,50 @@ public
   end realValue;
 
   function applySubscripts
-    input output Expression exp;
     input list<Subscript> subscripts;
+    input output Expression exp;
   algorithm
     for sub in subscripts loop
-      exp := applySubscript(exp, sub);
+      exp := applySubscript(sub, exp);
     end for;
   end applySubscripts;
 
   function applySubscript
-    input output Expression exp;
     input Subscript sub;
+    input Expression exp;
+    output Expression subscriptedExp;
+  algorithm
+    subscriptedExp := match sub
+      case Subscript.INDEX() then applyIndexSubscript(sub.index, exp);
+      case Subscript.SLICE() then applySliceSubscript(sub.slice, exp);
+      case Subscript.WHOLE() then exp;
+      else
+        algorithm
+          Error.assertion(false, getInstanceName() + " got untyped subscript " +
+            Subscript.toString(sub), sourceInfo());
+        then
+          fail();
+    end match;
+  end applySubscript;
+
+  function applyIndexSubscript
+    input Expression indexExp;
+    input output Expression exp;
   protected
     Integer index;
     Boolean is_scalar_const;
     Expression texp;
     Type exp_ty;
   algorithm
-
-    if not Subscript.isScalar(sub) then
-      // We need to properly compute the resulting type. Just unlifting the type is not enough if sub is not scalar.
-      // Use Type.subscript to compute the type and make sure SUPSCRIPTED_EXP doesn't result in complicated types.
-      Error.assertion(false, getInstanceName() + ": Application of non-scalar subs on expressoins not implemented. "
-                      + "Exp: " + toString(exp)
-                      + ", Sub: "+ Subscript.toString(sub)
-                      , sourceInfo());
-      fail();
-    end if;
-    is_scalar_const := Subscript.isScalarConst(sub);
+    is_scalar_const := Expression.isScalarConst(indexExp);
 
     // check exp has array type. Don't apply subs to scalar exp.
     exp_ty := typeOf(exp);
     if not Type.isArray(exp_ty) then
       Error.assertion(false, getInstanceName() + ": Application of subs on non-array expressoin not allowed. "
                       + "Exp: " + toString(exp)
                       + ", Exp type: " + Type.toString(exp_ty)
-                      + ", Sub: " + Subscript.toString(sub)
+                      + ", Sub: " + toString(indexExp)
                       , sourceInfo());
       fail();
     end if;
@@ -619,7 +628,7 @@ public
         ComponentRef cref;
 
       case CREF() algorithm
-        cref := ComponentRef.addSubscript(sub, exp.cref);
+        cref := ComponentRef.addSubscript(Subscript.INDEX(indexExp), exp.cref);
         texp := CREF(Type.unliftArray(exp.ty), cref);
       then texp;
 
@@ -630,25 +639,70 @@ public
         // Do we want to create SUBSCRIPTED_EXP and go through the ASUB hell of the old FrontEnd?
         // k = {1,i,2}[j];
         if is_scalar_const then
-           index := Subscript.toInteger(sub);
+           index := Expression.toInteger(indexExp);
            texp := listGet(exp.elements, index);
         else
-          texp := SUBSCRIPTED_EXP(exp, {Subscript.toExp(sub)}, Type.unliftArray(exp.ty));
+          texp := SUBSCRIPTED_EXP(exp, {indexExp}, Type.unliftArray(exp.ty));
           // Error.assertion(false, getInstanceName() + " failed on " + Subscript.toString(sub), sourceInfo());
           // fail();
         end if;
       then texp;
 
       case SUBSCRIPTED_EXP() algorithm
-        texp := SUBSCRIPTED_EXP(exp.exp, listAppend(exp.subscripts,{Subscript.toExp(sub)}), Type.unliftArray(exp.ty));
+        texp := SUBSCRIPTED_EXP(exp.exp, listAppend(exp.subscripts,{indexExp}), Type.unliftArray(exp.ty));
       then texp;
 
       else algorithm
-        texp := SUBSCRIPTED_EXP(exp, {Subscript.toExp(sub)}, Type.unliftArray(exp_ty));
+        texp := SUBSCRIPTED_EXP(exp, {indexExp}, Type.unliftArray(exp_ty));
       then texp;
 
     end match;
-  end applySubscript;
+  end applyIndexSubscript;
+
+  function applySliceSubscript
+    input Expression slice;
+    input Expression exp;
+    output Expression subscriptedExp;
+  protected
+    list<Expression> expl;
+    RangeIterator iter;
+    Expression e;
+    Type ty;
+    ComponentRef cref;
+  algorithm
+    // Replace the last dimension of the expression type with the dimension of the slice type.
+    ty := Type.liftArrayLeft(Type.unliftArray(typeOf(exp)), Type.nthDimension(typeOf(slice), 1));
+    iter := RangeIterator.fromExp(slice);
+
+    if RangeIterator.isValid(iter) then
+      // If the slice is a range of known size, apply each subscript in the slice
+      // to the expression and create a new array from the resulting elements.
+      expl := {};
+
+      while RangeIterator.hasNext(iter) loop
+        (iter, e) := RangeIterator.next(iter);
+        e := applyIndexSubscript(e, exp);
+        expl := e :: expl;
+      end while;
+
+      ty := Type.liftArrayLeft(Type.unliftArray(typeOf(exp)), Dimension.fromInteger(listLength(expl)));
+      subscriptedExp := ARRAY(ty, listReverseInPlace(expl));
+    else
+      // If the slice can't be expanded, just add it to the expression as a slice subscript.
+      subscriptedExp := match exp
+        case CREF()
+          algorithm
+            cref := ComponentRef.addSubscript(Subscript.SLICE(slice), exp.cref);
+          then
+            CREF(ty, cref);
+
+        case SUBSCRIPTED_EXP()
+          then SUBSCRIPTED_EXP(exp.exp, listAppend(exp.subscripts, {slice}), ty);
+
+        else SUBSCRIPTED_EXP(exp, {slice}, ty);
+      end match;
+    end if;
+  end applySliceSubscript;
 
   function arrayFromList
     input list<Expression> inExps;

Compiler/NFFrontEnd/NFFlatten.mo

@@ -429,7 +429,7 @@ algorithm
 
         if binding_level > 0 then
           subs := List.flatten(ComponentRef.subscriptsN(prefix, InstNode.level(component) - binding_level));
-          binding.bindingExp := Expression.applySubscripts(binding.bindingExp, subs);
+          binding.bindingExp := Expression.applySubscripts(subs, binding.bindingExp);
         end if;
       then
         ();

Compiler/NFFrontEnd/NFRangeIterator.mo

@@ -47,14 +47,33 @@ public
   record REAL_RANGE
     Real start;
     Real stepsize;
-    Real stop;
+    Integer current;
+    Integer steps;
   end REAL_RANGE;
 
   record ARRAY_RANGE
     list<Expression> values;
   end ARRAY_RANGE;
 
+  record INVALID_RANGE
+    Expression exp;
+  end INVALID_RANGE;
+
+  function isValid
+    input RangeIterator iterator;
+    output Boolean isValid;
+  algorithm
+    isValid := match iterator
+      case INVALID_RANGE() then false;
+      else true;
+    end match;
+  end isValid;
+
   function fromExp
+    "Returns a RangeIterator created from the given expression. If the
+     expression isn't an expression that can be expanded into elements an
+     invalid range will be returned that will trigger an assertion when used.
+     The valididity of the returned iterator can be checked with isValid."
     input Expression exp;
     output RangeIterator iterator;
   algorithm
@@ -72,7 +91,8 @@ public
       case Expression.RANGE(start = Expression.INTEGER(istart),
                             step = SOME(Expression.INTEGER(istep)),
                             stop = Expression.INTEGER(istop))
-        then INT_RANGE(istart, istep, istop);
+        then
+          INT_RANGE(istart, istep, istop);
 
       case Expression.RANGE(start = Expression.INTEGER(istart),
                             step = NONE(),
@@ -82,12 +102,12 @@ public
       case Expression.RANGE(start = Expression.REAL(rstart),
                             step = SOME(Expression.REAL(rstep)),
                             stop = Expression.REAL(rstop))
-        then REAL_RANGE(rstart, rstep, rstop);
+        then REAL_RANGE(rstart, rstep, 0, Util.realRangeSize(rstart, rstep, rstop));
 
       case Expression.RANGE(start = Expression.REAL(rstart),
                             step = NONE(),
                             stop = Expression.REAL(rstop))
-        then REAL_RANGE(rstart, 1.0, rstop);
+        then REAL_RANGE(rstart, 1.0, 0, Util.realRangeSize(rstart, 1.0, rstop));
 
       case Expression.RANGE(start = Expression.ENUM_LITERAL(ty = ty, index = istart),
                             step = NONE(),
@@ -111,11 +131,7 @@ public
         then
           ARRAY_RANGE(values);
 
-      else
-        algorithm
-          Error.assertion(false, getInstanceName() + " got unknown range", sourceInfo());
-        then
-          fail();
+      else INVALID_RANGE(exp);
 
     end match;
   end fromExp;
@@ -160,13 +176,26 @@ public
         then
           nextExp;
 
+      case REAL_RANGE()
+        algorithm
+          nextExp := Expression.REAL(iterator.start + iterator.stepsize * iterator.current);
+          iterator.current := iterator.current + 1;
+        then
+          nextExp;
+
       case ARRAY_RANGE()
         algorithm
           nextExp := listHead(iterator.values);
           iterator.values := listRest(iterator.values);
         then
           nextExp;
 
+      case INVALID_RANGE()
+        algorithm
+          Error.assertion(false, getInstanceName() + " got invalid range " +
+            Expression.toString(iterator.exp), sourceInfo());
+        then
+          fail();
     end match;
   end next;
 
@@ -176,7 +205,14 @@ public
   algorithm
     hasNext := match iterator
       case INT_RANGE() then iterator.current <= iterator.last;
+      case REAL_RANGE() then iterator.current < iterator.steps;
       case ARRAY_RANGE() then not listEmpty(iterator.values);
+      case INVALID_RANGE()
+        algorithm
+          Error.assertion(false, getInstanceName() + " got invalid range " +
+            Expression.toString(iterator.exp), sourceInfo());
+        then
+          fail();
     end match;
   end hasNext;
 

Compiler/NFFrontEnd/NFSubscript.mo

@@ -38,6 +38,7 @@ protected
   import SimplifyExp = NFSimplifyExp;
   import Type = NFType;
   import RangeIterator = NFRangeIterator;
+  import Dump;
 
 public
   import Expression = NFExpression;
@@ -147,9 +148,7 @@ public
     output Boolean isScalarConst;
   algorithm
     isScalarConst := match sub
-      case INDEX(Expression.INTEGER()) then true;
-      case INDEX(Expression.BOOLEAN()) then true;
-      case INDEX(Expression.ENUM_LITERAL()) then true;
+      case INDEX() then Expression.isScalarConst(sub.index);
       else false;
     end match;
   end isScalarConst;
@@ -290,6 +289,7 @@ public
     output String string;
   algorithm
     string := match subscript
+      case RAW_SUBSCRIPT() then Dump.printSubscriptStr(subscript.subscript);
       case UNTYPED() then Expression.toString(subscript.exp);
       case INDEX() then Expression.toString(subscript.index);
       case SLICE() then Expression.toString(subscript.slice);

Compiler/NFFrontEnd/NFTypeCheck.mo

@@ -1985,7 +1985,7 @@ algorithm
       algorithm
         // Don't allow infinite ranges.
         if step == 0 then
-          Error.addSourceMessageAndFail(Error.RANGE_ZERO_STEP, {}, info);
+          Error.addSourceMessageAndFail(Error.RANGE_TOO_SMALL_STEP, {String(step)}, info);
         end if;
       then
         Dimension.fromInteger(max(intDiv(stopExp.value - startExp.value, step) + 1, 0));
@@ -2003,18 +2003,17 @@ function getRangeTypeReal
 algorithm
   dim := match (startExp, stepExp, stopExp)
     local
-      Real step;
+      Real start, step;
 
     case (Expression.REAL(), NONE(), Expression.REAL())
       then Dimension.fromInteger(Util.realRangeSize(startExp.value, 1.0, stopExp.value));
 
-    case (Expression.REAL(), SOME(Expression.REAL(value = step)), Expression.REAL())
+    case (Expression.REAL(value = start), SOME(Expression.REAL(value = step)), Expression.REAL())
       algorithm
-        // The old inst checked that step > 1e-14, but that's actually ok if
-        // start and stop are also small. We could maybe check that the range
-        // doesn't become too large, but then we'd have to define 'too large'.
-        if step == 0.0 then
-          Error.addSourceMessageAndFail(Error.RANGE_ZERO_STEP, {}, info);
+        // Check that adding step to start actually produces a different value,
+        // otherwise the step size is too small.
+        if start == start + step then
+          Error.addSourceMessageAndFail(Error.RANGE_TOO_SMALL_STEP, {String(step)}, info);
         end if;
       then
         Dimension.fromInteger(Util.realRangeSize(startExp.value, step, stopExp.value));

Compiler/Util/Error.mo

@@ -718,8 +718,8 @@ public constant Message INITIAL_CALL_WARNING = MESSAGE(294, TRANSLATION(), WARNI
   Util.gettext("The standard says that initial() may only be used as a when condition (when initial() or when {..., initial(), ...}), but got condition %s."));
 public constant Message RANGE_TYPE_MISMATCH = MESSAGE(295, TRANSLATION(), ERROR(),
   Util.gettext("Type mismatch in range: '%s' of type\n  %s\nis not type compatible with '%s' of type\n  %s"));
-public constant Message RANGE_ZERO_STEP = MESSAGE(296, TRANSLATION(), ERROR(),
-  Util.gettext("Range may not have a step size of 0."));
+public constant Message RANGE_TOO_SMALL_STEP = MESSAGE(296, TRANSLATION(), ERROR(),
+  Util.gettext("Step size %s in range is too small."));
 public constant Message RANGE_INVALID_STEP = MESSAGE(297, TRANSLATION(),
 ERROR(),
   Util.gettext("Range of type %s may not specify a step size."));