[NF] Restrict cardinality usage.

- Implemented stricter checks for where cardinality is allowed to be
  used, to improve the user feedback.

Belonging to [master]:
  - OpenModelica/OpenModelica#99
  - #2949
  - OpenModelica/OpenModelica-testsuite#1128

Author: perost

Compiler/NFFrontEnd/NFBuiltinCall.mo

@@ -1281,6 +1281,15 @@ protected
     Function fn;
     InstNode node;
   algorithm
+    // cardinality may only be used in a condition of an assert or
+    // if-statement/equation (the specification says only if-statement,
+    // but e.g. the MSL only uses them in if-equations and asserts).
+    if not (ExpOrigin.flagSet(origin, ExpOrigin.CONDITION) and
+       (ExpOrigin.flagSet(origin, ExpOrigin.IF) or
+        ExpOrigin.flagSet(origin, ExpOrigin.ASSERT))) then
+      Error.addSourceMessageAndFail(Error.INVALID_CARDINALITY_CONTEXT, {}, info);
+    end if;
+
     Call.UNTYPED_CALL(ref = fn_ref, arguments = args, named_args = named_args) := call;
     assertNoNamedParams("cardinality", named_args, info);
 

Compiler/NFFrontEnd/NFTyping.mo

@@ -135,6 +135,7 @@ package ExpOrigin
   constant Type SUBEXPRESSION   = intBitLShift(1, 16); // Part of a larger expression.
   constant Type CONNECT         = intBitLShift(1, 17); // Part of connect argument.
   constant Type NOEVENT         = intBitLShift(1, 18); // Part of noEvent argument.
+  constant Type ASSERT          = intBitLShift(1, 19); // Part of assert argument.
 
   // Combined flags:
   constant Type EQ_SUBEXPRESSION = intBitOr(EQUATION, SUBEXPRESSION);
@@ -2402,9 +2403,11 @@ algorithm
     case Equation.ASSERT()
       algorithm
         info := ElementSource.getInfo(eq.source);
-        e1 := typeOperatorArg(eq.condition, Type.BOOLEAN(), origin, "assert", "condition", 1, info);
-        e2 := typeOperatorArg(eq.message, Type.STRING(), origin, "assert", "message", 2, info);
-        e3 := typeOperatorArg(eq.level, NFBuiltin.ASSERTIONLEVEL_TYPE, origin, "assert", "level", 3, info);
+        next_origin := ExpOrigin.setFlag(origin, ExpOrigin.ASSERT);
+        e1 := typeOperatorArg(eq.condition, Type.BOOLEAN(),
+          ExpOrigin.setFlag(next_origin, ExpOrigin.CONDITION), "assert", "condition", 1, info);
+        e2 := typeOperatorArg(eq.message, Type.STRING(), next_origin, "assert", "message", 2, info);
+        e3 := typeOperatorArg(eq.level, NFBuiltin.ASSERTIONLEVEL_TYPE, next_origin, "assert", "level", 3, info);
       then
         Equation.ASSERT(e1, e2, e3, eq.source);
 
@@ -2562,7 +2565,7 @@ algorithm
       list<tuple<Expression, list<Statement>>> tybrs;
       InstNode iterator;
       MatchKind mk;
-      Integer next_origin;
+      ExpOrigin.Type next_origin, cond_origin;
       SourceInfo info;
 
     case Statement.ASSIGNMENT()
@@ -2602,11 +2605,14 @@ algorithm
 
     case Statement.IF()
       algorithm
+        next_origin := ExpOrigin.setFlag(origin, ExpOrigin.IF);
+        cond_origin := ExpOrigin.setFlag(next_origin, ExpOrigin.CONDITION);
+
         tybrs := list(
           match br case(cond, body)
             algorithm
-              e1 := typeCondition(cond, origin, st.source, Error.IF_CONDITION_TYPE_ERROR);
-              sts1 := list(typeStatement(bst, origin) for bst in body);
+              e1 := typeCondition(cond, cond_origin, st.source, Error.IF_CONDITION_TYPE_ERROR);
+              sts1 := list(typeStatement(bst, next_origin) for bst in body);
             then (e1, sts1);
           end match
         for br in st.branches);
@@ -2631,9 +2637,11 @@ algorithm
     case Statement.ASSERT()
       algorithm
         info := ElementSource.getInfo(st.source);
-        e1 := typeOperatorArg(st.condition, Type.BOOLEAN(), origin, "assert", "condition", 1, info);
-        e2 := typeOperatorArg(st.message, Type.STRING(), origin, "assert", "message", 2, info);
-        e3 := typeOperatorArg(st.level, NFBuiltin.ASSERTIONLEVEL_TYPE, origin, "assert", "level", 3, info);
+        next_origin := ExpOrigin.setFlag(origin, ExpOrigin.ASSERT);
+        e1 := typeOperatorArg(st.condition, Type.BOOLEAN(),
+          ExpOrigin.setFlag(next_origin, ExpOrigin.CONDITION), "assert", "condition", 1, info);
+        e2 := typeOperatorArg(st.message, Type.STRING(), next_origin, "assert", "message", 2, info);
+        e3 := typeOperatorArg(st.level, NFBuiltin.ASSERTIONLEVEL_TYPE, next_origin, "assert", "level", 3, info);
       then
         Statement.ASSERT(e1, e2, e3, st.source);
 
@@ -2718,12 +2726,13 @@ protected
   list<Equation> eql;
   Variability accum_var = Variability.CONSTANT, var;
   list<Equation.Branch> bl = {}, bl2 = {};
-  Integer next_origin = origin;
+  ExpOrigin.Type next_origin = ExpOrigin.setFlag(origin, ExpOrigin.IF);
+  ExpOrigin.Type cond_origin = ExpOrigin.setFlag(next_origin, ExpOrigin.CONDITION);
 algorithm
   // Type the conditions of all the branches.
   for b in branches loop
     Equation.Branch.BRANCH(cond, _, eql) := b;
-    (cond, var) := typeCondition(cond, origin, source, Error.IF_CONDITION_TYPE_ERROR);
+    (cond, var) := typeCondition(cond, cond_origin, source, Error.IF_CONDITION_TYPE_ERROR);
 
     if var > Variability.PARAMETER or isNonExpandableExp(cond) then
       // If the condition doesn't fulfill the requirements for allowing

Compiler/Util/Error.mo

@@ -818,6 +818,8 @@ public constant Message INVALID_REDUCTION_TYPE = MESSAGE(344, TRANSLATION(), ERR
   Util.gettext("Invalid expression ‘%s‘ of type %s in %s reduction, expected %s."));
 public constant Message INVALID_COMPONENT_PREFIX = MESSAGE(345, TRANSLATION(), ERROR(),
   Util.gettext("Prefix ‘%s‘ on component ‘%s‘ not allowed in class specialization ‘%s‘."));
+public constant Message INVALID_CARDINALITY_CONTEXT = MESSAGE(346, TRANSLATION(), ERROR(),
+  Util.gettext("cardinality may only be used in the condition of an if-statement/equation or an assert."));
 public constant Message INITIALIZATION_NOT_FULLY_SPECIFIED = MESSAGE(496, TRANSLATION(), WARNING(),
   Util.gettext("The initial conditions are not fully specified. %s."));
 public constant Message INITIALIZATION_OVER_SPECIFIED = MESSAGE(497, TRANSLATION(), WARNING(),