Changeset 12311


Ignore:
Timestamp:
Jan 31, 2019 10:09:44 AM (10 months ago)
Author:
mjohnsson
Message:

#5726 Merge to trunk

Location:
trunk
Files:
5 edited
1 copied

Legend:

Unmodified
Added
Removed
  • trunk

  • trunk/CHANGELOG.txt

    r12293 r12311  
    11================= Unreleased ==================
     2# Feature ; Minor ; Compiler ; #5726
     3Orginal annotations should be preserved when classes are redeclared
     4 unless new annotations are added in the redeclaring declaration.
    25
    36; Feature ; Minor ; Compiler ; #5725
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstanceTree.jrag

    r11911 r12311  
    162162
    163163        public Environment clone() {
    164             Environment env = new Environment();
    165             env.addAll(this);
    166             return env;
    167         }
    168        
    169         /**
    170         * TODO: implement!
    171         */
     164            Environment env = new Environment();
     165            env.addAll(this);
     166            return env;
     167        }
     168
     169        /**
     170        * TODO: implement!
     171        */
    172172        public Environment peel(String name) {
    173             return new Environment();
     173            return new Environment();
    174174        }
    175175
     
    213213aspect InstModifications{
    214214
    215     public ArrayList<InstModification> InstModification.expand() {
    216         ArrayList<InstModification> l = new ArrayList<InstModification>();
    217         l.add(this);
    218         return l;
    219     }
    220 
    221     public ArrayList<InstModification> InstCompleteModification.expand() {
    222         ArrayList<InstModification> l = new ArrayList<InstModification>();
    223         for (InstModification im : getInstClassModification().getInstArguments())
    224             l.add(im);
    225         if (hasInstValueModification())
    226             l.add(getInstValueModification());
    227         return l;   
    228        
    229     }
    230 
    231     public ArrayList<InstModification> InstClassModification.expand() {
    232         ArrayList<InstModification> l = new ArrayList<InstModification>();
    233         for (InstModification im : getInstArguments())
    234             l.add(im);
    235         return l;   
    236     }
    237 
    238     public abstract InstModification SrcModification.newInstModification();
    239     public InstCompleteModification SrcCompleteModification.newInstModification() {
    240         InstCompleteModification icm = new InstCompleteModification(this,getSrcClassModification().newInstModification(),new Opt());
     215    public ArrayList<InstModification> InstModification.expand() {
     216        ArrayList<InstModification> l = new ArrayList<InstModification>();
     217        l.add(this);
     218        return l;
     219    }
     220
     221    public ArrayList<InstModification> InstCompleteModification.expand() {
     222        ArrayList<InstModification> l = new ArrayList<InstModification>();
     223        for (InstModification im : getInstClassModification().getInstArguments())
     224            l.add(im);
     225        if (hasInstValueModification())
     226            l.add(getInstValueModification());
     227        return l;   
     228   
     229    }
     230
     231    public ArrayList<InstModification> InstClassModification.expand() {
     232        ArrayList<InstModification> l = new ArrayList<InstModification>();
     233        for (InstModification im : getInstArguments())
     234            l.add(im);
     235        return l;   
     236    }
     237
     238    public abstract InstModification SrcModification.newInstModification();
     239    public InstCompleteModification SrcCompleteModification.newInstModification() {
     240        InstCompleteModification icm = new InstCompleteModification(this,getSrcClassModification().newInstModification(),new Opt());
    241241        if (hasSrcValueModification())
    242             icm.setInstValueModification(getSrcValueModification().newInstModification());
     242            icm.setInstValueModification(getSrcValueModification().newInstModification());
    243243        return icm;
    244     }   
    245     public InstValueModification SrcValueModification.newInstModification() {
    246         return new InstValueModification(this);
    247     }
    248     public InstClassModification SrcClassModification.newInstModification () {
    249         List l = new List();
    250         for (SrcArgument a : getSrcArguments()) {
    251             l.add(a.newInstModification());
    252         }
    253         return new InstClassModification(this,l);
    254     }
     244    }
     245    public InstValueModification SrcValueModification.newInstModification() {
     246        return new InstValueModification(this);
     247    }
     248    public InstClassModification SrcClassModification.newInstModification () {
     249        List l = new List();
     250        for (SrcArgument a : getSrcArguments()) {
     251            l.add(a.newInstModification());
     252        }
     253        return new InstClassModification(this,l);
     254    }
    255255
    256256    public InstComponentModification SrcComponentModification.newInstModification() {
     
    278278    }
    279279
    280     public InstComponentRedeclare SrcComponentRedeclare.newInstModification() {
    281         InstComponentRedeclare icr = new InstComponentRedeclare(this, getEach(), getFinal(), getName().newInstAccess());
    282         icr.setLocation(this);
    283         return icr;
    284     }
     280    public InstComponentRedeclare SrcComponentRedeclare.newInstModification() {
     281        InstComponentRedeclare icr = new InstComponentRedeclare(this, getEach(), getFinal(), getName().newInstAccess());
     282        icr.setLocation(this);
     283        return icr;
     284    }
    285285    public InstComponentRedeclare SrcComponentDecl.newInstModification() {
    286286        if (!hasRedeclare()) {
     
    299299    }
    300300
    301     public InstClassRedeclare SrcClassRedeclare.newInstModification() {
    302         InstClassRedeclare icr = new InstClassRedeclare(this, getEach(), getFinal(), getName().newInstAccess());
    303         icr.setLocation(this);
    304         return icr;
    305     }
     301    public InstClassRedeclare SrcClassRedeclare.newInstModification() {
     302        InstClassRedeclare icr = new InstClassRedeclare(this, getEach(), getFinal(), getName().newInstAccess());
     303        icr.setLocation(this);
     304        return icr;
     305    }
    306306
    307307
     
    448448    }
    449449
    450     /**
    451     * Return OriginalInstClass for nodes that have it, null otherwise.
    452     */
    453     syn InstClassDecl InstClassDecl.originalInstClass()      = null;
    454     eq InstReplacingShortClassDecl.originalInstClass()       = getOriginalInstClass();
    455     eq InstReplacingSimpleShortClassDecl.originalInstClass() = getOriginalInstClass();
    456     eq InstReplacingFullClassDecl.originalInstClass()        = getOriginalInstClass();
     450    /**
     451    * Return OriginalInstClass for nodes that have it, null otherwise.
     452    */
     453    syn InstClassDecl InstClassDecl.originalInstClass()      = null;
     454    eq InstReplacingShortClassDecl.originalInstClass()       = getOriginalInstClass();
     455    eq InstReplacingSimpleShortClassDecl.originalInstClass() = getOriginalInstClass();
     456    eq InstReplacingFullClassDecl.originalInstClass()        = getOriginalInstClass();
    457457
    458458    syn boolean InstClassDecl.hasInstClassModification() = false;
     
    509509        myInstClassDecl().getMergedEnvironment().mergeOuterClone(getInstModifications());
    510510
     511    /**
     512     *  Gives the environment filtered on this InstNode. The result includes only include modifications on/for this
     513     *  InstNode.
     514     */
    511515    syn Environment InstNode.filteredEnvironment() = nameScope() ? myEnvironment(name()) : myEnvironment();
    512516
     
    525529    }
    526530
     531    /**
     532     * Helper method for calculating the environment.
     533     */
    527534    inh Environment InstExtends.myEnvironmentNoClass();
    528535    inh Environment InstExtends.myEnvironmentClass();
     
    605612    }
    606613
    607     eq Program.getInstProgramRoot().myEnvironment() = new Environment();
    608     eq Program.getInstProgramRoot().myEnvironment(String name) = new Environment();
     614    eq Program.getInstProgramRoot().myEnvironment() = new Environment();
     615    eq Program.getInstProgramRoot().myEnvironment(String name) = new Environment();
    609616
    610617    syn lazy List<InstArrayModification> InstValueModification.getInstArrayModificationList() {
     
    664671   
    665672   
    666     /**
    667     * Find the InstModification containing this expression, if any.
    668     */
    669     inh InstModification FExp.surroundingInstModification();
     673    /**
     674    * Find the InstModification containing this expression, if any.
     675    */
     676    inh InstModification FExp.surroundingInstModification();
    670677    eq InstModification.getChild().surroundingInstModification() = this;
    671678    eq InstNode.getChild().surroundingInstModification()         = null;
    672679    eq Root.getChild().surroundingInstModification()             = null;
    673    
    674    
    675     syn InstComponentRedeclare InstModification.matchInstComponentRedeclare(String name) = null;
    676     eq InstComponentRedeclare.matchInstComponentRedeclare(String name) {
    677         if (getName().name().equals(name))
    678             return this;
    679         else
    680             return null;
    681     }
    682    
     680   
     681   
     682    syn InstComponentRedeclare InstModification.matchInstComponentRedeclare(String name) = null;
     683    eq InstComponentRedeclare.matchInstComponentRedeclare(String name) {
     684        if (getName().name().equals(name))
     685            return this;
     686        else
     687            return null;
     688    }
     689
    683690    syn InstClassRedeclare InstModification.matchInstClassRedeclare(String name) = null;
    684     eq InstClassRedeclare.matchInstClassRedeclare(String name) {
    685         if (getName().name().equals(name))
    686             return this;
    687         else
    688             return null;
    689     }
    690    
    691     syn InstComponentRedeclare InstNode.retrieveReplacingComponent(String name) {
    692         for (InstModification im : getMergedEnvironment()) {
    693             InstComponentRedeclare icr = im.matchInstComponentRedeclare(name);
    694             if (icr != null)
    695                 return icr;
    696         }
    697         return null;
    698     }
     691    eq InstClassRedeclare.matchInstClassRedeclare(String name) {
     692        if (getName().name().equals(name))
     693            return this;
     694        else
     695            return null;
     696    }
     697
     698    syn InstComponentRedeclare InstNode.retrieveReplacingComponent(String name) {
     699        for (InstModification im : getMergedEnvironment()) {
     700            InstComponentRedeclare icr = im.matchInstComponentRedeclare(name);
     701            if (icr != null)
     702                return icr;
     703        }
     704        return null;
     705    }
    699706
    700707    syn InstComponentRedeclare InstNode.retrieveConstrainingComponent(String name) {
     
    707714    }
    708715
    709     // TODO: make sure components are created using the right class now
    710     syn InstRedeclareClassNode InstNode.retrieveReplacingClass(String name) {
    711         for (InstModification im : getMergedEnvironment()) {
    712             InstClassRedeclare icr = im.matchInstClassRedeclare(name);
    713             if (icr != null)
    714                 return icr;
    715         }
    716         return null;
    717     }
     716    // TODO: make sure components are created using the right class now
     717    syn InstRedeclareClassNode InstNode.retrieveReplacingClass(String name) {
     718        for (InstModification im : getMergedEnvironment()) {
     719            InstClassRedeclare icr = im.matchInstClassRedeclare(name);
     720            if (icr != null)
     721                return icr;
     722        }
     723        return null;
     724    }
    718725
    719726    syn InstRedeclareClassNode InstNode.retrieveConstrainingClass(String name) {
     
    726733    }
    727734
    728     eq InstExtends.retrieveReplacingClass(String name) {
    729         InstRedeclareClassNode res = super.retrieveReplacingClass(name);
    730         return (res == null) ? lookupReplacingClass(name) : res;
    731     }
    732    
    733     inh InstRedeclareClassNode InstExtends.lookupReplacingClass(String name);
    734     eq InstNode.getInstExtends().lookupReplacingClass(String name) {
    735         for (InstClassDecl icd : getRedeclaredInstClassDecls())
    736             if (icd.name().equals(name))
    737                 return icd;
    738         return retrieveReplacingClass(name);
    739     }
    740     eq InstExtends.getChild().lookupReplacingClass(String name) {
    741         InstRedeclareClassNode res = lookupReplacingClass(name);
    742         if (res != null)
    743             return res;
    744         for (InstClassDecl icd : getRedeclaredInstClassDecls())
    745             if (icd.name().equals(name))
    746                 return icd;
    747         return super.retrieveReplacingClass(name);
    748     }
     735    eq InstExtends.retrieveReplacingClass(String name) {
     736        InstRedeclareClassNode res = super.retrieveReplacingClass(name);
     737        return (res == null) ? lookupReplacingClass(name) : res;
     738    }
     739   
     740    inh InstRedeclareClassNode InstExtends.lookupReplacingClass(String name);
     741    eq InstNode.getInstExtends().lookupReplacingClass(String name) {
     742        for (InstClassDecl icd : getRedeclaredInstClassDecls())
     743            if (icd.name().equals(name))
     744                return icd;
     745        return retrieveReplacingClass(name);
     746    }
     747    eq InstExtends.getChild().lookupReplacingClass(String name) {
     748        InstRedeclareClassNode res = lookupReplacingClass(name);
     749        if (res != null)
     750            return res;
     751        for (InstClassDecl icd : getRedeclaredInstClassDecls())
     752            if (icd.name().equals(name))
     753                return icd;
     754        return super.retrieveReplacingClass(name);
     755    }
    749756    eq InstRoot.getChild().lookupReplacingClass(String name) = null;
    750757    eq Root.getChild().lookupReplacingClass(String name)     = null;
     
    905912    }
    906913   
    907     /**
    908     * Dynamically places an FAbstractEquation in the tree under this FAbstractEquation.
    909     *
    910     * @return  the final version of the dynamically placed node.
    911     */
    912     public FAbstractEquation FAbstractEquation.dynamicFAbstractEquation(FAbstractEquation eqn) {
    913         if (eqn == this)
    914             return eqn;
    915         getDynamicFAbstractEquationOpt().setChild(eqn, 0);
    916         return (FAbstractEquation) getDynamicFAbstractEquationOpt().getChild(0);
    917     }
     914    /**
     915    * Dynamically places an FAbstractEquation in the tree under this FAbstractEquation.
     916    *
     917    * @return  the final version of the dynamically placed node.
     918    */
     919    public FAbstractEquation FAbstractEquation.dynamicFAbstractEquation(FAbstractEquation eqn) {
     920        if (eqn == this)
     921            return eqn;
     922        getDynamicFAbstractEquationOpt().setChild(eqn, 0);
     923        return (FAbstractEquation) getDynamicFAbstractEquationOpt().getChild(0);
     924    }
    918925
    919926
     
    10691076
    10701077
    1071     syn lazy List<InstModification> InstNode.getElementInstModificationList() {
     1078    syn lazy List<InstModification> InstNode.getElementInstModificationList() {
    10721079        List<InstModification> l = new List<InstModification>();
    10731080        for (SrcModificationOrRedeclareElement m : elementModifications())
    10741081            l.add(m.newInstModification());
    10751082        return l;
    1076     }
     1083    }
    10771084
    10781085
     
    10991106     
    11001107     rewrite InstCreateComponentDecl {
    1101         to InstComponentDecl getClassName().myInstClassDecl().newInstComponentDecl(getSrcComponentDecl());
     1108         to InstComponentDecl getClassName().myInstClassDecl().newInstComponentDecl(getSrcComponentDecl());
    11021109     }
    11031110     
    11041111     rewrite InstCreateForIndexPrimitive {
    1105         to InstPrimitive (InstPrimitive) getClassName().myInstClassDecl().newInstComponentDecl(getSrcComponentDecl());
     1112         to InstPrimitive (InstPrimitive) getClassName().myInstClassDecl().newInstComponentDecl(getSrcComponentDecl());
    11061113     }
    11071114
     
    12001207    }
    12011208
    1202     eq InstNamedModification.matches(String str) = name().equals(str);
    1203    
    1204     inh boolean InstNode.isInInstModification();
    1205     eq InstModification.getChild().isInInstModification() = true;
    1206     eq InstRoot.getChild().isInInstModification()         = false;
    1207     eq Root.getChild().isInInstModification()             = false;
    1208 
    1209     syn boolean SrcExtendsClause.needsReplacingExtends()  = false;
    1210     eq SrcExtendsClauseShortClass.needsReplacingExtends() = true;
    1211    
     1209    eq InstNamedModification.matches(String str) = name().equals(str);
     1210
     1211    inh boolean InstNode.isInInstModification();
     1212    eq InstModification.getChild().isInInstModification() = true;
     1213    eq InstRoot.getChild().isInInstModification()         = false;
     1214    eq Root.getChild().isInInstModification()             = false;
     1215
     1216    syn boolean SrcExtendsClause.needsReplacingExtends()  = false;
     1217    eq SrcExtendsClauseShortClass.needsReplacingExtends() = true;
     1218
    12121219
    12131220    public InstComponentDecl InstClassDecl.newInstComponentDecl(SrcComponentDecl cd) {
     
    14781485    // Create InstRestriction
    14791486    public InstRestriction SrcBaseClassDecl.newInstRestriction() {
    1480         return getSrcRestriction().newInstRestriction();
     1487        return getSrcRestriction().newInstRestriction();
    14811488    }
    14821489   
     
    15591566    }
    15601567
    1561     public InstAccess SrcComponentDecl.newInstClassAccess() {
    1562         return getClassName().newInstAccess();
    1563     }
     1568    public InstAccess SrcComponentDecl.newInstClassAccess() {
     1569        return getClassName().newInstAccess();
     1570    }
    15641571
    15651572    public abstract InstAccess SrcAccess.newInstAccess();
     
    15921599    }
    15931600
    1594     syn boolean InstExtends.hasInstClassModification()           = false;
    1595     eq InstReplacingExtendsShortClass.hasInstClassModification() = getInstExtendsShortClass().hasInstClassModification();
    1596    
    1597     syn InstClassModification InstExtends.getInstClassModification() = null;
    1598     eq InstReplacingExtendsShortClass.getInstClassModification()     = getInstExtendsShortClass().getInstClassModification();
     1601    syn boolean InstExtends.hasInstClassModification()           = false;
     1602    eq InstReplacingExtendsShortClass.hasInstClassModification() = getInstExtendsShortClass().hasInstClassModification();
     1603
     1604    syn InstClassModification InstExtends.getInstClassModification() = null;
     1605    eq InstReplacingExtendsShortClass.getInstClassModification()     = getInstExtendsShortClass().getInstClassModification();
    15991606
    16001607    syn lazy InstProgramRoot Program.getInstProgramRoot() {
     
    16021609    }
    16031610
    1604     syn lazy InstClassDecl InstClassRedeclare.getInstClassDecl() {
    1605         return getSrcClassRedeclare().getSrcBaseClassDecl().newInstClassDecl();
    1606     }
     1611    syn lazy InstClassDecl InstClassRedeclare.getInstClassDecl() {
     1612        return getSrcClassRedeclare().getSrcBaseClassDecl().newInstClassDecl();
     1613    }
    16071614
    16081615    syn lazy InstComponentDecl InstComponentRedeclare.getInstComponentDecl() =
    16091616        new InstCreateComponentDecl(getComponentRedeclareDecl(), null);
    16101617
    1611     syn lazy InstComponentDecl InstReplacingRecord.getOriginalInstComponent() =
    1612         new InstCreateComponentDecl(getOriginalDecl(), null);
     1618    syn lazy InstComponentDecl InstReplacingRecord.getOriginalInstComponent() =
     1619        new InstCreateComponentDecl(getOriginalDecl(), null);
    16131620
    16141621    syn lazy InstComponentDecl InstReplacingComposite.getOriginalInstComponent() =
     
    16191626
    16201627
    1621     syn lazy InstClassDecl InstReplacingShortClassDecl.getOriginalInstClass() =
    1622         getOriginalClassDecl().newInstClassDecl();
    1623 
    1624     syn lazy InstClassDecl InstReplacingSimpleShortClassDecl.getOriginalInstClass() =
    1625         getOriginalClassDecl().newInstClassDecl();
    1626 
    1627     syn lazy InstClassDecl InstReplacingFullClassDecl.getOriginalInstClass() =
    1628         getOriginalClassDecl().newInstClassDecl();
    1629 
    1630     /**
    1631     * Returns the FExp associated with this argument, if any.
    1632     */
    1633     public FExp InstFunctionArgument.getFExp() { return null; }
     1628    syn lazy InstClassDecl InstReplacingShortClassDecl.getOriginalInstClass() =
     1629        getOriginalClassDecl().newInstClassDecl();
     1630
     1631    syn lazy InstClassDecl InstReplacingSimpleShortClassDecl.getOriginalInstClass() =
     1632        getOriginalClassDecl().newInstClassDecl();
     1633
     1634    syn lazy InstClassDecl InstReplacingFullClassDecl.getOriginalInstClass() =
     1635        getOriginalClassDecl().newInstClassDecl();
     1636
     1637    /**
     1638    * Returns the FExp associated with this argument, if any.
     1639    */
     1640    public FExp InstFunctionArgument.getFExp() { return null; }
    16341641
    16351642    /**
     
    16411648    public FExp InstGivenArgument.getOriginalFExp()    { return getFExpNoTransform(); }
    16421649
    1643     syn lazy FFunctionCallStmt InstExternalObject.getDestructorCall() {
    1644         InstAccess name = getClassName().copyAndAppend("destructor");
    1645         List<InstFunctionArgument> args = new List<InstFunctionArgument>();
    1646         args.add(new InstPositionalArgument(createAccessExp(), 0));
    1647         InstFunctionCall ifc = new InstFunctionCall(name, args);
    1648         ifc.generated = true;
    1649         FFunctionCallStmt stmt = new FFunctionCallStmt(new List(), ifc);
    1650         return stmt;
    1651     }
    1652 
    1653    
    1654     private boolean InstShortClassDecl.simpleRewriteDone = false;
    1655    
    1656     rewrite InstShortClassDecl {
    1657         when (!simpleRewriteDone) to InstAbstractShortClassDecl {
    1658             simpleRewriteDone = true;
    1659             if (shouldBeExpanded())
    1660                 return this;
    1661             InstSimpleShortClassDecl res = createInstSimpleShortClassDecl();
    1662             res.setLocation(this);
    1663             return res;
    1664         }   
    1665     }
    1666    
    1667     public InstSimpleShortClassDecl InstShortClassDecl.createInstSimpleShortClassDecl() {
    1668         return new InstSimpleShortClassDecl(getSrcClassDecl(), getInstConstrainingClassOpt(), getInstRestriction());
    1669     }
    1670    
    1671     public InstReplacingSimpleShortClassDecl InstReplacingShortClassDecl.createInstSimpleShortClassDecl() {
    1672         return new InstReplacingSimpleShortClassDecl(getSrcClassDecl(), getInstConstrainingClassOpt(),
    1673                 getInstRestriction(), getOriginalClassDecl(), getInstClassRedeclare());
    1674     }
     1650    syn lazy FFunctionCallStmt InstExternalObject.getDestructorCall() {
     1651        InstAccess name = getClassName().copyAndAppend("destructor");
     1652        List<InstFunctionArgument> args = new List<InstFunctionArgument>();
     1653        args.add(new InstPositionalArgument(createAccessExp(), 0));
     1654        InstFunctionCall ifc = new InstFunctionCall(name, args);
     1655        ifc.generated = true;
     1656        FFunctionCallStmt stmt = new FFunctionCallStmt(new List(), ifc);
     1657        return stmt;
     1658    }
     1659
     1660
     1661    private boolean InstShortClassDecl.simpleRewriteDone = false;
     1662
     1663    rewrite InstShortClassDecl {
     1664        when (!simpleRewriteDone) to InstAbstractShortClassDecl {
     1665            simpleRewriteDone = true;
     1666            if (shouldBeExpanded())
     1667                return this;
     1668            InstSimpleShortClassDecl res = createInstSimpleShortClassDecl();
     1669            res.setLocation(this);
     1670            return res;
     1671        }
     1672    }
     1673
     1674    public InstSimpleShortClassDecl InstShortClassDecl.createInstSimpleShortClassDecl() {
     1675        return new InstSimpleShortClassDecl(getSrcClassDecl(), getInstConstrainingClassOpt(), getInstRestriction());
     1676    }
     1677
     1678    public InstReplacingSimpleShortClassDecl InstReplacingShortClassDecl.createInstSimpleShortClassDecl() {
     1679        return new InstReplacingSimpleShortClassDecl(getSrcClassDecl(), getInstConstrainingClassOpt(),
     1680               getInstRestriction(), getOriginalClassDecl(), getInstClassRedeclare());
     1681    }
    16751682
    16761683    syn boolean InstShortClassDecl.shouldBeExpanded() =
     
    16841691        (isFunction() && !instModificationsFromConstrainingType().isEmpty());
    16851692
    1686     syn boolean SrcClassDecl.hasSrcTypePrefix() = false;
    1687     eq SrcShortClassDecl.hasSrcTypePrefix()     = getSrcExtendsClauseShortClass().hasSrcTypePrefix();
    1688    
    1689     syn boolean SrcExtendsClauseShortClass.hasSrcTypePrefix() =
    1690         hasSrcTypePrefixFlow() || hasSrcTypePrefixVariability() || hasSrcTypePrefixInputOutput();
     1693    syn boolean SrcClassDecl.hasSrcTypePrefix() = false;
     1694    eq SrcShortClassDecl.hasSrcTypePrefix()     = getSrcExtendsClauseShortClass().hasSrcTypePrefix();
     1695
     1696    syn boolean SrcExtendsClauseShortClass.hasSrcTypePrefix() =
     1697        hasSrcTypePrefixFlow() || hasSrcTypePrefixVariability() || hasSrcTypePrefixInputOutput();
    16911698
    16921699    syn lazy InstAccess InstSimpleShortClassDecl.getTarget() =
     
    17181725        throw new UnsupportedOperationException();
    17191726    }
    1720    
     1727
    17211728    public List<InstClassDecl> InstSimpleShortClassDecl.getInstClassDeclList() {
    17221729        throw new UnsupportedOperationException();
     
    17251732        throw new UnsupportedOperationException();
    17261733    }
    1727    
     1734
    17281735    public List<InstExtends> InstSimpleShortClassDecl.getInstExtendsList() {
    17291736        throw new UnsupportedOperationException();
     
    17321739        throw new UnsupportedOperationException();
    17331740    }
    1734    
     1741
    17351742    public List<InstImport> InstSimpleShortClassDecl.getInstImportList() {
    17361743        throw new UnsupportedOperationException();
     
    17391746        throw new UnsupportedOperationException();
    17401747    }
    1741    
     1748
    17421749    public List<InstClassDecl> InstSimpleShortClassDecl.getRedeclaredInstClassDeclList() {
    17431750        throw new UnsupportedOperationException();
     
    18651872    eq SrcDummyModification.instantiateExp()       = myFExp().treeCopy();
    18661873
    1867     public List InstNode.buildFAbstractEquationList() {
    1868         List l = new List();
     1874    public List InstNode.buildFAbstractEquationList() {
     1875    List l = new List();
    18691876        for (SrcAbstractEquation e : equations()) {
    1870             l.add(e.instantiate());
     1877            l.add(e.instantiate());
    18711878        }
    18721879        for (SrcAlgorithm a : algorithms()) {
    1873             l.add(a.instantiate());
     1880            l.add(a.instantiate());
    18741881        }
    18751882        for (FAlgorithm a : fAlgorithms()) {
     
    18781885        return l;
    18791886    }
    1880    
    1881     public List InstArrayComponentDecl.buildFAbstractEquationList() {
    1882         return instComponentDecl().buildFAbstractEquationList();
    1883     }
    1884    
    1885     syn lazy List InstNode.getFAbstractEquationList() =
    1886         buildFAbstractEquationList();
    1887     eq InstComponentDecl.getFAbstractEquationList() =
    1888         isArrayParent() ? new List() : buildFAbstractEquationList();
    1889 
    1890     // TODO: Change behaviour of isArrayDecl to this instead?
    1891     syn boolean InstComponentDecl.isArrayParent() =
    1892         getNumInstComponentDecl() > 0 && getInstComponentDecl(0).isArrayChild();
    1893 
    1894     syn boolean InstComponentDecl.isArrayChild() = false;
    1895     eq InstArrayComponentDecl.isArrayChild()     = true;
     1887
     1888    public List InstArrayComponentDecl.buildFAbstractEquationList() {
     1889        return instComponentDecl().buildFAbstractEquationList();
     1890    }
     1891
     1892    syn lazy List InstNode.getFAbstractEquationList() =
     1893        buildFAbstractEquationList();
     1894    eq InstComponentDecl.getFAbstractEquationList() =
     1895        isArrayParent() ? new List() : buildFAbstractEquationList();
     1896
     1897    // TODO: Change behaviour of isArrayDecl to this instead?
     1898    syn boolean InstComponentDecl.isArrayParent() =
     1899        getNumInstComponentDecl() > 0 && getInstComponentDecl(0).isArrayChild();
     1900
     1901    syn boolean InstComponentDecl.isArrayChild() = false;
     1902    eq InstArrayComponentDecl.isArrayChild()     = true;
    18961903}
    18971904
     
    21582165    }
    21592166
    2160     /**
    2161     * Check if this node is a class declaration or an extends in one.
    2162     */
    2163     syn boolean InstNode.isClassDecl() = false;
    2164     eq InstClassDecl.isClassDecl()     = true;
    2165     eq InstExtends.isClassDecl()       = isInClassDecl();
     2167    /**
     2168    * Check if this node is a class declaration or an extends in one.
     2169    */
     2170    syn boolean InstNode.isClassDecl() = false;
     2171    eq InstClassDecl.isClassDecl()     = true;
     2172    eq InstExtends.isClassDecl()       = isInClassDecl();
    21662173   
    21672174    /**
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/util/Annotations.jrag

    r12306 r12311  
    6565
    6666    eq SrcFullClassDecl.annotation(InstContext instContext)           = annotationOfChild(getSrcAnnotationOpt(), instContext);
    67     eq InstClassDecl.annotation(InstContext instContext)              = getSrcClassDecl().annotation(instContext);
     67    eq InstClassDecl.annotation(InstContext instContext)              = mySrcAnnotatable().annotation(instContext);
     68    eq InstAbstractShortClassDecl.annotation(InstContext instContext) = mySrcAnnotatable().annotation(instContext);
    6869    eq SrcShortClassDecl.annotation(InstContext instContext)          = getSrcExtendsClauseShortClass().annotation(instContext);
    6970    eq SrcLibNode.annotation(InstContext instContext)                 = myClass().annotation(instContext);
     
    7374
    7475    eq SrcComponentDecl.annotation(InstContext instContext)  = getSrcComment().annotation(instContext);
    75     eq InstComponentDecl.annotation(InstContext instContext) = getSrcComponentDecl().annotation(instContext);
     76    eq InstComponentDecl.annotation(InstContext instContext) = mySrcAnnotatable().annotation(instContext);
    7677
    7778    eq InstExtends.annotation(InstContext instContext)      = getSrcExtendsClause().annotation(instContext);
     
    19191920    }
    19201921   
     1922    /**
     1923     * obtaining the owning source modification or entity. Primary used to
     1924     * obtain the Component / ComponentModification
     1925     */
     1926    syn SrcAnnotatable InstModification.getElementModification() = getSrcModification();
     1927    eq InstValueModification.getElementModification() = elementModification();
     1928   
     1929    inh SrcAnnotatable InstValueModification.elementModification();
     1930    eq  InstModification.getChild().elementModification() = getSrcModification();
     1931    eq  InstComponentDecl.getChild().elementModification() = getSrcComponentDecl();
     1932    eq  InstClassDecl.getChild().elementModification() = getSrcClassDecl();
     1933    eq  InstNode.getChild().elementModification() = null;
     1934
     1935    SrcModificationOrRedeclareElement extends SrcAnnotatable;
     1936    SrcClassDecl implements SrcAnnotatable;
     1937
     1938    public interface SrcAnnotatable {
     1939        public SrcAnnotationProvider srcAnnotationProvider();
     1940        public AnnotationNode annotation(InstContext instContext);
     1941    }
     1942
     1943    public SrcAnnotationProvider SrcModification.srcAnnotationProvider() {
     1944        return this;
     1945    }
     1946
     1947    public interface SrcAnnotationProvider {
     1948        /**
     1949         * Check if there is annotations at this location.
     1950         */
     1951        public boolean hasAnnotation();
     1952    }
     1953
     1954    public class SrcSingeltonProvider {
     1955        @Override
     1956        public boolean hasAnnotation() {
     1957            return provider.hasAnnotation();
     1958        }
     1959    }
     1960
     1961    public class ExpValueProvider {
     1962        @Override
     1963        public boolean hasAnnotation() {
     1964            return annotationSubNodes().iterator().hasNext();
     1965        }
     1966    }
     1967
     1968    public class SrcAnnotationsIteratorProvider {
     1969        @Override
     1970        public boolean hasAnnotation() {
     1971            return providers.size()>0 && annotationSubNodes().iterator().hasNext();
     1972        }
     1973    }
     1974
     1975    public class SrcModification {
     1976        @Override
     1977        public boolean hasAnnotation() {
     1978            return annotationSubNodes().iterator().hasNext();
     1979        }
     1980    }
     1981
     1982    public abstract class RootAnnotationProviderProxy {
     1983        @Override
     1984        public boolean hasAnnotation() {
     1985            return hasProvider();
     1986        }
     1987    }
     1988
     1989    @Override
     1990    public boolean SrcNamedArgument.hasAnnotation() {
     1991        return annotationSubNodes().iterator().hasNext();
     1992    }
     1993
     1994    @Override
     1995    public boolean SrcFunctionArguments.hasAnnotation() {
     1996        return annotationSubNodes().iterator().hasNext();
     1997    }
     1998
     1999    @Override
     2000    public boolean SrcParseAnnotation.hasAnnotation() {
     2001        return annotationSubNodes().iterator().hasNext();
     2002    }
     2003
     2004    syn boolean InstModification.isRedeclare() = false;
     2005    eq InstComponentRedeclare.isRedeclare()    = true;
     2006    eq InstClassRedeclare.isRedeclare()        = true;
     2007   
     2008
     2009   
     2010    /**
     2011     * Search for the applicable annotation from the enviroment. FilteredEnviroment
     2012     * is not used since it peeling which is undesireable
     2013     */
     2014    public SrcAnnotatable InstNode.srcannotatableFromEnviroment() {
     2015        Environment enviroment = myEnvironment();
     2016        for (InstModification im : enviroment) {
     2017            if (im.matches(name()) && im.isRedeclare()) {
     2018                SrcAnnotatable annotatable = im.getElementModification();
     2019                SrcAnnotationProvider provider = annotatable.srcAnnotationProvider();
     2020                annotatable = provider.isClassRedeclare() ?
     2021                        provider.getSrcClassRedeclare() : annotatable;
     2022                annotatable = provider.isComponentRedeclare() ?
     2023                        provider.getSrcComponentRedeclare() : annotatable;
     2024                if (annotatable.srcAnnotationProvider().hasAnnotation()) {
     2025                    return annotatable;
     2026                }
     2027            }
     2028        }
     2029        return null;
     2030    }
     2031
     2032    /**
     2033     * Obtaines the orginal annotatable for a class or component.
     2034     *   
     2035     */
     2036    syn SrcAnnotatable InstClassDecl.orginalAnnotatable() = getSrcClassDecl();
     2037    eq InstReplacingFullClassDecl.orginalAnnotatable() = getOriginalClassDecl();
     2038    syn SrcAnnotatable InstComponentDecl.orginalAnnotatable() = getSrcComponentDecl();
     2039    eq InstReplacingComposite.orginalAnnotatable() = getOriginalDecl();
     2040    eq InstReplacingPrimitive.orginalAnnotatable() = getOriginalDecl();
     2041   
     2042    public SrcAnnotatable InstReplacingShortClassDecl.orginalAnnotatable() {
     2043        SrcClassDecl clazz = getOriginalClassDecl();
     2044        if (!clazz.isUnknown()) {
     2045            SrcAnnotationProvider provider = clazz.srcAnnotationProvider();
     2046            if (provider.hasAnnotation()) {
     2047                return clazz;
     2048            }
     2049        }
     2050        // Throw or raise suitable exception
     2051        return getSrcClassDecl();
     2052    }
     2053   
     2054    public SrcAnnotatable InstReplacingSimpleShortClassDecl.orginalAnnotatable() {
     2055        SrcClassDecl clazz = getOriginalClassDecl();
     2056        if (!clazz.isUnknown()) {
     2057            SrcAnnotationProvider provider = clazz.srcAnnotationProvider();
     2058            if (provider.hasAnnotation()) {
     2059                return clazz;
     2060            }
     2061        }
     2062        return getSrcClassDecl();
     2063    }
     2064
     2065    /**
     2066     * Obtain the SrcAnnotationProvider respecting the inheritance.
     2067     */
     2068    public SrcAnnotationProvider InstClassDecl.myAnnotation() {
     2069        return mySrcAnnotatable().srcAnnotationProvider();
     2070    }
     2071
     2072    public SrcAnnotatable InstComponentDecl.mySrcAnnotatable() {
     2073        boolean hasAnnotations = getSrcComponentDecl().srcAnnotationProvider().hasAnnotation();
     2074        if (!hasAnnotations) {
     2075            SrcAnnotatable annotatable = srcannotatableFromEnviroment();
     2076            if (annotatable != null) {
     2077                return annotatable;
     2078            }
     2079            SrcAnnotatable orginal = orginalAnnotatable();
     2080            if (orginal.srcAnnotationProvider().hasAnnotation()) {
     2081                return orginal;
     2082            }
     2083        }
     2084        return getSrcComponentDecl();
     2085    }
     2086   
     2087    /**
     2088     * Obtain the source node which is responsable for providing the annotation.
     2089     * A match against this with the same qualifiedName and same fullyQualifiedName is made in the
     2090     * Enviroment.
     2091     */
     2092    public SrcAnnotatable InstAbstractShortClassDecl.mySrcAnnotatable() {
     2093        boolean hasAnnotations = getSrcClassDecl().srcAnnotationProvider().hasAnnotation();
     2094        if (!hasAnnotations) {
     2095            SrcAnnotatable annotatable = srcannotatableFromEnviroment();
     2096            if (annotatable != null) {
     2097                return annotatable;
     2098            }
     2099            return orginalAnnotatable();
     2100        }
     2101        return getSrcClassDecl();
     2102    }
     2103
     2104    /**
     2105     * Obtain the source node which is responsable for providing the annotation.
     2106     */
     2107    public SrcAnnotatable InstClassDecl.mySrcAnnotatable() {
     2108        return getSrcClassDecl();
     2109    }
     2110
     2111    /**
     2112     * Test method which obtains the string representation of the
     2113     * annotation for the inner class with the given name.
     2114     * This method is only intended for testing
     2115     */
     2116    public String InstClassDecl.testClassAnnotations(String name) {
     2117        InstClassDecl iclass = null;
     2118        for (InstClassDecl icd :  allInstClassDecls()) {
     2119            if (icd.matches(name)) {
     2120                iclass = icd;
     2121                break;
     2122            }
     2123        }
     2124        Iterator<AnnotationNode> iter = iclass.annotation().iterator();
     2125        return iter.hasNext() ? iter.next().toString() : "";
     2126    }
     2127
     2128    /**
     2129     *  Test method which can obtain either a inner class or inner component of a given name from a
     2130     *  component in the current class.
     2131     *  Requires there to only be one component with a inner class or inner component with the given name.
     2132     *  This method is only intended for testing
     2133     */
     2134    public String InstClassDecl.testComponentAnnotations(boolean clazz, String name) {
     2135        StringBuilder sb = new StringBuilder();
     2136        for (InstComponentDecl icd : getInstComponentDecls()) {
     2137            InstNode annotable = null;
     2138            if (clazz) {
     2139                annotable = icd.genericLookupInstClass(name).targetOrNull();
     2140            } else {
     2141                for (InstComponentDecl inner : icd.allInstComponentDecls()) {
     2142                    if (inner.matches(name)) {
     2143                        annotable = inner;
     2144                    }
     2145                }
     2146            }
     2147            if (annotable != null) {
     2148                Iterator<AnnotationNode> iter = annotable.annotation().iterator();
     2149                sb.append(iter.hasNext() ? iter.next().toString() : "");
     2150                sb.append(System.lineSeparator());
     2151            }
     2152        }
     2153        return sb.toString();
     2154    }
     2155
    19212156}
    19222157
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/AnnotationTests.mo

    r10071 r12311  
    108108end ComponentConstrainedByBoth;
    109109
     110package inheritance
     111    package classes
     112        package BaseNoAnnotation
     113        end BaseNoAnnotation;
     114       
     115        model BaseWithAnnotation
     116            replaceable package testPackage = BaseNoAnnotation annotation(Dialog(tab="a", group="b"));
     117            replaceable BaseNoAnnotation testComponent() annotation(Dialog(tab="ac", group="b"));
     118                annotation(__JModelica(UnitTesting(tests={
     119            InstClassMethodTestCase(
     120                name="instAnnotationFromRedeclare",
     121                description="Check that the annotation is from the replaceable.",
     122                methodName="testClassAnnotations",
     123                arguments={"testPackage"},
     124                methodResult="
     125    Dialog(tab = \"a\", group = \"b\")
     126    ")})));
     127        end BaseWithAnnotation;
     128       
     129        model B
     130            extends BaseWithAnnotation;
     131            annotation(__JModelica(UnitTesting(tests={
     132            InstClassMethodTestCase(
     133                name="extendedHaveAnnotation",
     134                description="Check that the annotation is inherited.",
     135                methodName="testClassAnnotations",
     136                arguments={"testPackage"},
     137                methodResult="
     138    Dialog(tab = \"a\", group = \"b\")
     139    ")})));
     140        end B;
     141       
     142        model C
     143            extends BaseWithAnnotation(
     144                redeclare replaceable package testPackage
     145                    = BaseNoAnnotation annotation(Dialog(tab="c", group="new")),
     146                redeclare replaceable BaseNoAnnotation testComponent()
     147                    annotation(Dialog(tab="cc", group="new")));
     148                   
     149            annotation(__JModelica(UnitTesting(tests={
     150            InstClassMethodTestCase(
     151                name="replacedInExtend",
     152                description="Check that the new annotation is used.",
     153                methodName="testClassAnnotations",
     154                arguments={"testPackage"},
     155                methodResult="Dialog(tab = \"c\", group = \"new\")")})));
     156        end C;
     157       
     158        model C2
     159            extends C(redeclare replaceable package testPackage = BaseNoAnnotation);
     160            annotation(__JModelica(UnitTesting(tests={
     161            InstClassMethodTestCase(
     162                name="extendNoRedeclare",
     163                description="Check that the inherited annotation is used.",
     164                methodName="testClassAnnotations",
     165                arguments={"testPackage"},
     166                methodResult="Dialog(tab = \"c\", group = \"new\")")})));
     167        end C2;
     168       
     169        model A2
     170            package BaseAnnotation
     171                replaceable BaseNoAnnotation testComponent();
     172                replaceable package testPackage = BaseNoAnnotation;
     173            end BaseAnnotation;
     174            BaseAnnotation.testComponent testComponent;
     175            BaseAnnotation.testPackage testPackage;
     176        end A2;
     177       
     178        package BaseAnnotationAlt
     179                replaceable BaseNoAnnotation testComponent() annotation(Dialog(group="altComponent"));
     180                replaceable package testPackage = BaseNoAnnotation annotation(Dialog(group="altPackage"));
     181            end BaseAnnotationAlt;
     182       
     183        model AnnotationFromReplacedContainingPackage
     184            extends A2(redeclare replaceable package BaseAnnotation = BaseAnnotationAlt)
     185            annotation(__JModelica(UnitTesting(tests={
     186            InstClassMethodTestCase(
     187                name="AnnotationFromReplacedContainingPackage",
     188                description="Check that the annotation from the alt class is used.",
     189                methodName="testClassAnnotations",
     190                arguments={"testPackage"},
     191                methodResult="Dialog(tab = \"c4\", group = \"extends\")")})));
     192        end AnnotationFromReplacedContainingPackage;
     193       
     194        model C3
     195            extends C(
     196                        redeclare replaceable BaseNoAnnotation testComponent() annotation(),
     197                        redeclare replaceable package testPackage = BaseNoAnnotation annotation()
     198                     );
     199            annotation(__JModelica(UnitTesting(tests={
     200            InstClassMethodTestCase(
     201                name="extendsEmptyReplace",
     202                description="Check that the empty annotation is used.",
     203                methodName="testClassAnnotations",
     204                arguments={"testPackage"},
     205                methodResult="")})));
     206        end C3;
     207       
     208        model C4
     209            extends C(
     210                redeclare replaceable package testPackage
     211                    = BaseNoAnnotation annotation(Dialog(tab="c4", group="extends")),
     212                redeclare replaceable BaseNoAnnotation testComponent()
     213                    annotation(Dialog(tab="cc4", group="extends"))
     214                    );
     215            annotation(__JModelica(UnitTesting(tests={
     216            InstClassMethodTestCase(
     217                name="extendedReplacement",
     218                description="Check that the latest annotation is used.",
     219                methodName="testClassAnnotations",
     220                arguments={"testPackage"},
     221                methodResult="Dialog(tab = \"c4\", group = \"extends\")")})));
     222        end C4;
     223           
     224        model C5
     225            extends C4;
     226            annotation(__JModelica(UnitTesting(tests={
     227            InstClassMethodTestCase(
     228                name="extendExtendReplacement",
     229                description="Check that the latest annotation is used.",
     230                methodName="testClassAnnotations",
     231                arguments={"testPackage"},
     232                methodResult="Dialog(tab = \"c4\", group = \"extends\")")})));
     233        end C5;
     234       
     235        model D
     236            extends BaseWithAnnotation(
     237                redeclare replaceable BaseNoAnnotation testComponent() annotation(),
     238                redeclare replaceable package testPackage = BaseNoAnnotation annotation());
     239           
     240            annotation(__JModelica(UnitTesting(tests={
     241            InstClassMethodTestCase(
     242                name="emptyExtendReplace",
     243                description="Check that the latest annotation is used.",
     244                methodName="testClassAnnotations",
     245                arguments={"testPackage"},
     246                methodResult="")})));
     247        end D;
     248       
     249        model D2
     250            extends D;
     251            annotation(__JModelica(UnitTesting(tests={
     252            InstClassMethodTestCase(
     253                name="extendEmptyFromExtend",
     254                description="Check that the latest annotation is used.",
     255                methodName="testClassAnnotations",
     256                arguments={"testPackage"},
     257                methodResult="")})));
     258        end D2;
     259       
     260        model E
     261            extends BaseWithAnnotation(
     262                redeclare replaceable package testPackage = BaseNoAnnotation,
     263                redeclare replaceable BaseNoAnnotation testComponent()
     264                );
     265            annotation(__JModelica(UnitTesting(tests={
     266            InstClassMethodTestCase(
     267                name="noneReplacingRedeclaration",
     268                description="Check that the latest inherited annotation is used.",
     269                methodName="testClassAnnotations",
     270                arguments={"testPackage"},
     271                methodResult="
     272    Dialog(tab = \"a\", group = \"b\")
     273    ")})));
     274        end E;
     275   
     276        model E2
     277            extends E;
     278            annotation(__JModelica(UnitTesting(tests={
     279            InstClassMethodTestCase(
     280                name="extendNoneReplacingRedeclaration",
     281                description="Check that the latest inherited annotation is used.",
     282                methodName="testClassAnnotations",
     283                arguments={"testPackage"},
     284                methodResult="
     285    Dialog(tab = \"a\", group = \"b\")
     286    ")})));
     287        end E2;
     288    end classes;
     289   
     290   
     291    package components
     292        import AnnotationTests.inheritance.classes.*;
     293        model redeclaredWithAnnotationInExtends
     294            C redeclaredWithAnnotationInExtends;
     295            annotation(__JModelica(UnitTesting(tests={
     296                InstClassMethodTestCase(
     297                    name="redeclaredWithAnnotationInExtends",
     298                    description="Annotation from Extends for component inner class.",
     299                    methodName="testComponentAnnotations",
     300                    arguments={true, "testPackage"},
     301                    methodResult="
     302        Dialog(tab = \"c\", group = \"new\")
     303        ")}))); 
     304        end  redeclaredWithAnnotationInExtends;
     305       
     306        model redeclaredWithNoAnnotationInExtends
     307            C2 redeclaredWithNoAnnotationInExtends;
     308            annotation(__JModelica(UnitTesting(tests={
     309                InstClassMethodTestCase(
     310                    name="redeclaredWithNoAnnotationInExtends",
     311                    description="Base annotation since not change in Extends for component inner class.",
     312                    methodName="testComponentAnnotations",
     313                    arguments={true, "testPackage"},
     314                    methodResult="
     315        Dialog(tab = \"c\", group = \"new\")
     316        ")}))); 
     317        end redeclaredWithNoAnnotationInExtends;
     318       
     319        model redeclaredWithEmptyAnnotationInExtends
     320            C3 redeclaredWithEmptyAnnotationInExtends;
     321            annotation(__JModelica(UnitTesting(tests={
     322                InstClassMethodTestCase(
     323                    name="redeclaredWithEmptyAnnotationInExtends",
     324                    description="Empty annotation removes the original annotation.",
     325                    methodName="testComponentAnnotations",
     326                    arguments={true, "testPackage"},
     327                    methodResult="
     328
     329        ")})));             
     330        end redeclaredWithEmptyAnnotationInExtends;
     331       
     332        model redeclaredInOwnAndAncestorsExtends
     333            C4 redeclaredInOwnAndAncestorsExtends;
     334            annotation(__JModelica(UnitTesting(tests={
     335                InstClassMethodTestCase(
     336                    name="redeclaredInOwnAndAncestorsExtends",
     337                    description="Annotation from latest extends for component inner class.",
     338                    methodName="testComponentAnnotations",
     339                    arguments={true, "testPackage"},
     340                    methodResult="
     341        Dialog(tab = \"c4\", group = \"extends\")
     342        ")})));             
     343        end redeclaredInOwnAndAncestorsExtends;
     344       
     345        model redeclaredInParentExtends
     346            C5 redeclaredInParentExtends;
     347            annotation(__JModelica(UnitTesting(tests={
     348                InstClassMethodTestCase(
     349                    name="redeclaredInParentExtends",
     350                    description="Annotation from parent extends for component inner class.",
     351                    methodName="testComponentAnnotations",
     352                    arguments={true, "testPackage"},
     353                    methodResult="
     354        Dialog(tab = \"c4\", group = \"extends\")
     355        ")}))); 
     356        end redeclaredInParentExtends;
     357       
     358        model redeclaredInDeclarationNoAnnotation
     359            C5 redeclaredInDeclarationNoAnnotation(
     360                    redeclare replaceable package testPackage = BaseNoAnnotation,
     361                    redeclare replaceable BaseNoAnnotation testComponent());
     362            annotation(__JModelica(UnitTesting(tests={
     363                InstClassMethodTestCase(
     364                    name="redeclaredInDeclarationNoAnnotation",
     365                    description="Check that the components have correct annotation.",
     366                    methodName="testComponentAnnotations",
     367                    arguments={true, "testPackage"},
     368                    methodResult="
     369        Dialog(tab=\"c4\", group=\"extends\")
     370        ")})));                 
     371        end redeclaredInDeclarationNoAnnotation;
     372       
     373        model redeclaredInDeclarationWithEmptyAnnotation
     374            C5 redeclaredInDeclarationWithEmptyAnnotation(
     375                    redeclare replaceable package testPackage = BaseNoAnnotation annotation(),
     376                    redeclare replaceable BaseNoAnnotation testComponent() annotation());
     377            annotation(__JModelica(UnitTesting(tests={
     378                InstClassMethodTestCase(
     379                    name="redeclaredInDeclarationWithEmptyAnnotation",
     380                    description="Check that the components have correct annotation.",
     381                    methodName="testComponentAnnotations",
     382                    arguments={true, "testPackage"},
     383                    methodResult="
     384
     385        ")})));           
     386        end redeclaredInDeclarationWithEmptyAnnotation;
     387       
     388        model redeclaredInDeclaration
     389            C5  redeclaredInDeclaration(
     390                    redeclare replaceable package testPackage = BaseNoAnnotation
     391                        annotation(Dialog(tab="redeclaredInDeclaration", group="extends")));
     392            annotation(__JModelica(UnitTesting(tests={
     393                InstClassMethodTestCase(
     394                    name="redeclaredInDeclaration",
     395                    description="Check that the components have correct annotation.",
     396                    methodName="testComponentAnnotations",
     397                    arguments={true, "testPackage"},
     398                    methodResult="
     399        Dialog(tab = \"redeclaredInDeclaration\", group = \"extends\")
     400        ")}))); 
     401        end redeclaredInDeclaration;
     402    end components;
     403   
     404    package componentsGetComponent
     405        import AnnotationTests.inheritance.classes.*;
     406        model componentRedeclaredWithAnnotationInExtends
     407            C redeclaredWithAnnotationInExtends;
     408            annotation(__JModelica(UnitTesting(tests={
     409                InstClassMethodTestCase(
     410                    name="componentRedeclaredWithAnnotationInExtends",
     411                    description="Annotation from Extends for component inner component.",
     412                    methodName="testComponentAnnotations",
     413                    arguments={false, "testComponent"},
     414                    methodResult="
     415        Dialog(tab = \"cc\", group = \"new\")
     416        ")}))); 
     417        end  componentRedeclaredWithAnnotationInExtends;
     418       
     419        model componentRedeclaredWithNoAnnotationInExtends
     420            C2 redeclaredWithNoAnnotationInExtends;
     421            annotation(__JModelica(UnitTesting(tests={
     422                InstClassMethodTestCase(
     423                    name="componentRedeclaredWithNoAnnotationInExtends",
     424                    description="Check that the components have correct annotation.",
     425                    methodName="testComponentAnnotations",
     426                    arguments={false, "testComponent"},
     427                    methodResult="
     428        Dialog(tab = \"cc\", group = \"new\")
     429        ")}))); 
     430        end componentRedeclaredWithNoAnnotationInExtends;
     431       
     432        model componentRedeclaredWithEmptyAnnotationInExtends
     433            C3 redeclaredWithEmptyAnnotationInExtends;
     434            annotation(__JModelica(UnitTesting(tests={
     435                InstClassMethodTestCase(
     436                    name="componentRedeclaredWithEmptyAnnotationInExtends",
     437                    description="Check that the components have correct annotation.",
     438                    methodName="testComponentAnnotations",
     439                    arguments={false, "testComponent"},
     440                    methodResult="
     441
     442        ")})));             
     443        end componentRedeclaredWithEmptyAnnotationInExtends;
     444       
     445        model componentRedeclaredInOwnAndAncestorsExtends
     446            C4 redeclaredInOwnAndAncestorsExtends;
     447            annotation(__JModelica(UnitTesting(tests={
     448                InstClassMethodTestCase(
     449                    name="componentRedeclaredInOwnAndAncestorsExtends",
     450                    description="Check that the components have correct annotation.",
     451                    methodName="testComponentAnnotations",
     452                    arguments={false, "testComponent"},
     453                    methodResult="
     454        Dialog(tab = \"cc4\", group = \"extends\")
     455        ")})));             
     456        end componentRedeclaredInOwnAndAncestorsExtends;
     457       
     458        model componentRedeclaredInParentExtends
     459            C5 redeclaredInParentExtends;
     460            annotation(__JModelica(UnitTesting(tests={
     461                InstClassMethodTestCase(
     462                    name="componentRedeclaredInParentExtends",
     463                    description="Check that the components have correct annotation.",
     464                    methodName="testComponentAnnotations",
     465                    arguments={false, "testComponent"},
     466                    methodResult="
     467        Dialog(tab = \"cc4\", group = \"extends\")
     468        ")}))); 
     469        end componentRedeclaredInParentExtends;
     470       
     471        model componentRedeclaredInDeclarationNoAnnotation
     472            C5 redeclaredInDeclarationNoAnnotation(
     473                    redeclare replaceable package testPackage = BaseNoAnnotation,
     474                    redeclare replaceable BaseNoAnnotation testComponent());
     475            annotation(__JModelica(UnitTesting(tests={
     476                InstClassMethodTestCase(
     477                    name="componentRedeclaredInDeclarationNoAnnotation",
     478                    description="Check that the components have correct annotation.",
     479                    methodName="testComponentAnnotations",
     480                    arguments={false, "testComponent"},
     481                    methodResult="
     482        Dialog(tab=\"cc4\", group=\"extends\")
     483        ")})));                 
     484        end componentRedeclaredInDeclarationNoAnnotation;
     485       
     486        model componentRedeclaredInDeclarationWithEmptyAnnotation
     487            C5 redeclaredInDeclarationWithEmptyAnnotation(
     488                    redeclare replaceable package testPackage = BaseNoAnnotation annotation(),
     489                    redeclare replaceable BaseNoAnnotation testComponent() annotation());
     490            annotation(__JModelica(UnitTesting(tests={
     491                InstClassMethodTestCase(
     492                    name="componentRedeclaredInDeclarationWithEmptyAnnotation",
     493                    description="Check that the components have correct annotation.",
     494                    methodName="testComponentAnnotations",
     495                    arguments={false, "TestComponent"},
     496                    methodResult="
     497
     498        ")})));           
     499        end componentRedeclaredInDeclarationWithEmptyAnnotation;
     500       
     501        model componentRedeclaredInDeclaration
     502            C5  redeclaredInDeclaration(
     503                    redeclare replaceable package testPackage = BaseNoAnnotation
     504                        annotation(Dialog(tab="redeclaredInDeclaration", group="extends")),
     505                    redeclare replaceable BaseNoAnnotation testComponent()
     506                        annotation(Dialog(tab="redeclaredInDeclaration", group="component"))
     507                    );
     508            annotation(__JModelica(UnitTesting(tests={
     509                InstClassMethodTestCase(
     510                    name="componentRedeclaredInDeclaration",
     511                    description="Check that the components have correct annotation.",
     512                    methodName="testComponentAnnotations",
     513                    arguments={false, "testComponent"},
     514                    methodResult="
     515        Dialog(tab = \"redeclaredInDeclaration\", group = \"component\")
     516        ")}))); 
     517        end componentRedeclaredInDeclaration;
     518    end componentsGetComponent;
     519end inheritance;
    110520
    111521end AnnotationTests;
Note: See TracChangeset for help on using the changeset viewer.