source: trunk/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstLookupComponents.jrag @ 12934

Last change on this file since 12934 was 12934, checked in by Jesper Mattsson, 6 months ago

Reverted r12897 due to some test models failing. (#5752)

File size: 38.5 KB
Line 
1/*
2    Copyright (C) 2009 Modelon AB
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, version 3 of the License.
7
8    This program is distributed in the hope that it will be useful,
9    but WITHOUT ANY WARRANTY; without even the implied warranty of
10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11    GNU General Public License for more details.
12
13    You should have received a copy of the GNU General Public License
14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
15*/
16
17
18aspect InstLookupComponents {
19   
20    class InstComponentDecl implements InstLookupResult.Item {}
21    class InstClassDecl     implements InstLookupResult.Item {}
22    interface InstCallable  extends    InstLookupResult.Item {}
23
24    /**
25     * Result class for lookups in the instance tree.
26     *
27     * Use the static fields and methods to generate results.
28     */
29    public abstract class InstLookupResult<T extends InstLookupResult.Item> {
30
31        public interface Item {
32            public InstLookupResult<InstComponentDecl> memberInstComponent(String name);
33            public InstCallable asCallable();
34        }
35       
36        /**
37         * Indicates that the target was not found.
38         */
39        public static <T extends Item> InstLookupResult<T> notFound() {
40            return (InstLookupResult<T>) NOT_FOUND;
41        }
42
43        /**
44         * Indicates that the target was found.
45         *
46         * Includes the found class or component.
47         */
48        public static <T extends Item> InstLookupResult<T> found(T target) {
49            return new Found(target);
50        }
51
52        /**
53         * Indicates that the target was found, but not accessible due to a constrainedby clause.
54         *
55         * Includes the declaration with the limiting constrainedby clause.
56         */
57        public static <T extends Item> InstLookupResult<T> constrained(T target, InstNode constr) {
58            return new Constrained(target, constr);
59        }
60
61        /**
62         * Indicates that the target was found, but not accessible due to a constrainedby clause.
63         *
64         * Includes the declaration with the limiting constrainedby clause.
65         */
66        public static <T extends Item> InstLookupResult<T> constrained(InstLookupResult<T> res, InstNode constr) {
67            return new Constrained(res.target(), constr);
68        }
69       
70        /**
71         * Indicates that the target was found as an outer, target() returns the corresponding inner.
72         */
73        public static InstLookupResult<InstComponentDecl> outer(InstComponentDecl outer) {
74            return new Outer(outer);
75        }
76
77        /**
78         * Did the lookup succeed?
79         */
80        public boolean successful() {
81            return false;
82        }
83
84        /**
85         * Is this a "not found" result?
86         */
87        public boolean isNotFound() {
88            return false;
89        }
90
91        /**
92         * Is this a result that should generate an error?
93         */
94        public boolean isError() { return false; }
95       
96        /**
97         * Is this a result that should generate an error or warning?
98         */
99        public boolean isProblem() { return false; }
100
101        /**
102         * Get the found class or component, if any.
103         *
104         * Returns <code>null</code> if lookup was not successful.
105         */
106        public T targetOrNull() {
107            return null;
108        }
109       
110        /**
111         * Returns the outer for outer lookup results, this for rest.
112         */
113        public InstLookupResult<T> unresolved() {
114            return this;
115        }
116       
117        /**
118         * @param target The new target
119         * @return a copy of this InstLookupResult with a new target.
120         */
121        public abstract <NT extends Item> InstLookupResult<NT> create(NT target);
122       
123        /**
124         * @param name Name of target subcomponent
125         * @return <code>this</code> if <code>this</code> is an error, else lookup
126         *         result of member <code>name</code> in <code>target()</code>
127         */
128        public abstract InstLookupResult<InstComponentDecl> memberInstComponent(String name);
129       
130        /**
131         * Get the found class or component, if any.
132         *
133         * @throws UnsupportedOperationException  if lookup was not successful.
134         */
135        public T target() {
136            throw new UnsupportedOperationException("Trying to use result of failed name lookup");
137        }
138
139        /**
140         * Get the found class or component, or a default value.
141         *
142         * Returns <code>gen.generate(src)</code> if lookup was not successful.
143         */
144        public T target(DefaultGenerator<T> gen, ASTNode src) {
145            return successful() ? target() : gen.generate(src);
146        }
147
148        /**
149         * Generate warnings and errors for unsuccessful lookup result.
150         *
151         * @param src   node to generate problem on
152         * @param kind  how to describe the declaration being sought, e.g. "component"
153         * @param name  the name being sought
154         */
155        public boolean problem(ASTNode src, String kind, String name) {
156            return false;
157        }
158
159        /**
160         * Generates a default value for {@link #target(DefaultGenerator, ASTNode)}.
161         */
162        public static interface DefaultGenerator<T extends Item> {
163            public T generate(ASTNode src);
164        }
165
166        private final static InstLookupResult NOT_FOUND = new NotFound(); 
167
168        private static class NotFound<T extends Item> extends InstLookupResult<T> {
169           
170            public <NT extends Item> InstLookupResult<NT> create(NT target) {
171                return notFound();
172            }
173           
174            public boolean isNotFound() {
175                return true;
176            }
177           
178            @Override
179            public boolean isError() { return true; }
180           
181            @Override
182            public boolean isProblem() { return true; }
183           
184            @Override
185            public boolean problem(ASTNode src, String kind, String name) {
186                src.error("Cannot find %s declaration for %s", kind, name);
187                return true;
188            }
189           
190            public InstLookupResult<InstComponentDecl> memberInstComponent(String name) {
191                return (InstLookupResult<InstComponentDecl>) this;
192            }
193        }
194
195        private static class Found<T extends Item> extends InstLookupResult<T> {
196            private T target;
197
198            public <NT extends Item> InstLookupResult<NT> create(NT target) {
199                return new Found(target);
200            }
201           
202            public Found(T target) {
203                this.target = target;
204            }
205
206            public boolean successful() {
207                return true;
208            }
209
210            public T target() {
211                return target;
212            }
213
214            public T targetOrNull() {
215                return target;
216            }
217           
218            public InstLookupResult<InstComponentDecl> memberInstComponent(String name) {
219                return target().memberInstComponent(name);
220            }
221        }
222
223        private static class Constrained<T extends Item> extends Found<T> {
224            private InstNode constr;
225
226            public <NT extends Item> InstLookupResult<NT> create(NT target) {
227                return new Constrained(target, constr);
228            }
229           
230            public Constrained(T target, InstNode constr) {
231                super(target);
232                this.constr = constr;
233            }
234           
235            @Override
236            public boolean isError() { return true; }
237           
238            @Override
239            public boolean isProblem() { return true; }
240           
241            @Override
242            public boolean problem(ASTNode src, String kind, String name) {
243                ASTNode.NOT_IN_CONSTRAINING_TYPE.invoke(src, kind, name, constr);
244                return false;
245            }
246           
247        }
248       
249        private static class Outer extends Found<InstComponentDecl> {
250           
251            private InstLookupResult<InstComponentDecl> outer;
252           
253            public InstLookupResult<InstComponentDecl> create(InstComponentDecl target) {
254                return new Outer(target);
255            }
256           
257            public Outer(InstComponentDecl target) {
258                super(target);
259                this.outer = InstLookupResult.found(target);
260            }
261           
262            public InstComponentDecl target() {
263                InstComponentDecl inner = outer.target().myInnerInstComponentDecl();
264                if (inner == null) {
265                    return outer.target().unknownInstComponentDecl();
266                }
267                return inner;
268            }
269
270            public InstComponentDecl targetOrNull() {
271                return target();
272            }
273           
274            public InstLookupResult<InstComponentDecl> unresolved() {
275                return outer;
276            }
277           
278            public InstLookupResult<InstComponentDecl> memberInstComponent(String name) {
279                InstLookupResult<InstComponentDecl> res = super.memberInstComponent(name);
280                if (!res.isError() && !outer.target().memberInstComponent(name).successful())
281                    return new OuterError(res.target());
282                return res;
283            }
284           
285            private class OuterError extends Found<InstComponentDecl> {
286               
287                public InstLookupResult<InstComponentDecl> create(InstComponentDecl target) {
288                    return new OuterError(target);
289                }
290               
291                public OuterError(InstComponentDecl target) {
292                    super(target);
293                }
294               
295                @Override
296                public boolean isError() { return true; }
297               
298                @Override
299                public boolean isProblem() { return true; }
300               
301                @Override
302                public boolean problem(ASTNode src, String kind, String name) {
303                    src.error("Cannot use %s %s in inner '%s', because it is not present in outer '%s'", kind, name, Outer.this.target(), outer.target());
304                    return true;
305                }
306            }
307        }
308    }
309
310    protected static final InstLookupResult.DefaultGenerator<InstComponentDecl> ASTNode.INST_UNKNOWN_COMPONENT = 
311            new InstLookupResult.DefaultGenerator<InstComponentDecl>() {
312        public InstComponentDecl generate(ASTNode src) {
313            return src.unknownInstComponentDecl();
314        }
315    };
316
317    inh InstLookupResult<InstComponentDecl> InstAccess.lookupInstComponent(String name);
318    inh InstLookupResult<InstComponentDecl> InstConstraining.lookupInstComponent(String name);
319    inh lazy InstLookupResult<InstComponentDecl> InstNode.lookupInstComponent(String name);
320    inh lazy InstLookupResult<InstComponentDecl> InstModification.lookupInstComponent(String name);
321    eq InstNode.getChild().lookupInstComponent(String name)   = genericLookupInstComponent(name);
322    eq InstRoot.getChild().lookupInstComponent(String name)   = InstLookupResult.notFound();
323    eq InstImport.getChild().lookupInstComponent(String name) = InstLookupResult.notFound();
324
325    eq InstComponentDecl.getInstModification().lookupInstComponent(String name)          = lookupInstComponent(name);
326    eq InstComponentDecl.getInstConstrainingComponent().lookupInstComponent(String name) = lookupInstComponent(name);
327    eq InstComponentDecl.getConditionalAttribute().lookupInstComponent(String name)      = lookupInstComponent(name);
328    eq InstComponentDecl.getFArraySubscripts().lookupInstComponent(String name)          = lookupInstComponent(name);
329    eq InstComponentDecl.getLocalFArraySubscripts().lookupInstComponent(String name)     = lookupInstComponent(name);
330
331    eq InstExpandableConnectorDecl.getInstComponentDecl(int i).lookupInstComponent(String name)          = 
332        useTemplate(i) ? template(i).lookupInstComponent(name) : genericLookupInstComponent(name);
333    eq InstArrayExpandableConnector.getInstComponentDecl(int i).lookupInstComponent(String name)         = 
334        useTemplate(i) ? template(i).lookupInstComponent(name) : genericLookupInstComponent(name);
335    eq InstReplacingExpandableConnectorDecl.getInstComponentDecl(int i).lookupInstComponent(String name) = 
336        useTemplate(i) ? template(i).lookupInstComponent(name) : genericLookupInstComponent(name);
337
338    eq InstReplacingRecord.getOriginalInstComponent().lookupInstComponent(String name)    = lookupInstComponent(name);
339    eq InstReplacingComposite.getOriginalInstComponent().lookupInstComponent(String name) = lookupInstComponent(name);
340    eq InstReplacingPrimitive.getOriginalInstComponent().lookupInstComponent(String name) = lookupInstComponent(name);
341    eq InstNormalExtends.getInstClassModification().lookupInstComponent(String name)      = lookupInstComponent(name);
342    eq InstExtendsShortClass.getInstClassModification().lookupInstComponent(String name)  = getLookupNode().lookupInstComponent(name);
343    eq InstShortClassDecl.getChild().lookupInstComponent(String name)                     = lookupInstComponent(name);
344    eq InstSimpleShortClassDecl.getChild().lookupInstComponent(String name)               = lookupInstComponent(name);
345    eq InstLibNode.getChild().lookupInstComponent(String name)                            = lookupInstComponent(name);
346    eq InstExternalObject.getDestructorCall().lookupInstComponent(String name)            = lookupInstComponent(name);
347    eq InstConstrainingComponent.getChild().lookupInstComponent(String name)              = 
348        (getInstRedeclare() != null) ? getInstRedeclare().lookupInstComponent(name) : lookupInstComponent(name);
349    eq InstConstrainingClass.getChild().lookupInstComponent(String name)                  = 
350        (getInstRedeclare() != null) ? getInstRedeclare().lookupInstComponent(name) : lookupInstComponent(name);
351
352    eq InstDot.getInstAccess(int i).lookupInstComponent(String name)             = 
353        (i == 0) ? lookupInstComponent(name) : getInstAccessNoListTrans(i - 1).qualifiedLookupInstComponent(name);
354    eq InstScalarAccess.getExpandedSubscripts().lookupInstComponent(String name) = getTopInstAccess().lookupInstComponent(name);
355    eq InstArrayAccess.getFArraySubscripts().lookupInstComponent(String name)    = getTopInstAccess().lookupInstComponent(name);
356    eq InstGlobalAccess.getInstAccess().lookupInstComponent(String name)         = InstLookupResult.notFound();
357   
358   
359    syn InstLookupResult<InstComponentDecl> InstAccess.qualifiedLookupInstComponent(String name) {
360        InstLookupResult<InstComponentDecl> res = qualifiedLookupInstComponentUnconstrained(name);
361        if (res.successful()) { // TODO: limit to only replaceable and replaced components and their children?
362            InstNode constr = lookupConstrainingInstNode();
363            if (constr != null && !constr.memberInstComponent(name).successful())
364                return InstLookupResult.<InstComponentDecl>constrained(res, closestConstrainingDecl());
365        }
366        return res;
367    }
368
369    syn InstLookupResult<InstComponentDecl> InstAccess.qualifiedLookupInstComponentUnconstrained(String name) = 
370        InstLookupResult.notFound();
371    eq InstClassAccess.qualifiedLookupInstComponentUnconstrained(String name)                                 = 
372        myInstClassDecl().memberInstComponent(name);
373    eq InstComponentAccess.qualifiedLookupInstComponentUnconstrained(String name)                             = 
374        lookupArrayElement(myInstLookup()).memberInstComponent(name);
375    eq InstComponentArrayAccess.qualifiedLookupInstComponentUnconstrained(String name)                        = 
376        lookupArrayElement(myInstLookup()).memberInstComponent(name);
377
378    syn InstNode InstAccess.lookupConstrainingInstNode()     = null;
379    eq InstComponentAccess.lookupConstrainingInstNode()      = 
380        lookupArrayElement(inQualified() ? lookupConstrainingInstComponent(name()) : lookupConstrainingInstComponentHelper(null, name()));
381    eq InstComponentArrayAccess.lookupConstrainingInstNode() = 
382        lookupArrayElement(inQualified() ? lookupConstrainingInstComponent(name()) : lookupConstrainingInstComponentHelper(null, name()));
383
384    inh InstComponentDecl InstAccess.lookupConstrainingInstComponent(String name);
385    eq BaseNode.getChild().lookupConstrainingInstComponent(String name)          = null;
386    eq InstDot.getInstAccess(int i).lookupConstrainingInstComponent(String name) =
387        lookupConstrainingInstComponentHelper((i == 0) ? null : getInstAccessNoListTrans(i - 1), name);
388
389    syn InstComponentDecl InstAccess.lookupConstrainingInstComponentHelper(InstAccess part, String name) {
390        InstLookupResult<InstComponentDecl> res;
391        if (part == null) {
392            res = lookupInstComponent(name);
393        } else {
394            InstNode parent = part.lookupConstrainingInstNode();
395            res = (parent != null) ? parent.memberInstComponent(name) : InstLookupResult.<InstComponentDecl>notFound();
396        }
397        if (!res.successful())
398            return null;
399        InstComponentDecl icd = res.target();
400        if (!icd.isReplaceable())
401            return icd;
402        return icd.constrainingInstComponentDecl();
403    }
404
405    syn InstNode InstAccess.closestConstrainingDecl()     = null;
406    eq InstClassAccess.closestConstrainingDecl()          = 
407        myInstClassDecl().isConstrained() ? myInstClassDecl().myConstrainingDecl() : findClosestConstrainingInstNode();
408    eq InstComponentAccess.closestConstrainingDecl()      = 
409        myInstComponentDecl().isConstrained() ? myInstComponentDecl().myConstrainingDecl() : findClosestConstrainingInstNode();
410    eq InstComponentArrayAccess.closestConstrainingDecl() = 
411        myInstComponentDecl().isConstrained() ? myInstComponentDecl().myConstrainingDecl() : findClosestConstrainingInstNode();
412
413    inh InstNode InstAccess.findClosestConstrainingInstNode();
414    eq InstDot.getInstAccess(int i).findClosestConstrainingInstNode() = 
415        (i == 0) ? null : getInstAccessNoListTrans(i - 1).closestConstrainingDecl();
416    eq BaseNode.getChild().findClosestConstrainingInstNode()          = null;
417
418    syn InstNode InstNode.myConstrainingDecl() {
419        if (hasInstConstraining() && getInstConstraining().hasInstRedeclare()) {
420            return getInstConstraining().getRedeclareInstNode();
421        } else {
422            return myDefaultConstrainingDecl();
423        }
424    }
425    eq InstLibNode.myConstrainingDecl() = resolveLib().myConstrainingDecl();
426
427    syn InstNode InstNode.myDefaultConstrainingDecl()                = this;
428    eq InstReplacingFullClassDecl.myDefaultConstrainingDecl()        = getOriginalInstClass();
429    eq InstReplacingShortClassDecl.myDefaultConstrainingDecl()       = getOriginalInstClass();
430    eq InstReplacingSimpleShortClassDecl.myDefaultConstrainingDecl() = getOriginalInstClass();
431    eq InstReplacingComposite.myDefaultConstrainingDecl()            = getOriginalInstComponent();
432    eq InstReplacingRecord.myDefaultConstrainingDecl()               = getOriginalInstComponent();
433    eq InstReplacingPrimitive.myDefaultConstrainingDecl()            = getOriginalInstComponent();
434
435
436    inh InstLookupResult<InstComponentDecl> InstAccess.localLookupInstComponent(String name);
437    eq InstRoot.getChild().localLookupInstComponent(String name)          = InstLookupResult.notFound();
438    eq FlatRoot.getChild().localLookupInstComponent(String name)          = InstLookupResult.notFound();
439    eq InstClassDecl.getChild().localLookupInstComponent(String name)     = memberInstComponent(name);
440    eq InstComponentDecl.getChild().localLookupInstComponent(String name) = memberInstComponent(name);
441
442    syn InstLookupResult<InstComponentDecl> InstValueModification.lookupInstComponentForBindingExp(String name) = lookupInstComponent(name);
443   
444    /**
445     * Get a specific child access, triggering transformations on that child, but *not* on the entire list.
446     */
447    syn InstAccess InstDot.getInstAccessNoListTrans(int i) = getInstAccessListNoTransform().getChild(i);
448
449    /**
450     * Lookup the specific array component corresponding to this access, using current ceval()
451     * value for indices. If no specific component can be found or this access is not to a specific
452     * element, the component for the array is returned.
453     *
454     * @param array  the component node for the array
455     */
456    public InstComponentDecl InstAccess.lookupArrayElement(InstComponentDecl array) {
457        return array;
458    }
459
460    public InstComponentDecl InstArrayAccess.lookupArrayElement(InstComponentDecl array) {
461        if (!isArray() && array != null) {
462            // If we can, try to get the correct InstArrayComponentDecl to do lookup from
463            try {
464                Index i = getFArraySubscripts().createIndex();
465                InstComponentDecl icd = array;
466                for (int dim = 0; dim < i.ndims(); dim++) {
467                    int j = i.get(dim) - 1;
468                    if (j < 0 || j >= icd.getNumInstComponentDecl()) {
469                        return array;
470                    } else {
471                        icd = icd.getInstComponentDecl(j);
472                        if (!(icd instanceof InstArrayComponentDecl))
473                            return array;
474                    }
475                }
476                return icd;
477            } catch (ConstantEvaluationException e) {
478            }
479        }
480        return array;
481    }
482   
483    public InstLookupResult<InstComponentDecl> InstAccess.lookupArrayElement(InstLookupResult<InstComponentDecl> array) {
484        if (array.isError()) {
485            return array;
486        }
487       
488        InstComponentDecl icd = lookupArrayElement(array.target());
489        if (icd == array.target()) {
490            return array;
491        }
492        return array.create(icd);
493    }
494
495    /**
496     * Lookup component, re-evaluating any array accesses except in last component.
497     */
498    public InstComponentDecl InstAccess.lookupEvaluatingIndices() {
499        InstAccess cur = getFirstInstAccess();
500        InstComponentDecl icd = cur.myInstComponentDecl();
501       
502        InstAccess next = cur.getNextInstAccess();
503        while (next != null && icd != null && !icd.isUnknown()) {
504            icd = cur.lookupArrayElement(icd);
505            icd = icd.memberInstComponent(next.name()).targetOrNull();
506            cur = next;
507            next = next.getNextInstAccess();
508        }
509        icd = cur.lookupArrayElement(icd);
510       
511        return (icd == null) ? unknownInstComponentDecl() : icd;
512    }
513
514    inh InstLookupResult<InstComponentDecl> FIterExp.lookupInstComponent(String name);
515    inh InstLookupResult<InstComponentDecl> InstForClauseE.lookupInstComponent(String name);
516    inh InstLookupResult<InstComponentDecl> InstForStmt.lookupInstComponent(String name);
517    inh InstLookupResult<InstComponentDecl> InstForIndex.lookupInstComponent(String name);
518
519    /*
520     * Ensures that lookup of for-indices is only performed from right to left in order
521     * to avoid lookup loops within them.
522     */
523    eq InstForClauseE.getChild().lookupInstComponent(String name) =
524            getInstForIndex(getNumInstForIndex() - 1).localLookupInstComponent(name);
525    eq InstForClauseE.getInstForIndex(int index).lookupInstComponent(String name) =
526            index == 0 ? lookupInstComponent(name) : getInstForIndex(index - 1).localLookupInstComponent(name);
527    eq InstForStmt.getChild().lookupInstComponent(String name) =
528            getInstForIndex(getNumInstForIndex() - 1).localLookupInstComponent(name);
529    eq InstForStmt.getInstForIndex(int index).lookupInstComponent(String name) =
530            index == 0 ? lookupInstComponent(name) : getInstForIndex(index - 1).localLookupInstComponent(name);
531    eq FIterExp.getChild().lookupInstComponent(String name) =
532            getForIndex(getNumForIndex() - 1).localLookupInstComponent(name);
533    eq FIterExp.getForIndex(int index).lookupInstComponent(String name) =
534            index == 0 ? lookupInstComponent(name) : getForIndex(index - 1).localLookupInstComponent(name);
535
536    syn InstLookupResult<InstComponentDecl> CommonForIndex.localLookupInstComponent(String name) = null;
537    syn InstLookupResult<InstComponentDecl> InstForIndex.localLookupInstComponent(String name) {
538        InstPrimitive var = getInstPrimitive();
539        if (var.name().equals(name)) {
540            return InstLookupResult.<InstComponentDecl> found(var);
541        }
542        return lookupInstComponent(name);
543    }
544
545    eq SourceRoot.getChild().lookupInstComponent(String name) = InstLookupResult.notFound();
546    // This equation is necessary since InstAccesses may be present in FExps.
547    eq FlatRoot.getChild().lookupInstComponent(String name)   = InstLookupResult.notFound();
548
549    inh InstLookupResult<InstComponentDecl> InstRecordConstructor.lookupInstComponent(String name);
550    eq InstRecordConstructor.getChild().lookupInstComponent(String name)             = lookupInstComponent(name);
551    eq InstRecordConstructor.getInstComponentDecl().lookupInstComponent(String name) = genericLookupInstComponent(name);
552
553    syn lazy InstLookupResult<InstComponentDecl> InstRecordConstructor.genericLookupInstComponent(String name) {
554        InstLookupResult<InstComponentDecl> res = localLookupInstComponent(name);
555        return res.successful() ? res : lookupInstComponent(name);
556    }
557
558    syn lazy InstLookupResult<InstComponentDecl> InstRecordConstructor.localLookupInstComponent(String name) {
559        for (InstComponentDecl icd : getInstComponentDecls()) {
560            if (icd.matches(name)) {
561                return InstLookupResult.<InstComponentDecl>found(icd);
562            }
563        }
564        for (InstExtends ie : getInstExtendss()) {
565            InstLookupResult<InstComponentDecl> res = ie.memberInstComponent(name);
566            if (res.successful()) {
567                return res;
568            }
569        }
570        return InstLookupResult.notFound();
571    }
572
573    /**
574     * Lookup name in the record declaration.
575     */
576    syn InstComponentDecl InstRecordConstructor.declarationInstComponent(String name) = 
577        myInstClassDecl().memberInstComponent(name).target(INST_UNKNOWN_COMPONENT, this);
578
579    syn lazy InstLookupResult<InstComponentDecl> InstNode.genericLookupInstComponent(String name) {
580        InstLookupResult<InstComponentDecl> res = memberInstComponent(name);
581        if (res.successful())
582            return res;
583        for (InstImport ii : getInstImports()) {
584            res = ii.lookupInstConstantInImport(name);
585            if (res.successful())
586                return res;
587        }
588        return genericLookupInstConstant(name);
589    }
590    eq InstSimpleShortClassDecl.genericLookupInstComponent(String name) = actualInstClass().genericLookupInstComponent(name);
591    eq InstLibNode.genericLookupInstComponent(String name)              = actualInstClass().genericLookupInstComponent(name);
592
593    syn InstLookupResult<InstComponentDecl> InstNode.genericLookupInstConstant(String name) = lookupInstConstant(name);
594    eq InstComponentDecl.genericLookupInstConstant(String name)                             = myInstClass().lookupInstConstant(name);
595    eq InstExtends.genericLookupInstConstant(String name)                                   = myInstClass().lookupInstConstant(name);
596
597
598    syn InstLookupResult<InstComponentDecl> InstNode.arrayMemberInstComponent(String name, int ndims) {
599        if (ndims == 0) 
600            return memberInstComponent(name);
601        return getInstComponentDecl(0).arrayMemberInstComponent(name, ndims - 1);
602    }
603    eq InstSimpleShortClassDecl.arrayMemberInstComponent(String name, int ndims) = actualInstClass().arrayMemberInstComponent(name, ndims);
604    eq InstLibNode.arrayMemberInstComponent(String name, int ndims)              = actualInstClass().arrayMemberInstComponent(name, ndims);
605
606    syn lazy InstLookupResult<InstComponentDecl> InstNode.memberInstComponent(String name)  {
607        if (isArray()) {
608            return arrayMemberInstComponent(name, ndims());
609        } else {   
610            for (InstComponentDecl ic : getInstComponentDecls()) 
611                if (ic.matches(name))
612                    return findInnerComponentIfAny(ic.duplicateOriginal());
613
614            for (InstExtends ie : getInstExtendss()) {
615                InstLookupResult<InstComponentDecl> res = ie.memberInstComponent(name);
616                if (res.successful())
617                    return res;
618            }
619           
620            return InstLookupResult.notFound();
621        }
622    }
623    eq InstSimpleShortClassDecl.memberInstComponent(String name) = actualInstClass().memberInstComponent(name);
624    eq InstLibNode.memberInstComponent(String name)              = actualInstClass().memberInstComponent(name);
625   
626    public InstLookupResult InstNode.findInnerComponentIfAny(InstComponentDecl icd) {
627        if (icd.isOuter()) {
628            return InstLookupResult.outer(icd);
629        }
630        return InstLookupResult.found(icd);
631    }
632   
633   
634    inh lazy InstLookupResult<InstComponentDecl> InstNode.lookupInstConstant(String name);
635    eq Root.getChild().lookupInstConstant(String name)        = InstLookupResult.notFound();
636    eq InstNode.getChild().lookupInstConstant(String name)    = memberInstConstantFirst(name);
637    eq InstLibNode.getChild().lookupInstConstant(String name) = lookupInstConstant(name);
638
639    syn InstLookupResult<InstComponentDecl> InstNode.memberInstConstantFirst(String name) {
640        InstLookupResult<InstComponentDecl> res = memberInstConstantWithExtends(name);
641        if (res.successful())
642            return res;
643       
644        for (InstImport ii : getInstImports()) {
645            res = ii.lookupInstConstantInImport(name);
646            if (res.successful())
647                return res;
648        }
649       
650        return lookupInstConstant(name);
651    }
652    eq InstSimpleShortClassDecl.memberInstConstantFirst(String name) = actualInstClass().memberInstConstantFirst(name);
653    eq InstLibNode.memberInstConstantFirst(String name)              = actualInstClass().memberInstConstantFirst(name);
654
655    syn lazy InstLookupResult<InstComponentDecl> InstNode.memberInstConstantWithExtends(String name) {
656        InstLookupResult<InstComponentDecl> res = memberInstConstant(name);
657        if (res.successful())
658            return res;
659       
660        for (InstExtends ie : getInstExtendss()) {
661            res = ie.memberInstConstantWithExtends(name);
662            if (res.successful())
663                return res;
664        }
665       
666        return InstLookupResult.notFound();
667    }
668    eq InstSimpleShortClassDecl.memberInstConstantWithExtends(String name) = actualInstClass().memberInstConstantWithExtends(name);
669    eq InstLibNode.memberInstConstantWithExtends(String name)              = actualInstClass().memberInstConstantWithExtends(name);
670
671    syn lazy InstLookupResult<InstComponentDecl> InstNode.memberInstConstant(String name) {
672        for (InstComponentDecl ic : getInstComponentDecls()) 
673            if (ic.getSrcComponentDecl().isConstant() && ic.matches(name))
674                return InstLookupResult.found(ic.duplicateOriginal());
675       
676        return InstLookupResult.notFound();
677    }
678    eq InstSimpleShortClassDecl.memberInstConstant(String name) = actualInstClass().memberInstConstant(name);
679    eq InstLibNode.memberInstConstant(String name)              = actualInstClass().memberInstConstant(name);
680
681    syn InstLookupResult<InstComponentDecl> InstImport.lookupInstConstantInImport(String name) {
682        // Assume import points to a single (constant) component
683        if (name.equals(name())) {
684            String className = getPackageName().enclosingName();
685            if (!className.equals("")) {
686                InstClassDecl icd = ((SourceRoot)root()).getProgram().getInstProgramRoot().
687                   simpleLookupInstClassDecl(className);
688                return icd.memberInstConstant(getPackageName().getLastInstAccess().name());
689            }
690        }
691        return InstLookupResult.notFound();
692    }
693
694    eq InstImportUnqualified.lookupInstConstantInImport(String name)  {
695        return getImportedClass().memberInstConstant(name);
696    }
697
698    // This is needed since the member components of InstPrimitive:s (which are attributes)
699    // are not instantiated
700    eq InstPrimitive.memberInstComponent(String name)      = myInstClass().memberInstComponent(name);
701    eq InstExtends.memberInstComponent(String name)   = 
702        extendsPrimitive() ? myInstClass().memberInstComponent(name) : super.memberInstComponent(name);
703
704    eq InstComponentDecl.matches(String str) = name().equals(str);
705    eq InstForIndex.matches(String str)      = getInstPrimitive().matches(str);
706
707
708    /**
709     * Check if this access has a lookup error.
710     */
711    syn boolean InstAccess.hasLookupProblem()      = false;
712    eq InstAmbiguousAccess.hasLookupProblem()      = true;
713    eq InstAmbiguousArrayAccess.hasLookupProblem() = true;
714    eq InstGlobalAccess.hasLookupProblem()         = getInstAccess().hasLookupProblem();
715    eq InstDot.hasLookupProblem()                  = getInstAccess(getNumInstAccess() - 1).hasLookupProblem();
716    eq InstNamedAccess.hasLookupProblem()          = myInstLookup().isProblem();
717
718    syn InstComponentDecl InstAccess.myInstComponentDecl() = unknownInstComponentDecl();
719    eq InstDot.myInstComponentDecl()                       = getLastInstAccess().myInstComponentDecl();
720    eq InstGlobalAccess.myInstComponentDecl()              = getInstAccess().myInstComponentDecl();
721    eq InstComponentAccess.myInstComponentDecl()           = myInstLookup().target(INST_UNKNOWN_COMPONENT, this);
722    eq InstComponentArrayAccess.myInstComponentDecl()      = myInstLookup().target(INST_UNKNOWN_COMPONENT, this);
723   
724    syn InstLookupResult<InstComponentDecl> InstAccess.myInstLookupComponent() = lookupInstComponent(name());
725   
726    syn InstLookupResult<? extends InstLookupResult.Item>  InstAccess.myInstLookup() = myInstLookupClass();
727    eq InstDot.myInstLookup()          = getLastInstAccess().myInstLookup();
728    eq InstGlobalAccess.myInstLookup() = getInstAccess().myInstLookup();
729    syn lazy InstLookupResult<InstComponentDecl> InstComponentAccess.myInstLookup()      = myInstLookupComponent();
730    syn lazy InstLookupResult<InstComponentDecl> InstComponentArrayAccess.myInstLookup() = myInstLookupComponent();
731
732    syn InstComponentDecl InstAccess.myInstComponentElement() = unknownInstComponentDecl();
733    eq InstDot.myInstComponentElement()                       = getLastInstAccess().myInstComponentElement();
734    eq InstGlobalAccess.myInstComponentElement()              = getInstAccess().myInstComponentElement();
735    eq InstComponentAccess.myInstComponentElement()           = 
736        lookupArrayElement(myInstLookup()).target(INST_UNKNOWN_COMPONENT, this);
737    eq InstComponentArrayAccess.myInstComponentElement()      = 
738        lookupArrayElement(myInstLookup()).target(INST_UNKNOWN_COMPONENT, this);
739}
740
741aspect LookupInstComponentsInModifications {
742
743    eq InstNamedModification.getName().lookupInstComponent(String name) = lookupInstComponentInInstElement(name);
744
745    /**
746     * This attribute defines the lookup mechanism for left hand component references in modifications.
747     * They are looked up in the element that the modification is attached to, not the surrounding scope.
748     */
749    inh InstLookupResult<InstComponentDecl> InstElementModification.lookupInstComponentInInstElement(String name);
750    inh InstLookupResult<InstComponentDecl> InstNamedModification.lookupInstComponentInInstElement(String name);
751    inh InstLookupResult<InstComponentDecl> InstComponentRedeclare.lookupInstComponentInInstElement(String name);
752
753    eq InstConstrainingClass.getInstClassModification().lookupInstComponentInInstElement(String name)     = getInstNode().memberInstComponent(name).unresolved();
754    eq InstConstrainingComponent.getInstClassModification().lookupInstComponentInInstElement(String name) = getInstNode().memberInstComponent(name).unresolved();
755    eq InstComponentDecl.getInstModification().lookupInstComponentInInstElement(String name)              = memberInstComponent(name).unresolved();
756    eq InstNode.getElementInstModification().lookupInstComponentInInstElement(String name)                = memberInstComponent(name).unresolved();
757    eq InstElementModification.getInstModification().lookupInstComponentInInstElement(String name)        = getName().qualifiedLookupInstComponent(name);
758    eq InstNormalExtends.getInstClassModification().lookupInstComponentInInstElement(String name)         = memberInstComponent(name).unresolved();
759    eq InstComponentRedeclare.getName().lookupInstComponent(String name)                                  = lookupInstComponentInInstElement(name);
760    eq InstRoot.getChild().lookupInstComponentInInstElement(String name)                                  = InstLookupResult.notFound();
761    eq FlatRoot.getChild().lookupInstComponentInInstElement(String name)                                  = InstLookupResult.notFound();
762
763    /**
764     * Find the actual redeclared component for a redeclaration modification.
765     */
766    syn InstComponentDecl InstComponentRedeclare.myInstReplacingComponent() = 
767        lookupInstReplacingComponent(name()).target(INST_UNKNOWN_COMPONENT, this);
768
769    inh InstLookupResult<InstComponentDecl> InstComponentRedeclare.lookupInstReplacingComponent(String name);
770    eq InstNamedModification.getChild().lookupInstReplacingComponent(String name) = getName().qualifiedLookupInstComponent(name);
771    eq InstNode.getChild().lookupInstReplacingComponent(String name)              = memberInstComponent(name).unresolved();
772    eq Root.getChild().lookupInstReplacingComponent(String name)                  = InstLookupResult.notFound();
773
774}
775
776aspect SimpleLookupInstComponentDecl {
777    syn InstComponentDecl InstNode.simpleLookupInstComponentDecl(String name) {
778        for (InstComponentDecl icd : getInstComponentDecls()) {
779            if (icd.name().matches(name))
780                return icd;
781        }
782        for (InstExtends ie : getInstExtendss()) {
783            InstComponentDecl match = ie.simpleLookupInstComponentDecl(name);
784            if (match != null)
785                return match;
786        }
787        return null;
788    }
789}
Note: See TracBrowser for help on using the repository browser.