inner/outer handling for nfinst.

- Implemented handling of inner/outer, including automatic generation
  of inner elements when missing.
- Moved setting the type of a component from instComponent to
  instClass, to allow lookup in a component's parent component
  during instantiation.
- Fixed scoping of builtin variables (i.e. time), to avoid them
  being incorrectly prefixed.
- Fixed lookup of self-referencing extends and added check for
  inherited base classes.

Author: perost

Compiler/FrontEnd/SCode.mo

@@ -3871,6 +3871,24 @@ algorithm
   end match;
 end isNotBuiltinClass;
 
+public function getElementNamedAnnotation
+  "Returns the annotation with the given name in the element, or fails if no
+   such annotation could be found."
+  input Element element;
+  input String name;
+  output Absyn.Exp exp;
+protected
+  Annotation ann;
+algorithm
+  ann := match element
+    case EXTENDS(ann = SOME(ann)) then ann;
+    case CLASS(cmt = COMMENT(annotation_ = SOME(ann))) then ann;
+    case COMPONENT(comment = COMMENT(annotation_ = SOME(ann))) then ann;
+  end match;
+
+  exp := getNamedAnnotation(ann, name);
+end getElementNamedAnnotation;
+
 public function getNamedAnnotation
   "Checks if the given annotation contains an entry with the given name with the
    value true."

Compiler/NFFrontEnd/NFClassTree.mo

@@ -43,6 +43,8 @@ protected
   import NFComponent.Component;
   import Inst = NFInst;
   import List;
+  import Lookup = NFLookup;
+  import SCodeDump;
 
 public
   encapsulated package LookupTree
@@ -445,8 +447,9 @@ public
       array<Mutable<InstNode>> clss, comps, ext_clss;
       list<Integer> local_comps = {};
       Integer cls_idx = 1, comp_idx = 1, cls_count, comp_count;
-      InstNode node;
+      InstNode node, parent_scope, inner_node;
       DuplicateTree.Tree dups;
+      Component comp;
     algorithm
       // TODO: If we don't have any extends we could probably generate a flat
       // tree directly and skip a lot of this.
@@ -461,6 +464,9 @@ public
             // If the instance is an empty node, use the cloned clsNode as the instance.
             if InstNode.isEmpty(instance) then
               instance := clsNode;
+              parent_scope := InstNode.parent(clsNode);
+            else
+              parent_scope := instance;
             end if;
 
             // Fetch the elements from the class tree.
@@ -490,6 +496,14 @@ public
             // class we're instantiating to be their parent.
             for c in old_clss loop
               c := InstNode.setParent(clsNode, c);
+
+              // If the class is outer, check that it's valid and link it with
+              // the corresponding inner class.
+              if InstNode.isOuter(c) then
+                checkOuterClass(c);
+                c := linkInnerOuter(c, parent_scope);
+              end if;
+
               arrayUpdateNoBoundsChecking(clss, cls_idx, Mutable.create(c));
               cls_idx := cls_idx + 1;
             end for;
@@ -513,9 +527,18 @@ public
               () := match c
                 case InstNode.COMPONENT_NODE()
                   algorithm
-                    // Set the components parent and create a unique instance for it.
+                    // Set the component's parent and create a unique instance for it.
                     node := InstNode.setParent(instance, c);
-                    node := InstNode.replaceComponent(InstNode.component(node), node);
+                    comp := InstNode.component(node);
+                    node := InstNode.replaceComponent(comp, node);
+
+                    // If the component is outer, link it with the corresponding
+                    // inner component.
+                    if Component.isOuter(comp) then
+                      node := linkInnerOuter(node, instance);
+                    end if;
+
+                    // Add the node to the component array.
                     arrayUpdateNoBoundsChecking(comps, comp_idx, Mutable.create(node));
                     local_comps := comp_idx :: local_comps;
                     comp_idx := comp_idx + 1;
@@ -574,6 +597,36 @@ public
       end match;
     end replaceDuplicates;
 
+    function appendComponentsToInstTree
+      "Appens a list of local components to an instantiated class tree."
+      input list<Mutable<InstNode>> components;
+      input output ClassTree tree;
+    algorithm
+      if listEmpty(components) then
+        return;
+      else
+        () := match tree
+          local
+            Integer comp_idx;
+            list<Integer> local_comps;
+
+          case INSTANTIATED_TREE()
+            algorithm
+              comp_idx := arrayLength(tree.components);
+              tree.components := Array.appendList(tree.components, components);
+              local_comps := tree.localComponents;
+
+              for i in comp_idx+1:comp_idx+listLength(components) loop
+                local_comps := i :: local_comps;
+              end for;
+
+              tree.localComponents := local_comps;
+            then
+              ();
+        end match;
+      end if;
+    end appendComponentsToInstTree;
+
     function flatten
       input output ClassTree tree;
     algorithm
@@ -1512,6 +1565,63 @@ public
       entry.children := list(replaceDuplicates3(c, parent, tree) for c in entry.children);
     end replaceDuplicates3;
 
+    function linkInnerOuter
+      "Looks up the corresponding inner node for the given outer node,
+       and returns an INNER_OUTER_NODE containing them both."
+      input InstNode outerNode;
+      input InstNode scope;
+      output InstNode innerOuterNode;
+    protected
+      InstNode inner_node;
+    algorithm
+      inner_node := Lookup.lookupInner(outerNode, scope);
+
+      // Make sure we found a node of the same kind.
+      if valueConstructor(outerNode) <> valueConstructor(inner_node) then
+        Error.addMultiSourceMessage(Error.FOUND_WRONG_INNER_ELEMENT,
+          {InstNode.typeName(inner_node), InstNode.name(outerNode), InstNode.typeName(outerNode)},
+          {InstNode.info(outerNode), InstNode.info(inner_node)});
+        fail();
+      end if;
+
+      innerOuterNode := InstNode.INNER_OUTER_NODE(inner_node, outerNode);
+    end linkInnerOuter;
+
+    function checkOuterClass
+      "Checks that a class used as outer is valid, i.e. is a short class
+       definition with no modifier."
+      input InstNode outerCls;
+    protected
+      SCode.ClassDef def;
+    algorithm
+      if InstNode.isOnlyOuter(outerCls) then
+        def := SCode.getClassDef(InstNode.definition(outerCls));
+
+        () := match def
+          // Outer short class definition without mod is ok.
+          case SCode.ClassDef.DERIVED(modifications = SCode.Mod.NOMOD()) then ();
+
+          // Outer short class definition with mod is an error.
+          case SCode.ClassDef.DERIVED()
+            algorithm
+              Error.addSourceMessage(Error.OUTER_ELEMENT_MOD,
+                {SCodeDump.printModStr(def.modifications), InstNode.name(outerCls)},
+                InstNode.info(outerCls));
+            then
+              fail();
+
+          // Outer long class definition is an error.
+          else
+            algorithm
+              Error.addSourceMessage(Error.OUTER_LONG_CLASS,
+                {InstNode.name(outerCls)}, InstNode.info(outerCls));
+            then
+              fail();
+
+        end match;
+      end if;
+    end checkOuterClass;
+
   end ClassTree;
 
 annotation(__OpenModelica_Interface="frontend");

Compiler/NFFrontEnd/NFComponent.mo

@@ -41,11 +41,12 @@ import SCode.Element;
 import SCode;
 import Type = NFType;
 import Expression = NFExpression;
-import NFPrefixes.Variability;
+import NFPrefixes.{Variability, InnerOuter};
 
 protected
 import NFInstUtil;
 import List;
+import Prefixes = NFPrefixes;
 
 public
 constant Component.Attributes CONST_ATTR =
@@ -54,7 +55,7 @@ constant Component.Attributes CONST_ATTR =
      DAE.NON_PARALLEL(),
      Variability.CONTINUOUS,
      DAE.BIDIR(),
-     DAE.NOT_INNER_OUTER(),
+     InnerOuter.NOT_INNER_OUTER,
      DAE.PUBLIC());
 
 constant Component.Attributes INPUT_ATTR =
@@ -63,7 +64,7 @@ constant Component.Attributes INPUT_ATTR =
      DAE.NON_PARALLEL(),
      Variability.CONTINUOUS,
      DAE.INPUT(),
-     DAE.NOT_INNER_OUTER(),
+     InnerOuter.NOT_INNER_OUTER,
      DAE.PUBLIC());
 
 constant Component.Attributes OUTPUT_ATTR =
@@ -72,7 +73,7 @@ constant Component.Attributes OUTPUT_ATTR =
      DAE.NON_PARALLEL(),
      Variability.CONTINUOUS,
      DAE.OUTPUT(),
-     DAE.NOT_INNER_OUTER(),
+     InnerOuter.NOT_INNER_OUTER,
      DAE.PUBLIC());
 
 uniontype Component
@@ -83,7 +84,7 @@ uniontype Component
       DAE.VarParallelism parallelism;
       Variability variability;
       DAE.VarDirection direction;
-      DAE.VarInnerOuter innerOuter;
+      InnerOuter innerOuter;
       DAE.VarVisibility visibility;
     end ATTRIBUTES;
 
@@ -376,7 +377,7 @@ uniontype Component
 
   function isVar
     input Component component;
-    output Boolean isConst = variability(component) == Variability.CONTINUOUS;
+    output Boolean isVar = variability(component) == Variability.CONTINUOUS;
   end isVar;
 
   function visibility
@@ -404,6 +405,54 @@ uniontype Component
     end match;
   end isPublic;
 
+  function isRedeclare
+    input Component component;
+    output Boolean isRedeclare;
+  algorithm
+    isRedeclare := match component
+      case COMPONENT_DEF() then SCode.isElementRedeclare(component.definition);
+      case UNTYPED_COMPONENT() then component.isRedeclare;
+      else false;
+    end match;
+  end isRedeclare;
+
+  function innerOuter
+    input Component component;
+    output InnerOuter io;
+  algorithm
+    io := match component
+      case UNTYPED_COMPONENT(attributes = Attributes.ATTRIBUTES(innerOuter = io)) then io;
+      case TYPED_COMPONENT(attributes = Attributes.ATTRIBUTES(innerOuter = io)) then io;
+      case COMPONENT_DEF()
+        then Prefixes.innerOuterFromSCode(SCode.prefixesInnerOuter(
+          SCode.elementPrefixes(component.definition)));
+      else InnerOuter.NOT_INNER_OUTER;
+    end match;
+  end innerOuter;
+
+  function isInner
+    input Component component;
+    output Boolean isInner;
+  protected
+    InnerOuter io = innerOuter(component);
+  algorithm
+    isInner := io == InnerOuter.INNER or io == InnerOuter.INNER_OUTER;
+  end isInner;
+
+  function isOuter
+    input Component component;
+    output Boolean isOuter;
+  protected
+    InnerOuter io = innerOuter(component);
+  algorithm
+    isOuter := io == InnerOuter.OUTER or io == InnerOuter.INNER_OUTER;
+  end isOuter;
+
+  function isOnlyOuter
+    input Component component;
+    output Boolean isOuter = innerOuter(component) == InnerOuter.OUTER;
+  end isOnlyOuter;
+
   function isIdentical
     input Component comp1;
     input Component comp2;
@@ -448,17 +497,6 @@ uniontype Component
     end match;
   end toString;
 
-  function isRedeclare
-    input Component component;
-    output Boolean isRedeclare;
-  algorithm
-    isRedeclare := match component
-      case COMPONENT_DEF() then SCode.isElementRedeclare(component.definition);
-      case UNTYPED_COMPONENT() then component.isRedeclare;
-      else false;
-    end match;
-  end isRedeclare;
-
   function dimensionCount
     input Component component;
     output Integer count;

Compiler/NFFrontEnd/NFFlatten.mo

@@ -167,7 +167,7 @@ function flattenComponent
 
   import Origin = NFComponentRef.Origin;
 protected
-  Component c = InstNode.component(component);
+  Component c;
   ComponentRef new_pre;
   Type ty;
   Option<Expression> binding_exp;
@@ -176,6 +176,19 @@ protected
   list<Dimension> dims;
   Equation binding_eq;
 algorithm
+  if InstNode.isInnerOuterNode(component) then
+    // If we get an outer component, flatten it if it's also inner.
+    if InstNode.isInner(component) then
+      c := InstNode.component(InstNode.resolveOuter(component));
+    else
+      // If it's only outer we skip it since we don't want outer component in the DAE.
+      return;
+    end if;
+  else
+    // A non-outer component, proceed as normal.
+    c := InstNode.component(component);
+  end if;
+
   _ := match c
     case Component.TYPED_COMPONENT()
       algorithm

Compiler/NFFrontEnd/NFFunction.mo

@@ -36,7 +36,7 @@ import Expression = NFExpression;
 import Pointer;
 import NFInstNode.InstNode;
 import Type = NFType;
-import NFPrefixes.Variability;
+import NFPrefixes.{Variability, InnerOuter};
 
 protected
 import Inst = NFInst;
@@ -769,7 +769,7 @@ protected
     output DAE.VarDirection direction;
   protected
     DAE.ConnectorType cty;
-    DAE.VarInnerOuter io;
+    InnerOuter io;
     DAE.VarVisibility vis;
   algorithm
     Component.Attributes.ATTRIBUTES(
@@ -793,16 +793,12 @@ protected
     end match;
 
     // Function components may not be inner/outer.
-    () := match io
-      case DAE.VarInnerOuter.NOT_INNER_OUTER() then ();
-      else
-        algorithm
-          Error.addSourceMessage(Error.INNER_OUTER_FORMAL_PARAMETER,
-            {DAEDump.unparseVarInnerOuter(io), InstNode.name(component)},
-            InstNode.info(component));
-        then
-          fail();
-    end match;
+    if io <> InnerOuter.NOT_INNER_OUTER then
+      Error.addSourceMessage(Error.INNER_OUTER_FORMAL_PARAMETER,
+        {Prefixes.innerOuterString(io), InstNode.name(component)},
+        InstNode.info(component));
+      fail();
+    end if;
 
     // Formal parameters must be public, other function variables must be protected.
     () := match (direction, vis)