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:6
027     * @production ParClassDecl : {@link ClassDecl} ::= <span class="component">Argument:{@link Access}*</span> <span class="component">[SuperClass:{@link Access}]</span> <span class="component">Implements:{@link Access}*</span> <span class="component">{@link BodyDecl}*</span>;
028    
029     */
030    public class ParClassDecl extends ClassDecl implements Cloneable, ParTypeDecl, MemberSubstitutor {
031      /**
032       * @aspect GenericsNameBinding
033       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:789
034       */
035      public void collectErrors() {
036        // Disable error check for ParClassDecl which is an instanciated GenericClassDecl
037      }
038      /**
039       * @aspect Java5PrettyPrint
040       * @declaredat /home/jesper/git/extendj/java5/frontend/PrettyPrint.jadd:35
041       */
042      public void prettyPrint(PrettyPrinter out) {
043        if (hasDocComment()) {
044          out.print(docComment());
045        }
046        if (!out.isNewLine()) {
047          out.println();
048        }
049        out.print(getModifiers());
050        out.print("class ");
051        out.print(getID());
052        out.print("<");
053        out.join(getArgumentList(), new PrettyPrinter.Joiner() {
054          @Override
055          public void printSeparator(PrettyPrinter out) {
056            out.print(", ");
057          }
058        });
059        out.print(">");
060        if (hasSuperClass()) {
061          out.print(" extends ");
062          out.print(getSuperClass());
063        }
064        if (hasImplements()) {
065          out.print(" implements ");
066          out.join(getImplementss(), new PrettyPrinter.Joiner() {
067            @Override
068            public void printSeparator(PrettyPrinter out) {
069              out.print(", ");
070            }
071          });
072        }
073        out.print(" {");
074        out.println();
075        out.indent(1);
076        out.join(getBodyDecls(), new PrettyPrinter.Joiner() {
077          @Override
078          public void printSeparator(PrettyPrinter out) {
079            out.println();
080            out.println();
081          }
082        });
083        if (!out.isNewLine()) {
084          out.println();
085        }
086        out.print("}");
087      }
088      /**
089       * @aspect LookupParTypeDecl
090       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:959
091       */
092      public TypeDecl substitute(TypeVariable typeVariable) {
093        for (int i = 0; i < numTypeParameter(); i++) {
094          if (typeParameter(i) == typeVariable) {
095            return getArgument(i).type();
096          }
097        }
098        return super.substitute(typeVariable);
099      }
100      /**
101       * @aspect LookupParTypeDecl
102       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:990
103       */
104      public int numTypeParameter() {
105        return ((GenericTypeDecl) original()).getNumTypeParameter();
106      }
107      /**
108       * @aspect LookupParTypeDecl
109       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:994
110       */
111      public TypeVariable typeParameter(int index) {
112        return ((GenericTypeDecl) original()).getTypeParameter(index);
113      }
114      /**
115       * @aspect GenericsParTypeDecl
116       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:99
117       */
118      public Access createQualifiedAccess() {
119        List typeArgumentList = new List();
120        for (int i = 0; i < getNumArgument(); i++) {
121          Access a = (Access) getArgument(i);
122          if (a instanceof TypeAccess) {
123            typeArgumentList.add(a.type().createQualifiedAccess());
124          } else {
125            typeArgumentList.add(a.treeCopyNoTransform());
126          }
127        }
128        if (!isTopLevelType()) {
129          if (isRawType()) {
130            return enclosingType().createQualifiedAccess().qualifiesAccess(
131              new TypeAccess("", getID())
132            );
133          } else {
134            return enclosingType().createQualifiedAccess().qualifiesAccess(
135              new ParTypeAccess(new TypeAccess("", getID()), typeArgumentList)
136            );
137          }
138        } else {
139          if (isRawType()) {
140            return new TypeAccess(packageName(), getID());
141          } else {
142            return new ParTypeAccess(new TypeAccess(packageName(), getID()), typeArgumentList);
143          }
144        }
145      }
146      /**
147       * @aspect GenericsCodegen
148       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:302
149       */
150      public void transformation() {
151      }
152      /**
153       * @aspect LambdaExpr
154       * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:111
155       */
156       
157      public Access substitute(Parameterization parTypeDecl) {
158        // TODO: include nesting as well....
159        if (parTypeDecl.isRawType()) {
160          return ((GenericTypeDecl) genericDecl()).rawType().createBoundAccess();
161        }
162    
163        /* These lines have been removed because they erase arguments from
164          parameter types when they are not using type variables, for example
165          C<String> is substituted to only C, which I don't think is correct?
166          And if the ParTypeDecl doesn't use any type variables, why is there
167          even any need for further substitution?
168    
169        if (!usesTypeVariable()) {
170          return super.substitute(parTypeDecl);
171        }
172        */
173        List<Access> list = new List<Access>();
174        for (Access argument : getArgumentList()) {
175          list.add(argument.type().substitute(parTypeDecl));
176        }
177        return new ParTypeAccess(genericDecl().createQualifiedAccess(), list);
178      }
179      /**
180       * @declaredat ASTNode:1
181       */
182      public ParClassDecl() {
183        super();
184      }
185      /**
186       * Initializes the child array to the correct size.
187       * Initializes List and Opt nta children.
188       * @apilevel internal
189       * @ast method
190       * @declaredat ASTNode:10
191       */
192      public void init$Children() {
193        children = new ASTNode[6];
194        setChild(new List(), 1);
195        setChild(new Opt(), 2);
196        setChild(new Opt(), 3);
197        setChild(new List(), 4);
198        setChild(new List(), 5);
199      }
200      /**
201       * @declaredat ASTNode:18
202       */
203      public ParClassDecl(Modifiers p0, String p1, List<Access> p2) {
204        setChild(p0, 0);
205        setID(p1);
206        setChild(p2, 1);
207      }
208      /**
209       * @declaredat ASTNode:23
210       */
211      public ParClassDecl(Modifiers p0, beaver.Symbol p1, List<Access> p2) {
212        setChild(p0, 0);
213        setID(p1);
214        setChild(p2, 1);
215      }
216      /**
217       * @apilevel low-level
218       * @declaredat ASTNode:31
219       */
220      protected int numChildren() {
221        return 2;
222      }
223      /**
224       * @apilevel internal
225       * @declaredat ASTNode:37
226       */
227      public boolean mayHaveRewrite() {
228        return false;
229      }
230      /**
231       * @apilevel internal
232       * @declaredat ASTNode:43
233       */
234      public void flushAttrCache() {
235        super.flushAttrCache();
236        involvesTypeParameters_reset();
237        erasure_reset();
238        getSuperClassOpt_reset();
239        getImplementsList_reset();
240        getBodyDeclList_reset();
241        subtype_TypeDecl_reset();
242        sameStructure_TypeDecl_reset();
243        instanceOf_TypeDecl_reset();
244        typeDescriptor_reset();
245        constantPoolName_reset();
246        needsSignatureAttribute_reset();
247        strictSubtype_TypeDecl_reset();
248        sameSignature_java_util_List_TypeDecl__reset();
249        usesTypeVariable_reset();
250        sourceTypeDecl_reset();
251        fullName_reset();
252        typeName_reset();
253        unimplementedMethods_reset();
254        uniqueIndex_reset();
255        localMethodsSignatureMap_reset();
256        localFields_String_reset();
257        localTypeDecls_String_reset();
258        constructors_reset();
259        genericDecl_reset();
260      }
261      /**
262       * @apilevel internal
263       * @declaredat ASTNode:73
264       */
265      public void flushCollectionCache() {
266        super.flushCollectionCache();
267      }
268      /**
269       * @apilevel internal
270       * @declaredat ASTNode:79
271       */
272      public void flushRewriteCache() {
273        super.flushRewriteCache();
274      }
275      /**
276       * @apilevel internal
277       * @declaredat ASTNode:85
278       */
279      public ParClassDecl clone() throws CloneNotSupportedException {
280        ParClassDecl node = (ParClassDecl) super.clone();
281        return node;
282      }
283      /**
284       * @apilevel internal
285       * @declaredat ASTNode:92
286       */
287      public ParClassDecl copy() {
288        try {
289          ParClassDecl node = (ParClassDecl) clone();
290          node.parent = null;
291          if (children != null) {
292            node.children = (ASTNode[]) children.clone();
293          }
294          return node;
295        } catch (CloneNotSupportedException e) {
296          throw new Error("Error: clone not supported for " + getClass().getName());
297        }
298      }
299      /**
300       * Create a deep copy of the AST subtree at this node.
301       * The copy is dangling, i.e. has no parent.
302       * @return dangling copy of the subtree at this node
303       * @apilevel low-level
304       * @deprecated Please use treeCopy or treeCopyNoTransform instead
305       * @declaredat ASTNode:111
306       */
307      @Deprecated
308      public ParClassDecl fullCopy() {
309        return treeCopyNoTransform();
310      }
311      /**
312       * Create a deep copy of the AST subtree at this node.
313       * The copy is dangling, i.e. has no parent.
314       * @return dangling copy of the subtree at this node
315       * @apilevel low-level
316       * @declaredat ASTNode:121
317       */
318      public ParClassDecl treeCopyNoTransform() {
319        ParClassDecl tree = (ParClassDecl) copy();
320        if (children != null) {
321          for (int i = 0; i < children.length; ++i) {
322            switch (i) {
323            case 2:
324            case 3:
325              tree.children[i] = new Opt();
326              continue;
327            case 4:
328            case 5:
329              tree.children[i] = new List();
330              continue;
331            }
332            ASTNode child = (ASTNode) children[i];
333            if (child != null) {
334              child = child.treeCopyNoTransform();
335              tree.setChild(child, i);
336            }
337          }
338        }
339        return tree;
340      }
341      /**
342       * Create a deep copy of the AST subtree at this node.
343       * The subtree of this node is traversed to trigger rewrites before copy.
344       * The copy is dangling, i.e. has no parent.
345       * @return dangling copy of the subtree at this node
346       * @apilevel low-level
347       * @declaredat ASTNode:151
348       */
349      public ParClassDecl treeCopy() {
350        doFullTraversal();
351        return treeCopyNoTransform();
352      }
353      /**
354       * @apilevel internal
355       * @declaredat ASTNode:158
356       */
357      protected boolean is$Equal(ASTNode node) {
358        return super.is$Equal(node) && (tokenString_ID == ((ParClassDecl)node).tokenString_ID);    
359      }
360      /**
361       * Replaces the Modifiers child.
362       * @param node The new node to replace the Modifiers child.
363       * @apilevel high-level
364       */
365      public void setModifiers(Modifiers node) {
366        setChild(node, 0);
367      }
368      /**
369       * Retrieves the Modifiers child.
370       * @return The current node used as the Modifiers child.
371       * @apilevel high-level
372       */
373      @ASTNodeAnnotation.Child(name="Modifiers")
374      public Modifiers getModifiers() {
375        return (Modifiers) getChild(0);
376      }
377      /**
378       * Retrieves the Modifiers child.
379       * <p><em>This method does not invoke AST transformations.</em></p>
380       * @return The current node used as the Modifiers child.
381       * @apilevel low-level
382       */
383      public Modifiers getModifiersNoTransform() {
384        return (Modifiers) getChildNoTransform(0);
385      }
386      /**
387       * Replaces the lexeme ID.
388       * @param value The new value for the lexeme ID.
389       * @apilevel high-level
390       */
391      public void setID(String value) {
392        tokenString_ID = value;
393      }
394      /**
395       * JastAdd-internal setter for lexeme ID using the Beaver parser.
396       * @param symbol Symbol containing the new value for the lexeme ID
397       * @apilevel internal
398       */
399      public void setID(beaver.Symbol symbol) {
400        if (symbol.value != null && !(symbol.value instanceof String))
401        throw new UnsupportedOperationException("setID is only valid for String lexemes");
402        tokenString_ID = (String)symbol.value;
403        IDstart = symbol.getStart();
404        IDend = symbol.getEnd();
405      }
406      /**
407       * Retrieves the value for the lexeme ID.
408       * @return The value for the lexeme ID.
409       * @apilevel high-level
410       */
411      @ASTNodeAnnotation.Token(name="ID")
412      public String getID() {
413        return tokenString_ID != null ? tokenString_ID : "";
414      }
415      /**
416       * Replaces the Argument list.
417       * @param list The new list node to be used as the Argument list.
418       * @apilevel high-level
419       */
420      public void setArgumentList(List<Access> list) {
421        setChild(list, 1);
422      }
423      /**
424       * Retrieves the number of children in the Argument list.
425       * @return Number of children in the Argument list.
426       * @apilevel high-level
427       */
428      public int getNumArgument() {
429        return getArgumentList().getNumChild();
430      }
431      /**
432       * Retrieves the number of children in the Argument list.
433       * Calling this method will not trigger rewrites.
434       * @return Number of children in the Argument list.
435       * @apilevel low-level
436       */
437      public int getNumArgumentNoTransform() {
438        return getArgumentListNoTransform().getNumChildNoTransform();
439      }
440      /**
441       * Retrieves the element at index {@code i} in the Argument list.
442       * @param i Index of the element to return.
443       * @return The element at position {@code i} in the Argument list.
444       * @apilevel high-level
445       */
446      public Access getArgument(int i) {
447        return (Access) getArgumentList().getChild(i);
448      }
449      /**
450       * Check whether the Argument list has any children.
451       * @return {@code true} if it has at least one child, {@code false} otherwise.
452       * @apilevel high-level
453       */
454      public boolean hasArgument() {
455        return getArgumentList().getNumChild() != 0;
456      }
457      /**
458       * Append an element to the Argument list.
459       * @param node The element to append to the Argument list.
460       * @apilevel high-level
461       */
462      public void addArgument(Access node) {
463        List<Access> list = (parent == null) ? getArgumentListNoTransform() : getArgumentList();
464        list.addChild(node);
465      }
466      /**
467       * @apilevel low-level
468       */
469      public void addArgumentNoTransform(Access node) {
470        List<Access> list = getArgumentListNoTransform();
471        list.addChild(node);
472      }
473      /**
474       * Replaces the Argument list element at index {@code i} with the new node {@code node}.
475       * @param node The new node to replace the old list element.
476       * @param i The list index of the node to be replaced.
477       * @apilevel high-level
478       */
479      public void setArgument(Access node, int i) {
480        List<Access> list = getArgumentList();
481        list.setChild(node, i);
482      }
483      /**
484       * Retrieves the Argument list.
485       * @return The node representing the Argument list.
486       * @apilevel high-level
487       */
488      @ASTNodeAnnotation.ListChild(name="Argument")
489      public List<Access> getArgumentList() {
490        List<Access> list = (List<Access>) getChild(1);
491        return list;
492      }
493      /**
494       * Retrieves the Argument list.
495       * <p><em>This method does not invoke AST transformations.</em></p>
496       * @return The node representing the Argument list.
497       * @apilevel low-level
498       */
499      public List<Access> getArgumentListNoTransform() {
500        return (List<Access>) getChildNoTransform(1);
501      }
502      /**
503       * Retrieves the Argument list.
504       * @return The node representing the Argument list.
505       * @apilevel high-level
506       */
507      public List<Access> getArguments() {
508        return getArgumentList();
509      }
510      /**
511       * Retrieves the Argument list.
512       * <p><em>This method does not invoke AST transformations.</em></p>
513       * @return The node representing the Argument list.
514       * @apilevel low-level
515       */
516      public List<Access> getArgumentsNoTransform() {
517        return getArgumentListNoTransform();
518      }
519      /**
520       * Replaces the (optional) ImplicitConstructor child.
521       * @param node The new node to be used as the ImplicitConstructor child.
522       * @apilevel high-level
523       */
524      public void setImplicitConstructor(ConstructorDecl node) {
525        getImplicitConstructorOpt().setChild(node, 0);
526      }
527      /**
528       * Check whether the optional ImplicitConstructor child exists.
529       * @return {@code true} if the optional ImplicitConstructor child exists, {@code false} if it does not.
530       * @apilevel high-level
531       */
532      public boolean hasImplicitConstructor() {
533        return getImplicitConstructorOpt().getNumChild() != 0;
534      }
535      /**
536       * Retrieves the (optional) ImplicitConstructor child.
537       * @return The ImplicitConstructor child, if it exists. Returns {@code null} otherwise.
538       * @apilevel low-level
539       */
540      public ConstructorDecl getImplicitConstructor() {
541        return (ConstructorDecl) getImplicitConstructorOpt().getChild(0);
542      }
543      /**
544       * Retrieves the optional node for child ImplicitConstructor. This is the <code>Opt</code> node containing the child ImplicitConstructor, not the actual child!
545       * <p><em>This method does not invoke AST transformations.</em></p>
546       * @return The optional node for child ImplicitConstructor.
547       * @apilevel low-level
548       */
549      public Opt<ConstructorDecl> getImplicitConstructorOptNoTransform() {
550        return (Opt<ConstructorDecl>) getChildNoTransform(2);
551      }
552      /**
553       * Retrieves the child position of the optional child ImplicitConstructor.
554       * @return The the child position of the optional child ImplicitConstructor.
555       * @apilevel low-level
556       */
557      protected int getImplicitConstructorOptChildPosition() {
558        return 2;
559      }
560      /**
561       * This method should not be called. This method throws an exception due to
562       * the corresponding child being an NTA shadowing a non-NTA child.
563       * @param node
564       * @apilevel internal
565       */
566      public void setSuperClassOpt(Opt<Access> node) {
567        throw new Error("Can not replace NTA child SuperClassOpt in ParClassDecl!");
568      }
569      /**
570       * Replaces the (optional) SuperClass child.
571       * @param node The new node to be used as the SuperClass child.
572       * @apilevel high-level
573       */
574      public void setSuperClass(Access node) {
575        getSuperClassOpt().setChild(node, 0);
576      }
577      /**
578       * Check whether the optional SuperClass child exists.
579       * @return {@code true} if the optional SuperClass child exists, {@code false} if it does not.
580       * @apilevel high-level
581       */
582      public boolean hasSuperClass() {
583        return getSuperClassOpt().getNumChild() != 0;
584      }
585      /**
586       * Retrieves the (optional) SuperClass child.
587       * @return The SuperClass child, if it exists. Returns {@code null} otherwise.
588       * @apilevel low-level
589       */
590      public Access getSuperClass() {
591        return (Access) getSuperClassOpt().getChild(0);
592      }
593      /**
594       * Retrieves the optional node for child SuperClass. This is the <code>Opt</code> node containing the child SuperClass, not the actual child!
595       * <p><em>This method does not invoke AST transformations.</em></p>
596       * @return The optional node for child SuperClass.
597       * @apilevel low-level
598       */
599      public Opt<Access> getSuperClassOptNoTransform() {
600        return (Opt<Access>) getChildNoTransform(3);
601      }
602      /**
603       * Retrieves the child position of the optional child SuperClass.
604       * @return The the child position of the optional child SuperClass.
605       * @apilevel low-level
606       */
607      protected int getSuperClassOptChildPosition() {
608        return 3;
609      }
610      /**
611       * This method should not be called. This method throws an exception due to
612       * the corresponding child being an NTA shadowing a non-NTA child.
613       * @param node
614       * @apilevel internal
615       */
616      public void setImplementsList(List<Access> node) {
617        throw new Error("Can not replace NTA child ImplementsList in ParClassDecl!");
618      }
619      /**
620       * Retrieves the number of children in the Implements list.
621       * @return Number of children in the Implements list.
622       * @apilevel high-level
623       */
624      public int getNumImplements() {
625        return getImplementsList().getNumChild();
626      }
627      /**
628       * Retrieves the number of children in the Implements list.
629       * Calling this method will not trigger rewrites.
630       * @return Number of children in the Implements list.
631       * @apilevel low-level
632       */
633      public int getNumImplementsNoTransform() {
634        return getImplementsListNoTransform().getNumChildNoTransform();
635      }
636      /**
637       * Retrieves the element at index {@code i} in the Implements list.
638       * @param i Index of the element to return.
639       * @return The element at position {@code i} in the Implements list.
640       * @apilevel high-level
641       */
642      public Access getImplements(int i) {
643        return (Access) getImplementsList().getChild(i);
644      }
645      /**
646       * Check whether the Implements list has any children.
647       * @return {@code true} if it has at least one child, {@code false} otherwise.
648       * @apilevel high-level
649       */
650      public boolean hasImplements() {
651        return getImplementsList().getNumChild() != 0;
652      }
653      /**
654       * Append an element to the Implements list.
655       * @param node The element to append to the Implements list.
656       * @apilevel high-level
657       */
658      public void addImplements(Access node) {
659        List<Access> list = (parent == null) ? getImplementsListNoTransform() : getImplementsList();
660        list.addChild(node);
661      }
662      /**
663       * @apilevel low-level
664       */
665      public void addImplementsNoTransform(Access node) {
666        List<Access> list = getImplementsListNoTransform();
667        list.addChild(node);
668      }
669      /**
670       * Replaces the Implements list element at index {@code i} with the new node {@code node}.
671       * @param node The new node to replace the old list element.
672       * @param i The list index of the node to be replaced.
673       * @apilevel high-level
674       */
675      public void setImplements(Access node, int i) {
676        List<Access> list = getImplementsList();
677        list.setChild(node, i);
678      }
679      /**
680       * Retrieves the child position of the Implements list.
681       * @return The the child position of the Implements list.
682       * @apilevel low-level
683       */
684      protected int getImplementsListChildPosition() {
685        return 4;
686      }
687      /**
688       * Retrieves the Implements list.
689       * <p><em>This method does not invoke AST transformations.</em></p>
690       * @return The node representing the Implements list.
691       * @apilevel low-level
692       */
693      public List<Access> getImplementsListNoTransform() {
694        return (List<Access>) getChildNoTransform(4);
695      }
696      /**
697       * Retrieves the Implements list.
698       * @return The node representing the Implements list.
699       * @apilevel high-level
700       */
701      public List<Access> getImplementss() {
702        return getImplementsList();
703      }
704      /**
705       * Retrieves the Implements list.
706       * <p><em>This method does not invoke AST transformations.</em></p>
707       * @return The node representing the Implements list.
708       * @apilevel low-level
709       */
710      public List<Access> getImplementssNoTransform() {
711        return getImplementsListNoTransform();
712      }
713      /**
714       * This method should not be called. This method throws an exception due to
715       * the corresponding child being an NTA shadowing a non-NTA child.
716       * @param node
717       * @apilevel internal
718       */
719      public void setBodyDeclList(List<BodyDecl> node) {
720        throw new Error("Can not replace NTA child BodyDeclList in ParClassDecl!");
721      }
722      /**
723       * Retrieves the number of children in the BodyDecl list.
724       * @return Number of children in the BodyDecl list.
725       * @apilevel high-level
726       */
727      public int getNumBodyDecl() {
728        return getBodyDeclList().getNumChild();
729      }
730      /**
731       * Retrieves the number of children in the BodyDecl list.
732       * Calling this method will not trigger rewrites.
733       * @return Number of children in the BodyDecl list.
734       * @apilevel low-level
735       */
736      public int getNumBodyDeclNoTransform() {
737        return getBodyDeclListNoTransform().getNumChildNoTransform();
738      }
739      /**
740       * Retrieves the element at index {@code i} in the BodyDecl list.
741       * @param i Index of the element to return.
742       * @return The element at position {@code i} in the BodyDecl list.
743       * @apilevel high-level
744       */
745      public BodyDecl getBodyDecl(int i) {
746        return (BodyDecl) getBodyDeclList().getChild(i);
747      }
748      /**
749       * Check whether the BodyDecl list has any children.
750       * @return {@code true} if it has at least one child, {@code false} otherwise.
751       * @apilevel high-level
752       */
753      public boolean hasBodyDecl() {
754        return getBodyDeclList().getNumChild() != 0;
755      }
756      /**
757       * Append an element to the BodyDecl list.
758       * @param node The element to append to the BodyDecl list.
759       * @apilevel high-level
760       */
761      public void addBodyDecl(BodyDecl node) {
762        List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
763        list.addChild(node);
764      }
765      /**
766       * @apilevel low-level
767       */
768      public void addBodyDeclNoTransform(BodyDecl node) {
769        List<BodyDecl> list = getBodyDeclListNoTransform();
770        list.addChild(node);
771      }
772      /**
773       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
774       * @param node The new node to replace the old list element.
775       * @param i The list index of the node to be replaced.
776       * @apilevel high-level
777       */
778      public void setBodyDecl(BodyDecl node, int i) {
779        List<BodyDecl> list = getBodyDeclList();
780        list.setChild(node, i);
781      }
782      /**
783       * Retrieves the child position of the BodyDecl list.
784       * @return The the child position of the BodyDecl list.
785       * @apilevel low-level
786       */
787      protected int getBodyDeclListChildPosition() {
788        return 5;
789      }
790      /**
791       * Retrieves the BodyDecl list.
792       * <p><em>This method does not invoke AST transformations.</em></p>
793       * @return The node representing the BodyDecl list.
794       * @apilevel low-level
795       */
796      public List<BodyDecl> getBodyDeclListNoTransform() {
797        return (List<BodyDecl>) getChildNoTransform(5);
798      }
799      /**
800       * Retrieves the BodyDecl list.
801       * @return The node representing the BodyDecl list.
802       * @apilevel high-level
803       */
804      public List<BodyDecl> getBodyDecls() {
805        return getBodyDeclList();
806      }
807      /**
808       * Retrieves the BodyDecl list.
809       * <p><em>This method does not invoke AST transformations.</em></p>
810       * @return The node representing the BodyDecl list.
811       * @apilevel low-level
812       */
813      public List<BodyDecl> getBodyDeclsNoTransform() {
814        return getBodyDeclListNoTransform();
815      }
816      /**
817       * @apilevel internal
818       */
819      protected int involvesTypeParameters_visited = -1;
820      /**
821       * @apilevel internal
822       */
823      private void involvesTypeParameters_reset() {
824        involvesTypeParameters_computed = false;
825        involvesTypeParameters_initialized = false;
826        involvesTypeParameters_visited = -1;
827      }
828      /**
829       * @apilevel internal
830       */
831      protected boolean involvesTypeParameters_computed = false;
832      /**
833       * @apilevel internal
834       */
835      protected boolean involvesTypeParameters_initialized = false;
836      /**
837       * @apilevel internal
838       */
839      protected boolean involvesTypeParameters_value;
840      @ASTNodeAnnotation.Attribute
841      public boolean involvesTypeParameters() {
842        if (involvesTypeParameters_computed) {
843          return involvesTypeParameters_value;
844        }
845        ASTNode$State state = state();
846        boolean new_involvesTypeParameters_value;
847        if (!involvesTypeParameters_initialized) {
848          involvesTypeParameters_initialized = true;
849          involvesTypeParameters_value = false;
850        }
851        if (!state.IN_CIRCLE) {
852          state.IN_CIRCLE = true;
853          int num = state.boundariesCrossed;
854          boolean isFinal = this.is$Final();
855          do {
856            involvesTypeParameters_visited = state.CIRCLE_INDEX;
857            state.CHANGE = false;
858            new_involvesTypeParameters_value = involvesTypeParameters_compute();
859            if (new_involvesTypeParameters_value != involvesTypeParameters_value) {
860              state.CHANGE = true;
861            }
862            involvesTypeParameters_value = new_involvesTypeParameters_value;
863            state.CIRCLE_INDEX++;
864          } while (state.CHANGE);
865          if (isFinal && num == state().boundariesCrossed) {
866            involvesTypeParameters_computed = true;
867          } else {
868            state.RESET_CYCLE = true;
869            boolean $tmp = involvesTypeParameters_compute();
870            state.RESET_CYCLE = false;
871            involvesTypeParameters_computed = false;
872            involvesTypeParameters_initialized = false;
873          }
874          state.IN_CIRCLE = false;
875          state.INTERMEDIATE_VALUE = false;
876          return involvesTypeParameters_value;
877        }
878        if (involvesTypeParameters_visited != state.CIRCLE_INDEX) {
879          involvesTypeParameters_visited = state.CIRCLE_INDEX;
880          if (state.RESET_CYCLE) {
881            involvesTypeParameters_computed = false;
882            involvesTypeParameters_initialized = false;
883            involvesTypeParameters_visited = -1;
884            return involvesTypeParameters_value;
885          }
886          new_involvesTypeParameters_value = involvesTypeParameters_compute();
887          if (new_involvesTypeParameters_value != involvesTypeParameters_value) {
888            state.CHANGE = true;
889          }
890          involvesTypeParameters_value = new_involvesTypeParameters_value;
891          state.INTERMEDIATE_VALUE = true;
892          return involvesTypeParameters_value;
893        }
894        state.INTERMEDIATE_VALUE = true;
895        return involvesTypeParameters_value;
896      }
897      /**
898       * @apilevel internal
899       */
900      private boolean involvesTypeParameters_compute() {
901          for (int i = 0; i < getNumArgument(); i++) {
902            if (getArgument(i).type().involvesTypeParameters()) {
903              return true;
904            }
905          }
906          return false;
907        }
908      /**
909       * @attribute syn
910       * @aspect NestedTypes
911       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:624
912       */
913      @ASTNodeAnnotation.Attribute
914      public TypeDecl hostType() {
915        TypeDecl hostType_value = original();
916    
917        return hostType_value;
918      }
919      /**
920       * @attribute syn
921       * @aspect NestedTypes
922       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:545
923       */
924      @ASTNodeAnnotation.Attribute
925      public TypeDecl topLevelType() {
926        TypeDecl topLevelType_value = erasure().topLevelType();
927    
928        return topLevelType_value;
929      }
930      /**
931       * @attribute syn
932       * @aspect Generics
933       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:307
934       */
935      @ASTNodeAnnotation.Attribute
936      public boolean isRawType() {
937        boolean isRawType_value = isNestedType() && enclosingType().isRawType();
938    
939        return isRawType_value;
940      }
941      /**
942       * @apilevel internal
943       */
944      protected boolean erasure_computed = false;
945      /**
946       * @apilevel internal
947       */
948      protected TypeDecl erasure_value;
949      /**
950       * @apilevel internal
951       */
952      private void erasure_reset() {
953        erasure_computed = false;
954        erasure_value = null;
955      }
956      /**
957       * @attribute syn
958       * @aspect GenericsErasure
959       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:422
960       */
961      @ASTNodeAnnotation.Attribute
962      public TypeDecl erasure() {
963        ASTNode$State state = state();
964        if (erasure_computed) {
965          return erasure_value;
966        }
967        boolean intermediate = state.INTERMEDIATE_VALUE;
968        state.INTERMEDIATE_VALUE = false;
969        int num = state.boundariesCrossed;
970        boolean isFinal = this.is$Final();
971        erasure_value = genericDecl();
972        if (isFinal && num == state().boundariesCrossed) {
973          erasure_computed = true;
974        } else {
975        }
976        state.INTERMEDIATE_VALUE |= intermediate;
977    
978        return erasure_value;
979      }
980      /**
981       * @apilevel internal
982       */
983      protected boolean getSuperClassOpt_computed = false;
984      /**
985       * @apilevel internal
986       */
987      protected Opt getSuperClassOpt_value;
988      /**
989       * @apilevel internal
990       */
991      private void getSuperClassOpt_reset() {
992        getSuperClassOpt_computed = false;
993        getSuperClassOpt_value = null;
994      }
995      /**
996       * @attribute syn nta
997       * @aspect LookupParTypeDecl
998       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1201
999       */
1000      @ASTNodeAnnotation.Attribute
1001      public Opt getSuperClassOpt() {
1002        ASTNode$State state = state();
1003        if (getSuperClassOpt_computed) {
1004          return (Opt) getChild(getSuperClassOptChildPosition());
1005        }
1006        boolean intermediate = state.INTERMEDIATE_VALUE;
1007        state.INTERMEDIATE_VALUE = false;
1008        int num = state.boundariesCrossed;
1009        boolean isFinal = this.is$Final();
1010        getSuperClassOpt_value = getSuperClassOpt_compute();
1011        setChild(getSuperClassOpt_value, getSuperClassOptChildPosition());
1012        if (isFinal && num == state().boundariesCrossed) {
1013          getSuperClassOpt_computed = true;
1014        } else {
1015        }
1016        state.INTERMEDIATE_VALUE |= intermediate;
1017    
1018        Opt node = (Opt) this.getChild(getSuperClassOptChildPosition());
1019        return node;
1020      }
1021      /**
1022       * @apilevel internal
1023       */
1024      private Opt getSuperClassOpt_compute() {
1025          GenericClassDecl decl = (GenericClassDecl) genericDecl();
1026          Opt opt;
1027          //System.err.println("Begin substituting extends clause");
1028          if (decl.hasSuperClass()) {
1029            opt = new Opt((decl.getSuperClass().type().substitute(this)));
1030          } else {
1031            opt = new Opt();
1032          }
1033          //System.err.println("End substituting extends clause");
1034          return opt;
1035        }
1036      /**
1037       * @apilevel internal
1038       */
1039      protected boolean getImplementsList_computed = false;
1040      /**
1041       * @apilevel internal
1042       */
1043      protected List getImplementsList_value;
1044      /**
1045       * @apilevel internal
1046       */
1047      private void getImplementsList_reset() {
1048        getImplementsList_computed = false;
1049        getImplementsList_value = null;
1050      }
1051      /**
1052       * @attribute syn nta
1053       * @aspect LookupParTypeDecl
1054       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1214
1055       */
1056      @ASTNodeAnnotation.Attribute
1057      public List getImplementsList() {
1058        ASTNode$State state = state();
1059        if (getImplementsList_computed) {
1060          return (List) getChild(getImplementsListChildPosition());
1061        }
1062        boolean intermediate = state.INTERMEDIATE_VALUE;
1063        state.INTERMEDIATE_VALUE = false;
1064        int num = state.boundariesCrossed;
1065        boolean isFinal = this.is$Final();
1066        getImplementsList_value = getImplementsList_compute();
1067        setChild(getImplementsList_value, getImplementsListChildPosition());
1068        if (isFinal && num == state().boundariesCrossed) {
1069          getImplementsList_computed = true;
1070        } else {
1071        }
1072        state.INTERMEDIATE_VALUE |= intermediate;
1073    
1074        List node = (List) this.getChild(getImplementsListChildPosition());
1075        return node;
1076      }
1077      /**
1078       * @apilevel internal
1079       */
1080      private List getImplementsList_compute() {
1081          GenericClassDecl decl = (GenericClassDecl) genericDecl();
1082          //System.err.println("Begin substituting implements list");
1083          List list = decl.getImplementsList().substitute(this);
1084          //System.err.println("End substituting implements list");
1085          return list;
1086        }
1087      /**
1088       * @apilevel internal
1089       */
1090      protected boolean getBodyDeclList_computed = false;
1091      /**
1092       * @apilevel internal
1093       */
1094      protected List getBodyDeclList_value;
1095      /**
1096       * @apilevel internal
1097       */
1098      private void getBodyDeclList_reset() {
1099        getBodyDeclList_computed = false;
1100        getBodyDeclList_value = null;
1101      }
1102      /**
1103       * @attribute syn nta
1104       * @aspect LookupParTypeDecl
1105       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1222
1106       */
1107      @ASTNodeAnnotation.Attribute
1108      public List getBodyDeclList() {
1109        ASTNode$State state = state();
1110        if (getBodyDeclList_computed) {
1111          return (List) getChild(getBodyDeclListChildPosition());
1112        }
1113        boolean intermediate = state.INTERMEDIATE_VALUE;
1114        state.INTERMEDIATE_VALUE = false;
1115        int num = state.boundariesCrossed;
1116        boolean isFinal = this.is$Final();
1117        getBodyDeclList_value = new BodyDeclList();
1118        setChild(getBodyDeclList_value, getBodyDeclListChildPosition());
1119        if (isFinal && num == state().boundariesCrossed) {
1120          getBodyDeclList_computed = true;
1121        } else {
1122        }
1123        state.INTERMEDIATE_VALUE |= intermediate;
1124    
1125        List node = (List) this.getChild(getBodyDeclListChildPosition());
1126        return node;
1127      }
1128      /**
1129       * @attribute syn
1130       * @aspect GenericsSubtype
1131       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:35
1132       */
1133      @ASTNodeAnnotation.Attribute
1134      public boolean supertypeGenericClassDecl(GenericClassDecl type) {
1135        boolean supertypeGenericClassDecl_GenericClassDecl_value = type.subtype(genericDecl().original());
1136    
1137        return supertypeGenericClassDecl_GenericClassDecl_value;
1138      }
1139      /**
1140       * @attribute syn
1141       * @aspect GenericsSubtype
1142       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:448
1143       */
1144      @ASTNodeAnnotation.Attribute
1145      public boolean supertypeClassDecl(ClassDecl type) {
1146        boolean supertypeClassDecl_ClassDecl_value = super.supertypeClassDecl(type);
1147    
1148        return supertypeClassDecl_ClassDecl_value;
1149      }
1150      /**
1151       * @apilevel internal
1152       */
1153      private void subtype_TypeDecl_reset() {
1154        subtype_TypeDecl_values = null;
1155      }
1156      protected java.util.Map subtype_TypeDecl_values;
1157      @ASTNodeAnnotation.Attribute
1158      public boolean subtype(TypeDecl type) {
1159        Object _parameters = type;
1160        if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1161        ASTNode$State.CircularValue _value;
1162        if (subtype_TypeDecl_values.containsKey(_parameters)) {
1163          Object _o = subtype_TypeDecl_values.get(_parameters);
1164          if (!(_o instanceof ASTNode$State.CircularValue)) {
1165            return (Boolean) _o;
1166          } else {
1167            _value = (ASTNode$State.CircularValue) _o;
1168          }
1169        } else {
1170          _value = new ASTNode$State.CircularValue();
1171          subtype_TypeDecl_values.put(_parameters, _value);
1172          _value.value = true;
1173        }
1174        ASTNode$State state = state();
1175        boolean new_subtype_TypeDecl_value;
1176        if (!state.IN_CIRCLE) {
1177          state.IN_CIRCLE = true;
1178          int num = state.boundariesCrossed;
1179          boolean isFinal = this.is$Final();
1180          // TODO: fixme
1181          // state().CIRCLE_INDEX = 1;
1182          do {
1183            _value.visited = state.CIRCLE_INDEX;
1184            state.CHANGE = false;
1185            new_subtype_TypeDecl_value = type.supertypeParClassDecl(this);
1186            if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
1187              state.CHANGE = true;
1188              _value.value = new_subtype_TypeDecl_value;
1189            }
1190            state.CIRCLE_INDEX++;
1191          } while (state.CHANGE);
1192          if (isFinal && num == state().boundariesCrossed) {
1193            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
1194          } else {
1195            subtype_TypeDecl_values.remove(_parameters);
1196            state.RESET_CYCLE = true;
1197            boolean $tmp = type.supertypeParClassDecl(this);
1198            state.RESET_CYCLE = false;
1199          }
1200          state.IN_CIRCLE = false;
1201          state.INTERMEDIATE_VALUE = false;
1202          return new_subtype_TypeDecl_value;
1203        }
1204        if (state.CIRCLE_INDEX != _value.visited) {
1205          _value.visited = state.CIRCLE_INDEX;
1206          new_subtype_TypeDecl_value = type.supertypeParClassDecl(this);
1207          if (state.RESET_CYCLE) {
1208            subtype_TypeDecl_values.remove(_parameters);
1209          }
1210          else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
1211            state.CHANGE = true;
1212            _value.value = new_subtype_TypeDecl_value;
1213          }
1214          state.INTERMEDIATE_VALUE = true;
1215          return new_subtype_TypeDecl_value;
1216        }
1217        state.INTERMEDIATE_VALUE = true;
1218        return (Boolean) _value.value;
1219      }
1220      /**
1221       * @attribute syn
1222       * @aspect GenericsSubtype
1223       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:46
1224       */
1225      @ASTNodeAnnotation.Attribute
1226      public boolean supertypeRawClassDecl(RawClassDecl type) {
1227        boolean supertypeRawClassDecl_RawClassDecl_value = type.genericDecl().original().subtype(genericDecl().original());
1228    
1229        return supertypeRawClassDecl_RawClassDecl_value;
1230      }
1231      /**
1232       * @attribute syn
1233       * @aspect GenericsSubtype
1234       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:50
1235       */
1236      @ASTNodeAnnotation.Attribute
1237      public boolean supertypeRawInterfaceDecl(RawInterfaceDecl type) {
1238        boolean supertypeRawInterfaceDecl_RawInterfaceDecl_value = type.genericDecl().original().subtype(genericDecl().original());
1239    
1240        return supertypeRawInterfaceDecl_RawInterfaceDecl_value;
1241      }
1242      /**
1243       * @apilevel internal
1244       */
1245      private void sameStructure_TypeDecl_reset() {
1246        sameStructure_TypeDecl_values = null;
1247      }
1248      protected java.util.Map sameStructure_TypeDecl_values;
1249      @ASTNodeAnnotation.Attribute
1250      public boolean sameStructure(TypeDecl t) {
1251        Object _parameters = t;
1252        if (sameStructure_TypeDecl_values == null) sameStructure_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1253        ASTNode$State.CircularValue _value;
1254        if (sameStructure_TypeDecl_values.containsKey(_parameters)) {
1255          Object _o = sameStructure_TypeDecl_values.get(_parameters);
1256          if (!(_o instanceof ASTNode$State.CircularValue)) {
1257            return (Boolean) _o;
1258          } else {
1259            _value = (ASTNode$State.CircularValue) _o;
1260          }
1261        } else {
1262          _value = new ASTNode$State.CircularValue();
1263          sameStructure_TypeDecl_values.put(_parameters, _value);
1264          _value.value = true;
1265        }
1266        ASTNode$State state = state();
1267        boolean new_sameStructure_TypeDecl_value;
1268        if (!state.IN_CIRCLE) {
1269          state.IN_CIRCLE = true;
1270          int num = state.boundariesCrossed;
1271          boolean isFinal = this.is$Final();
1272          // TODO: fixme
1273          // state().CIRCLE_INDEX = 1;
1274          do {
1275            _value.visited = state.CIRCLE_INDEX;
1276            state.CHANGE = false;
1277            new_sameStructure_TypeDecl_value = sameStructure_compute(t);
1278            if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) {
1279              state.CHANGE = true;
1280              _value.value = new_sameStructure_TypeDecl_value;
1281            }
1282            state.CIRCLE_INDEX++;
1283          } while (state.CHANGE);
1284          if (isFinal && num == state().boundariesCrossed) {
1285            sameStructure_TypeDecl_values.put(_parameters, new_sameStructure_TypeDecl_value);
1286          } else {
1287            sameStructure_TypeDecl_values.remove(_parameters);
1288            state.RESET_CYCLE = true;
1289            boolean $tmp = sameStructure_compute(t);
1290            state.RESET_CYCLE = false;
1291          }
1292          state.IN_CIRCLE = false;
1293          state.INTERMEDIATE_VALUE = false;
1294          return new_sameStructure_TypeDecl_value;
1295        }
1296        if (state.CIRCLE_INDEX != _value.visited) {
1297          _value.visited = state.CIRCLE_INDEX;
1298          new_sameStructure_TypeDecl_value = sameStructure_compute(t);
1299          if (state.RESET_CYCLE) {
1300            sameStructure_TypeDecl_values.remove(_parameters);
1301          }
1302          else if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) {
1303            state.CHANGE = true;
1304            _value.value = new_sameStructure_TypeDecl_value;
1305          }
1306          state.INTERMEDIATE_VALUE = true;
1307          return new_sameStructure_TypeDecl_value;
1308        }
1309        state.INTERMEDIATE_VALUE = true;
1310        return (Boolean) _value.value;
1311      }
1312      /**
1313       * @apilevel internal
1314       */
1315      private boolean sameStructure_compute(TypeDecl t) {
1316          if (!(t instanceof ParClassDecl)) {
1317            return false;
1318          }
1319          ParClassDecl type = (ParClassDecl) t;
1320          if (type.genericDecl().original() == genericDecl().original() &&
1321             type.getNumArgument() == getNumArgument()) {
1322            for (int i = 0; i < getNumArgument(); i++)
1323              if (!type.getArgument(i).type().sameStructure(getArgument(i).type())) {
1324                return false;
1325              }
1326            if (isNestedType() && type.isNestedType()) {
1327              return type.enclosingType().sameStructure(enclosingType());
1328            }
1329            return true;
1330          }
1331          return false;
1332        }
1333      /**
1334       * @attribute syn
1335       * @aspect GenericsSubtype
1336       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:134
1337       */
1338      @ASTNodeAnnotation.Attribute
1339      public boolean supertypeParClassDecl(ParClassDecl type) {
1340        {
1341            if (type.genericDecl().original() == genericDecl().original() &&
1342               type.getNumArgument() == getNumArgument()) {
1343              for (int i = 0; i < getNumArgument(); i++)
1344                if (!type.getArgument(i).type().containedIn(getArgument(i).type())) {
1345                  return false;
1346                }
1347              if (isNestedType() && type.isNestedType()) {
1348                return type.enclosingType().subtype(enclosingType());
1349              }
1350              return true;
1351            }
1352            return supertypeClassDecl(type);
1353          }
1354      }
1355      /**
1356       * @attribute syn
1357       * @aspect GenericsSubtype
1358       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:137
1359       */
1360      @ASTNodeAnnotation.Attribute
1361      public boolean supertypeParInterfaceDecl(ParInterfaceDecl type) {
1362        boolean supertypeParInterfaceDecl_ParInterfaceDecl_value = false;
1363    
1364        return supertypeParInterfaceDecl_ParInterfaceDecl_value;
1365      }
1366      /**
1367       * @apilevel internal
1368       */
1369      protected java.util.Map instanceOf_TypeDecl_values;
1370      /**
1371       * @apilevel internal
1372       */
1373      private void instanceOf_TypeDecl_reset() {
1374        instanceOf_TypeDecl_values = null;
1375      }
1376      /**
1377       * @attribute syn
1378       * @aspect TypeWideningAndIdentity
1379       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442
1380       */
1381      @ASTNodeAnnotation.Attribute
1382      public boolean instanceOf(TypeDecl type) {
1383        Object _parameters = type;
1384        if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1385        ASTNode$State state = state();
1386        if (instanceOf_TypeDecl_values.containsKey(_parameters)) {
1387          return (Boolean) instanceOf_TypeDecl_values.get(_parameters);
1388        }
1389        boolean intermediate = state.INTERMEDIATE_VALUE;
1390        state.INTERMEDIATE_VALUE = false;
1391        int num = state.boundariesCrossed;
1392        boolean isFinal = this.is$Final();
1393        boolean instanceOf_TypeDecl_value = subtype(type);
1394        if (isFinal && num == state().boundariesCrossed) {
1395          instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value);
1396        } else {
1397        }
1398        state.INTERMEDIATE_VALUE |= intermediate;
1399    
1400        return instanceOf_TypeDecl_value;
1401      }
1402      /**
1403       * A type is reifiable if it either refers to a non-parameterized type,
1404       * is a raw type, is a parameterized type with only unbound wildcard
1405       * parameters or is an array type with a reifiable type parameter.
1406       * 
1407       * @see "JLS SE7 &sect;4.7"
1408       * @attribute syn
1409       * @aspect ReifiableTypes
1410       * @declaredat /home/jesper/git/extendj/java5/frontend/ReifiableTypes.jrag:39
1411       */
1412      @ASTNodeAnnotation.Attribute
1413      public boolean isReifiable() {
1414        {
1415            if (original().isInnerClass() && !original().enclosingType().isReifiable()) {
1416              return false;
1417            }
1418            for (Access argument: getArgumentList()) {
1419              if (!argument.isWildcard()) {
1420                return false;
1421              }
1422            }
1423            return true;
1424          }
1425      }
1426      /**
1427       * @apilevel internal
1428       */
1429      protected boolean typeDescriptor_computed = false;
1430      /**
1431       * @apilevel internal
1432       */
1433      protected String typeDescriptor_value;
1434      /**
1435       * @apilevel internal
1436       */
1437      private void typeDescriptor_reset() {
1438        typeDescriptor_computed = false;
1439        typeDescriptor_value = null;
1440      }
1441      /**
1442       * @attribute syn
1443       * @aspect ConstantPoolNames
1444       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77
1445       */
1446      @ASTNodeAnnotation.Attribute
1447      public String typeDescriptor() {
1448        ASTNode$State state = state();
1449        if (typeDescriptor_computed) {
1450          return typeDescriptor_value;
1451        }
1452        boolean intermediate = state.INTERMEDIATE_VALUE;
1453        state.INTERMEDIATE_VALUE = false;
1454        int num = state.boundariesCrossed;
1455        boolean isFinal = this.is$Final();
1456        typeDescriptor_value = erasure().typeDescriptor();
1457        if (isFinal && num == state().boundariesCrossed) {
1458          typeDescriptor_computed = true;
1459        } else {
1460        }
1461        state.INTERMEDIATE_VALUE |= intermediate;
1462    
1463        return typeDescriptor_value;
1464      }
1465      /**
1466       * @attribute syn
1467       * @aspect CreateBCode
1468       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:900
1469       */
1470      @ASTNodeAnnotation.Attribute
1471      public String arrayTypeDescriptor() {
1472        String arrayTypeDescriptor_value = erasure().arrayTypeDescriptor();
1473    
1474        return arrayTypeDescriptor_value;
1475      }
1476      /**
1477       * @apilevel internal
1478       */
1479      protected boolean constantPoolName_computed = false;
1480      /**
1481       * @apilevel internal
1482       */
1483      protected String constantPoolName_value;
1484      /**
1485       * @apilevel internal
1486       */
1487      private void constantPoolName_reset() {
1488        constantPoolName_computed = false;
1489        constantPoolName_value = null;
1490      }
1491      /**
1492       * For a top-level type the constant pool name of the type is the same as the
1493       * canonical name but with dots replaced by solidus.
1494       * 
1495       * <p>For nested types the constant pool name is based on the enclosing top-level
1496       * types constant pool name followed by a dollar sign and a unique index and/or
1497       * the type name.
1498       * 
1499       * @return constant pool name of this type
1500       * @attribute syn
1501       * @aspect ConstantPoolNames
1502       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:44
1503       */
1504      @ASTNodeAnnotation.Attribute
1505      public String constantPoolName() {
1506        ASTNode$State state = state();
1507        if (constantPoolName_computed) {
1508          return constantPoolName_value;
1509        }
1510        boolean intermediate = state.INTERMEDIATE_VALUE;
1511        state.INTERMEDIATE_VALUE = false;
1512        int num = state.boundariesCrossed;
1513        boolean isFinal = this.is$Final();
1514        constantPoolName_value = genericDecl().constantPoolName();
1515        if (isFinal && num == state().boundariesCrossed) {
1516          constantPoolName_computed = true;
1517        } else {
1518        }
1519        state.INTERMEDIATE_VALUE |= intermediate;
1520    
1521        return constantPoolName_value;
1522      }
1523      /**
1524       * @apilevel internal
1525       */
1526      protected boolean needsSignatureAttribute_computed = false;
1527      /**
1528       * @apilevel internal
1529       */
1530      protected boolean needsSignatureAttribute_value;
1531      /**
1532       * @apilevel internal
1533       */
1534      private void needsSignatureAttribute_reset() {
1535        needsSignatureAttribute_computed = false;
1536      }
1537      /**
1538       * @attribute syn
1539       * @aspect GenericsCodegen
1540       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:345
1541       */
1542      @ASTNodeAnnotation.Attribute
1543      public boolean needsSignatureAttribute() {
1544        ASTNode$State state = state();
1545        if (needsSignatureAttribute_computed) {
1546          return needsSignatureAttribute_value;
1547        }
1548        boolean intermediate = state.INTERMEDIATE_VALUE;
1549        state.INTERMEDIATE_VALUE = false;
1550        int num = state.boundariesCrossed;
1551        boolean isFinal = this.is$Final();
1552        needsSignatureAttribute_value = true;
1553        if (isFinal && num == state().boundariesCrossed) {
1554          needsSignatureAttribute_computed = true;
1555        } else {
1556        }
1557        state.INTERMEDIATE_VALUE |= intermediate;
1558    
1559        return needsSignatureAttribute_value;
1560      }
1561      /**
1562       * @attribute syn
1563       * @aspect StrictSubtype
1564       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:39
1565       */
1566      @ASTNodeAnnotation.Attribute
1567      public boolean strictSupertypeGenericClassDecl(GenericClassDecl type) {
1568        boolean strictSupertypeGenericClassDecl_GenericClassDecl_value = type.strictSubtype(genericDecl().original());
1569    
1570        return strictSupertypeGenericClassDecl_GenericClassDecl_value;
1571      }
1572      /**
1573       * @attribute syn
1574       * @aspect StrictSubtype
1575       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:370
1576       */
1577      @ASTNodeAnnotation.Attribute
1578      public boolean strictSupertypeClassDecl(ClassDecl type) {
1579        boolean strictSupertypeClassDecl_ClassDecl_value = super.strictSupertypeClassDecl(type);
1580    
1581        return strictSupertypeClassDecl_ClassDecl_value;
1582      }
1583      /**
1584       * @apilevel internal
1585       */
1586      private void strictSubtype_TypeDecl_reset() {
1587        strictSubtype_TypeDecl_values = null;
1588      }
1589      protected java.util.Map strictSubtype_TypeDecl_values;
1590      @ASTNodeAnnotation.Attribute
1591      public boolean strictSubtype(TypeDecl type) {
1592        Object _parameters = type;
1593        if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1594        ASTNode$State.CircularValue _value;
1595        if (strictSubtype_TypeDecl_values.containsKey(_parameters)) {
1596          Object _o = strictSubtype_TypeDecl_values.get(_parameters);
1597          if (!(_o instanceof ASTNode$State.CircularValue)) {
1598            return (Boolean) _o;
1599          } else {
1600            _value = (ASTNode$State.CircularValue) _o;
1601          }
1602        } else {
1603          _value = new ASTNode$State.CircularValue();
1604          strictSubtype_TypeDecl_values.put(_parameters, _value);
1605          _value.value = true;
1606        }
1607        ASTNode$State state = state();
1608        boolean new_strictSubtype_TypeDecl_value;
1609        if (!state.IN_CIRCLE) {
1610          state.IN_CIRCLE = true;
1611          int num = state.boundariesCrossed;
1612          boolean isFinal = this.is$Final();
1613          // TODO: fixme
1614          // state().CIRCLE_INDEX = 1;
1615          do {
1616            _value.visited = state.CIRCLE_INDEX;
1617            state.CHANGE = false;
1618            new_strictSubtype_TypeDecl_value = type.strictSupertypeParClassDecl(this);
1619            if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
1620              state.CHANGE = true;
1621              _value.value = new_strictSubtype_TypeDecl_value;
1622            }
1623            state.CIRCLE_INDEX++;
1624          } while (state.CHANGE);
1625          if (isFinal && num == state().boundariesCrossed) {
1626            strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value);
1627          } else {
1628            strictSubtype_TypeDecl_values.remove(_parameters);
1629            state.RESET_CYCLE = true;
1630            boolean $tmp = type.strictSupertypeParClassDecl(this);
1631            state.RESET_CYCLE = false;
1632          }
1633          state.IN_CIRCLE = false;
1634          state.INTERMEDIATE_VALUE = false;
1635          return new_strictSubtype_TypeDecl_value;
1636        }
1637        if (state.CIRCLE_INDEX != _value.visited) {
1638          _value.visited = state.CIRCLE_INDEX;
1639          new_strictSubtype_TypeDecl_value = type.strictSupertypeParClassDecl(this);
1640          if (state.RESET_CYCLE) {
1641            strictSubtype_TypeDecl_values.remove(_parameters);
1642          }
1643          else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
1644            state.CHANGE = true;
1645            _value.value = new_strictSubtype_TypeDecl_value;
1646          }
1647          state.INTERMEDIATE_VALUE = true;
1648          return new_strictSubtype_TypeDecl_value;
1649        }
1650        state.INTERMEDIATE_VALUE = true;
1651        return (Boolean) _value.value;
1652      }
1653      /**
1654       * @attribute syn
1655       * @aspect StrictSubtype
1656       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:52
1657       */
1658      @ASTNodeAnnotation.Attribute
1659      public boolean strictSupertypeRawClassDecl(RawClassDecl type) {
1660        boolean strictSupertypeRawClassDecl_RawClassDecl_value = type.genericDecl().original().strictSubtype(genericDecl().original());
1661    
1662        return strictSupertypeRawClassDecl_RawClassDecl_value;
1663      }
1664      /**
1665       * @attribute syn
1666       * @aspect StrictSubtype
1667       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:56
1668       */
1669      @ASTNodeAnnotation.Attribute
1670      public boolean strictSupertypeRawInterfaceDecl(RawInterfaceDecl type) {
1671        boolean strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value = type.genericDecl().original().strictSubtype(genericDecl().original());
1672    
1673        return strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value;
1674      }
1675      /**
1676       * @attribute syn
1677       * @aspect StrictSubtype
1678       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:155
1679       */
1680      @ASTNodeAnnotation.Attribute
1681      public boolean strictSupertypeParClassDecl(ParClassDecl type) {
1682        {
1683            if (type.genericDecl().original() == genericDecl().original()
1684                && type.getNumArgument() == getNumArgument()) {
1685              for (int i = 0; i < getNumArgument(); i++) {
1686                if (!type.getArgument(i).type().strictContainedIn(getArgument(i).type())) {
1687                  return false;
1688                }
1689              }
1690              if (isNestedType() && type.isNestedType()) {
1691                return type.enclosingType().strictSubtype(enclosingType());
1692              }
1693              return true;
1694            }
1695            return strictSupertypeClassDecl(type);
1696          }
1697      }
1698      /**
1699       * @attribute syn
1700       * @aspect StrictSubtype
1701       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:159
1702       */
1703      @ASTNodeAnnotation.Attribute
1704      public boolean strictSupertypeParInterfaceDecl(ParInterfaceDecl type) {
1705        boolean strictSupertypeParInterfaceDecl_ParInterfaceDecl_value = false;
1706    
1707        return strictSupertypeParInterfaceDecl_ParInterfaceDecl_value;
1708      }
1709      /**
1710       * @attribute syn
1711       * @aspect Generics
1712       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:306
1713       */
1714      @ASTNodeAnnotation.Attribute
1715      public boolean isParameterizedType() {
1716        boolean isParameterizedType_value = true;
1717    
1718        return isParameterizedType_value;
1719      }
1720      /**
1721       * @attribute syn
1722       * @aspect GenericsTypeCheck
1723       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:591
1724       */
1725      @ASTNodeAnnotation.Attribute
1726      public boolean sameArgument(ParTypeDecl decl) {
1727        {
1728            if (this == decl) {
1729              return true;
1730            }
1731            if (genericDecl() != decl.genericDecl()) {
1732              return false;
1733            }
1734            for (int i = 0; i < getNumArgument(); i++) {
1735              TypeDecl t1 = getArgument(i).type();
1736              TypeDecl t2 = decl.getArgument(i).type();
1737              if (t1 instanceof ParTypeDecl && t2 instanceof ParTypeDecl) {
1738                if (!((ParTypeDecl) t1).sameArgument((ParTypeDecl) t2)) {
1739                  return false;
1740                }
1741              } else {
1742                if (t1 != t2) {
1743                  return false;
1744                }
1745              }
1746            }
1747            return true;
1748          }
1749      }
1750      /**
1751       * @attribute syn
1752       * @aspect LookupParTypeDecl
1753       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:816
1754       */
1755      @ASTNodeAnnotation.Attribute
1756      public boolean sameSignature(Access a) {
1757        {
1758            if (a instanceof ParTypeAccess) {
1759              ParTypeAccess ta = (ParTypeAccess) a;
1760              if (genericDecl() != ta.genericDecl()) {
1761                return false;
1762              }
1763              if (getNumArgument() != ta.getNumTypeArgument()) {
1764                return false;
1765              }
1766              for (int i = 0; i < getNumArgument(); i++) {
1767                if (!getArgument(i).type().sameSignature(ta.getTypeArgument(i))) {
1768                  return false;
1769                }
1770              }
1771              return true;
1772            } else if (a instanceof TypeAccess && ((TypeAccess) a).isRaw()) {
1773              return false;
1774            }
1775            return super.sameSignature(a);
1776          }
1777      }
1778      /**
1779       * @apilevel internal
1780       */
1781      private void sameSignature_java_util_List_TypeDecl__reset() {
1782        sameSignature_java_util_List_TypeDecl__values = null;
1783      }
1784      protected java.util.Map sameSignature_java_util_List_TypeDecl__values;
1785      @ASTNodeAnnotation.Attribute
1786      public boolean sameSignature(java.util.List<TypeDecl> list) {
1787        Object _parameters = list;
1788        if (sameSignature_java_util_List_TypeDecl__values == null) sameSignature_java_util_List_TypeDecl__values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1789        ASTNode$State.CircularValue _value;
1790        if (sameSignature_java_util_List_TypeDecl__values.containsKey(_parameters)) {
1791          Object _o = sameSignature_java_util_List_TypeDecl__values.get(_parameters);
1792          if (!(_o instanceof ASTNode$State.CircularValue)) {
1793            return (Boolean) _o;
1794          } else {
1795            _value = (ASTNode$State.CircularValue) _o;
1796          }
1797        } else {
1798          _value = new ASTNode$State.CircularValue();
1799          sameSignature_java_util_List_TypeDecl__values.put(_parameters, _value);
1800          _value.value = true;
1801        }
1802        ASTNode$State state = state();
1803        boolean new_sameSignature_java_util_List_TypeDecl__value;
1804        if (!state.IN_CIRCLE) {
1805          state.IN_CIRCLE = true;
1806          int num = state.boundariesCrossed;
1807          boolean isFinal = this.is$Final();
1808          // TODO: fixme
1809          // state().CIRCLE_INDEX = 1;
1810          do {
1811            _value.visited = state.CIRCLE_INDEX;
1812            state.CHANGE = false;
1813            new_sameSignature_java_util_List_TypeDecl__value = sameSignature_compute(list);
1814            if (new_sameSignature_java_util_List_TypeDecl__value != ((Boolean)_value.value)) {
1815              state.CHANGE = true;
1816              _value.value = new_sameSignature_java_util_List_TypeDecl__value;
1817            }
1818            state.CIRCLE_INDEX++;
1819          } while (state.CHANGE);
1820          if (isFinal && num == state().boundariesCrossed) {
1821            sameSignature_java_util_List_TypeDecl__values.put(_parameters, new_sameSignature_java_util_List_TypeDecl__value);
1822          } else {
1823            sameSignature_java_util_List_TypeDecl__values.remove(_parameters);
1824            state.RESET_CYCLE = true;
1825            boolean $tmp = sameSignature_compute(list);
1826            state.RESET_CYCLE = false;
1827          }
1828          state.IN_CIRCLE = false;
1829          state.INTERMEDIATE_VALUE = false;
1830          return new_sameSignature_java_util_List_TypeDecl__value;
1831        }
1832        if (state.CIRCLE_INDEX != _value.visited) {
1833          _value.visited = state.CIRCLE_INDEX;
1834          new_sameSignature_java_util_List_TypeDecl__value = sameSignature_compute(list);
1835          if (state.RESET_CYCLE) {
1836            sameSignature_java_util_List_TypeDecl__values.remove(_parameters);
1837          }
1838          else if (new_sameSignature_java_util_List_TypeDecl__value != ((Boolean)_value.value)) {
1839            state.CHANGE = true;
1840            _value.value = new_sameSignature_java_util_List_TypeDecl__value;
1841          }
1842          state.INTERMEDIATE_VALUE = true;
1843          return new_sameSignature_java_util_List_TypeDecl__value;
1844        }
1845        state.INTERMEDIATE_VALUE = true;
1846        return (Boolean) _value.value;
1847      }
1848      /**
1849       * @apilevel internal
1850       */
1851      private boolean sameSignature_compute(java.util.List<TypeDecl> list) {
1852          if (getNumArgument() != list.size()) {
1853            return false;
1854          }
1855          for (int i = 0; i < list.size(); i++) {
1856            if (getArgument(i).type() != list.get(i)) {
1857              return false;
1858            }
1859          }
1860          return true;
1861        }
1862      /**
1863       * @apilevel internal
1864       */
1865      protected int usesTypeVariable_visited = -1;
1866      /**
1867       * @apilevel internal
1868       */
1869      private void usesTypeVariable_reset() {
1870        usesTypeVariable_computed = false;
1871        usesTypeVariable_initialized = false;
1872        usesTypeVariable_visited = -1;
1873      }
1874      /**
1875       * @apilevel internal
1876       */
1877      protected boolean usesTypeVariable_computed = false;
1878      /**
1879       * @apilevel internal
1880       */
1881      protected boolean usesTypeVariable_initialized = false;
1882      /**
1883       * @apilevel internal
1884       */
1885      protected boolean usesTypeVariable_value;
1886      @ASTNodeAnnotation.Attribute
1887      public boolean usesTypeVariable() {
1888        if (usesTypeVariable_computed) {
1889          return usesTypeVariable_value;
1890        }
1891        ASTNode$State state = state();
1892        boolean new_usesTypeVariable_value;
1893        if (!usesTypeVariable_initialized) {
1894          usesTypeVariable_initialized = true;
1895          usesTypeVariable_value = false;
1896        }
1897        if (!state.IN_CIRCLE) {
1898          state.IN_CIRCLE = true;
1899          int num = state.boundariesCrossed;
1900          boolean isFinal = this.is$Final();
1901          do {
1902            usesTypeVariable_visited = state.CIRCLE_INDEX;
1903            state.CHANGE = false;
1904            new_usesTypeVariable_value = usesTypeVariable_compute();
1905            if (new_usesTypeVariable_value != usesTypeVariable_value) {
1906              state.CHANGE = true;
1907            }
1908            usesTypeVariable_value = new_usesTypeVariable_value;
1909            state.CIRCLE_INDEX++;
1910          } while (state.CHANGE);
1911          if (isFinal && num == state().boundariesCrossed) {
1912            usesTypeVariable_computed = true;
1913          } else {
1914            state.RESET_CYCLE = true;
1915            boolean $tmp = usesTypeVariable_compute();
1916            state.RESET_CYCLE = false;
1917            usesTypeVariable_computed = false;
1918            usesTypeVariable_initialized = false;
1919          }
1920          state.IN_CIRCLE = false;
1921          state.INTERMEDIATE_VALUE = false;
1922          return usesTypeVariable_value;
1923        }
1924        if (usesTypeVariable_visited != state.CIRCLE_INDEX) {
1925          usesTypeVariable_visited = state.CIRCLE_INDEX;
1926          if (state.RESET_CYCLE) {
1927            usesTypeVariable_computed = false;
1928            usesTypeVariable_initialized = false;
1929            usesTypeVariable_visited = -1;
1930            return usesTypeVariable_value;
1931          }
1932          new_usesTypeVariable_value = usesTypeVariable_compute();
1933          if (new_usesTypeVariable_value != usesTypeVariable_value) {
1934            state.CHANGE = true;
1935          }
1936          usesTypeVariable_value = new_usesTypeVariable_value;
1937          state.INTERMEDIATE_VALUE = true;
1938          return usesTypeVariable_value;
1939        }
1940        state.INTERMEDIATE_VALUE = true;
1941        return usesTypeVariable_value;
1942      }
1943      /**
1944       * @apilevel internal
1945       */
1946      private boolean usesTypeVariable_compute() {
1947          if (super.usesTypeVariable()) {
1948            return true;
1949          }
1950          for (int i = 0; i < getNumArgument(); i++)
1951            if (getArgument(i).type().usesTypeVariable()) {
1952              return true;
1953            }
1954          return false;
1955        }
1956      /**
1957       * @attribute syn
1958       * @aspect LookupParTypeDecl
1959       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1417
1960       */
1961      @ASTNodeAnnotation.Attribute
1962      public TypeDecl original() {
1963        TypeDecl original_value = genericDecl().original();
1964    
1965        return original_value;
1966      }
1967      /**
1968       * @apilevel internal
1969       */
1970      protected boolean sourceTypeDecl_computed = false;
1971      /**
1972       * @apilevel internal
1973       */
1974      protected TypeDecl sourceTypeDecl_value;
1975      /**
1976       * @apilevel internal
1977       */
1978      private void sourceTypeDecl_reset() {
1979        sourceTypeDecl_computed = false;
1980        sourceTypeDecl_value = null;
1981      }
1982      /**
1983       * @attribute syn
1984       * @aspect SourceDeclarations
1985       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1618
1986       */
1987      @ASTNodeAnnotation.Attribute
1988      public TypeDecl sourceTypeDecl() {
1989        ASTNode$State state = state();
1990        if (sourceTypeDecl_computed) {
1991          return sourceTypeDecl_value;
1992        }
1993        boolean intermediate = state.INTERMEDIATE_VALUE;
1994        state.INTERMEDIATE_VALUE = false;
1995        int num = state.boundariesCrossed;
1996        boolean isFinal = this.is$Final();
1997        sourceTypeDecl_value = genericDecl().original().sourceTypeDecl();
1998        if (isFinal && num == state().boundariesCrossed) {
1999          sourceTypeDecl_computed = true;
2000        } else {
2001        }
2002        state.INTERMEDIATE_VALUE |= intermediate;
2003    
2004        return sourceTypeDecl_value;
2005      }
2006      /**
2007       * @apilevel internal
2008       */
2009      protected boolean fullName_computed = false;
2010      /**
2011       * @apilevel internal
2012       */
2013      protected String fullName_value;
2014      /**
2015       * @apilevel internal
2016       */
2017      private void fullName_reset() {
2018        fullName_computed = false;
2019        fullName_value = null;
2020      }
2021      /**
2022       * @attribute syn
2023       * @aspect TypeName
2024       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:80
2025       */
2026      @ASTNodeAnnotation.Attribute
2027      public String fullName() {
2028        ASTNode$State state = state();
2029        if (fullName_computed) {
2030          return fullName_value;
2031        }
2032        boolean intermediate = state.INTERMEDIATE_VALUE;
2033        state.INTERMEDIATE_VALUE = false;
2034        int num = state.boundariesCrossed;
2035        boolean isFinal = this.is$Final();
2036        fullName_value = fullName_compute();
2037        if (isFinal && num == state().boundariesCrossed) {
2038          fullName_computed = true;
2039        } else {
2040        }
2041        state.INTERMEDIATE_VALUE |= intermediate;
2042    
2043        return fullName_value;
2044      }
2045      /**
2046       * @apilevel internal
2047       */
2048      private String fullName_compute() {
2049          if (isNestedType()) {
2050            return enclosingType().fullName() + "." + nameWithArgs();
2051          }
2052          String packageName = packageName();
2053          if (packageName.equals("")) {
2054            return nameWithArgs();
2055          }
2056          return packageName + "." + nameWithArgs();
2057        }
2058      /**
2059       * @apilevel internal
2060       */
2061      protected boolean typeName_computed = false;
2062      /**
2063       * @apilevel internal
2064       */
2065      protected String typeName_value;
2066      /**
2067       * @apilevel internal
2068       */
2069      private void typeName_reset() {
2070        typeName_computed = false;
2071        typeName_value = null;
2072      }
2073      /**
2074       * @attribute syn
2075       * @aspect TypeName
2076       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:91
2077       */
2078      @ASTNodeAnnotation.Attribute
2079      public String typeName() {
2080        ASTNode$State state = state();
2081        if (typeName_computed) {
2082          return typeName_value;
2083        }
2084        boolean intermediate = state.INTERMEDIATE_VALUE;
2085        state.INTERMEDIATE_VALUE = false;
2086        int num = state.boundariesCrossed;
2087        boolean isFinal = this.is$Final();
2088        typeName_value = typeName_compute();
2089        if (isFinal && num == state().boundariesCrossed) {
2090          typeName_computed = true;
2091        } else {
2092        }
2093        state.INTERMEDIATE_VALUE |= intermediate;
2094    
2095        return typeName_value;
2096      }
2097      /**
2098       * @apilevel internal
2099       */
2100      private String typeName_compute() {
2101          if (isNestedType()) {
2102            return enclosingType().typeName() + "." + nameWithArgs();
2103          }
2104          String packageName = packageName();
2105          if (packageName.equals("") || packageName.equals(PRIMITIVE_PACKAGE_NAME)) {
2106            return nameWithArgs();
2107          }
2108          return packageName + "." + nameWithArgs();
2109        }
2110      /**
2111       * @attribute syn
2112       * @aspect GenericsParTypeDecl
2113       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:55
2114       */
2115      @ASTNodeAnnotation.Attribute
2116      public String nameWithArgs() {
2117        {
2118            StringBuilder sb = new StringBuilder();
2119            sb.append(name());
2120            sb.append("<");
2121            for (int i = 0; i < getNumArgument(); i++) {
2122              if (i != 0) {
2123                sb.append(", ");
2124              }
2125              sb.append(getArgument(i).type().fullName());
2126            }
2127            sb.append(">");
2128            return sb.toString();
2129          }
2130      }
2131      /**
2132       * @apilevel internal
2133       */
2134      protected boolean unimplementedMethods_computed = false;
2135      /**
2136       * @apilevel internal
2137       */
2138      protected Collection unimplementedMethods_value;
2139      /**
2140       * @apilevel internal
2141       */
2142      private void unimplementedMethods_reset() {
2143        unimplementedMethods_computed = false;
2144        unimplementedMethods_value = null;
2145      }
2146      /**
2147       * @attribute syn
2148       * @aspect Modifiers
2149       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:37
2150       */
2151      @ASTNodeAnnotation.Attribute
2152      public Collection unimplementedMethods() {
2153        ASTNode$State state = state();
2154        if (unimplementedMethods_computed) {
2155          return unimplementedMethods_value;
2156        }
2157        boolean intermediate = state.INTERMEDIATE_VALUE;
2158        state.INTERMEDIATE_VALUE = false;
2159        int num = state.boundariesCrossed;
2160        boolean isFinal = this.is$Final();
2161        unimplementedMethods_value = unimplementedMethods_compute();
2162        if (isFinal && num == state().boundariesCrossed) {
2163          unimplementedMethods_computed = true;
2164        } else {
2165        }
2166        state.INTERMEDIATE_VALUE |= intermediate;
2167    
2168        return unimplementedMethods_value;
2169      }
2170      /**
2171       * @apilevel internal
2172       */
2173      private Collection unimplementedMethods_compute() {
2174          HashSet set = new HashSet();
2175          HashSet result = new HashSet();
2176          for (Iterator iter = genericDecl().unimplementedMethods().iterator(); iter.hasNext(); ) {
2177            MethodDecl m = (MethodDecl) iter.next();
2178            set.add(m.sourceMethodDecl());
2179          }
2180          for (Iterator iter = super.unimplementedMethods().iterator(); iter.hasNext(); ) {
2181            MethodDecl m = (MethodDecl) iter.next();
2182            if (set.contains(m.sourceMethodDecl())) {
2183              result.add(m);
2184            }
2185          }
2186          return result;
2187        }
2188      /**
2189       * @apilevel internal
2190       */
2191      protected boolean uniqueIndex_computed = false;
2192      /**
2193       * @apilevel internal
2194       */
2195      protected int uniqueIndex_value;
2196      /**
2197       * @apilevel internal
2198       */
2199      private void uniqueIndex_reset() {
2200        uniqueIndex_computed = false;
2201      }
2202      /**
2203       * @attribute syn
2204       * @aspect Java2Rewrites
2205       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:33
2206       */
2207      @ASTNodeAnnotation.Attribute
2208      public int uniqueIndex() {
2209        ASTNode$State state = state();
2210        if (uniqueIndex_computed) {
2211          return uniqueIndex_value;
2212        }
2213        boolean intermediate = state.INTERMEDIATE_VALUE;
2214        state.INTERMEDIATE_VALUE = false;
2215        int num = state.boundariesCrossed;
2216        boolean isFinal = this.is$Final();
2217        uniqueIndex_value = genericDecl().uniqueIndex();
2218        if (isFinal && num == state().boundariesCrossed) {
2219          uniqueIndex_computed = true;
2220        } else {
2221        }
2222        state.INTERMEDIATE_VALUE |= intermediate;
2223    
2224        return uniqueIndex_value;
2225      }
2226      /**
2227       * @attribute syn
2228       * @aspect GenericsCodegen
2229       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:495
2230       */
2231      @ASTNodeAnnotation.Attribute
2232      public String typeArgumentsOpt() {
2233        {
2234            StringBuilder buf = new StringBuilder();
2235            buf.append("<");
2236            for (int i = 0; i < getNumArgument(); i++) {
2237              buf.append(getArgument(i).type().fieldTypeSignature());
2238            }
2239            buf.append(">");
2240            return buf.toString();
2241          }
2242      }
2243      /**
2244       * @apilevel internal
2245       */
2246      protected boolean localMethodsSignatureMap_computed = false;
2247      /**
2248       * @apilevel internal
2249       */
2250      protected Map<String,SimpleSet> localMethodsSignatureMap_value;
2251      /**
2252       * @apilevel internal
2253       */
2254      private void localMethodsSignatureMap_reset() {
2255        localMethodsSignatureMap_computed = false;
2256        localMethodsSignatureMap_value = null;
2257      }
2258      /**
2259       * @attribute syn
2260       * @aspect LookupParTypeDecl
2261       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1278
2262       */
2263      @ASTNodeAnnotation.Attribute
2264      public Map<String,SimpleSet> localMethodsSignatureMap() {
2265        ASTNode$State state = state();
2266        if (localMethodsSignatureMap_computed) {
2267          return localMethodsSignatureMap_value;
2268        }
2269        boolean intermediate = state.INTERMEDIATE_VALUE;
2270        state.INTERMEDIATE_VALUE = false;
2271        int num = state.boundariesCrossed;
2272        boolean isFinal = this.is$Final();
2273        localMethodsSignatureMap_value = localMethodsSignatureMap_compute();
2274        if (true) {
2275          localMethodsSignatureMap_computed = true;
2276        } else {
2277        }
2278        state.INTERMEDIATE_VALUE |= intermediate;
2279    
2280        return localMethodsSignatureMap_value;
2281      }
2282      /**
2283       * @apilevel internal
2284       */
2285      private Map<String,SimpleSet> localMethodsSignatureMap_compute() {
2286          Map<String,SimpleSet> map = new HashMap<String,SimpleSet>();
2287          for (Iterator<MethodDecl> iter = original().localMethodsIterator(); iter.hasNext(); ) {
2288            MethodDecl decl = iter.next();
2289      
2290            if (!decl.isStatic() && (decl.usesTypeVariable() || isRawType())) {
2291              BodyDecl copyDecl = ((BodyDeclList) getBodyDeclList()).localMethodSignatureCopy(decl, this);
2292              decl = (MethodDecl) copyDecl;
2293            }
2294            putSimpleSetElement(map, decl.signature(), decl);
2295      
2296          }
2297          return map;
2298        }
2299      /**
2300       * @apilevel internal
2301       */
2302      protected java.util.Map localFields_String_values;
2303      /**
2304       * @apilevel internal
2305       */
2306      private void localFields_String_reset() {
2307        localFields_String_values = null;
2308      }
2309      /**
2310       * @attribute syn
2311       * @aspect LookupParTypeDecl
2312       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1296
2313       */
2314      @ASTNodeAnnotation.Attribute
2315      public SimpleSet localFields(String name) {
2316        Object _parameters = name;
2317        if (localFields_String_values == null) localFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2318        ASTNode$State state = state();
2319        if (localFields_String_values.containsKey(_parameters)) {
2320          return (SimpleSet) localFields_String_values.get(_parameters);
2321        }
2322        boolean intermediate = state.INTERMEDIATE_VALUE;
2323        state.INTERMEDIATE_VALUE = false;
2324        int num = state.boundariesCrossed;
2325        boolean isFinal = this.is$Final();
2326        SimpleSet localFields_String_value = localFields_compute(name);
2327        if (true) {
2328          localFields_String_values.put(_parameters, localFields_String_value);
2329        } else {
2330        }
2331        state.INTERMEDIATE_VALUE |= intermediate;
2332    
2333        return localFields_String_value;
2334      }
2335      /**
2336       * @apilevel internal
2337       */
2338      private SimpleSet localFields_compute(String name) {
2339          SimpleSet set = SimpleSet.emptySet;
2340          for (Iterator iter = original().localFields(name).iterator(); iter.hasNext(); ) {
2341            FieldDeclaration f = (FieldDeclaration) iter.next();
2342      
2343            if (!f.isStatic() && (f.usesTypeVariable() || isRawType())) {
2344              BodyDecl fCopy = ((BodyDeclList) getBodyDeclList()).localFieldCopy(f, this);
2345              f = (FieldDeclaration) fCopy;
2346            }
2347            set = set.add(f);
2348      
2349          }
2350          return set;
2351        }
2352      /**
2353       * @apilevel internal
2354       */
2355      private void localTypeDecls_String_reset() {
2356        localTypeDecls_String_values = null;
2357      }
2358      protected java.util.Map localTypeDecls_String_values;
2359      @ASTNodeAnnotation.Attribute
2360      public SimpleSet localTypeDecls(String name) {
2361        Object _parameters = name;
2362        if (localTypeDecls_String_values == null) localTypeDecls_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2363        ASTNode$State.CircularValue _value;
2364        if (localTypeDecls_String_values.containsKey(_parameters)) {
2365          Object _o = localTypeDecls_String_values.get(_parameters);
2366          if (!(_o instanceof ASTNode$State.CircularValue)) {
2367            return (SimpleSet) _o;
2368          } else {
2369            _value = (ASTNode$State.CircularValue) _o;
2370          }
2371        } else {
2372          _value = new ASTNode$State.CircularValue();
2373          localTypeDecls_String_values.put(_parameters, _value);
2374          _value.value = SimpleSet.emptySet;
2375        }
2376        ASTNode$State state = state();
2377        SimpleSet new_localTypeDecls_String_value;
2378        if (!state.IN_CIRCLE) {
2379          state.IN_CIRCLE = true;
2380          int num = state.boundariesCrossed;
2381          boolean isFinal = this.is$Final();
2382          // TODO: fixme
2383          // state().CIRCLE_INDEX = 1;
2384          do {
2385            _value.visited = state.CIRCLE_INDEX;
2386            state.CHANGE = false;
2387            new_localTypeDecls_String_value = localTypeDecls_compute(name);
2388            if ((new_localTypeDecls_String_value==null && (SimpleSet)_value.value!=null) || (new_localTypeDecls_String_value!=null && !new_localTypeDecls_String_value.equals((SimpleSet)_value.value))) {
2389              state.CHANGE = true;
2390              _value.value = new_localTypeDecls_String_value;
2391            }
2392            state.CIRCLE_INDEX++;
2393          } while (state.CHANGE);
2394          if (true) {
2395            localTypeDecls_String_values.put(_parameters, new_localTypeDecls_String_value);
2396          } else {
2397            localTypeDecls_String_values.remove(_parameters);
2398            state.RESET_CYCLE = true;
2399            SimpleSet $tmp = localTypeDecls_compute(name);
2400            state.RESET_CYCLE = false;
2401          }
2402          state.IN_CIRCLE = false;
2403          state.INTERMEDIATE_VALUE = false;
2404          return new_localTypeDecls_String_value;
2405        }
2406        if (state.CIRCLE_INDEX != _value.visited) {
2407          _value.visited = state.CIRCLE_INDEX;
2408          new_localTypeDecls_String_value = localTypeDecls_compute(name);
2409          if (state.RESET_CYCLE) {
2410            localTypeDecls_String_values.remove(_parameters);
2411          }
2412          else if ((new_localTypeDecls_String_value==null && (SimpleSet)_value.value!=null) || (new_localTypeDecls_String_value!=null && !new_localTypeDecls_String_value.equals((SimpleSet)_value.value))) {
2413            state.CHANGE = true;
2414            _value.value = new_localTypeDecls_String_value;
2415          }
2416          state.INTERMEDIATE_VALUE = true;
2417          return new_localTypeDecls_String_value;
2418        }
2419        state.INTERMEDIATE_VALUE = true;
2420        return (SimpleSet) _value.value;
2421      }
2422      /**
2423       * @apilevel internal
2424       */
2425      private SimpleSet localTypeDecls_compute(String name) {
2426          SimpleSet set = SimpleSet.emptySet;
2427          for (Iterator iter = original().localTypeDecls(name).iterator(); iter.hasNext(); ) {
2428            TypeDecl t = (TypeDecl) iter.next();
2429      
2430            if (t.isStatic()) {
2431              set = set.add(t);
2432            } else if (t instanceof ClassDecl) {
2433              MemberClassDecl copy =
2434                ((BodyDeclList) getBodyDeclList()).localClassDeclCopy((ClassDecl) t, this);
2435              set = set.add(copy.getClassDecl());
2436            } else if (t instanceof InterfaceDecl) {
2437              MemberInterfaceDecl copy =
2438                ((BodyDeclList) getBodyDeclList()).localInterfaceDeclCopy((InterfaceDecl) t, this);
2439              set = set.add(copy.getInterfaceDecl());
2440            }
2441          }
2442          return set;
2443        }
2444      /**
2445       * @apilevel internal
2446       */
2447      protected boolean constructors_computed = false;
2448      /**
2449       * @apilevel internal
2450       */
2451      protected Collection<ConstructorDecl> constructors_value;
2452      /**
2453       * @apilevel internal
2454       */
2455      private void constructors_reset() {
2456        constructors_computed = false;
2457        constructors_value = null;
2458      }
2459      /**
2460       * @attribute syn
2461       * @aspect LookupParTypeDecl
2462       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1347
2463       */
2464      @ASTNodeAnnotation.Attribute
2465      public Collection<ConstructorDecl> constructors() {
2466        ASTNode$State state = state();
2467        if (constructors_computed) {
2468          return constructors_value;
2469        }
2470        boolean intermediate = state.INTERMEDIATE_VALUE;
2471        state.INTERMEDIATE_VALUE = false;
2472        int num = state.boundariesCrossed;
2473        boolean isFinal = this.is$Final();
2474        constructors_value = constructors_compute();
2475        if (isFinal && num == state().boundariesCrossed) {
2476          constructors_computed = true;
2477        } else {
2478        }
2479        state.INTERMEDIATE_VALUE |= intermediate;
2480    
2481        return constructors_value;
2482      }
2483      /**
2484       * @apilevel internal
2485       */
2486      private Collection<ConstructorDecl> constructors_compute() {
2487          Collection<ConstructorDecl> constructors = new ArrayList<ConstructorDecl>();
2488          for (Iterator iter = original().constructors().iterator(); iter.hasNext(); ) {
2489            ConstructorDecl c = (ConstructorDecl) iter.next();
2490      
2491            ConstructorDecl b = ((BodyDeclList) getBodyDeclList()).constructorCopy(c, this);
2492            constructors.add(b);
2493          }
2494          return constructors;
2495        }
2496      /**
2497       * @attribute inh
2498       * @aspect GenericsParTypeDecl
2499       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:71
2500       */
2501      /**
2502       * @attribute inh
2503       * @aspect GenericsParTypeDecl
2504       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:71
2505       */
2506      @ASTNodeAnnotation.Attribute
2507      public TypeDecl genericDecl() {
2508        ASTNode$State state = state();
2509        if (genericDecl_computed) {
2510          return genericDecl_value;
2511        }
2512        boolean intermediate = state.INTERMEDIATE_VALUE;
2513        state.INTERMEDIATE_VALUE = false;
2514        int num = state.boundariesCrossed;
2515        boolean isFinal = this.is$Final();
2516        genericDecl_value = getParent().Define_genericDecl(this, null);
2517        if (isFinal && num == state().boundariesCrossed) {
2518          genericDecl_computed = true;
2519        } else {
2520        }
2521        state.INTERMEDIATE_VALUE |= intermediate;
2522    
2523        return genericDecl_value;
2524      }
2525      /**
2526       * @apilevel internal
2527       */
2528      protected boolean genericDecl_computed = false;
2529      /**
2530       * @apilevel internal
2531       */
2532      protected TypeDecl genericDecl_value;
2533      /**
2534       * @apilevel internal
2535       */
2536      private void genericDecl_reset() {
2537        genericDecl_computed = false;
2538        genericDecl_value = null;
2539      }
2540      /**
2541       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
2542       * @apilevel internal
2543       */
2544      public NameType Define_nameType(ASTNode caller, ASTNode child) {
2545        if (caller == getArgumentListNoTransform()) {
2546          // @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:703
2547          int childIndex = caller.getIndexOfChild(child);
2548          return NameType.TYPE_NAME;
2549        }
2550        else {
2551          return super.Define_nameType(caller, child);
2552        }
2553      }
2554      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
2555        return true;
2556      }
2557      /**
2558       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:71
2559       * @apilevel internal
2560       */
2561      public TypeDecl Define_genericDecl(ASTNode caller, ASTNode child) {
2562        if (caller == getBodyDeclListNoTransform()) {
2563          // @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:75
2564          int index = caller.getIndexOfChild(child);
2565          {
2566              if (getBodyDecl(index) instanceof MemberTypeDecl) {
2567                MemberTypeDecl m = (MemberTypeDecl) getBodyDecl(index);
2568                return extractSingleType(genericDecl().memberTypes(m.typeDecl().name()));
2569              }
2570              return genericDecl();
2571            }
2572        }
2573        else {
2574          return getParent().Define_genericDecl(this, caller);
2575        }
2576      }
2577      protected boolean canDefine_genericDecl(ASTNode caller, ASTNode child) {
2578        return true;
2579      }
2580      /**
2581       * @apilevel internal
2582       */
2583      public ASTNode rewriteTo() {
2584        return super.rewriteTo();
2585      }
2586    }