[NF] Handle if-expressions better.

- Handle if-expressions that have branches with different dimensions
  better.

Author: perost

OMCompiler/Compiler/NFFrontEnd/NFConnectEquations.mo

@@ -807,6 +807,11 @@ algorithm
 
   if isSome(attr_oexp) then
     SOME(attr_exp) := attr_oexp;
+
+    if Expression.variability(attr_exp) <= Variability.STRUCTURAL_PARAMETER then
+      attr_exp := Ceval.evalExp(attr_exp);
+    end if;
+
     isZero := Expression.isZero(Expression.getBindingExp(attr_exp));
   else
     isZero := false;

OMCompiler/Compiler/NFFrontEnd/NFTypeCheck.mo

@@ -3197,5 +3197,66 @@ algorithm
   end for;
 end checkSumComplexType;
 
+function matchIfBranches
+  input output Expression trueBranch;
+  input Type trueType;
+  input output Expression falseBranch;
+  input Type falseType;
+  input Expression condition;
+  input Variability conditionVar;
+  input Boolean allowUnknown = false;
+        output Type compatibleType;
+        output MatchKind matchKind;
+protected
+  Expression tdim_exp, fdim_exp;
+  Type tety, fety;
+  list<Dimension> tdims, fdims, dims;
+  Dimension fdim;
+  Variability var;
+algorithm
+  tety := Type.arrayElementType(trueType);
+  fety := Type.arrayElementType(falseType);
+  tdims := Type.arrayDims(trueType);
+  fdims := Type.arrayDims(falseType);
+
+  // Both branches must have the same number of dimensions.
+  if listLength(tdims) <> listLength(fdims) then
+    matchKind := MatchKind.NOT_COMPATIBLE;
+    compatibleType := trueType;
+    return;
+  end if;
+
+  (trueBranch, falseBranch, compatibleType, matchKind) :=
+    matchExpressions(trueBranch, tety, falseBranch, fety);
+
+  // Both branches must have the same element type.
+  if isIncompatibleMatch(matchKind) then
+    return;
+  end if;
+
+  dims := {};
+
+  for tdim in tdims loop
+    fdim :: fdims := fdims;
+
+    if Dimension.isEqual(tdim, fdim) then
+      dims := tdim :: dims;
+    elseif conditionVar <= Variability.PARAMETER and
+           Dimension.isKnown(tdim, allowExp = true) and
+           Dimension.isKnown(fdim, allowExp = true) then
+      tdim_exp := Dimension.sizeExp(tdim);
+      fdim_exp := Dimension.sizeExp(fdim);
+      var := Prefixes.variabilityMax(Expression.variability(tdim_exp),
+                                     Expression.variability(fdim_exp));
+      dims := Dimension.fromExp(Expression.IF(condition, tdim_exp, fdim_exp), var) :: dims;
+    else
+      matchKind := MatchKind.NOT_COMPATIBLE;
+      return;
+    end if;
+  end for;
+
+  compatibleType := Type.liftArrayLeftList(compatibleType, listReverse(dims));
+end matchIfBranches;
+
 annotation(__OpenModelica_Interface="frontend");
 end NFTypeCheck;

OMCompiler/Compiler/NFFrontEnd/NFTyping.mo

@@ -2219,39 +2219,19 @@ algorithm
     fail();
   end if;
 
-  if cond_var <= Variability.STRUCTURAL_PARAMETER and
-    not Expression.contains(cond, isNonConstantIfCondition) then
-    // If the condition is constant, always do branch selection.
-    if evaluateCondition(cond, origin, info) then
-      (ifExp, ty, var) := typeExp(tb, next_origin, info);
-    else
-      (ifExp, ty, var) := typeExp(fb, next_origin, info);
-    end if;
-  else
-    // Otherwise type both of the branches.
-    (tb, tb_ty, tb_var) := typeExp(tb, next_origin, info);
-    (fb, fb_ty, fb_var) := typeExp(fb, next_origin, info);
-
-    (tb2, fb2, ty, ty_match) := TypeCheck.matchExpressions(tb, tb_ty, fb, fb_ty);
+  (tb, tb_ty, tb_var) := typeExp(tb, next_origin, info);
+  (fb, fb_ty, fb_var) := typeExp(fb, next_origin, info);
+  (tb2, fb2, ty, ty_match) := TypeCheck.matchIfBranches(tb, tb_ty, fb, fb_ty, cond, cond_var);
 
-    if TypeCheck.isIncompatibleMatch(ty_match) then
-      if cond_var <= Variability.PARAMETER then
-        // If the branches have different types but the condition is a parameter
-        // expression, do branch selection.
-        (ifExp, ty, var) := if evaluateCondition(cond, origin, info) then (tb, tb_ty, tb_var) else (fb, fb_ty, fb_var);
-      else
-        // Otherwise give a type mismatch error.
-        Error.addSourceMessage(Error.TYPE_MISMATCH_IF_EXP,
-          {"", Expression.toString(tb), Type.toString(tb_ty),
-               Expression.toString(fb), Type.toString(fb_ty)}, info);
-        fail();
-      end if;
-    else
-      // If the types match, return a typed if-expression.
-      ifExp := Expression.IF(cond, tb2, fb2);
-      var := Prefixes.variabilityMax(cond_var, Prefixes.variabilityMax(tb_var, fb_var));
-    end if;
+  if TypeCheck.isIncompatibleMatch(ty_match) then
+    Error.addSourceMessage(Error.TYPE_MISMATCH_IF_EXP,
+      {"", Expression.toString(tb), Type.toString(tb_ty),
+           Expression.toString(fb), Type.toString(fb_ty)}, info);
+    fail();
   end if;
+
+  ifExp := Expression.IF(cond, tb2, fb2);
+  var := Prefixes.variabilityMax(cond_var, Prefixes.variabilityMax(tb_var, fb_var));
 end typeIfExpression;
 
 function evaluateCondition

testsuite/flattening/modelica/scodeinst/IfExpression4.mo

@@ -15,6 +15,6 @@ end IfExpression4;
 //   Real x[1];
 //   Real x[2];
 // equation
-//   x = {1.0, 2.0};
+//   x = if b then {1.0, 2.0} else {3.0, 4.0, 5.0};
 // end IfExpression4;
 // endResult