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