[NF] Improve type casting of some builtins.

- Added special cases for type casting fill and diagonal.
- Renamed Expression.typeCastElements to Expression.typeCast,
  and removed the old unused Expression.typeCast.

Belonging to [master]:
  - #2953

Author: perost

Compiler/NFFrontEnd/NFBuiltinCall.mo

@@ -593,7 +593,7 @@ protected
 
     if Type.isInteger(ety) then
       ty := Type.setArrayElementType(ty, Type.REAL());
-      arg := Expression.typeCastElements(arg, Type.REAL());
+      arg := Expression.typeCast(arg, Type.REAL());
     elseif not Type.isReal(ety) then
       Error.addSourceMessageAndFail(Error.ARG_TYPE_MISMATCH,
         {"1", ComponentRef.toString(fn_ref), "", Expression.toString(arg),

Compiler/NFFrontEnd/NFCall.mo

@@ -845,6 +845,42 @@ uniontype Call
     end match;
   end retype;
 
+  function typeCast
+    input output Expression callExp;
+    input Type ty;
+  protected
+    Call call;
+  algorithm
+    Expression.CALL(call = call) := callExp;
+
+    callExp := match call
+      case TYPED_CALL() guard Function.isBuiltin(call.fn)
+        then
+          match Absyn.pathFirstIdent(Function.name(call.fn))
+            // For 'fill' we can type cast the first argument rather than the
+            // whole array that 'fill' constructs.
+            case "fill"
+              algorithm
+                call.arguments := Expression.typeCast(listHead(call.arguments), ty) ::
+                                  listRest(call.arguments);
+              then
+                Expression.CALL(call);
+
+            // For diagonal we can type cast the argument rather than the
+            // matrix that diagonal constructs.
+            case "diagonal"
+              algorithm
+                call.arguments := {Expression.typeCast(listHead(call.arguments), ty)};
+              then
+                Expression.CALL(call);
+
+            else Expression.CAST(Type.setArrayElementType(call.ty, ty), callExp);
+          end match;
+
+      else Expression.CAST(Type.setArrayElementType(typeOf(call), ty), callExp);
+    end match;
+  end typeCast;
+
 protected
   function instNormalCall
     input Absyn.ComponentRef functionName;

Compiler/NFFrontEnd/NFCeval.mo

@@ -1537,9 +1537,9 @@ function evalCast
   input Type castTy;
   output Expression exp;
 algorithm
-  exp := Expression.typeCastElements(castExp, Type.elementType(castTy));
+  exp := Expression.typeCast(castExp, Type.elementType(castTy));
 
-  // Expression.typeCastElements will just create a CAST if it can't typecast
+  // Expression.typeCast will just create a CAST if it can't typecast
   // the expression, so make sure we actually got something else back.
   () := match exp
     case Expression.CAST()

Compiler/NFFrontEnd/NFExpandExp.mo

@@ -947,7 +947,7 @@ public
     (outExp, expanded) := expand(exp);
 
     if expanded then
-      outExp := Expression.typeCastElements(outExp, ty);
+      outExp := Expression.typeCast(outExp, ty);
     else
       outExp := exp;
     end if;

Compiler/NFFrontEnd/NFExpression.mo

@@ -806,12 +806,6 @@ public
   end setType;
 
   function typeCast
-    input Expression exp;
-    input Type castTy;
-    output Expression castExp = CAST(castTy, exp);
-  end typeCast;
-
-  function typeCastElements
     input output Expression exp;
     input Type ty;
   algorithm
@@ -828,18 +822,19 @@ public
       case (ARRAY(ty = t, elements = el), _)
         algorithm
           ety := Type.arrayElementType(ty);
-          el := list(typeCastElements(e, ety) for e in el);
+          el := list(typeCast(e, ety) for e in el);
           t := Type.setArrayElementType(t, ty);
         then
           ARRAY(t, el, exp.literal);
 
       case (UNARY(), _)
-        then UNARY(exp.operator, typeCastElements(exp.exp, ty));
+        then UNARY(exp.operator, typeCast(exp.exp, ty));
 
       case (IF(), _)
-        then IF(exp.condition,
-                typeCastElements(exp.trueBranch, ty),
-                typeCastElements(exp.falseBranch, ty));
+        then IF(exp.condition, typeCast(exp.trueBranch, ty), typeCast(exp.falseBranch, ty));
+
+      case (CALL(), _)
+        then Call.typeCast(exp, ty);
 
       else
         algorithm
@@ -849,7 +844,7 @@ public
           CAST(t, exp);
 
     end match;
-  end typeCastElements;
+  end typeCast;
 
   function realValue
     input Expression exp;

Compiler/NFFrontEnd/NFTypeCheck.mo

@@ -2155,13 +2155,13 @@ algorithm
     // Integer can be cast to Real.
     case (Type.INTEGER(), Type.REAL())
       algorithm
-        exp1 := Expression.typeCastElements(exp1, type2);
+        exp1 := Expression.typeCast(exp1, type2);
       then
         (type2, MatchKind.CAST);
 
     case (Type.REAL(), Type.INTEGER())
       algorithm
-        exp2 := Expression.typeCastElements(exp2, type1);
+        exp2 := Expression.typeCast(exp2, type1);
       then
         (type1, MatchKind.CAST);
 
@@ -2635,7 +2635,7 @@ algorithm
     // Integer can be cast to Real.
     case (Type.INTEGER(), Type.REAL())
       algorithm
-        expression := Expression.typeCastElements(expression, expectedType);
+        expression := Expression.typeCast(expression, expectedType);
       then
         (expectedType, MatchKind.CAST);