[NF] Handle derived class bindings better.

Belonging to [master]:
  - OpenModelica/OMCompiler#2107
  - OpenModelica/OpenModelica-testsuite#821

Compiler/NFFrontEnd/NFBinding.mo

@@ -36,35 +36,35 @@ public
   import SCode;
   import Type = NFType;
   import NFPrefixes.Variability;
+  import BindingOrigin = NFBindingOrigin;
 
 protected
   import Dump;
   import Binding = NFBinding;
 
 public
+  type Origin = enumeration(COMPONENT, EXTENDS, CLASS);
+
   record UNBOUND end UNBOUND;
 
   record RAW_BINDING
     Absyn.Exp bindingExp;
     InstNode scope;
-    Integer originLevel;
-    SourceInfo info;
+    BindingOrigin origin;
   end RAW_BINDING;
 
   record UNTYPED_BINDING
     Expression bindingExp;
     Boolean isProcessing;
     InstNode scope;
-    Integer originLevel;
-    SourceInfo info;
+    BindingOrigin origin;
   end UNTYPED_BINDING;
 
   record TYPED_BINDING
     Expression bindingExp;
     Type bindingType;
     Variability variability;
-    Integer originLevel;
-    SourceInfo info;
+    BindingOrigin origin;
   end TYPED_BINDING;
 
   record FLAT_BINDING
@@ -78,14 +78,15 @@ public
     input Integer level;
     input InstNode scope;
     input SourceInfo info;
+    input BindingOrigin.ElementType ty = NFBindingOrigin.ElementType.COMPONENT;
     output Binding binding;
   algorithm
     binding := match bindingExp
       local
         Absyn.Exp exp;
 
       case SOME(exp)
-        then RAW_BINDING(exp, scope, if eachPrefix then -level else level, info);
+        then RAW_BINDING(exp, scope, BindingOrigin.create(eachPrefix, level, ty, info));
 
       else UNBOUND();
     end match;
@@ -168,12 +169,23 @@ public
   algorithm
     info := match binding
       case UNBOUND() then Absyn.dummyInfo;
-      case RAW_BINDING() then binding.info;
-      case UNTYPED_BINDING() then binding.info;
-      case TYPED_BINDING() then binding.info;
+      case RAW_BINDING() then binding.origin.info;
+      case UNTYPED_BINDING() then binding.origin.info;
+      case TYPED_BINDING() then binding.origin.info;
     end match;
   end getInfo;
 
+  function getOrigin
+    input Binding binding;
+    output BindingOrigin origin;
+  algorithm
+    origin := match binding
+      case RAW_BINDING() then binding.origin;
+      case UNTYPED_BINDING() then binding.origin;
+      case TYPED_BINDING() then binding.origin;
+    end match;
+  end getOrigin;
+
   function getType
     input Binding binding;
     output Type ty;
@@ -186,9 +198,9 @@ public
     output Boolean isEach;
   algorithm
     isEach := match binding
-      case RAW_BINDING() then binding.originLevel < 0;
-      case UNTYPED_BINDING() then binding.originLevel < 0;
-      case TYPED_BINDING() then binding.originLevel < 0;
+      case RAW_BINDING() then BindingOrigin.isEach(binding.origin);
+      case UNTYPED_BINDING() then BindingOrigin.isEach(binding.origin);
+      case TYPED_BINDING() then BindingOrigin.isEach(binding.origin);
       else false;
     end match;
   end isEach;

Compiler/NFFrontEnd/NFBindingOrigin.mo

@@ -0,0 +1,82 @@
+/*
+ * This file is part of OpenModelica.
+ *
+ * Copyright (c) 1998-2014, Open Source Modelica Consortium (OSMC),
+ * c/o Linköpings universitet, Department of Computer and Information Science,
+ * SE-58183 Linköping, Sweden.
+ *
+ * All rights reserved.
+ *
+ * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF GPL VERSION 3 LICENSE OR
+ * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.2.
+ * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES
+ * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GPL VERSION 3,
+ * ACCORDING TO RECIPIENTS CHOICE.
+ *
+ * The OpenModelica software and the Open Source Modelica
+ * Consortium (OSMC) Public License (OSMC-PL) are obtained
+ * from OSMC, either from the above address,
+ * from the URLs: http://www.ida.liu.se/projects/OpenModelica or
+ * http://www.openmodelica.org, and in the OpenModelica distribution.
+ * GNU version 3 is obtained from: http://www.gnu.org/copyleft/gpl.html.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without
+ * even the implied warranty of  MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY SET FORTH
+ * IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF OSMC-PL.
+ *
+ * See the full OSMC Public License conditions for more details.
+ *
+ */
+
+encapsulated uniontype NFBindingOrigin
+  import NFModifier.ModifierScope;
+
+protected
+  import BindingOrigin = NFBindingOrigin;
+
+public
+  type ElementType = enumeration(COMPONENT, EXTENDS, CLASS);
+
+  record ORIGIN
+    Integer level;
+    ElementType ty;
+    SourceInfo info;
+  end ORIGIN;
+
+  function create
+    input Boolean eachPrefix;
+    input Integer level;
+    input ElementType ty;
+    input SourceInfo info;
+    output BindingOrigin origin;
+  algorithm
+    origin := ORIGIN(if eachPrefix then -level else level, ty, info);
+  end create;
+
+  function level
+    input BindingOrigin origin;
+    output Integer level = origin.level;
+  end level;
+
+  function isEach
+    input BindingOrigin origin;
+    output Boolean isEach = origin.level < 0;
+  end isEach;
+
+  function info
+    input BindingOrigin origin;
+    output SourceInfo info = origin.info;
+  end info;
+
+  function isFromClass
+    input BindingOrigin origin;
+    output Boolean fromClass;
+  protected
+    ElementType ty = origin.ty;
+  algorithm
+    fromClass := ty == ElementType.CLASS;
+  end isFromClass;
+
+  annotation(__OpenModelica_Interface="frontend");
+end NFBindingOrigin;

Compiler/NFFrontEnd/NFBuiltin.mo

@@ -44,6 +44,7 @@ public
 import Absyn;
 import SCode;
 import Binding = NFBinding;
+import BindingOrigin = NFBindingOrigin;
 import NFClass.Class;
 import NFClassTree;
 import NFComponent.Component;
@@ -196,40 +197,35 @@ constant Binding STATESELECT_NEVER_BINDING =
     Expression.ENUM_LITERAL(STATESELECT_TYPE, "never", 1),
     STATESELECT_TYPE,
     Variability.CONSTANT,
-    -1,
-    Absyn.dummyInfo);
+    BindingOrigin.ORIGIN(-1, NFBindingOrigin.ElementType.CLASS, Absyn.dummyInfo));
 
 constant Binding STATESELECT_AVOID_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE, "avoid", 2),
     STATESELECT_TYPE,
     Variability.CONSTANT,
-    -1,
-    Absyn.dummyInfo);
+    BindingOrigin.ORIGIN(-1, NFBindingOrigin.ElementType.CLASS, Absyn.dummyInfo));
 
 constant Binding STATESELECT_DEFAULT_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE, "default", 3),
     STATESELECT_TYPE,
     Variability,
-    -1,
-    Absyn.dummyInfo);
+    BindingOrigin.ORIGIN(-1, NFBindingOrigin.ElementType.CLASS, Absyn.dummyInfo));
 
 constant Binding STATESELECT_PREFER_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE, "prefer", 4),
     STATESELECT_TYPE,
     Variability.CONSTANT,
-    -1,
-    Absyn.dummyInfo);
+    BindingOrigin.ORIGIN(-1, NFBindingOrigin.ElementType.CLASS, Absyn.dummyInfo));
 
 constant Binding STATESELECT_ALWAYS_BINDING =
   Binding.TYPED_BINDING(
     Expression.ENUM_LITERAL(STATESELECT_TYPE, "always", 5),
     STATESELECT_TYPE,
     Variability.CONSTANT,
-    -1,
-    Absyn.dummyInfo);
+    BindingOrigin.ORIGIN(-1, NFBindingOrigin.ElementType.CLASS, Absyn.dummyInfo));
 
 constant InstNode STATESELECT_NEVER =
   InstNode.COMPONENT_NODE("never",

Compiler/NFFrontEnd/NFCeval.mo

@@ -59,8 +59,7 @@ uniontype EvalTarget
   end DIMENSION;
 
   record ATTRIBUTE
-    Expression exp;
-    SourceInfo info;
+    Binding binding;
   end ATTRIBUTE;
 
   record RANGE
@@ -102,7 +101,7 @@ uniontype EvalTarget
   algorithm
     info := match target
       case DIMENSION() then target.info;
-      case ATTRIBUTE() then target.info;
+      case ATTRIBUTE() then Binding.getInfo(target.binding);
       case RANGE() then target.info;
       case CONDITION() then target.info;
     end match;

Compiler/NFFrontEnd/NFExpressionIterator.mo

@@ -33,6 +33,7 @@ encapsulated uniontype NFExpressionIterator
 protected
   import ExpressionIterator = NFExpressionIterator;
   import ComponentRef = NFComponentRef;
+  import BindingOrigin = NFBindingOrigin;
 
 public
   import Expression = NFExpression;
@@ -103,8 +104,8 @@ public
   algorithm
     iterator := match binding
       case Binding.TYPED_BINDING()
-        then if binding.originLevel > 0 then
-          fromExp(binding.bindingExp) else EACH_ITERATOR(binding.bindingExp);
+        then if BindingOrigin.isEach(binding.origin) or BindingOrigin.isFromClass(binding.origin) then
+          EACH_ITERATOR(binding.bindingExp) else fromExp(binding.bindingExp);
 
       case Binding.FLAT_BINDING()
         then SCALAR_ITERATOR(binding.bindingExp);

Compiler/NFFrontEnd/NFFlatten.mo

@@ -77,6 +77,7 @@ import ComplexType = NFComplexType;
 import NFInstNode.CachedData;
 import NFPrefixes.Variability;
 import Variable = NFVariable;
+import BindingOrigin = NFBindingOrigin;
 
 public
 type FunctionTree = FunctionTreeImpl.Tree;
@@ -335,13 +336,16 @@ algorithm
   () := match binding
     local
       list<Subscript> subs;
+      Integer binding_level;
 
     case Binding.UNBOUND() then ();
 
     case Binding.TYPED_BINDING()
       algorithm
-        if binding.originLevel > 0 then
-          subs := List.flatten(ComponentRef.subscriptsN(prefix, InstNode.level(component) - binding.originLevel));
+        binding_level := BindingOrigin.level(binding.origin);
+
+        if binding_level > 0 then
+          subs := List.flatten(ComponentRef.subscriptsN(prefix, InstNode.level(component) - binding_level));
           binding.bindingExp := Expression.subscript(binding.bindingExp, subs);
         end if;
       then

Compiler/NFFrontEnd/NFInst.mo

@@ -92,6 +92,7 @@ import ComplexType = NFComplexType;
 import Package = NFPackage;
 import NFFunction.Function;
 import FlatModel = NFFlatModel;
+import BindingOrigin = NFBindingOrigin;
 
 type EquationScope = enumeration(NORMAL, INITIAL, WHEN);
 
@@ -1464,9 +1465,9 @@ algorithm
 
     case Binding.RAW_BINDING()
       algorithm
-        bind_exp := instExp(binding.bindingExp, binding.scope, binding.info);
+        bind_exp := instExp(binding.bindingExp, binding.scope, BindingOrigin.info(binding.origin));
       then
-        Binding.UNTYPED_BINDING(bind_exp, false, binding.scope, binding.originLevel, binding.info);
+        Binding.UNTYPED_BINDING(bind_exp, false, binding.scope, binding.origin);
 
     else binding;
   end match;

Compiler/NFFrontEnd/NFModifier.mo

@@ -116,15 +116,17 @@ uniontype ModifierScope
     end match;
   end toString;
 
-  function isClass
+  function toElementType
     input ModifierScope scope;
-    output Boolean isClass;
+    output ElementType origin;
+    import NFBindingOrigin.ElementType;
   algorithm
-    isClass := match scope
-      case CLASS() then true;
-      else false;
+    origin := match scope
+      case COMPONENT() then ElementType.COMPONENT;
+      case CLASS() then ElementType.CLASS;
+      case EXTENDS() then ElementType.EXTENDS;
     end match;
-  end isClass;
+  end toElementType;
 end ModifierScope;
 
 uniontype Modifier
@@ -169,8 +171,9 @@ public
 
       case SCode.MOD()
         algorithm
-          is_each := SCode.eachBool(mod.eachPrefix) or ModifierScope.isClass(modScope);
-          binding := Binding.fromAbsyn(mod.binding, is_each, level, scope, mod.info);
+          is_each := SCode.eachBool(mod.eachPrefix);
+          binding := Binding.fromAbsyn(mod.binding, is_each, level,
+             scope, mod.info, ModifierScope.toElementType(modScope));
           lvl := if is_each then level + 1 else level;
           submod_lst := list((m.ident, createSubMod(m, modScope, lvl, scope)) for m in mod.subModLst);
           submod_table := ModTable.fromList(submod_lst,

Compiler/NFFrontEnd/NFTypeCheck.mo

@@ -61,6 +61,7 @@ import DAEUtil;
 import Prefixes = NFPrefixes;
 import Restriction = NFRestriction;
 import ComplexType = NFComplexType;
+import BindingOrigin = NFBindingOrigin;
 
 public
 type MatchKind = enumeration(
@@ -2426,15 +2427,17 @@ algorithm
       Type ty, comp_ty;
       InstNode parent;
       list<Dimension> dims;
+      Integer binding_level;
 
     case Binding.TYPED_BINDING()
       algorithm
         comp_ty := componentType;
+        binding_level := BindingOrigin.level(binding.origin);
 
-        if binding.originLevel >= 0 then
+        if binding_level >= 0 then
           parent := component;
 
-          for i in 1:InstNode.level(component) - binding.originLevel loop
+          for i in 1:InstNode.level(component) - binding_level loop
             parent := InstNode.parent(component);
             dims := Type.arrayDims(InstNode.getType(parent));
             comp_ty := Type.liftArrayLeftList(comp_ty, dims);
@@ -2446,10 +2449,10 @@ algorithm
         if not isCompatibleMatch(ty_match) then
           Error.addSourceMessage(Error.VARIABLE_BINDING_TYPE_MISMATCH,
             {name, Binding.toString(binding), Type.toString(comp_ty),
-             Type.toString(binding.bindingType)}, binding.info);
+             Type.toString(binding.bindingType)}, Binding.getInfo(binding));
           fail();
         elseif isCastMatch(ty_match) then
-          binding := Binding.TYPED_BINDING(exp, ty, binding.variability, binding.originLevel, binding.info);
+          binding := Binding.TYPED_BINDING(exp, ty, binding.variability, binding.origin);
         end if;
       then
         ();