Fix min/max for enumerations.

- Fixed elaboration and constant evaluation of min/max with
  enumeration arguments.

Author: perost

Compiler/FrontEnd/Ceval.mo

@@ -3680,6 +3680,8 @@ algorithm
     case (Values.INTEGER(i1), Values.INTEGER(i2)) then Values.INTEGER(max(i1, i2));
     case (Values.REAL(r1), Values.REAL(r2)) then Values.REAL(max(r1, r2));
     case (Values.BOOL(b1), Values.BOOL(b2)) then Values.BOOL(b1 or b2);
+    case (Values.ENUM_LITERAL(), Values.ENUM_LITERAL())
+      then if v1.index > v2.index then v1 else v2;
     else
       algorithm
         true := Flags.isSet(Flags.FAILTRACE);
@@ -3756,6 +3758,8 @@ algorithm
     case (Values.INTEGER(i1), Values.INTEGER(i2)) then Values.INTEGER(min(i1, i2));
     case (Values.REAL(r1), Values.REAL(r2)) then Values.REAL(min(r1, r2));
     case (Values.BOOL(b1), Values.BOOL(b2)) then Values.BOOL(b1 and b2);
+    case (Values.ENUM_LITERAL(), Values.ENUM_LITERAL())
+      then if v1.index < v2.index then v1 else v2;
     else
       algorithm
         true := Flags.isSet(Flags.FAILTRACE);

Compiler/FrontEnd/Static.mo

@@ -1865,6 +1865,14 @@ algorithm
       then
         (exp, ty, ty, NONE(), fn);
 
+    case (Absyn.IDENT("min"), DAE.T_ENUMERATION())
+      algorithm
+        v := Values.ENUM_LITERAL(Absyn.suffixPath(unboxedType.path,
+          List.last(unboxedType.names)), listLength(unboxedType.names));
+        (exp, ty) := Types.matchType(inExp, inType, DAE.T_ENUMERATION_DEFAULT, true);
+      then
+        (exp, ty, ty, SOME(v), fn);
+
     case (Absyn.IDENT("max"), DAE.T_REAL())
       algorithm
         r := realNeg(System.realMaxLit());
@@ -1895,6 +1903,13 @@ algorithm
       then
         (exp, ty, ty, SOME(v), fn);
 
+    case (Absyn.IDENT("max"), DAE.T_ENUMERATION())
+      algorithm
+        v := Values.ENUM_LITERAL(Absyn.suffixPath(unboxedType.path, listHead(unboxedType.names)), 1);
+        (exp, ty) := Types.matchType(inExp, inType, DAE.T_ENUMERATION_DEFAULT, true);
+      then
+        (exp, ty, ty, SOME(v), fn);
+
     case (Absyn.IDENT("sum"), DAE.T_REAL())
       algorithm
         v := Values.REAL(0.0);
@@ -4508,62 +4523,54 @@ end elabBuiltinMin;
 protected function elabBuiltinMinMaxCommon
   "Helper function to elabBuiltinMin and elabBuiltinMax, containing common
   functionality."
-  input FCore.Cache inCache;
-  input FCore.Graph inEnv;
+  input output FCore.Cache cache;
+  input FCore.Graph env;
   input String inFnName;
   input list<Absyn.Exp> inFnArgs;
-  input Boolean inImpl;
-  input Prefix.Prefix inPrefix;
+  input Boolean impl;
+  input Prefix.Prefix prefix;
   input SourceInfo info;
-  output FCore.Cache outCache;
-  output DAE.Exp outExp;
-  output DAE.Properties outProperties;
+        output DAE.Exp outExp;
+        output DAE.Properties outProperties;
 algorithm
-  (outCache, outExp, outProperties):=
-  match (inCache, inEnv, inFnName, inFnArgs, inImpl, inPrefix, info)
+  (outExp, outProperties) := match inFnArgs
     local
       DAE.Exp arrexp_1,s1_1,s2_1, call;
       DAE.Type tp;
       DAE.Type ty,ty1,ty2,elt_ty;
       DAE.Const c,c1,c2;
-      FCore.Graph env;
       Absyn.Exp arrexp,s1,s2;
-      Boolean impl;
-      FCore.Cache cache;
-      Prefix.Prefix pre;
       DAE.Properties p;
 
     // min|max(vector)
-    case (cache, env, _, {arrexp}, impl, pre, _)
+    case {arrexp}
       equation
         (cache, arrexp_1, DAE.PROP(ty, c), _) =
-          elabExpInExpression(cache, env, arrexp, impl,NONE(), true, pre, info);
+          elabExpInExpression(cache, env, arrexp, impl,NONE(), true, prefix, info);
         true = Types.isArray(ty);
         arrexp_1 = Expression.matrixToArray(arrexp_1);
         elt_ty = Types.arrayElementType(ty);
         tp = Types.simplifyType(elt_ty);
         false = Types.isString(tp);
         call = Expression.makePureBuiltinCall(inFnName, {arrexp_1}, tp);
       then
-        (cache, call, DAE.PROP(elt_ty,c));
+        (call, DAE.PROP(elt_ty,c));
 
     // min|max(x,y) where x & y are scalars.
-    case (cache, env, _, {s1, s2}, impl, pre, _)
+    case {s1, s2}
       equation
         (cache, s1_1, DAE.PROP(ty1, c1), _) =
-          elabExpInExpression(cache, env, s1, impl,NONE(), true, pre, info);
+          elabExpInExpression(cache, env, s1, impl, NONE(), true, prefix, info);
         (cache, s2_1, DAE.PROP(ty2, c2), _) =
-          elabExpInExpression(cache, env, s2, impl,NONE(), true, pre, info);
+          elabExpInExpression(cache, env, s2, impl, NONE(), true, prefix, info);
 
-        ty = Types.scalarSuperType(ty1,ty2);
-        (s1_1,_) = Types.matchType(s1_1, ty1, ty, true);
-        (s2_1,_) = Types.matchType(s2_1, ty2, ty, true);
+        (s1_1, s2_1, ty, true) = Types.checkTypeCompat(s1_1, ty1, s2_1, ty2);
         c = Types.constAnd(c1, c2);
         tp = Types.simplifyType(ty);
         false = Types.isString(tp);
         call = Expression.makePureBuiltinCall(inFnName, {s1_1, s2_1}, tp);
       then
-        (cache, call, DAE.PROP(ty,c));
+        (call, DAE.PROP(ty,c));
 
   end match;
 end elabBuiltinMinMaxCommon;

Compiler/FrontEnd/Types.mo

@@ -7292,27 +7292,6 @@ algorithm
   end match;
 end varHasMetaRecordType;
 
-public function scalarSuperType
-  "Checks that the givens types are scalar and that one is subtype of the other (in the case of integers)."
-  input DAE.Type ity1;
-  input DAE.Type ity2;
-  output DAE.Type ty;
-algorithm
-  ty := match (ity1,ity2)
-    local Type ty1, ty2;
-    case (DAE.T_INTEGER(),DAE.T_INTEGER()) then DAE.T_INTEGER_DEFAULT;
-    case (DAE.T_REAL(),DAE.T_REAL())       then DAE.T_REAL_DEFAULT;
-    case (DAE.T_INTEGER(),DAE.T_REAL())    then DAE.T_REAL_DEFAULT;
-    case (DAE.T_REAL(),DAE.T_INTEGER())    then DAE.T_REAL_DEFAULT;
-    case (DAE.T_SUBTYPE_BASIC(complexType = ty1),ty2)          then scalarSuperType(ty1,ty2);
-    case (ty1,DAE.T_SUBTYPE_BASIC(complexType = ty2))          then scalarSuperType(ty1,ty2);
-
-    case (DAE.T_BOOL(),DAE.T_BOOL())       then DAE.T_BOOL_DEFAULT;
-    // adrpo: TODO? Why not string here?
-    // case (DAE.T_STRING(varLst = _),DAE.T_STRING(varLst = _))   then DAE.T_STRING_DEFAULT;
-  end match;
-end scalarSuperType;
-
 protected function optInteger
   input Option<Integer> inInt;
   output Integer outInt;

Compiler/NFFrontEnd/NFType.mo

@@ -367,21 +367,6 @@ public
     end match;
   end dimensionCount;
 
-  function scalarSuperType
-    "Checks that the given types are scalar and that one is a subtype of the other."
-    input Type ty1;
-    input Type ty2;
-    output Type ty;
-  algorithm
-    ty := match (ty1, ty2)
-      case (INTEGER(), INTEGER()) then INTEGER();
-      case (REAL(), REAL()) then REAL();
-      case (INTEGER(), REAL()) then REAL();
-      case (REAL(), INTEGER()) then REAL();
-      case (BOOLEAN(), BOOLEAN()) then BOOLEAN();
-    end match;
-  end scalarSuperType;
-
   function toString
     input Type ty;
     output String str;