Changeset 12341


Ignore:
Timestamp:
Feb 13, 2019 7:20:40 PM (10 months ago)
Author:
amartensen
Message:

#5726 reverse-merged r12311 r12306 to branches/2.8.x

Location:
branches/2.8.x
Files:
1 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • branches/2.8.x

  • branches/2.8.x/CHANGELOG.txt

    r12329 r12341  
    11================= Unreleased ==================
    2 # Feature ; Minor ; Compiler ; #5726
    3 Orginal annotations should be preserved when classes are redeclared
    4  unless new annotations are added in the redeclaring declaration.
    52
    63; Feature ; Minor ; Compiler ; #5725
  • branches/2.8.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternalCeval.jrag

    r12328 r12341  
    260260    eq CommonAccessExp.externalArgument() = myCommonVarDecl().externalArgument(this);
    261261
    262     public interface CommonVariableDecl {
     262    interface CommonVariableDecl {
    263263        ExternalArgument externalArgument(FExp exp);
    264264    }
  • branches/2.8.x/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r12328 r12341  
    32553255        public CValue ceval(VariableEvaluator evaluator, Index i);
    32563256        public String name();
    3257         public String qualifiedName();
    32583257        public Size size();
    32593258        public TypePrefixVariability variability();
  • branches/2.8.x/Compiler/ModelicaFlatTree/src/jastadd/FlatUtil.jrag

    r12328 r12341  
    334334    syn String FFunctionDecl.qualifiedName()     = name();
    335335    syn String FFunctionVariable.qualifiedName() = name();
    336     syn String FAbstractVariable.qualifiedName() = name();
    337336   
    338337    syn String FAbstractFunctionCall.name();
  • branches/2.8.x/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstanceTree.jrag

    r12329 r12341  
    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      */
    515511    syn Environment InstNode.filteredEnvironment() = nameScope() ? myEnvironment(name()) : myEnvironment();
    516512
     
    529525    }
    530526
    531     /**
    532      * Helper method for calculating the environment.
    533      */
    534527    inh Environment InstExtends.myEnvironmentNoClass();
    535528    inh Environment InstExtends.myEnvironmentClass();
     
    612605    }
    613606
    614     eq Program.getInstProgramRoot().myEnvironment() = new Environment();
    615     eq Program.getInstProgramRoot().myEnvironment(String name) = new Environment();
     607    eq Program.getInstProgramRoot().myEnvironment() = new Environment();
     608    eq Program.getInstProgramRoot().myEnvironment(String name) = new Environment();
    616609
    617610    syn lazy List<InstArrayModification> InstValueModification.getInstArrayModificationList() {
     
    671664   
    672665   
    673     /**
    674     * Find the InstModification containing this expression, if any.
    675     */
    676     inh InstModification FExp.surroundingInstModification();
     666    /**
     667    * Find the InstModification containing this expression, if any.
     668    */
     669    inh InstModification FExp.surroundingInstModification();
    677670    eq InstModification.getChild().surroundingInstModification() = this;
    678671    eq InstNode.getChild().surroundingInstModification()         = null;
    679672    eq Root.getChild().surroundingInstModification()             = null;
    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 
     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   
    690683    syn InstClassRedeclare InstModification.matchInstClassRedeclare(String name) = null;
    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     }
     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    }
    706699
    707700    syn InstComponentRedeclare InstNode.retrieveConstrainingComponent(String name) {
     
    714707    }
    715708
    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     }
     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    }
    725718
    726719    syn InstRedeclareClassNode InstNode.retrieveConstrainingClass(String name) {
     
    733726    }
    734727
    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     }
     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    }
    756749    eq InstRoot.getChild().lookupReplacingClass(String name) = null;
    757750    eq Root.getChild().lookupReplacingClass(String name)     = null;
     
    912905    }
    913906   
    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     }
     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    }
    925918
    926919
     
    10761069
    10771070
    1078     syn lazy List<InstModification> InstNode.getElementInstModificationList() {
     1071    syn lazy List<InstModification> InstNode.getElementInstModificationList() {
    10791072        List<InstModification> l = new List<InstModification>();
    10801073        for (SrcModificationOrRedeclareElement m : elementModifications())
    10811074            l.add(m.newInstModification());
    10821075        return l;
    1083     }
     1076    }
    10841077
    10851078
     
    11061099     
    11071100     rewrite InstCreateComponentDecl {
    1108          to InstComponentDecl getClassName().myInstClassDecl().newInstComponentDecl(getSrcComponentDecl());
     1101        to InstComponentDecl getClassName().myInstClassDecl().newInstComponentDecl(getSrcComponentDecl());
    11091102     }
    11101103     
    11111104     rewrite InstCreateForIndexPrimitive {
    1112          to InstPrimitive (InstPrimitive) getClassName().myInstClassDecl().newInstComponentDecl(getSrcComponentDecl());
     1105        to InstPrimitive (InstPrimitive) getClassName().myInstClassDecl().newInstComponentDecl(getSrcComponentDecl());
    11131106     }
    11141107
     
    12071200    }
    12081201
    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 
     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   
    12191212
    12201213    public InstComponentDecl InstClassDecl.newInstComponentDecl(SrcComponentDecl cd) {
     
    14851478    // Create InstRestriction
    14861479    public InstRestriction SrcBaseClassDecl.newInstRestriction() {
    1487         return getSrcRestriction().newInstRestriction();
     1480        return getSrcRestriction().newInstRestriction();
    14881481    }
    14891482   
     
    15661559    }
    15671560
    1568     public InstAccess SrcComponentDecl.newInstClassAccess() {
    1569         return getClassName().newInstAccess();
    1570     }
     1561    public InstAccess SrcComponentDecl.newInstClassAccess() {
     1562        return getClassName().newInstAccess();
     1563    }
    15711564
    15721565    public abstract InstAccess SrcAccess.newInstAccess();
     
    15991592    }
    16001593
    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();
     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();
    16061599
    16071600    syn lazy InstProgramRoot Program.getInstProgramRoot() {
     
    16091602    }
    16101603
    1611     syn lazy InstClassDecl InstClassRedeclare.getInstClassDecl() {
    1612         return getSrcClassRedeclare().getSrcBaseClassDecl().newInstClassDecl();
    1613     }
     1604    syn lazy InstClassDecl InstClassRedeclare.getInstClassDecl() {
     1605        return getSrcClassRedeclare().getSrcBaseClassDecl().newInstClassDecl();
     1606    }
    16141607
    16151608    syn lazy InstComponentDecl InstComponentRedeclare.getInstComponentDecl() =
    16161609        new InstCreateComponentDecl(getComponentRedeclareDecl(), null);
    16171610
    1618     syn lazy InstComponentDecl InstReplacingRecord.getOriginalInstComponent() =
    1619         new InstCreateComponentDecl(getOriginalDecl(), null);
     1611    syn lazy InstComponentDecl InstReplacingRecord.getOriginalInstComponent() =
     1612        new InstCreateComponentDecl(getOriginalDecl(), null);
    16201613
    16211614    syn lazy InstComponentDecl InstReplacingComposite.getOriginalInstComponent() =
     
    16261619
    16271620
    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; }
     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; }
    16411634
    16421635    /**
     
    16481641    public FExp InstGivenArgument.getOriginalFExp()    { return getFExpNoTransform(); }
    16491642
    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     }
     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    }
    16821675
    16831676    syn boolean InstShortClassDecl.shouldBeExpanded() =
     
    16911684        (isFunction() && !instModificationsFromConstrainingType().isEmpty());
    16921685
    1693     syn boolean SrcClassDecl.hasSrcTypePrefix() = false;
    1694     eq SrcShortClassDecl.hasSrcTypePrefix()     = getSrcExtendsClauseShortClass().hasSrcTypePrefix();
    1695 
    1696     syn boolean SrcExtendsClauseShortClass.hasSrcTypePrefix() =
    1697         hasSrcTypePrefixFlow() || hasSrcTypePrefixVariability() || hasSrcTypePrefixInputOutput();
     1686    syn boolean SrcClassDecl.hasSrcTypePrefix() = false;
     1687    eq SrcShortClassDecl.hasSrcTypePrefix()     = getSrcExtendsClauseShortClass().hasSrcTypePrefix();
     1688   
     1689    syn boolean SrcExtendsClauseShortClass.hasSrcTypePrefix() =
     1690        hasSrcTypePrefixFlow() || hasSrcTypePrefixVariability() || hasSrcTypePrefixInputOutput();
    16981691
    16991692    syn lazy InstAccess InstSimpleShortClassDecl.getTarget() =
     
    17251718        throw new UnsupportedOperationException();
    17261719    }
    1727 
     1720   
    17281721    public List<InstClassDecl> InstSimpleShortClassDecl.getInstClassDeclList() {
    17291722        throw new UnsupportedOperationException();
     
    17321725        throw new UnsupportedOperationException();
    17331726    }
    1734 
     1727   
    17351728    public List<InstExtends> InstSimpleShortClassDecl.getInstExtendsList() {
    17361729        throw new UnsupportedOperationException();
     
    17391732        throw new UnsupportedOperationException();
    17401733    }
    1741 
     1734   
    17421735    public List<InstImport> InstSimpleShortClassDecl.getInstImportList() {
    17431736        throw new UnsupportedOperationException();
     
    17461739        throw new UnsupportedOperationException();
    17471740    }
    1748 
     1741   
    17491742    public List<InstClassDecl> InstSimpleShortClassDecl.getRedeclaredInstClassDeclList() {
    17501743        throw new UnsupportedOperationException();
     
    18721865    eq SrcDummyModification.instantiateExp()       = myFExp().treeCopy();
    18731866
    1874     public List InstNode.buildFAbstractEquationList() {
    1875     List l = new List();
     1867    public List InstNode.buildFAbstractEquationList() {
     1868        List l = new List();
    18761869        for (SrcAbstractEquation e : equations()) {
    1877             l.add(e.instantiate());
     1870            l.add(e.instantiate());
    18781871        }
    18791872        for (SrcAlgorithm a : algorithms()) {
    1880             l.add(a.instantiate());
     1873            l.add(a.instantiate());
    18811874        }
    18821875        for (FAlgorithm a : fAlgorithms()) {
     
    18851878        return l;
    18861879    }
    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;
     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;
    19031896}
    19041897
     
    21652158    }
    21662159
    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();
     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();
    21732166   
    21742167    /**
  • branches/2.8.x/Compiler/ModelicaFrontEnd/src/jastadd/util/Annotations.jrag

    r12329 r12341  
    6565
    6666    eq SrcFullClassDecl.annotation(InstContext instContext)           = annotationOfChild(getSrcAnnotationOpt(), instContext);
    67     eq InstClassDecl.annotation(InstContext instContext)              = mySrcAnnotatable().annotation(instContext);
    68     eq InstAbstractShortClassDecl.annotation(InstContext instContext) = mySrcAnnotatable().annotation(instContext);
     67    eq InstClassDecl.annotation(InstContext instContext)              = getSrcClassDecl().annotation(instContext);
    6968    eq SrcShortClassDecl.annotation(InstContext instContext)          = getSrcExtendsClauseShortClass().annotation(instContext);
    7069    eq SrcLibNode.annotation(InstContext instContext)                 = myClass().annotation(instContext);
     
    7473
    7574    eq SrcComponentDecl.annotation(InstContext instContext)  = getSrcComment().annotation(instContext);
    76     eq InstComponentDecl.annotation(InstContext instContext) = mySrcAnnotatable().annotation(instContext);
     75    eq InstComponentDecl.annotation(InstContext instContext) = getSrcComponentDecl().annotation(instContext);
    7776
    7877    eq InstExtends.annotation(InstContext instContext)      = getSrcExtendsClause().annotation(instContext);
     
    107106        return annotationExp(exp).ceval();
    108107    }
    109     public CValue InstNode.ceval(SrcExp exp, VariableEvaluator evaluator) {
    110         return annotationExp(exp).ceval(evaluator);
    111     }
    112108
    113109    public CValue InstExternal.ceval(SrcExp exp) {
    114110      return surroundingInstClass().ceval(exp);
    115     }
    116     public CValue InstExternal.ceval(SrcExp exp, VariableEvaluator evaluator) {
    117         return surroundingInstClass().ceval(exp, evaluator);
    118111    }
    119112
     
    443436    public interface InstContext {
    444437        CValue ceval(SrcExp exp);
    445         CValue ceval(SrcExp exp, VariableEvaluator evaluator);
    446438        InstLookupResult<InstClassDecl>     lookupInstClass(SrcExp exp);
    447439        InstLookupResult<InstComponentDecl> lookupInstComponent(SrcExp exp);
     
    477469            public CValue ceval(SrcExp exp) {
    478470                return exp.ceval();
    479             }
    480 
    481             public CValue ceval(SrcExp exp, VariableEvaluator evaluator) {
    482                 return exp.ceval(evaluator);
    483471            }
    484472
     
    19201908    }
    19211909   
    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 
    21561910}
    21571911
  • branches/2.8.x/Compiler/ModelicaFrontEnd/test/modelica/AnnotationTests.mo

    r12329 r12341  
    108108end ComponentConstrainedByBoth;
    109109
    110 package 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;
    519 end inheritance;
    520110
    521111end AnnotationTests;
Note: See TracChangeset for help on using the changeset viewer.