NFInst improvements.

- Added origin as argument to typeExp to handle 'end' and to allow
  specific handling of expression based on where they're occuring.
- Moved detection of invalid usage of typenames from the
  instantiation to the typing.
- Changed Variability to an enumeration for easier handling.
- Improved typing of subscripts, including type checking and checking
  the number of subscripts.

Author: perost

Compiler/FrontEnd/Static.mo

@@ -10217,7 +10217,7 @@ algorithm
       // Fail if the variability is wrong.
       if not Types.constEqualOrHigher(c1, c2) then
         exp_str := ExpressionDump.printExpStr(inExp);
-        c_str := DAEUtil.constStrFriendly(c2);
+        c_str := Types.unparseConst(c2);
         Error.addSourceMessageAndFail(Error.FUNCTION_SLOT_VARIABILITY,
           {fa1, exp_str, c_str}, inInfo);
       end if;

Compiler/NFFrontEnd/NFBinding.mo

@@ -31,11 +31,11 @@
 
 encapsulated uniontype NFBinding
 public
-  import DAE;
   import Expression = NFExpression;
   import NFInstNode.InstNode;
   import SCode;
   import Type = NFType;
+  import NFPrefixes.Variability;
 
 protected
   import Dump;
@@ -62,7 +62,7 @@ public
   record TYPED_BINDING
     Expression bindingExp;
     Type bindingType;
-    DAE.VarKind variability;
+    Variability variability;
     Integer propagatedLevels;
     SourceInfo info;
   end TYPED_BINDING;
@@ -142,7 +142,7 @@ public
 
   function variability
     input Binding binding;
-    output DAE.VarKind var;
+    output Variability var;
   algorithm
     TYPED_BINDING(variability = var) := binding;
   end variability;

Compiler/NFFrontEnd/NFBuiltin.mo

@@ -42,7 +42,6 @@ encapsulated package NFBuiltin
 
 public
 import Absyn;
-import DAE;
 import SCode;
 import Binding = NFBinding;
 import NFClass.Class;
@@ -55,6 +54,7 @@ import NFMod.Modifier;
 import Type = NFType;
 import BuiltinFuncs = NFBuiltinFuncs;
 import Pointer;
+import NFPrefixes.Variability;
 
 encapsulated package Elements
   import SCode;
@@ -152,39 +152,39 @@ constant Binding STATESELECT_NEVER_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE_TYPE, "never", 1),
     STATESELECT_TYPE_TYPE,
-    DAE.VarKind.CONST(),
+    Variability.CONSTANT,
     -1,
     Absyn.dummyInfo);
 
 constant Binding STATESELECT_AVOID_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE_TYPE, "avoid", 2),
     STATESELECT_TYPE_TYPE,
-    DAE.VarKind.CONST(),
+    Variability.CONSTANT,
     -1,
     Absyn.dummyInfo);
 
 constant Binding STATESELECT_DEFAULT_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE_TYPE, "default", 3),
     STATESELECT_TYPE_TYPE,
-    DAE.VarKind.CONST(),
+    Variability,
     -1,
     Absyn.dummyInfo);
 
 constant Binding STATESELECT_PREFER_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE_TYPE, "prefer", 4),
     STATESELECT_TYPE_TYPE,
-    DAE.VarKind.CONST(),
+    Variability.CONSTANT,
     -1,
     Absyn.dummyInfo);
 
 constant Binding STATESELECT_ALWAYS_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE_TYPE, "always", 5),
     STATESELECT_TYPE_TYPE,
-    DAE.VarKind.CONST(),
+    Variability.CONSTANT,
     -1,
     Absyn.dummyInfo);
 

Compiler/NFFrontEnd/NFCall.mo

@@ -36,6 +36,7 @@ import DAE;
 import NFInstNode.InstNode;
 import Expression = NFExpression;
 import Type = NFType;
+import NFPrefixes.Variability;
 
 protected
 import NFInstNode.CachedData;
@@ -45,12 +46,13 @@ import Inst = NFInst;
 import NFInstNode.InstNodeType;
 import Lookup = NFLookup;
 import Typing = NFTyping;
+import ExpOrigin = NFTyping.ExpOrigin;
 import Types;
 import List;
 import NFClass.Class;
 import ErrorExt;
 import Util;
-import InstUtil = NFInstUtil;
+import Prefixes = NFPrefixes;
 
 protected
 import NFFunction.NamedArg;
@@ -172,7 +174,7 @@ uniontype Call
     input output Expression callExp;
     input SourceInfo info;
           output Type ty;
-          output DAE.VarKind variability;
+          output Variability variability;
   protected
     Call call, argtycall;
     InstNode fn_node;
@@ -181,7 +183,7 @@ uniontype Call
     Function fn;
     list<Expression> args;
     list<Type> arg_ty;
-    list<DAE.VarKind> arg_var;
+    list<Variability> arg_var;
     CallAttributes ca;
     list<TypedArg> tyArgs;
   algorithm
@@ -204,9 +206,9 @@ uniontype Call
 
           args := list(Util.tuple31(a) for a in tyArgs);
 
-          variability := DAE.VarKind.CONST();
+          variability := Variability.CONSTANT;
           for a in tyArgs loop
-            variability := InstUtil.variabilityAnd(variability,Util.tuple33(a));
+            variability := Prefixes.variabilityMax(variability, Util.tuple33(a));
           end for;
 
           // Construct the call expression.
@@ -241,15 +243,15 @@ uniontype Call
       local
         Expression arg;
         Type arg_ty;
-        DAE.VarKind arg_var;
+        Variability arg_var;
         list<TypedArg> typedArgs;
         list<TypedNamedArg> typedNamedArgs;
         String name;
 
       case UNTYPED_CALL() algorithm
         typedArgs := {};
         for arg in call.arguments loop
-          (arg, arg_ty, arg_var) := Typing.typeExp(arg,info);
+          (arg, arg_ty, arg_var) := Typing.typeExp(arg, info);
           typedArgs := (arg, arg_ty, arg_var)::typedArgs;
         end for;
 
@@ -258,7 +260,7 @@ uniontype Call
         typedNamedArgs := {};
         for narg in call.named_args loop
           (name,arg) := narg;
-          (arg, arg_ty, arg_var) := Typing.typeExp(arg,info);
+          (arg, arg_ty, arg_var) := Typing.typeExp(arg, info);
           typedNamedArgs := (name, arg, arg_ty, arg_var)::typedNamedArgs;
         end for;
         listReverse(typedNamedArgs);

Compiler/NFFrontEnd/NFComponent.mo

@@ -41,6 +41,7 @@ import SCode.Element;
 import SCode;
 import Type = NFType;
 import Expression = NFExpression;
+import NFPrefixes.Variability;
 
 protected
 import NFInstUtil;
@@ -51,7 +52,7 @@ constant Component.Attributes CONST_ATTR =
   Component.Attributes.ATTRIBUTES(
      DAE.NON_CONNECTOR(),
      DAE.NON_PARALLEL(),
-     DAE.VARIABLE(),
+     Variability.CONTINUOUS,
      DAE.BIDIR(),
      DAE.NOT_INNER_OUTER(),
      DAE.PUBLIC());
@@ -60,7 +61,7 @@ constant Component.Attributes INPUT_ATTR =
   Component.Attributes.ATTRIBUTES(
      DAE.NON_CONNECTOR(),
      DAE.NON_PARALLEL(),
-     DAE.VARIABLE(),
+     Variability.CONTINUOUS,
      DAE.INPUT(),
      DAE.NOT_INNER_OUTER(),
      DAE.PUBLIC());
@@ -69,7 +70,7 @@ constant Component.Attributes OUTPUT_ATTR =
   Component.Attributes.ATTRIBUTES(
      DAE.NON_CONNECTOR(),
      DAE.NON_PARALLEL(),
-     DAE.VARIABLE(),
+     Variability.CONTINUOUS,
      DAE.OUTPUT(),
      DAE.NOT_INNER_OUTER(),
      DAE.PUBLIC());
@@ -80,7 +81,7 @@ uniontype Component
       // adrpo: keep the order in DAE.ATTR
       DAE.ConnectorType connectorType;
       DAE.VarParallelism parallelism;
-      DAE.VarKind variability;
+      Variability variability;
       DAE.VarDirection direction;
       DAE.VarInnerOuter innerOuter;
       DAE.VarVisibility visibility;
@@ -356,36 +357,26 @@ uniontype Component
 
   function variability
     input Component component;
-    output DAE.VarKind variability;
+    output Variability variability;
   algorithm
     variability := match component
       case TYPED_COMPONENT(attributes = Attributes.ATTRIBUTES(variability = variability)) then variability;
-      case TYPED_COMPONENT(attributes = Attributes.DEFAULT()) then DAE.VarKind.VARIABLE();
+      case TYPED_COMPONENT(attributes = Attributes.DEFAULT()) then Variability.CONTINUOUS;
       case UNTYPED_COMPONENT(attributes = Attributes.ATTRIBUTES(variability = variability)) then variability;
-      case UNTYPED_COMPONENT(attributes = Attributes.DEFAULT()) then DAE.VarKind.VARIABLE();
-      case ITERATOR() then DAE.VarKind.CONST();
+      case UNTYPED_COMPONENT(attributes = Attributes.DEFAULT()) then Variability.CONTINUOUS;
+      case ITERATOR() then Variability.CONSTANT;
       else fail();
     end match;
   end variability;
 
   function isConst
     input Component component;
-    output Boolean isConst;
-  algorithm
-    isConst := match variability(component)
-      case DAE.VarKind.CONST() then true;
-      else false;
-    end match;
+    output Boolean isConst = variability(component) == Variability.CONSTANT;
   end isConst;
 
   function isVar
     input Component component;
-    output Boolean isConst;
-  algorithm
-    isConst := match variability(component)
-      case DAE.VarKind.VARIABLE() then true;
-      else false;
-    end match;
+    output Boolean isConst = variability(component) == Variability.CONTINUOUS;
   end isVar;
 
   function visibility

Compiler/NFFrontEnd/NFComponentRef.mo

@@ -39,6 +39,7 @@ protected
   import RangeIterator = NFRangeIterator;
   import Dimension = NFDimension;
   import Expression = NFExpression;
+  import NFPrefixes.Variability;
 
   import ComponentRef = NFComponentRef;
 
@@ -101,11 +102,11 @@ public
 
   function getVariability
     input ComponentRef cref;
-    output DAE.VarKind var;
+    output Variability var;
   algorithm
     var := match cref
       case CREF() then Component.variability(InstNode.component(cref.node));
-      else DAE.VarKind.VARIABLE();
+      else Variability.CONTINUOUS;
     end match;
   end getVariability;
 

Compiler/NFFrontEnd/NFDimension.mo

@@ -41,6 +41,7 @@ public
   import NFInstNode.InstNode;
   import Type = NFType;
   import ComponentRef = NFComponentRef;
+  import NFPrefixes.Variability;
 
   record RAW_DIM
     Absyn.Subscript dim;
@@ -64,13 +65,15 @@ public
 
   record EXP
     Expression exp;
+    Variability var;
   end EXP;
 
   record UNKNOWN
   end UNKNOWN;
 
   function fromExp
     input Expression exp;
+    input Variability var;
     output Dimension dim;
   algorithm
     dim := match exp
@@ -93,7 +96,7 @@ public
                 fail();
           end match;
 
-      else Dimension.EXP(exp);
+      else Dimension.EXP(exp, var);
     end match;
   end fromExp;
 
@@ -191,6 +194,20 @@ public
     end match;
   end isKnown;
 
+  function subscriptType
+    "Returns the expected type of a subscript for the given dimension."
+    input Dimension dim;
+    output Type ty;
+  algorithm
+    ty := match dim
+      case INTEGER() then Type.INTEGER();
+      case BOOLEAN() then Type.BOOLEAN();
+      case ENUM() then dim.enumType;
+      case EXP() then Expression.typeOf(dim.exp);
+      else Type.UNKNOWN();
+    end match;
+  end subscriptType;
+
   function toString
     input Dimension dim;
     output String str;

Compiler/NFFrontEnd/NFExpOrigin.mo

@@ -0,0 +1,41 @@
+
+encapsulated uniontype NFExpOrigin
+  "This uniontype is used to mark where an expression comes from in typeExp, so
+   that it can check things like 'end' only being used in subscripts."
+
+protected
+  import Dimension = NFDimension;
+  import ExpOrigin = NFExpOrigin;
+
+public
+  record DIMENSION end DIMENSION;
+
+  record SUBSCRIPT
+    Dimension dimension;
+  end SUBSCRIPT;
+
+  record LHS "lhs of equation/assignment" end LHS;
+  record RHS "rhs of equation/assignment" end RHS;
+  record ITERATION_RANGE end ITERATION_RANGE;
+  record BINDING end BINDING;
+  record NO_ORIGIN end NO_ORIGIN;
+
+  function next
+    "Some origins only apply to the whole expression. Tuples can for example only
+     be used on the lhs of an equation/assignment, but only if it's alone on the
+     lhs and not part of a larger expression. This function returns the next
+     appropriate origin when moving into an expression."
+    input ExpOrigin origin;
+    output ExpOrigin nextOrigin;
+  algorithm
+    nextOrigin := match origin
+      case LHS() then NO_ORIGIN();
+      case RHS() then NO_ORIGIN();
+      case ITERATION_RANGE() then NO_ORIGIN();
+      else origin;
+    end match;
+  end next;
+
+annotation(__OpenModelica_Interface="frontend");
+end NFExpOrigin;
+