Handling of self-referencing extends in nfinst.

- Handle extending a local class via the scope itself.
- Detect some cases of extends loops.

Author: perost

Compiler/NFFrontEnd/NFInst.mo

@@ -356,6 +356,7 @@ algorithm
   // Look up the base class and expand it.
   scope := InstNode.parent(ext);
   base_node := Lookup.lookupBaseClassName(base_path, scope, info);
+  checkExtendsLoop(base_node, base_path, info);
   checkReplaceableBaseClass(base_node, base_path, info);
   base_node := expand(base_node);
 
@@ -370,6 +371,28 @@ algorithm
   end if;
 end expandExtends;
 
+function checkExtendsLoop
+  "Gives an error if a base node is in the process of being expanded itself,
+   since that means we have an extends loop in the model."
+  input InstNode node;
+  input Absyn.Path path;
+  input SourceInfo info;
+algorithm
+  () := match InstNode.getClass(node)
+    // expand begins by changing the class to an EXPANDED_CLASS, but keeps the
+    // class tree. So finding a PARTIAL_TREE here means the class is in the
+    // process of being expanded.
+    case Class.EXPANDED_CLASS(elements = ClassTree.PARTIAL_TREE())
+      algorithm
+        Error.addSourceMessage(Error.EXTENDS_LOOP,
+          {Absyn.pathString(path)}, info);
+      then
+        fail();
+
+    else ();
+  end match;
+end checkExtendsLoop;
+
 function checkReplaceableBaseClass
   "Checks that all parts of a name used as a base class are transitively
    non-replaceable."

Compiler/NFFrontEnd/NFInstNode.mo

@@ -715,6 +715,24 @@ uniontype InstNode
       case IMPLICIT_SCOPE() then IMPLICIT_SCOPE(scope, iterator :: scope.locals);
     end match;
   end addIterator;
+
+  function refEqual
+    "Returns true if two nodes references the same class or component,
+     otherwise false."
+    input InstNode node1;
+    input InstNode node2;
+    output Boolean refEqual;
+  algorithm
+    refEqual := match (node1, node2)
+      case (CLASS_NODE(), CLASS_NODE())
+        then referenceEq(Pointer.access(node1.cls), Pointer.access(node2.cls));
+      case (COMPONENT_NODE(), COMPONENT_NODE())
+        then referenceEq(Pointer.access(node1.component), Pointer.access(node2.component));
+      // Other nodes like ref nodes might be equal, but we neither know nor care.
+      else false;
+    end match;
+  end refEqual;
+
 end InstNode;
 
 annotation(__OpenModelica_Interface="frontend");

Compiler/NFFrontEnd/NFLookup.mo

@@ -338,7 +338,7 @@ algorithm
       algorithm
         (node, state) := lookupFirstIdent(name.name, scope);
       then
-        lookupLocalName(name.path, node, state);
+        lookupLocalName(name.path, node, state, InstNode.refEqual(node, scope));
 
     // Fully qualified path, start from top scope.
     case Absyn.Path.FULLYQUALIFIED()
@@ -371,6 +371,7 @@ function lookupLocalName
   input Absyn.Path name;
   input output InstNode node;
   input output LookupState state;
+  input Boolean selfReference = false;
 algorithm
   // Looking something up in a component is only legal when the name begins with
   // a component reference, and for that we use lookupCref. So if the given node
@@ -380,7 +381,11 @@ algorithm
     return;
   end if;
 
-  node := Inst.instPackage(node);
+  // If the given node extends from itself, like 'extends Modelica.Icons.***' in
+  // the MSL, then it's already being instantiated here.
+  if not selfReference then
+    node := Inst.instPackage(node);
+  end if;
 
   // Look up the path in the scope.
   () := match name

Compiler/Util/Error.mo

@@ -164,8 +164,8 @@ public constant Message REM_ARG_ZERO = MESSAGE(17, TRANSLATION(), ERROR(),
   Util.gettext("Second argument in rem is zero in rem(%s,%s)."));
 public constant Message SCRIPT_READ_SIM_RES_ERROR = MESSAGE(18, SCRIPTING(), ERROR(),
   Util.gettext("Error reading simulation result."));
-public constant Message RECURSIVE_EXTENDS = MESSAGE(19, TRANSLATION(), ERROR(),
-  Util.gettext("Extending %s is not allowed, since it is an enclosing class."));
+public constant Message EXTENDS_LOOP = MESSAGE(19, TRANSLATION(), ERROR(),
+  Util.gettext("extends %s causes an instantiation loop."));
 public constant Message LOAD_MODEL_ERROR = MESSAGE(20, TRANSLATION(), ERROR(),
   Util.gettext("Class %s not found."));
 public constant Message WRITING_FILE_ERROR = MESSAGE(21, SCRIPTING(), ERROR(),