001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java5/grammar/Generics.ast:43
027     * @production GenericClassDeclSubstituted : {@link GenericClassDecl} ::= <span class="component">&lt;Original:TypeDecl&gt;</span> <span class="component">{@link BodyDecl}*</span>;
028    
029     */
030    public class GenericClassDeclSubstituted extends GenericClassDecl implements Cloneable, MemberSubstitutor {
031      /**
032       * @declaredat ASTNode:1
033       */
034      public GenericClassDeclSubstituted() {
035        super();
036      }
037      /**
038       * Initializes the child array to the correct size.
039       * Initializes List and Opt nta children.
040       * @apilevel internal
041       * @ast method
042       * @declaredat ASTNode:10
043       */
044      public void init$Children() {
045        children = new ASTNode[6];
046        setChild(new Opt(), 1);
047        setChild(new List(), 2);
048        setChild(new List(), 3);
049        setChild(new Opt(), 4);
050        setChild(new List(), 5);
051      }
052      /**
053       * @declaredat ASTNode:18
054       */
055      public GenericClassDeclSubstituted(Modifiers p0, String p1, Opt<Access> p2, List<Access> p3, List<TypeVariable> p4, TypeDecl p5) {
056        setChild(p0, 0);
057        setID(p1);
058        setChild(p2, 1);
059        setChild(p3, 2);
060        setChild(p4, 3);
061        setOriginal(p5);
062      }
063      /**
064       * @declaredat ASTNode:26
065       */
066      public GenericClassDeclSubstituted(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<Access> p3, List<TypeVariable> p4, TypeDecl p5) {
067        setChild(p0, 0);
068        setID(p1);
069        setChild(p2, 1);
070        setChild(p3, 2);
071        setChild(p4, 3);
072        setOriginal(p5);
073      }
074      /**
075       * @apilevel low-level
076       * @declaredat ASTNode:37
077       */
078      protected int numChildren() {
079        return 4;
080      }
081      /**
082       * @apilevel internal
083       * @declaredat ASTNode:43
084       */
085      public boolean mayHaveRewrite() {
086        return false;
087      }
088      /**
089       * @apilevel internal
090       * @declaredat ASTNode:49
091       */
092      public void flushAttrCache() {
093        super.flushAttrCache();
094        getBodyDeclList_reset();
095        sourceTypeDecl_reset();
096        instanceOf_TypeDecl_reset();
097        subtype_TypeDecl_reset();
098        typeDescriptor_reset();
099        constantPoolName_reset();
100        uniqueIndex_reset();
101        strictSubtype_TypeDecl_reset();
102        localMethodsSignatureMap_reset();
103        localFields_String_reset();
104        localTypeDecls_String_reset();
105        constructors_reset();
106      }
107      /**
108       * @apilevel internal
109       * @declaredat ASTNode:67
110       */
111      public void flushCollectionCache() {
112        super.flushCollectionCache();
113      }
114      /**
115       * @apilevel internal
116       * @declaredat ASTNode:73
117       */
118      public void flushRewriteCache() {
119        super.flushRewriteCache();
120      }
121      /**
122       * @apilevel internal
123       * @declaredat ASTNode:79
124       */
125      public GenericClassDeclSubstituted clone() throws CloneNotSupportedException {
126        GenericClassDeclSubstituted node = (GenericClassDeclSubstituted) super.clone();
127        return node;
128      }
129      /**
130       * @apilevel internal
131       * @declaredat ASTNode:86
132       */
133      public GenericClassDeclSubstituted copy() {
134        try {
135          GenericClassDeclSubstituted node = (GenericClassDeclSubstituted) clone();
136          node.parent = null;
137          if (children != null) {
138            node.children = (ASTNode[]) children.clone();
139          }
140          return node;
141        } catch (CloneNotSupportedException e) {
142          throw new Error("Error: clone not supported for " + getClass().getName());
143        }
144      }
145      /**
146       * Create a deep copy of the AST subtree at this node.
147       * The copy is dangling, i.e. has no parent.
148       * @return dangling copy of the subtree at this node
149       * @apilevel low-level
150       * @deprecated Please use treeCopy or treeCopyNoTransform instead
151       * @declaredat ASTNode:105
152       */
153      @Deprecated
154      public GenericClassDeclSubstituted fullCopy() {
155        return treeCopyNoTransform();
156      }
157      /**
158       * Create a deep copy of the AST subtree at this node.
159       * The copy is dangling, i.e. has no parent.
160       * @return dangling copy of the subtree at this node
161       * @apilevel low-level
162       * @declaredat ASTNode:115
163       */
164      public GenericClassDeclSubstituted treeCopyNoTransform() {
165        GenericClassDeclSubstituted tree = (GenericClassDeclSubstituted) copy();
166        if (children != null) {
167          for (int i = 0; i < children.length; ++i) {
168            switch (i) {
169            case 4:
170              tree.children[i] = new Opt();
171              continue;
172            case 5:
173              tree.children[i] = new List();
174              continue;
175            }
176            ASTNode child = (ASTNode) children[i];
177            if (child != null) {
178              child = child.treeCopyNoTransform();
179              tree.setChild(child, i);
180            }
181          }
182        }
183        return tree;
184      }
185      /**
186       * Create a deep copy of the AST subtree at this node.
187       * The subtree of this node is traversed to trigger rewrites before copy.
188       * The copy is dangling, i.e. has no parent.
189       * @return dangling copy of the subtree at this node
190       * @apilevel low-level
191       * @declaredat ASTNode:143
192       */
193      public GenericClassDeclSubstituted treeCopy() {
194        doFullTraversal();
195        return treeCopyNoTransform();
196      }
197      /**
198       * @apilevel internal
199       * @declaredat ASTNode:150
200       */
201      protected boolean is$Equal(ASTNode node) {
202        return super.is$Equal(node) && (tokenString_ID == ((GenericClassDeclSubstituted)node).tokenString_ID) && (tokenTypeDecl_Original == ((GenericClassDeclSubstituted)node).tokenTypeDecl_Original);    
203      }
204      /**
205       * Replaces the Modifiers child.
206       * @param node The new node to replace the Modifiers child.
207       * @apilevel high-level
208       */
209      public void setModifiers(Modifiers node) {
210        setChild(node, 0);
211      }
212      /**
213       * Retrieves the Modifiers child.
214       * @return The current node used as the Modifiers child.
215       * @apilevel high-level
216       */
217      @ASTNodeAnnotation.Child(name="Modifiers")
218      public Modifiers getModifiers() {
219        return (Modifiers) getChild(0);
220      }
221      /**
222       * Retrieves the Modifiers child.
223       * <p><em>This method does not invoke AST transformations.</em></p>
224       * @return The current node used as the Modifiers child.
225       * @apilevel low-level
226       */
227      public Modifiers getModifiersNoTransform() {
228        return (Modifiers) getChildNoTransform(0);
229      }
230      /**
231       * Replaces the lexeme ID.
232       * @param value The new value for the lexeme ID.
233       * @apilevel high-level
234       */
235      public void setID(String value) {
236        tokenString_ID = value;
237      }
238      /**
239       * JastAdd-internal setter for lexeme ID using the Beaver parser.
240       * @param symbol Symbol containing the new value for the lexeme ID
241       * @apilevel internal
242       */
243      public void setID(beaver.Symbol symbol) {
244        if (symbol.value != null && !(symbol.value instanceof String))
245        throw new UnsupportedOperationException("setID is only valid for String lexemes");
246        tokenString_ID = (String)symbol.value;
247        IDstart = symbol.getStart();
248        IDend = symbol.getEnd();
249      }
250      /**
251       * Retrieves the value for the lexeme ID.
252       * @return The value for the lexeme ID.
253       * @apilevel high-level
254       */
255      @ASTNodeAnnotation.Token(name="ID")
256      public String getID() {
257        return tokenString_ID != null ? tokenString_ID : "";
258      }
259      /**
260       * Replaces the optional node for the SuperClass child. This is the <code>Opt</code>
261       * node containing the child SuperClass, not the actual child!
262       * @param opt The new node to be used as the optional node for the SuperClass child.
263       * @apilevel low-level
264       */
265      public void setSuperClassOpt(Opt<Access> opt) {
266        setChild(opt, 1);
267      }
268      /**
269       * Replaces the (optional) SuperClass child.
270       * @param node The new node to be used as the SuperClass child.
271       * @apilevel high-level
272       */
273      public void setSuperClass(Access node) {
274        getSuperClassOpt().setChild(node, 0);
275      }
276      /**
277       * Check whether the optional SuperClass child exists.
278       * @return {@code true} if the optional SuperClass child exists, {@code false} if it does not.
279       * @apilevel high-level
280       */
281      public boolean hasSuperClass() {
282        return getSuperClassOpt().getNumChild() != 0;
283      }
284      /**
285       * Retrieves the (optional) SuperClass child.
286       * @return The SuperClass child, if it exists. Returns {@code null} otherwise.
287       * @apilevel low-level
288       */
289      public Access getSuperClass() {
290        return (Access) getSuperClassOpt().getChild(0);
291      }
292      /**
293       * Retrieves the optional node for the SuperClass child. This is the <code>Opt</code> node containing the child SuperClass, not the actual child!
294       * @return The optional node for child the SuperClass child.
295       * @apilevel low-level
296       */
297      @ASTNodeAnnotation.OptChild(name="SuperClass")
298      public Opt<Access> getSuperClassOpt() {
299        return (Opt<Access>) getChild(1);
300      }
301      /**
302       * Retrieves the optional node for child SuperClass. This is the <code>Opt</code> node containing the child SuperClass, not the actual child!
303       * <p><em>This method does not invoke AST transformations.</em></p>
304       * @return The optional node for child SuperClass.
305       * @apilevel low-level
306       */
307      public Opt<Access> getSuperClassOptNoTransform() {
308        return (Opt<Access>) getChildNoTransform(1);
309      }
310      /**
311       * Replaces the Implements list.
312       * @param list The new list node to be used as the Implements list.
313       * @apilevel high-level
314       */
315      public void setImplementsList(List<Access> list) {
316        setChild(list, 2);
317      }
318      /**
319       * Retrieves the number of children in the Implements list.
320       * @return Number of children in the Implements list.
321       * @apilevel high-level
322       */
323      public int getNumImplements() {
324        return getImplementsList().getNumChild();
325      }
326      /**
327       * Retrieves the number of children in the Implements list.
328       * Calling this method will not trigger rewrites.
329       * @return Number of children in the Implements list.
330       * @apilevel low-level
331       */
332      public int getNumImplementsNoTransform() {
333        return getImplementsListNoTransform().getNumChildNoTransform();
334      }
335      /**
336       * Retrieves the element at index {@code i} in the Implements list.
337       * @param i Index of the element to return.
338       * @return The element at position {@code i} in the Implements list.
339       * @apilevel high-level
340       */
341      public Access getImplements(int i) {
342        return (Access) getImplementsList().getChild(i);
343      }
344      /**
345       * Check whether the Implements list has any children.
346       * @return {@code true} if it has at least one child, {@code false} otherwise.
347       * @apilevel high-level
348       */
349      public boolean hasImplements() {
350        return getImplementsList().getNumChild() != 0;
351      }
352      /**
353       * Append an element to the Implements list.
354       * @param node The element to append to the Implements list.
355       * @apilevel high-level
356       */
357      public void addImplements(Access node) {
358        List<Access> list = (parent == null) ? getImplementsListNoTransform() : getImplementsList();
359        list.addChild(node);
360      }
361      /**
362       * @apilevel low-level
363       */
364      public void addImplementsNoTransform(Access node) {
365        List<Access> list = getImplementsListNoTransform();
366        list.addChild(node);
367      }
368      /**
369       * Replaces the Implements list element at index {@code i} with the new node {@code node}.
370       * @param node The new node to replace the old list element.
371       * @param i The list index of the node to be replaced.
372       * @apilevel high-level
373       */
374      public void setImplements(Access node, int i) {
375        List<Access> list = getImplementsList();
376        list.setChild(node, i);
377      }
378      /**
379       * Retrieves the Implements list.
380       * @return The node representing the Implements list.
381       * @apilevel high-level
382       */
383      @ASTNodeAnnotation.ListChild(name="Implements")
384      public List<Access> getImplementsList() {
385        List<Access> list = (List<Access>) getChild(2);
386        return list;
387      }
388      /**
389       * Retrieves the Implements list.
390       * <p><em>This method does not invoke AST transformations.</em></p>
391       * @return The node representing the Implements list.
392       * @apilevel low-level
393       */
394      public List<Access> getImplementsListNoTransform() {
395        return (List<Access>) getChildNoTransform(2);
396      }
397      /**
398       * Retrieves the Implements list.
399       * @return The node representing the Implements list.
400       * @apilevel high-level
401       */
402      public List<Access> getImplementss() {
403        return getImplementsList();
404      }
405      /**
406       * Retrieves the Implements list.
407       * <p><em>This method does not invoke AST transformations.</em></p>
408       * @return The node representing the Implements list.
409       * @apilevel low-level
410       */
411      public List<Access> getImplementssNoTransform() {
412        return getImplementsListNoTransform();
413      }
414      /**
415       * Replaces the TypeParameter list.
416       * @param list The new list node to be used as the TypeParameter list.
417       * @apilevel high-level
418       */
419      public void setTypeParameterList(List<TypeVariable> list) {
420        setChild(list, 3);
421      }
422      /**
423       * Retrieves the number of children in the TypeParameter list.
424       * @return Number of children in the TypeParameter list.
425       * @apilevel high-level
426       */
427      public int getNumTypeParameter() {
428        return getTypeParameterList().getNumChild();
429      }
430      /**
431       * Retrieves the number of children in the TypeParameter list.
432       * Calling this method will not trigger rewrites.
433       * @return Number of children in the TypeParameter list.
434       * @apilevel low-level
435       */
436      public int getNumTypeParameterNoTransform() {
437        return getTypeParameterListNoTransform().getNumChildNoTransform();
438      }
439      /**
440       * Retrieves the element at index {@code i} in the TypeParameter list.
441       * @param i Index of the element to return.
442       * @return The element at position {@code i} in the TypeParameter list.
443       * @apilevel high-level
444       */
445      public TypeVariable getTypeParameter(int i) {
446        return (TypeVariable) getTypeParameterList().getChild(i);
447      }
448      /**
449       * Check whether the TypeParameter list has any children.
450       * @return {@code true} if it has at least one child, {@code false} otherwise.
451       * @apilevel high-level
452       */
453      public boolean hasTypeParameter() {
454        return getTypeParameterList().getNumChild() != 0;
455      }
456      /**
457       * Append an element to the TypeParameter list.
458       * @param node The element to append to the TypeParameter list.
459       * @apilevel high-level
460       */
461      public void addTypeParameter(TypeVariable node) {
462        List<TypeVariable> list = (parent == null) ? getTypeParameterListNoTransform() : getTypeParameterList();
463        list.addChild(node);
464      }
465      /**
466       * @apilevel low-level
467       */
468      public void addTypeParameterNoTransform(TypeVariable node) {
469        List<TypeVariable> list = getTypeParameterListNoTransform();
470        list.addChild(node);
471      }
472      /**
473       * Replaces the TypeParameter list element at index {@code i} with the new node {@code node}.
474       * @param node The new node to replace the old list element.
475       * @param i The list index of the node to be replaced.
476       * @apilevel high-level
477       */
478      public void setTypeParameter(TypeVariable node, int i) {
479        List<TypeVariable> list = getTypeParameterList();
480        list.setChild(node, i);
481      }
482      /**
483       * Retrieves the TypeParameter list.
484       * @return The node representing the TypeParameter list.
485       * @apilevel high-level
486       */
487      @ASTNodeAnnotation.ListChild(name="TypeParameter")
488      public List<TypeVariable> getTypeParameterList() {
489        List<TypeVariable> list = (List<TypeVariable>) getChild(3);
490        return list;
491      }
492      /**
493       * Retrieves the TypeParameter list.
494       * <p><em>This method does not invoke AST transformations.</em></p>
495       * @return The node representing the TypeParameter list.
496       * @apilevel low-level
497       */
498      public List<TypeVariable> getTypeParameterListNoTransform() {
499        return (List<TypeVariable>) getChildNoTransform(3);
500      }
501      /**
502       * Retrieves the TypeParameter list.
503       * @return The node representing the TypeParameter list.
504       * @apilevel high-level
505       */
506      public List<TypeVariable> getTypeParameters() {
507        return getTypeParameterList();
508      }
509      /**
510       * Retrieves the TypeParameter list.
511       * <p><em>This method does not invoke AST transformations.</em></p>
512       * @return The node representing the TypeParameter list.
513       * @apilevel low-level
514       */
515      public List<TypeVariable> getTypeParametersNoTransform() {
516        return getTypeParameterListNoTransform();
517      }
518      /**
519       * Replaces the lexeme Original.
520       * @param value The new value for the lexeme Original.
521       * @apilevel high-level
522       */
523      public void setOriginal(TypeDecl value) {
524        tokenTypeDecl_Original = value;
525      }
526      /**
527       * @apilevel internal
528       */
529      protected TypeDecl tokenTypeDecl_Original;
530      /**
531       * Retrieves the value for the lexeme Original.
532       * @return The value for the lexeme Original.
533       * @apilevel high-level
534       */
535      @ASTNodeAnnotation.Token(name="Original")
536      public TypeDecl getOriginal() {
537        return tokenTypeDecl_Original;
538      }
539      /**
540       * Replaces the (optional) ImplicitConstructor child.
541       * @param node The new node to be used as the ImplicitConstructor child.
542       * @apilevel high-level
543       */
544      public void setImplicitConstructor(ConstructorDecl node) {
545        getImplicitConstructorOpt().setChild(node, 0);
546      }
547      /**
548       * Check whether the optional ImplicitConstructor child exists.
549       * @return {@code true} if the optional ImplicitConstructor child exists, {@code false} if it does not.
550       * @apilevel high-level
551       */
552      public boolean hasImplicitConstructor() {
553        return getImplicitConstructorOpt().getNumChild() != 0;
554      }
555      /**
556       * Retrieves the (optional) ImplicitConstructor child.
557       * @return The ImplicitConstructor child, if it exists. Returns {@code null} otherwise.
558       * @apilevel low-level
559       */
560      public ConstructorDecl getImplicitConstructor() {
561        return (ConstructorDecl) getImplicitConstructorOpt().getChild(0);
562      }
563      /**
564       * Retrieves the optional node for child ImplicitConstructor. This is the <code>Opt</code> node containing the child ImplicitConstructor, not the actual child!
565       * <p><em>This method does not invoke AST transformations.</em></p>
566       * @return The optional node for child ImplicitConstructor.
567       * @apilevel low-level
568       */
569      public Opt<ConstructorDecl> getImplicitConstructorOptNoTransform() {
570        return (Opt<ConstructorDecl>) getChildNoTransform(4);
571      }
572      /**
573       * Retrieves the child position of the optional child ImplicitConstructor.
574       * @return The the child position of the optional child ImplicitConstructor.
575       * @apilevel low-level
576       */
577      protected int getImplicitConstructorOptChildPosition() {
578        return 4;
579      }
580      /**
581       * This method should not be called. This method throws an exception due to
582       * the corresponding child being an NTA shadowing a non-NTA child.
583       * @param node
584       * @apilevel internal
585       */
586      public void setBodyDeclList(List<BodyDecl> node) {
587        throw new Error("Can not replace NTA child BodyDeclList in GenericClassDeclSubstituted!");
588      }
589      /**
590       * Retrieves the number of children in the BodyDecl list.
591       * @return Number of children in the BodyDecl list.
592       * @apilevel high-level
593       */
594      public int getNumBodyDecl() {
595        return getBodyDeclList().getNumChild();
596      }
597      /**
598       * Retrieves the number of children in the BodyDecl list.
599       * Calling this method will not trigger rewrites.
600       * @return Number of children in the BodyDecl list.
601       * @apilevel low-level
602       */
603      public int getNumBodyDeclNoTransform() {
604        return getBodyDeclListNoTransform().getNumChildNoTransform();
605      }
606      /**
607       * Retrieves the element at index {@code i} in the BodyDecl list.
608       * @param i Index of the element to return.
609       * @return The element at position {@code i} in the BodyDecl list.
610       * @apilevel high-level
611       */
612      public BodyDecl getBodyDecl(int i) {
613        return (BodyDecl) getBodyDeclList().getChild(i);
614      }
615      /**
616       * Check whether the BodyDecl list has any children.
617       * @return {@code true} if it has at least one child, {@code false} otherwise.
618       * @apilevel high-level
619       */
620      public boolean hasBodyDecl() {
621        return getBodyDeclList().getNumChild() != 0;
622      }
623      /**
624       * Append an element to the BodyDecl list.
625       * @param node The element to append to the BodyDecl list.
626       * @apilevel high-level
627       */
628      public void addBodyDecl(BodyDecl node) {
629        List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
630        list.addChild(node);
631      }
632      /**
633       * @apilevel low-level
634       */
635      public void addBodyDeclNoTransform(BodyDecl node) {
636        List<BodyDecl> list = getBodyDeclListNoTransform();
637        list.addChild(node);
638      }
639      /**
640       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
641       * @param node The new node to replace the old list element.
642       * @param i The list index of the node to be replaced.
643       * @apilevel high-level
644       */
645      public void setBodyDecl(BodyDecl node, int i) {
646        List<BodyDecl> list = getBodyDeclList();
647        list.setChild(node, i);
648      }
649      /**
650       * Retrieves the child position of the BodyDecl list.
651       * @return The the child position of the BodyDecl list.
652       * @apilevel low-level
653       */
654      protected int getBodyDeclListChildPosition() {
655        return 5;
656      }
657      /**
658       * Retrieves the BodyDecl list.
659       * <p><em>This method does not invoke AST transformations.</em></p>
660       * @return The node representing the BodyDecl list.
661       * @apilevel low-level
662       */
663      public List<BodyDecl> getBodyDeclListNoTransform() {
664        return (List<BodyDecl>) getChildNoTransform(5);
665      }
666      /**
667       * Retrieves the BodyDecl list.
668       * @return The node representing the BodyDecl list.
669       * @apilevel high-level
670       */
671      public List<BodyDecl> getBodyDecls() {
672        return getBodyDeclList();
673      }
674      /**
675       * Retrieves the BodyDecl list.
676       * <p><em>This method does not invoke AST transformations.</em></p>
677       * @return The node representing the BodyDecl list.
678       * @apilevel low-level
679       */
680      public List<BodyDecl> getBodyDeclsNoTransform() {
681        return getBodyDeclListNoTransform();
682      }
683      /**
684       * @attribute syn
685       * @aspect NestedTypes
686       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:624
687       */
688      @ASTNodeAnnotation.Attribute
689      public TypeDecl hostType() {
690        TypeDecl hostType_value = getOriginal();
691    
692        return hostType_value;
693      }
694      /**
695       * @apilevel internal
696       */
697      protected boolean getBodyDeclList_computed = false;
698      /**
699       * @apilevel internal
700       */
701      protected List getBodyDeclList_value;
702      /**
703       * @apilevel internal
704       */
705      private void getBodyDeclList_reset() {
706        getBodyDeclList_computed = false;
707        getBodyDeclList_value = null;
708      }
709      /**
710       * @attribute syn nta
711       * @aspect LookupParTypeDecl
712       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1236
713       */
714      @ASTNodeAnnotation.Attribute
715      public List getBodyDeclList() {
716        ASTNode$State state = state();
717        if (getBodyDeclList_computed) {
718          return (List) getChild(getBodyDeclListChildPosition());
719        }
720        boolean intermediate = state.INTERMEDIATE_VALUE;
721        state.INTERMEDIATE_VALUE = false;
722        int num = state.boundariesCrossed;
723        boolean isFinal = this.is$Final();
724        getBodyDeclList_value = new BodyDeclList();
725        setChild(getBodyDeclList_value, getBodyDeclListChildPosition());
726        if (isFinal && num == state().boundariesCrossed) {
727          getBodyDeclList_computed = true;
728        } else {
729        }
730        state.INTERMEDIATE_VALUE |= intermediate;
731    
732        List node = (List) this.getChild(getBodyDeclListChildPosition());
733        return node;
734      }
735      /**
736       * @attribute syn
737       * @aspect LookupParTypeDecl
738       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1417
739       */
740      @ASTNodeAnnotation.Attribute
741      public TypeDecl original() {
742        TypeDecl original_value = getOriginal().original();
743    
744        return original_value;
745      }
746      /**
747       * @apilevel internal
748       */
749      protected boolean sourceTypeDecl_computed = false;
750      /**
751       * @apilevel internal
752       */
753      protected TypeDecl sourceTypeDecl_value;
754      /**
755       * @apilevel internal
756       */
757      private void sourceTypeDecl_reset() {
758        sourceTypeDecl_computed = false;
759        sourceTypeDecl_value = null;
760      }
761      /**
762       * @attribute syn
763       * @aspect SourceDeclarations
764       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1618
765       */
766      @ASTNodeAnnotation.Attribute
767      public TypeDecl sourceTypeDecl() {
768        ASTNode$State state = state();
769        if (sourceTypeDecl_computed) {
770          return sourceTypeDecl_value;
771        }
772        boolean intermediate = state.INTERMEDIATE_VALUE;
773        state.INTERMEDIATE_VALUE = false;
774        int num = state.boundariesCrossed;
775        boolean isFinal = this.is$Final();
776        sourceTypeDecl_value = original().sourceTypeDecl();
777        if (isFinal && num == state().boundariesCrossed) {
778          sourceTypeDecl_computed = true;
779        } else {
780        }
781        state.INTERMEDIATE_VALUE |= intermediate;
782    
783        return sourceTypeDecl_value;
784      }
785      /**
786       * @apilevel internal
787       */
788      protected java.util.Map instanceOf_TypeDecl_values;
789      /**
790       * @apilevel internal
791       */
792      private void instanceOf_TypeDecl_reset() {
793        instanceOf_TypeDecl_values = null;
794      }
795      /**
796       * @attribute syn
797       * @aspect TypeWideningAndIdentity
798       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442
799       */
800      @ASTNodeAnnotation.Attribute
801      public boolean instanceOf(TypeDecl type) {
802        Object _parameters = type;
803        if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
804        ASTNode$State state = state();
805        if (instanceOf_TypeDecl_values.containsKey(_parameters)) {
806          return (Boolean) instanceOf_TypeDecl_values.get(_parameters);
807        }
808        boolean intermediate = state.INTERMEDIATE_VALUE;
809        state.INTERMEDIATE_VALUE = false;
810        int num = state.boundariesCrossed;
811        boolean isFinal = this.is$Final();
812        boolean instanceOf_TypeDecl_value = subtype(type);
813        if (isFinal && num == state().boundariesCrossed) {
814          instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value);
815        } else {
816        }
817        state.INTERMEDIATE_VALUE |= intermediate;
818    
819        return instanceOf_TypeDecl_value;
820      }
821      /**
822       * @apilevel internal
823       */
824      private void subtype_TypeDecl_reset() {
825        subtype_TypeDecl_values = null;
826      }
827      protected java.util.Map subtype_TypeDecl_values;
828      @ASTNodeAnnotation.Attribute
829      public boolean subtype(TypeDecl type) {
830        Object _parameters = type;
831        if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
832        ASTNode$State.CircularValue _value;
833        if (subtype_TypeDecl_values.containsKey(_parameters)) {
834          Object _o = subtype_TypeDecl_values.get(_parameters);
835          if (!(_o instanceof ASTNode$State.CircularValue)) {
836            return (Boolean) _o;
837          } else {
838            _value = (ASTNode$State.CircularValue) _o;
839          }
840        } else {
841          _value = new ASTNode$State.CircularValue();
842          subtype_TypeDecl_values.put(_parameters, _value);
843          _value.value = true;
844        }
845        ASTNode$State state = state();
846        boolean new_subtype_TypeDecl_value;
847        if (!state.IN_CIRCLE) {
848          state.IN_CIRCLE = true;
849          int num = state.boundariesCrossed;
850          boolean isFinal = this.is$Final();
851          // TODO: fixme
852          // state().CIRCLE_INDEX = 1;
853          do {
854            _value.visited = state.CIRCLE_INDEX;
855            state.CHANGE = false;
856            new_subtype_TypeDecl_value = type.supertypeGenericClassDeclSubstituted(this);
857            if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
858              state.CHANGE = true;
859              _value.value = new_subtype_TypeDecl_value;
860            }
861            state.CIRCLE_INDEX++;
862          } while (state.CHANGE);
863          if (isFinal && num == state().boundariesCrossed) {
864            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
865          } else {
866            subtype_TypeDecl_values.remove(_parameters);
867            state.RESET_CYCLE = true;
868            boolean $tmp = type.supertypeGenericClassDeclSubstituted(this);
869            state.RESET_CYCLE = false;
870          }
871          state.IN_CIRCLE = false;
872          state.INTERMEDIATE_VALUE = false;
873          return new_subtype_TypeDecl_value;
874        }
875        if (state.CIRCLE_INDEX != _value.visited) {
876          _value.visited = state.CIRCLE_INDEX;
877          new_subtype_TypeDecl_value = type.supertypeGenericClassDeclSubstituted(this);
878          if (state.RESET_CYCLE) {
879            subtype_TypeDecl_values.remove(_parameters);
880          }
881          else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
882            state.CHANGE = true;
883            _value.value = new_subtype_TypeDecl_value;
884          }
885          state.INTERMEDIATE_VALUE = true;
886          return new_subtype_TypeDecl_value;
887        }
888        state.INTERMEDIATE_VALUE = true;
889        return (Boolean) _value.value;
890      }
891      /**
892       * @attribute syn
893       * @aspect GenericsSubtype
894       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:548
895       */
896      @ASTNodeAnnotation.Attribute
897      public boolean supertypeGenericClassDeclSubstituted(GenericClassDeclSubstituted type) {
898        boolean supertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value = original() == type.original() && type.enclosingType().subtype(enclosingType())
899              || super.supertypeGenericClassDeclSubstituted(type);
900    
901        return supertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value;
902      }
903      /**
904       * @attribute syn
905       * @aspect GenericsSubtype
906       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:35
907       */
908      @ASTNodeAnnotation.Attribute
909      public boolean supertypeGenericClassDecl(GenericClassDecl type) {
910        boolean supertypeGenericClassDecl_GenericClassDecl_value = super.supertypeGenericClassDecl(type) || original().supertypeGenericClassDecl(type);
911    
912        return supertypeGenericClassDecl_GenericClassDecl_value;
913      }
914      /**
915       * @apilevel internal
916       */
917      protected boolean typeDescriptor_computed = false;
918      /**
919       * @apilevel internal
920       */
921      protected String typeDescriptor_value;
922      /**
923       * @apilevel internal
924       */
925      private void typeDescriptor_reset() {
926        typeDescriptor_computed = false;
927        typeDescriptor_value = null;
928      }
929      /**
930       * @attribute syn
931       * @aspect ConstantPoolNames
932       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77
933       */
934      @ASTNodeAnnotation.Attribute
935      public String typeDescriptor() {
936        ASTNode$State state = state();
937        if (typeDescriptor_computed) {
938          return typeDescriptor_value;
939        }
940        boolean intermediate = state.INTERMEDIATE_VALUE;
941        state.INTERMEDIATE_VALUE = false;
942        int num = state.boundariesCrossed;
943        boolean isFinal = this.is$Final();
944        typeDescriptor_value = original().typeDescriptor();
945        if (isFinal && num == state().boundariesCrossed) {
946          typeDescriptor_computed = true;
947        } else {
948        }
949        state.INTERMEDIATE_VALUE |= intermediate;
950    
951        return typeDescriptor_value;
952      }
953      /**
954       * @apilevel internal
955       */
956      protected boolean constantPoolName_computed = false;
957      /**
958       * @apilevel internal
959       */
960      protected String constantPoolName_value;
961      /**
962       * @apilevel internal
963       */
964      private void constantPoolName_reset() {
965        constantPoolName_computed = false;
966        constantPoolName_value = null;
967      }
968      /**
969       * For a top-level type the constant pool name of the type is the same as the
970       * canonical name but with dots replaced by solidus.
971       * 
972       * <p>For nested types the constant pool name is based on the enclosing top-level
973       * types constant pool name followed by a dollar sign and a unique index and/or
974       * the type name.
975       * 
976       * @return constant pool name of this type
977       * @attribute syn
978       * @aspect ConstantPoolNames
979       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:44
980       */
981      @ASTNodeAnnotation.Attribute
982      public String constantPoolName() {
983        ASTNode$State state = state();
984        if (constantPoolName_computed) {
985          return constantPoolName_value;
986        }
987        boolean intermediate = state.INTERMEDIATE_VALUE;
988        state.INTERMEDIATE_VALUE = false;
989        int num = state.boundariesCrossed;
990        boolean isFinal = this.is$Final();
991        constantPoolName_value = original().constantPoolName();
992        if (isFinal && num == state().boundariesCrossed) {
993          constantPoolName_computed = true;
994        } else {
995        }
996        state.INTERMEDIATE_VALUE |= intermediate;
997    
998        return constantPoolName_value;
999      }
1000      /**
1001       * @apilevel internal
1002       */
1003      protected boolean uniqueIndex_computed = false;
1004      /**
1005       * @apilevel internal
1006       */
1007      protected int uniqueIndex_value;
1008      /**
1009       * @apilevel internal
1010       */
1011      private void uniqueIndex_reset() {
1012        uniqueIndex_computed = false;
1013      }
1014      /**
1015       * @attribute syn
1016       * @aspect Java2Rewrites
1017       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:33
1018       */
1019      @ASTNodeAnnotation.Attribute
1020      public int uniqueIndex() {
1021        ASTNode$State state = state();
1022        if (uniqueIndex_computed) {
1023          return uniqueIndex_value;
1024        }
1025        boolean intermediate = state.INTERMEDIATE_VALUE;
1026        state.INTERMEDIATE_VALUE = false;
1027        int num = state.boundariesCrossed;
1028        boolean isFinal = this.is$Final();
1029        uniqueIndex_value = original().uniqueIndex();
1030        if (isFinal && num == state().boundariesCrossed) {
1031          uniqueIndex_computed = true;
1032        } else {
1033        }
1034        state.INTERMEDIATE_VALUE |= intermediate;
1035    
1036        return uniqueIndex_value;
1037      }
1038      /**
1039       * @attribute syn
1040       * @aspect CreateBCode
1041       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:900
1042       */
1043      @ASTNodeAnnotation.Attribute
1044      public String arrayTypeDescriptor() {
1045        String arrayTypeDescriptor_value = original().arrayTypeDescriptor();
1046    
1047        return arrayTypeDescriptor_value;
1048      }
1049      /**
1050       * @apilevel internal
1051       */
1052      private void strictSubtype_TypeDecl_reset() {
1053        strictSubtype_TypeDecl_values = null;
1054      }
1055      protected java.util.Map strictSubtype_TypeDecl_values;
1056      @ASTNodeAnnotation.Attribute
1057      public boolean strictSubtype(TypeDecl type) {
1058        Object _parameters = type;
1059        if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1060        ASTNode$State.CircularValue _value;
1061        if (strictSubtype_TypeDecl_values.containsKey(_parameters)) {
1062          Object _o = strictSubtype_TypeDecl_values.get(_parameters);
1063          if (!(_o instanceof ASTNode$State.CircularValue)) {
1064            return (Boolean) _o;
1065          } else {
1066            _value = (ASTNode$State.CircularValue) _o;
1067          }
1068        } else {
1069          _value = new ASTNode$State.CircularValue();
1070          strictSubtype_TypeDecl_values.put(_parameters, _value);
1071          _value.value = true;
1072        }
1073        ASTNode$State state = state();
1074        boolean new_strictSubtype_TypeDecl_value;
1075        if (!state.IN_CIRCLE) {
1076          state.IN_CIRCLE = true;
1077          int num = state.boundariesCrossed;
1078          boolean isFinal = this.is$Final();
1079          // TODO: fixme
1080          // state().CIRCLE_INDEX = 1;
1081          do {
1082            _value.visited = state.CIRCLE_INDEX;
1083            state.CHANGE = false;
1084            new_strictSubtype_TypeDecl_value = type.strictSupertypeGenericClassDeclSubstituted(this);
1085            if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
1086              state.CHANGE = true;
1087              _value.value = new_strictSubtype_TypeDecl_value;
1088            }
1089            state.CIRCLE_INDEX++;
1090          } while (state.CHANGE);
1091          if (isFinal && num == state().boundariesCrossed) {
1092            strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value);
1093          } else {
1094            strictSubtype_TypeDecl_values.remove(_parameters);
1095            state.RESET_CYCLE = true;
1096            boolean $tmp = type.strictSupertypeGenericClassDeclSubstituted(this);
1097            state.RESET_CYCLE = false;
1098          }
1099          state.IN_CIRCLE = false;
1100          state.INTERMEDIATE_VALUE = false;
1101          return new_strictSubtype_TypeDecl_value;
1102        }
1103        if (state.CIRCLE_INDEX != _value.visited) {
1104          _value.visited = state.CIRCLE_INDEX;
1105          new_strictSubtype_TypeDecl_value = type.strictSupertypeGenericClassDeclSubstituted(this);
1106          if (state.RESET_CYCLE) {
1107            strictSubtype_TypeDecl_values.remove(_parameters);
1108          }
1109          else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
1110            state.CHANGE = true;
1111            _value.value = new_strictSubtype_TypeDecl_value;
1112          }
1113          state.INTERMEDIATE_VALUE = true;
1114          return new_strictSubtype_TypeDecl_value;
1115        }
1116        state.INTERMEDIATE_VALUE = true;
1117        return (Boolean) _value.value;
1118      }
1119      /**
1120       * @attribute syn
1121       * @aspect StrictSubtype
1122       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:478
1123       */
1124      @ASTNodeAnnotation.Attribute
1125      public boolean strictSupertypeGenericClassDeclSubstituted(GenericClassDeclSubstituted type) {
1126        boolean strictSupertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value = original() == type.original() && type.enclosingType().strictSubtype(enclosingType())
1127              || super.strictSupertypeGenericClassDeclSubstituted(type);
1128    
1129        return strictSupertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value;
1130      }
1131      /**
1132       * @attribute syn
1133       * @aspect StrictSubtype
1134       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:39
1135       */
1136      @ASTNodeAnnotation.Attribute
1137      public boolean strictSupertypeGenericClassDecl(GenericClassDecl type) {
1138        boolean strictSupertypeGenericClassDecl_GenericClassDecl_value = super.strictSupertypeGenericClassDecl(type)
1139              || original().strictSupertypeGenericClassDecl(type);
1140    
1141        return strictSupertypeGenericClassDecl_GenericClassDecl_value;
1142      }
1143      /**
1144       * @apilevel internal
1145       */
1146      protected boolean localMethodsSignatureMap_computed = false;
1147      /**
1148       * @apilevel internal
1149       */
1150      protected Map<String,SimpleSet> localMethodsSignatureMap_value;
1151      /**
1152       * @apilevel internal
1153       */
1154      private void localMethodsSignatureMap_reset() {
1155        localMethodsSignatureMap_computed = false;
1156        localMethodsSignatureMap_value = null;
1157      }
1158      /**
1159       * @attribute syn
1160       * @aspect LookupParTypeDecl
1161       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1278
1162       */
1163      @ASTNodeAnnotation.Attribute
1164      public Map<String,SimpleSet> localMethodsSignatureMap() {
1165        ASTNode$State state = state();
1166        if (localMethodsSignatureMap_computed) {
1167          return localMethodsSignatureMap_value;
1168        }
1169        boolean intermediate = state.INTERMEDIATE_VALUE;
1170        state.INTERMEDIATE_VALUE = false;
1171        int num = state.boundariesCrossed;
1172        boolean isFinal = this.is$Final();
1173        localMethodsSignatureMap_value = localMethodsSignatureMap_compute();
1174        if (true) {
1175          localMethodsSignatureMap_computed = true;
1176        } else {
1177        }
1178        state.INTERMEDIATE_VALUE |= intermediate;
1179    
1180        return localMethodsSignatureMap_value;
1181      }
1182      /**
1183       * @apilevel internal
1184       */
1185      private Map<String,SimpleSet> localMethodsSignatureMap_compute() {
1186          Map<String,SimpleSet> map = new HashMap<String,SimpleSet>();
1187          for (Iterator<MethodDecl> iter = original().localMethodsIterator(); iter.hasNext(); ) {
1188            MethodDecl decl = iter.next();
1189      
1190            if (!decl.isStatic() && (decl.usesTypeVariable() || isRawType())) {
1191              BodyDecl copyDecl = ((BodyDeclList) getBodyDeclList()).localMethodSignatureCopy(decl, this);
1192              decl = (MethodDecl) copyDecl;
1193            }
1194            putSimpleSetElement(map, decl.signature(), decl);
1195      
1196          }
1197          return map;
1198        }
1199      /**
1200       * @apilevel internal
1201       */
1202      protected java.util.Map localFields_String_values;
1203      /**
1204       * @apilevel internal
1205       */
1206      private void localFields_String_reset() {
1207        localFields_String_values = null;
1208      }
1209      /**
1210       * @attribute syn
1211       * @aspect LookupParTypeDecl
1212       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1296
1213       */
1214      @ASTNodeAnnotation.Attribute
1215      public SimpleSet localFields(String name) {
1216        Object _parameters = name;
1217        if (localFields_String_values == null) localFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1218        ASTNode$State state = state();
1219        if (localFields_String_values.containsKey(_parameters)) {
1220          return (SimpleSet) localFields_String_values.get(_parameters);
1221        }
1222        boolean intermediate = state.INTERMEDIATE_VALUE;
1223        state.INTERMEDIATE_VALUE = false;
1224        int num = state.boundariesCrossed;
1225        boolean isFinal = this.is$Final();
1226        SimpleSet localFields_String_value = localFields_compute(name);
1227        if (true) {
1228          localFields_String_values.put(_parameters, localFields_String_value);
1229        } else {
1230        }
1231        state.INTERMEDIATE_VALUE |= intermediate;
1232    
1233        return localFields_String_value;
1234      }
1235      /**
1236       * @apilevel internal
1237       */
1238      private SimpleSet localFields_compute(String name) {
1239          SimpleSet set = SimpleSet.emptySet;
1240          for (Iterator iter = original().localFields(name).iterator(); iter.hasNext(); ) {
1241            FieldDeclaration f = (FieldDeclaration) iter.next();
1242      
1243            if (!f.isStatic() && (f.usesTypeVariable() || isRawType())) {
1244              BodyDecl fCopy = ((BodyDeclList) getBodyDeclList()).localFieldCopy(f, this);
1245              f = (FieldDeclaration) fCopy;
1246            }
1247            set = set.add(f);
1248      
1249          }
1250          return set;
1251        }
1252      /**
1253       * @apilevel internal
1254       */
1255      private void localTypeDecls_String_reset() {
1256        localTypeDecls_String_values = null;
1257      }
1258      protected java.util.Map localTypeDecls_String_values;
1259      @ASTNodeAnnotation.Attribute
1260      public SimpleSet localTypeDecls(String name) {
1261        Object _parameters = name;
1262        if (localTypeDecls_String_values == null) localTypeDecls_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1263        ASTNode$State.CircularValue _value;
1264        if (localTypeDecls_String_values.containsKey(_parameters)) {
1265          Object _o = localTypeDecls_String_values.get(_parameters);
1266          if (!(_o instanceof ASTNode$State.CircularValue)) {
1267            return (SimpleSet) _o;
1268          } else {
1269            _value = (ASTNode$State.CircularValue) _o;
1270          }
1271        } else {
1272          _value = new ASTNode$State.CircularValue();
1273          localTypeDecls_String_values.put(_parameters, _value);
1274          _value.value = SimpleSet.emptySet;
1275        }
1276        ASTNode$State state = state();
1277        SimpleSet new_localTypeDecls_String_value;
1278        if (!state.IN_CIRCLE) {
1279          state.IN_CIRCLE = true;
1280          int num = state.boundariesCrossed;
1281          boolean isFinal = this.is$Final();
1282          // TODO: fixme
1283          // state().CIRCLE_INDEX = 1;
1284          do {
1285            _value.visited = state.CIRCLE_INDEX;
1286            state.CHANGE = false;
1287            new_localTypeDecls_String_value = localTypeDecls_compute(name);
1288            if ((new_localTypeDecls_String_value==null && (SimpleSet)_value.value!=null) || (new_localTypeDecls_String_value!=null && !new_localTypeDecls_String_value.equals((SimpleSet)_value.value))) {
1289              state.CHANGE = true;
1290              _value.value = new_localTypeDecls_String_value;
1291            }
1292            state.CIRCLE_INDEX++;
1293          } while (state.CHANGE);
1294          if (true) {
1295            localTypeDecls_String_values.put(_parameters, new_localTypeDecls_String_value);
1296          } else {
1297            localTypeDecls_String_values.remove(_parameters);
1298            state.RESET_CYCLE = true;
1299            SimpleSet $tmp = localTypeDecls_compute(name);
1300            state.RESET_CYCLE = false;
1301          }
1302          state.IN_CIRCLE = false;
1303          state.INTERMEDIATE_VALUE = false;
1304          return new_localTypeDecls_String_value;
1305        }
1306        if (state.CIRCLE_INDEX != _value.visited) {
1307          _value.visited = state.CIRCLE_INDEX;
1308          new_localTypeDecls_String_value = localTypeDecls_compute(name);
1309          if (state.RESET_CYCLE) {
1310            localTypeDecls_String_values.remove(_parameters);
1311          }
1312          else if ((new_localTypeDecls_String_value==null && (SimpleSet)_value.value!=null) || (new_localTypeDecls_String_value!=null && !new_localTypeDecls_String_value.equals((SimpleSet)_value.value))) {
1313            state.CHANGE = true;
1314            _value.value = new_localTypeDecls_String_value;
1315          }
1316          state.INTERMEDIATE_VALUE = true;
1317          return new_localTypeDecls_String_value;
1318        }
1319        state.INTERMEDIATE_VALUE = true;
1320        return (SimpleSet) _value.value;
1321      }
1322      /**
1323       * @apilevel internal
1324       */
1325      private SimpleSet localTypeDecls_compute(String name) {
1326          SimpleSet set = SimpleSet.emptySet;
1327          for (Iterator iter = original().localTypeDecls(name).iterator(); iter.hasNext(); ) {
1328            TypeDecl t = (TypeDecl) iter.next();
1329      
1330            if (t.isStatic()) {
1331              set = set.add(t);
1332            } else if (t instanceof ClassDecl) {
1333              MemberClassDecl copy =
1334                ((BodyDeclList) getBodyDeclList()).localClassDeclCopy((ClassDecl) t, this);
1335              set = set.add(copy.getClassDecl());
1336            } else if (t instanceof InterfaceDecl) {
1337              MemberInterfaceDecl copy =
1338                ((BodyDeclList) getBodyDeclList()).localInterfaceDeclCopy((InterfaceDecl) t, this);
1339              set = set.add(copy.getInterfaceDecl());
1340            }
1341          }
1342          return set;
1343        }
1344      /**
1345       * @apilevel internal
1346       */
1347      protected boolean constructors_computed = false;
1348      /**
1349       * @apilevel internal
1350       */
1351      protected Collection<ConstructorDecl> constructors_value;
1352      /**
1353       * @apilevel internal
1354       */
1355      private void constructors_reset() {
1356        constructors_computed = false;
1357        constructors_value = null;
1358      }
1359      /**
1360       * @attribute syn
1361       * @aspect LookupParTypeDecl
1362       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1347
1363       */
1364      @ASTNodeAnnotation.Attribute
1365      public Collection<ConstructorDecl> constructors() {
1366        ASTNode$State state = state();
1367        if (constructors_computed) {
1368          return constructors_value;
1369        }
1370        boolean intermediate = state.INTERMEDIATE_VALUE;
1371        state.INTERMEDIATE_VALUE = false;
1372        int num = state.boundariesCrossed;
1373        boolean isFinal = this.is$Final();
1374        constructors_value = constructors_compute();
1375        if (isFinal && num == state().boundariesCrossed) {
1376          constructors_computed = true;
1377        } else {
1378        }
1379        state.INTERMEDIATE_VALUE |= intermediate;
1380    
1381        return constructors_value;
1382      }
1383      /**
1384       * @apilevel internal
1385       */
1386      private Collection<ConstructorDecl> constructors_compute() {
1387          Collection<ConstructorDecl> constructors = new ArrayList<ConstructorDecl>();
1388          for (Iterator iter = original().constructors().iterator(); iter.hasNext(); ) {
1389            ConstructorDecl c = (ConstructorDecl) iter.next();
1390      
1391            ConstructorDecl b = ((BodyDeclList) getBodyDeclList()).constructorCopy(c, this);
1392            constructors.add(b);
1393          }
1394          return constructors;
1395        }
1396      /**
1397       * @apilevel internal
1398       */
1399      public ASTNode rewriteTo() {
1400        return super.rewriteTo();
1401      }
1402    }