[NF] ones/zeros and dimensions type check fixes.

- Change ones/zeros to the appropriate fill calls, since the code
  generation expects that.
- Fixed equality check for dimensions to handle expressions better.

Belonging to [master]:
  - #2378
  - OpenModelica/OpenModelica-testsuite#925

Author: perost

Compiler/NFFrontEnd/NFBuiltinFuncs.mo

@@ -234,5 +234,9 @@ constant Function ARRAY_FUNC = Function.FUNCTION(Path.IDENT("array"),
   InstNode.EMPTY_NODE(), {}, {}, {}, {},
     Type.UNKNOWN(), DAE.FUNCTION_ATTRIBUTES_BUILTIN, Pointer.createImmutable(true));
 
+constant Function FILL_FUNC = Function.FUNCTION(Path.IDENT("fill"),
+  InstNode.EMPTY_NODE(), {}, {}, {}, {},
+    Type.UNKNOWN(), DAE.FUNCTION_ATTRIBUTES_BUILTIN, Pointer.createImmutable(true));
+
 annotation(__OpenModelica_Interface="frontend");
 end NFBuiltinFuncs;

Compiler/NFFrontEnd/NFCall.mo

@@ -1889,13 +1889,13 @@ protected
 
     // Type the first argument, which is the fill value.
     (fill_arg, ty, _) := Typing.typeExp(fill_arg, origin, info);
-    (callExp, ty, variability) := typeFillCall2(fn_ref, ty, {fill_arg}, args, origin, info);
+    (callExp, ty, variability) := typeFillCall2(fn_ref, ty, fill_arg, args, origin, info);
   end typeFillCall;
 
   function typeFillCall2
     input ComponentRef fnRef;
     input Type fillType;
-    input list<Expression> fillArgs;
+    input Expression fillArg;
     input list<Expression> dimensionArgs;
     input ExpOrigin.Type origin;
     input SourceInfo info;
@@ -1910,7 +1910,7 @@ protected
     Function fn;
     list<Dimension> dims;
   algorithm
-    ty_args := fillArgs;
+    ty_args := {fillArg};
     dims := {};
 
     // Type the dimension arguments.
@@ -1941,9 +1941,9 @@ protected
     ty := Type.ARRAY(fillType, dims);
 
     if variability <= Variability.STRUCTURAL_PARAMETER and intBitAnd(origin, ExpOrigin.FUNCTION) == 0 then
-      callExp := Ceval.evalBuiltinCall(fn, ty_args, Ceval.EvalTarget.IGNORE_ERRORS());
+      callExp := Ceval.evalBuiltinFill(ty_args);
     else
-      callExp := Expression.CALL(makeBuiltinCall2(fn, ty_args, ty, variability));
+      callExp := Expression.CALL(makeBuiltinCall2(NFBuiltinFuncs.FILL_FUNC, ty_args, ty, variability));
     end if;
   end typeFillCall2;
 
@@ -1974,7 +1974,13 @@ protected
         {toString(call), ComponentRef.toString(fn_ref) + "(Integer, ...) => Integer[:, ...]"}, info);
     end if;
 
-    (callExp, ty, variability) := typeFillCall2(fn_ref, Type.INTEGER(), {}, args, origin, info);
+    if ComponentRef.firstName(fn_ref) == "ones" then
+      fill_arg := Expression.INTEGER(1);
+    else
+      fill_arg := Expression.INTEGER(0);
+    end if;
+
+    (callExp, ty, variability) := typeFillCall2(fn_ref, Type.INTEGER(), fill_arg, args, origin, info);
   end typeZerosOnesCall;
 
   function typeScalarCall

Compiler/NFFrontEnd/NFCeval.mo

@@ -716,6 +716,7 @@ algorithm
   end match;
 end evalBuiltinExp;
 
+public
 function evalBuiltinFill
   input list<Expression> args;
   output Expression result;
@@ -744,6 +745,7 @@ algorithm
   end for;
 end evalBuiltinFill2;
 
+protected
 function evalBuiltinFloor
   input Expression arg;
   output Expression result;

Compiler/NFFrontEnd/NFDimension.mo

@@ -169,6 +169,7 @@ public
     isEqual := match (dim1, dim2)
       case (UNKNOWN(), _) then true;
       case (_, UNKNOWN()) then true;
+      case (EXP(), EXP()) then Expression.isEqual(dim1.exp, dim2.exp);
       case (EXP(), _) then true;
       case (_, EXP()) then true;
       else Dimension.size(dim1) == Dimension.size(dim2);

Compiler/NFFrontEnd/NFTypeCheck.mo

@@ -1827,21 +1827,21 @@ function matchDimensions
   input Boolean allowUnknown;
   output Dimension compatibleDim;
   output Boolean compatible;
-protected
-  Boolean known1, known2;
 algorithm
-  known1 := Dimension.isKnown(dim1);
-  known2 := Dimension.isKnown(dim2);
-
-  if known1 and known2 then
+  if Dimension.isEqual(dim1, dim2) then
     compatibleDim := dim1;
-    compatible := Dimension.isEqual(dim1, dim2);
-  elseif allowUnknown then
-    compatibleDim := if known1 then dim1 else dim2;
     compatible := true;
   else
-    compatibleDim := dim1;
-    compatible := false;
+    if not Dimension.isKnown(dim1) then
+      compatibleDim := dim2;
+      compatible := true;
+    elseif not Dimension.isKnown(dim2) then
+      compatibleDim := dim1;
+      compatible := true;
+    else
+      compatibleDim := dim1;
+      compatible := false;
+    end if;
   end if;
 end matchDimensions;