partial implementation of class extends

- the class extends changes are not applied to the baseclass, only the local scope
- check if this is the correct way to implement this, or we actually need to replace in the base class

Author: adrpo

Compiler/Global/Global.mo

@@ -76,6 +76,8 @@ constant Integer fgraph_nextId = 22;
 constant Integer backendDAE_cseIndex = 23;
 // strong component index
 constant Integer strongComponent_index = 24;
+// class extends
+constant Integer classExtends_index = 25;
 
 // ----------------------
 

Compiler/NFFrontEnd/NFInst.mo

@@ -59,12 +59,14 @@ protected
 import Array;
 import Error;
 import Flatten = NFFlatten;
+import Global;
 import InstUtil = NFInstUtil;
 import List;
 import Lookup = NFLookup;
 import MetaModelica.Dangerous;
 import Typing = NFTyping;
 import ExecStat.{execStat,execStatReset};
+import System;
 
 public
 function instClassInProgram
@@ -431,6 +433,13 @@ algorithm
       then
         node;
 
+    case SCode.CLASS(classDef = cdef as SCode.CLASS_EXTENDS())
+      algorithm
+        // get the already existing classes with the same name
+        print("Got class extends: " + def.name + "\n");
+      then
+        fail();
+
     else
       algorithm
         assert(false, getInstanceName() + " got unknown class");
@@ -732,9 +741,31 @@ function addInheritedElements2
   input ClassTree.Tree inScope;
   input Integer nodeIndex;
   output ClassTree.Tree scope;
+protected
+  SCode.Element c;
+  ClassTree.Entry idExisting;
+  InstNode nodeExisting;
 algorithm
   scope := match id
-    case ClassTree.Entry.CLASS() then ClassTree.add(inScope, name, id);
+    case ClassTree.Entry.CLASS()
+      algorithm
+        // check if class exists!
+        try
+          (idExisting as ClassTree.Entry.CLASS(nodeExisting)) := ClassTree.get(inScope, name);
+          c := InstNode.definition(nodeExisting);
+          scope := match c
+            // is it a class extends?
+            case SCode.CLASS(classDef = SCode.CLASS_EXTENDS())
+              then adaptClassExtendsChain(name, idExisting, id, inScope);
+            // TODO! FIXME! this seems to be a duplicate class definition, add an error
+            else
+              then ClassTree.add(inScope, name, id);
+          end match;
+        else
+          scope := ClassTree.add(inScope, name, id);
+        end try;
+      then
+        scope;
     case ClassTree.Entry.COMPONENT(node = 0)
       then ClassTree.add(inScope, name, ClassTree.Entry.COMPONENT(nodeIndex, id.index));
     else inScope;
@@ -1388,5 +1419,155 @@ algorithm
   end match;
 end instStatement;
 
+function adaptClassExtendsChain
+"@author: adrpo
+ handle class extends
+ 1. see if we already have a class with the same name
+ 2. patch the existing class with a new name Model_$ce$number
+ 3. patch the current class extends with an extends to the Model_$extends_number and change it to a normal class"
+  input String name;
+  input ClassTree.Entry idExisting "the class extends";
+  input ClassTree.Entry id "the base class";
+  input ClassTree.Tree inScope;
+  output ClassTree.Tree scope;
+protected
+  SCode.Element new, existing;
+  InstNode newNode, nodeExisting;
+  String newName;
+  Integer ceTick = System.tmpTickIndex(Global.classExtends_index);
+algorithm
+  scope := match id
+    case ClassTree.Entry.CLASS()
+      algorithm
+        // get the class extends class
+        newNode := id.node;
+        new := InstNode.definition(id.node);
+        /* this doen't seem to work to check for the baseclass
+           as WE HAVE the baseclass and we are searching for the
+           class extends. Somehow this needs to be handled the
+           other way, from class extends to the base class!
+        // get the existing base class
+        try
+          idExisting := ClassTree.get(inScope, name);
+        else
+          // report that the target of class extends does not exist!
+          Error.addSourceMessageAndFail(Error.CLASS_EXTENDS_TARGET_NOT_FOUND, {name}, SCode.elementInfo(new));
+        end try;*/
+        ClassTree.Entry.CLASS(nodeExisting) := idExisting;
+        // get the existing class in the environment
+        existing := InstNode.definition(nodeExisting);
+        // TODO! FIXME! check if the base class (id) is replaceable and add an error if not
+        // Error.NON_REPLACEABLE_CLASS_EXTENDS
+        newName := name + "$ce$" + String(ceTick);
+        // patch the base class and the class extends!
+        (new, existing) := patchBaseClassAndClassExtends(newName, name, new, existing);
+        // update nodes!
+        newNode := InstNode.rename(newNode, newName);
+        newNode := InstNode.setDefinition(new, newNode);
+        nodeExisting := InstNode.setDefinition(existing, nodeExisting);
+
+        // do partial instantiation again TODO! FIXME! is this needed??!!
+        newNode := partialInstClass(newNode);
+        nodeExisting := partialInstClass(nodeExisting);
+
+        // replace the class extends with the new definition
+        scope := ClassTree.add(inScope, name, ClassTree.Entry.CLASS(nodeExisting), ClassTree.addConflictReplace);
+
+        // add the base class with the new name to the scope
+        scope := ClassTree.add(scope, newName, ClassTree.Entry.CLASS(newNode));
+      then
+        scope;
+
+    else inScope;
+  end match;
+end adaptClassExtendsChain;
+
+protected function patchBaseClassAndClassExtends
+  input String inBaseEltName;
+  input String inClassExtendsEltName;
+  input SCode.Element inBaseElt;
+  input SCode.Element inClassExtendsElt;
+  output SCode.Element outBaseElt;
+  output SCode.Element outClassExtendsElt;
+algorithm
+  (outBaseElt,outClassExtendsElt) := matchcontinue (inBaseElt,inClassExtendsElt)
+    local
+      SCode.Element elt,compelt,classExtendsElt;
+      SCode.Element cl;
+      SCode.ClassDef classDef,classExtendsCdef;
+      SCode.Partial partialPrefix1,partialPrefix2;
+      SCode.Encapsulated encapsulatedPrefix1,encapsulatedPrefix2;
+      SCode.Restriction restriction1,restriction2;
+      SCode.Prefixes prefixes1,prefixes2;
+      SCode.Visibility vis2;
+      String name1,name2,env_path;
+      Option<SCode.ExternalDecl> externalDecl1,externalDecl2;
+      list<SCode.Annotation> annotationLst1,annotationLst2;
+      SCode.Comment comment1,comment2;
+      Option<SCode.Annotation> ann1,ann2;
+      list<SCode.Element> els1,els2;
+      list<SCode.Equation> nEqn1,nEqn2,inEqn1,inEqn2;
+      list<SCode.AlgorithmSection> nAlg1,nAlg2,inAlg1,inAlg2;
+      list<SCode.ConstraintSection> inCons1, inCons2;
+      list<Absyn.NamedArg> clats;
+      list<tuple<SCode.Element, DAE.Mod, Boolean>> rest;
+      tuple<SCode.Element, DAE.Mod, Boolean> first;
+      SCode.Mod mods, derivedMod;
+      DAE.Mod mod1,emod;
+      SourceInfo info1, info2;
+      Boolean b;
+      SCode.Attributes attrs;
+      Absyn.TypeSpec derivedTySpec;
+
+    // found the base class with parts
+    case (cl as SCode.CLASS(name = name2, classDef = SCode.PARTS()), classExtendsElt)
+      equation
+        name1 = inClassExtendsEltName;
+        name2 = inBaseEltName;
+
+        SCode.CLASS(_,prefixes2,encapsulatedPrefix2,partialPrefix2,restriction2,SCode.PARTS(els2,nEqn2,inEqn2,nAlg2,inAlg2,inCons2,clats,externalDecl2),comment2,info2) = cl;
+
+        SCode.CLASS(_, prefixes1, encapsulatedPrefix1, partialPrefix1, restriction1, classExtendsCdef, comment1, info1) = classExtendsElt;
+        SCode.CLASS_EXTENDS(_,mods,SCode.PARTS(els1,nEqn1,inEqn1,nAlg1,inAlg1,inCons1,_,externalDecl1)) = classExtendsCdef;
+
+        classDef = SCode.PARTS(els2,nEqn2,inEqn2,nAlg2,inAlg2,inCons2,clats,externalDecl2);
+        compelt = SCode.CLASS(name2,prefixes2,encapsulatedPrefix2,partialPrefix2,restriction2,classDef,comment2,info2);
+        vis2 = SCode.prefixesVisibility(prefixes2);
+        elt = SCode.EXTENDS(Absyn.IDENT(name2),vis2,mods,NONE(),info1);
+        classDef = SCode.PARTS(elt::els1,nEqn1,inEqn1,nAlg1,inAlg1,inCons1,clats,externalDecl1);
+        elt = SCode.CLASS(name1, prefixes1, encapsulatedPrefix1, partialPrefix1, restriction1, classDef, comment1, info1);
+      then
+        (compelt, elt);
+
+    // found the base class which is derived
+    case (cl as SCode.CLASS(name = name2, classDef = SCode.DERIVED()), classExtendsElt)
+      equation
+        name1 = inClassExtendsEltName;
+        name2 = inBaseEltName;
+
+        SCode.CLASS(_,prefixes2,encapsulatedPrefix2,partialPrefix2,restriction2,SCode.DERIVED(derivedTySpec, derivedMod, attrs),comment2,info2) = cl;
+
+        SCode.CLASS(_, prefixes1, encapsulatedPrefix1, partialPrefix1, restriction1, classExtendsCdef, comment1, info1) = classExtendsElt;
+        SCode.CLASS_EXTENDS(_,mods,SCode.PARTS(els1,nEqn1,inEqn1,nAlg1,inAlg1,inCons1,_,externalDecl1)) = classExtendsCdef;
+
+        classDef = SCode.DERIVED(derivedTySpec, derivedMod, attrs);
+        compelt = SCode.CLASS(name2,prefixes2,encapsulatedPrefix2,partialPrefix2,restriction2,classDef,comment2,info2);
+        vis2 = SCode.prefixesVisibility(prefixes2);
+        elt = SCode.EXTENDS(Absyn.IDENT(name2),vis2,mods,NONE(),info1);
+        classDef = SCode.PARTS(elt::els1,nEqn1,inEqn1,nAlg1,inAlg1,inCons1,{},externalDecl1);
+        elt = SCode.CLASS(name1, prefixes1, encapsulatedPrefix1, partialPrefix1, restriction1, classDef, comment1, info1);
+      then
+        (compelt, elt);
+
+    // something went wrong!
+    else
+      equation
+        assert(false, getInstanceName() + " could not rename class extends base class to: " + inBaseEltName);
+      then
+        fail();
+
+  end matchcontinue;
+end patchBaseClassAndClassExtends;
+
 annotation(__OpenModelica_Interface="frontend");
 end NFInst;

Compiler/Util/Error.mo

@@ -864,6 +864,8 @@ public constant Message USER_DEFINED_TEARING_ERROR = MESSAGE(577, SYMBOLIC(), ER
   Util.gettext("Wrong usage of user defined tearing: %s Make sure you use user defined tearing as stated in the flag description."));
 public constant Message USER_TEARING_VARS = MESSAGE(578, SYMBOLIC(), NOTIFICATION(),
   Util.gettext("Following iteration variables are selected by the user for strong component %s (DAE kind: %s):\n%s"));
+public constant Message CLASS_EXTENDS_TARGET_NOT_FOUND = MESSAGE(579, TRANSLATION(), ERROR(),
+  Util.gettext("Base class targeted by class extends %s not found in the inherited classes."));
 
 public constant Message MATCH_SHADOWING = MESSAGE(5001, TRANSLATION(), ERROR(),
   Util.gettext("Local variable '%s' shadows another variable."));