[NF] Improve expansion of reductions.

- Implemented expansion of reductions instead of relying on the
  generic expansion using subscripting.
- Added handling of more expressions in SimplifyExp.

Belonging to [master]:
  - #2465
  - OpenModelica/OpenModelica-testsuite#961

Author: perost

Compiler/NFFrontEnd/NFExpandExp.mo

@@ -34,6 +34,7 @@ encapsulated uniontype NFExpandExp
 
 protected
   import RangeIterator = NFRangeIterator;
+  import ExpressionIterator = NFExpressionIterator;
   import Subscript = NFSubscript;
   import Type = NFType;
   import NFCall.Call;
@@ -42,6 +43,9 @@ protected
   import NFFunction.Function;
   import Operator = NFOperator;
   import Ceval = NFCeval;
+  import NFInstNode.InstNode;
+  import SimplifyExp = NFSimplifyExp;
+  import MetaModelica.Dangerous.*;
 
 public
   function expand
@@ -173,6 +177,9 @@ protected
         guard Function.isBuiltin(call.fn) and not Function.isImpure(call.fn)
         then expandBuiltinCall(call.fn, call.arguments);
 
+      case Call.TYPED_MAP_CALL()
+        then expandReduction(call.exp, call.ty, call.iters);
+
       else expandGeneric(exp);
     end matchcontinue;
   end expandCall;
@@ -214,6 +221,67 @@ protected
     exp := Expression.promote(eexp, Expression.typeOf(eexp), n);
   end expandBuiltinPromote;
 
+  function expandReduction
+    input Expression exp;
+    input Type ty;
+    input list<tuple<InstNode, Expression>> iterators;
+    output Expression result;
+  protected
+    Expression e = exp, range;
+    InstNode node;
+    list<Expression> ranges = {}, expl;
+    Mutable<Expression> iter;
+    list<Mutable<Expression>> iters = {};
+  algorithm
+    for i in iterators loop
+      (node, range) := i;
+      iter := Mutable.create(Expression.INTEGER(0));
+      e := Expression.replaceIterator(e, node, Expression.MUTABLE(iter));
+      iters := iter :: iters;
+      ranges := expand(range) :: ranges;
+    end for;
+
+    result := expandReduction2(e, ty, ranges, iters);
+  end expandReduction;
+
+  function expandReduction2
+    input Expression exp;
+    input Type ty;
+    input list<Expression> ranges;
+    input list<Mutable<Expression>> iterators;
+    output Expression result;
+  protected
+    Expression range;
+    list<Expression> ranges_rest, expl = {};
+    Mutable<Expression> iter;
+    list<Mutable<Expression>> iters_rest;
+    ExpressionIterator range_iter;
+    Expression value;
+    Type el_ty;
+  algorithm
+    if listEmpty(ranges) then
+      // Normally it wouldn't be the expansion's task to simplify expressions,
+      // but we make an exception here since the generated expressions contain
+      // MUTABLE expressions that we need to get rid of. Also, expansion of
+      // reductions is often done during the scalarization phase, after the
+      // simplification phase, so they wouldn't otherwise be simplified.
+      result := expand(SimplifyExp.simplify(exp));
+    else
+      range :: ranges_rest := ranges;
+      iter :: iters_rest := iterators;
+      range_iter := ExpressionIterator.fromExp(range);
+      el_ty := Type.unliftArray(ty);
+
+      while ExpressionIterator.hasNext(range_iter) loop
+        (range_iter, value) := ExpressionIterator.next(range_iter);
+        Mutable.update(iter, value);
+        expl := expandReduction2(exp, el_ty, ranges_rest, iters_rest) :: expl;
+      end while;
+
+      result := Expression.ARRAY(ty, listReverseInPlace(expl));
+    end if;
+  end expandReduction2;
+
   function expandBinary
     input Expression exp1;
     input Operator op;

Compiler/NFFrontEnd/NFSimplifyExp.mo

@@ -63,6 +63,9 @@ algorithm
       then
         exp;
 
+    case Expression.RANGE()
+      then Expression.RANGE(exp.ty, simplify(exp.start), simplifyOpt(exp.step), simplify(exp.stop));
+
     case Expression.RECORD()
       algorithm
         exp.elements := list(simplify(e) for e in exp.elements);
@@ -78,7 +81,11 @@ algorithm
     case Expression.RELATION() then simplifyRelation(exp);
     case Expression.IF() then simplifyIf(exp);
     case Expression.CAST() then simplifyCast(simplify(exp.exp), exp.ty);
+    case Expression.UNBOX() then Expression.UNBOX(simplify(exp.exp), exp.ty);
     case Expression.SUBSCRIPTED_EXP() then simplifySubscriptedExp(exp);
+    case Expression.TUPLE_ELEMENT() then simplifyTupleElement(exp);
+    case Expression.BOX() then Expression.BOX(simplify(exp.exp));
+    case Expression.MUTABLE() then simplify(Mutable.access(exp.exp));
     else exp;
   end match;
 end simplify;
@@ -119,6 +126,13 @@ algorithm
       then
         callExp;
 
+    case Call.TYPED_MAP_CALL()
+      algorithm
+        call.exp := simplify(call.exp);
+        call.iters := list((Util.tuple21(i), simplify(Util.tuple22(i))) for i in call.iters);
+      then
+        Expression.CALL(call);
+
     else callExp;
   end match;
 end simplifyCall;
@@ -289,12 +303,28 @@ protected
   Type ty;
 algorithm
   Expression.SUBSCRIPTED_EXP(e, subs, ty) := subscriptedExp;
-  e := simplify(e);
+  subscriptedExp := simplify(e);
 
   for s in subs loop
-    e := Expression.applyIndexSubscript(simplify(s), e);
+    subscriptedExp := Expression.applyIndexSubscript(simplify(s), subscriptedExp);
   end for;
 end simplifySubscriptedExp;
 
+function simplifyTupleElement
+  input output Expression tupleExp;
+protected
+  Expression e;
+  Integer index;
+  Type ty;
+algorithm
+  Expression.TUPLE_ELEMENT(e, index, ty) := tupleExp;
+  e := simplify(e);
+
+  tupleExp := match e
+    case Expression.TUPLE() then listGet(e.elements, index);
+    else Expression.TUPLE_ELEMENT(e, index, ty);
+  end match;
+end simplifyTupleElement;
+
 annotation(__OpenModelica_Interface="frontend");
 end NFSimplifyExp;