Basic handling of component conditions in nfinst.

- Implemented handling of component conditions, including instantiation,
  typing and removal of component with a false condition, but not
  including removing connections to such components.

Belonging to [master]:
  - OpenModelica/OMCompiler#1992
  - OpenModelica/OpenModelica-testsuite#769

Compiler/NFFrontEnd/NFBinding.mo

@@ -104,6 +104,16 @@ public
     end match;
   end isBound;
 
+  function isUnbound
+    input Binding binding;
+    output Boolean isUnbound;
+  algorithm
+    isUnbound := match binding
+      case UNBOUND() then true;
+      else false;
+    end match;
+  end isUnbound;
+
   function untypedExp
     input Binding binding;
     output Option<Expression> exp;
@@ -120,6 +130,7 @@ public
   algorithm
     exp := match binding
       case TYPED_BINDING() then SOME(binding.bindingExp);
+      case FLAT_BINDING() then SOME(binding.bindingExp);
       else NONE();
     end match;
   end typedExp;
@@ -128,7 +139,10 @@ public
     input Binding binding;
     output Expression exp;
   algorithm
-    TYPED_BINDING(bindingExp = exp) := binding;
+    exp := match binding
+      case TYPED_BINDING() then binding.bindingExp;
+      case FLAT_BINDING() then binding.bindingExp;
+    end match;
   end getTypedExp;
 
   function setTypedExp

Compiler/NFFrontEnd/NFBuiltin.mo

@@ -233,6 +233,7 @@ constant InstNode STATESELECT_NEVER =
     Pointer.createImmutable(Component.TYPED_COMPONENT(
       InstNode.EMPTY_NODE(),
       STATESELECT_TYPE,
+      Binding.UNBOUND(),
       STATESELECT_NEVER_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
@@ -247,6 +248,7 @@ constant InstNode STATESELECT_AVOID =
     Pointer.createImmutable(Component.TYPED_COMPONENT(
       InstNode.EMPTY_NODE(),
       STATESELECT_TYPE,
+      Binding.UNBOUND(),
       STATESELECT_AVOID_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
@@ -261,6 +263,7 @@ constant InstNode STATESELECT_DEFAULT =
     Pointer.createImmutable(Component.TYPED_COMPONENT(
       InstNode.EMPTY_NODE(),
       STATESELECT_TYPE,
+      Binding.UNBOUND(),
       STATESELECT_DEFAULT_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
@@ -275,6 +278,7 @@ constant InstNode STATESELECT_PREFER =
     Pointer.createImmutable(Component.TYPED_COMPONENT(
       InstNode.EMPTY_NODE(),
       STATESELECT_TYPE,
+      Binding.UNBOUND(),
       STATESELECT_PREFER_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
@@ -289,6 +293,7 @@ constant InstNode STATESELECT_ALWAYS =
     Pointer.createImmutable(Component.TYPED_COMPONENT(
       InstNode.EMPTY_NODE(),
       STATESELECT_TYPE,
+      Binding.UNBOUND(),
       STATESELECT_ALWAYS_BINDING,
       NFComponent.CONSTANT_ATTR,
       Absyn.dummyInfo)),
@@ -313,6 +318,7 @@ constant InstNode TIME =
       REAL_NODE,
       Type.REAL(),
       Binding.UNBOUND(),
+      Binding.UNBOUND(),
       NFComponent.INPUT_ATTR,
       Absyn.dummyInfo)),
     InstNode.EMPTY_NODE());

Compiler/NFFrontEnd/NFBuiltinFuncs.mo

@@ -60,39 +60,39 @@ constant SCode.Element DUMMY_ELEMENT = SCode.COMPONENT("dummy",
 
 // Default Integer parameter.
 constant Component INT_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.INTEGER(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
+  Type.INTEGER(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode INT_PARAM = InstNode.COMPONENT_NODE("i",
   Visibility.PUBLIC,
   Pointer.createImmutable(INT_COMPONENT), InstNode.EMPTY_NODE());
 
 // Default Real parameter.
 constant Component REAL_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.REAL(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
+  Type.REAL(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode REAL_PARAM = InstNode.COMPONENT_NODE("r",
   Visibility.PUBLIC,
   Pointer.createImmutable(REAL_COMPONENT), InstNode.EMPTY_NODE());
 
 // Default Boolean parameter.
 constant Component BOOL_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.BOOLEAN(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
+  Type.BOOLEAN(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode BOOL_PARAM = InstNode.COMPONENT_NODE("b",
   Visibility.PUBLIC,
   Pointer.createImmutable(BOOL_COMPONENT), InstNode.EMPTY_NODE());
 
 // Default String parameter.
 constant Component STRING_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.STRING(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
+  Type.STRING(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode STRING_PARAM = InstNode.COMPONENT_NODE("s",
   Visibility.PUBLIC,
   Pointer.createImmutable(STRING_COMPONENT), InstNode.EMPTY_NODE());
 
 // Default enumeration(:) parameter.
 constant Component ENUM_COMPONENT = Component.TYPED_COMPONENT(NFInstNode.EMPTY_NODE(),
-  Type.ENUMERATION_ANY(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
+  Type.ENUMERATION_ANY(), Binding.UNBOUND(), Binding.UNBOUND(), Component.Attributes.DEFAULT(), Absyn.dummyInfo);
 
 constant InstNode ENUM_PARAM = InstNode.COMPONENT_NODE("e",
   Visibility.PUBLIC,

Compiler/NFFrontEnd/NFCeval.mo

@@ -60,6 +60,10 @@ uniontype EvalTarget
     SourceInfo info;
   end RANGE;
 
+  record CONDITION
+    SourceInfo info;
+  end CONDITION;
+
   record IGNORE_ERRORS end IGNORE_ERRORS;
 
   function isRange
@@ -239,6 +243,13 @@ algorithm
       then
         fail();
 
+    case EvalTarget.CONDITION()
+      algorithm
+        Error.addSourceMessage(Error.CONDITIONAL_EXP_WITHOUT_VALUE,
+          {Expression.toString(exp)}, target.info);
+      then
+        fail();
+
     else ();
   end match;
 end printUnboundError;

Compiler/NFFrontEnd/NFComponent.mo

@@ -109,6 +109,7 @@ uniontype Component
     InstNode classInst;
     array<Dimension> dimensions;
     Binding binding;
+    Binding condition;
     Component.Attributes attributes;
     SourceInfo info;
   end UNTYPED_COMPONENT;
@@ -117,6 +118,7 @@ uniontype Component
     InstNode classInst;
     Type ty;
     Binding binding;
+    Binding condition;
     Component.Attributes attributes;
     SourceInfo info;
   end TYPED_COMPONENT;
@@ -250,7 +252,8 @@ uniontype Component
   algorithm
     component := match component
       case UNTYPED_COMPONENT()
-        then TYPED_COMPONENT(component.classInst, ty, component.binding, component.attributes, component.info);
+        then TYPED_COMPONENT(component.classInst, ty, component.binding,
+          component.condition, component.attributes, component.info);
 
       case TYPED_COMPONENT()
         algorithm

Compiler/NFFrontEnd/NFExpOrigin.mo

@@ -18,6 +18,7 @@ public
   record RHS "rhs of equation/assignment" end RHS;
   record ITERATION_RANGE end ITERATION_RANGE;
   record BINDING end BINDING;
+  record CONDITION end CONDITION;
   record NO_ORIGIN end NO_ORIGIN;
 
   function next

Compiler/NFFrontEnd/NFFlatten.mo

@@ -192,7 +192,7 @@ protected
   Component c;
   Type ty;
   ComponentRef new_pre;
-  Binding binding;
+  Binding binding, condition;
   list<Dimension> dims;
   Class cls;
 algorithm
@@ -205,8 +205,13 @@ algorithm
   c := InstNode.component(comp_node);
 
   () := match c
-    case Component.TYPED_COMPONENT(ty = ty)
+    case Component.TYPED_COMPONENT(ty = ty, condition = condition)
       algorithm
+        // Don't add the component if it has a condition that's false.
+        if Binding.isBound(condition) and Expression.isFalse(Binding.getTypedExp(condition)) then
+          return;
+        end if;
+
         new_pre := ComponentRef.prefixCref(comp_node, ty, {}, prefix);
         cls := InstNode.getClass(c.classInst);
 

Compiler/NFFrontEnd/NFInst.mo

@@ -925,10 +925,11 @@ protected
   SCode.Element def;
   InstNode scp, cls, comp_node;
   Modifier mod, comp_mod;
-  Binding binding;
+  Binding binding, condition;
   DAE.Type ty;
   Component.Attributes attr, cls_attr;
   list<Dimension> dims;
+  SourceInfo info;
 algorithm
   comp_node := InstNode.resolveOuter(node);
   comp := InstNode.component(comp_node);
@@ -955,7 +956,7 @@ algorithm
       then
         ();
 
-    case (_, Component.COMPONENT_DEF(definition = def as SCode.COMPONENT()))
+    case (_, Component.COMPONENT_DEF(definition = def as SCode.COMPONENT(info = info)))
       algorithm
         comp_mod := Modifier.fromElement(def, parent);
         comp_mod := Modifier.merge(comp.modifier, comp_mod);
@@ -965,11 +966,12 @@ algorithm
         Modifier.checkEach(comp_mod, listEmpty(dims), InstNode.name(comp_node));
         binding := Modifier.binding(comp_mod);
         comp_mod := Modifier.propagate(comp_mod);
+        condition := Binding.fromAbsyn(def.condition, SCode.Each.NOT_EACH(), parent, info);
 
         // Instantiate attributes and create the untyped components.
         attr := instComponentAttributes(def.attributes, def.prefixes, attributes, comp_node);
         inst_comp := Component.UNTYPED_COMPONENT(InstNode.EMPTY_NODE(), listArray(dims),
-          binding, attr, def.info);
+          binding, condition, attr, def.info);
         InstNode.updateComponent(inst_comp, comp_node);
 
         // Instantiate the type of the component.
@@ -1239,6 +1241,7 @@ algorithm
     case Component.UNTYPED_COMPONENT(dimensions = dims)
       algorithm
         c.binding := instBinding(c.binding);
+        c.condition := instBinding(c.condition);
         instExpressions(c.classInst, node);
 
         cls_dims := Class.getDimensions(InstNode.getClass(c.classInst));

Compiler/NFFrontEnd/NFRecord.mo

@@ -92,6 +92,7 @@ algorithm
       node,
       Type.COMPLEX(node, ComplexType.CLASS()),
       Binding.UNBOUND(),
+      Binding.UNBOUND(),
       NFComponent.OUTPUT_ATTR,
       Absyn.dummyInfo)),
     node);

Compiler/NFFrontEnd/NFTyping.mo

@@ -456,7 +456,7 @@ algorithm
 end typeDimension;
 
 function typeBindings
-  input output InstNode cls;
+  input InstNode cls;
 protected
   Class c;
   ClassTree cls_tree;
@@ -524,12 +524,10 @@ algorithm
           c.binding := binding;
         end if;
 
-        cls := typeBindings(c.classInst);
+        typeBindings(c.classInst);
 
-        // The component's type can change, e.g. if it was a derived class that
-        // was resolved to its base class.
-        if not referenceEq(cls, c.classInst) then
-          c.classInst := cls;
+        if Binding.isBound(c.condition) then
+          c.condition := typeComponentCondition(c.condition);
           dirty := true;
         end if;
 
@@ -577,6 +575,42 @@ algorithm
   end match;
 end typeBinding;
 
+function typeComponentCondition
+  input output Binding condition;
+algorithm
+  condition := match condition
+    local
+      Expression exp;
+      Type ty;
+      Variability var;
+      SourceInfo info;
+      MatchKind mk;
+
+    case Binding.UNTYPED_BINDING(bindingExp = exp, info = info)
+      algorithm
+        (exp, ty, var) := typeExp(exp, info, ExpOrigin.CONDITION());
+        (exp, _, mk) := TypeCheck.matchTypes(ty, Type.BOOLEAN(), exp);
+
+        if TypeCheck.isIncompatibleMatch(mk) then
+          Error.addSourceMessage(Error.IF_CONDITION_TYPE_ERROR,
+            {Expression.toString(exp), Type.toString(ty)}, info);
+          fail();
+        end if;
+
+        if var > Variability.PARAMETER then
+          Error.addSourceMessage(Error.COMPONENT_CONDITION_VARIABILITY,
+            {Expression.toString(exp)}, info);
+          fail();
+        end if;
+
+        exp := Ceval.evalExp(exp, Ceval.EvalTarget.CONDITION(info));
+        exp := SimplifyExp.simplifyExp(exp);
+      then
+        Binding.FLAT_BINDING(exp);
+
+  end match;
+end typeComponentCondition;
+
 function typeTypeAttributes
   input output list<Modifier> attributes;
   input Type ty;