001    /* This file was generated with JastAdd2 (http://jastadd.org) version R20130213 */
002    package AST;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.*;
007    import beaver.*;
008    import java.util.ArrayList;
009    import java.util.zip.*;
010    import java.io.*;
011    import java.io.FileNotFoundException;
012    import java.util.Collection;
013    /**
014     * @production WildcardExtendsType : {@link AbstractWildcardType} ::= <span class="component">{@link Access}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.ast:27
017     */
018    public class WildcardExtendsType extends AbstractWildcardType implements Cloneable {
019      /**
020       * @apilevel low-level
021       */
022      public void flushCache() {
023      }
024      /**
025       * @apilevel internal
026       */
027      public void flushCollectionCache() {
028      }
029      /**
030       * @apilevel internal
031       */
032      @SuppressWarnings({"unchecked", "cast"})
033      public WildcardExtendsType clone() throws CloneNotSupportedException {
034        WildcardExtendsType node = (WildcardExtendsType)super.clone();
035        node.involvesTypeParameters_visited = -1;
036        node.involvesTypeParameters_computed = false;
037        node.involvesTypeParameters_initialized = false;
038        node.usesTypeVariable_visited = -1;
039        node.usesTypeVariable_computed = false;
040        node.usesTypeVariable_initialized = false;
041        node.subtype_TypeDecl_values = null;
042        node.containedIn_TypeDecl_values = null;
043        node.sameStructure_TypeDecl_values = null;
044        node.instanceOf_TypeDecl_values = null;
045        node.fieldTypeSignature_computed = false;
046        node.fieldTypeSignature_value = null;
047        node.in$Circle(false);
048        node.is$Final(false);
049        return node;
050      }
051    /**
052     * @apilevel internal
053     */
054      @SuppressWarnings({"unchecked", "cast"})
055    public WildcardExtendsType copy() {
056      
057      try {
058        WildcardExtendsType node = (WildcardExtendsType) clone();
059        node.parent = null;
060        if(children != null)
061          node.children = (ASTNode[]) children.clone();
062        
063        return node;
064      } catch (CloneNotSupportedException e) {
065        throw new Error("Error: clone not supported for " + getClass().getName());
066      }
067      
068    }/**
069     * Create a deep copy of the AST subtree at this node.
070     * The copy is dangling, i.e. has no parent.
071     * @return dangling copy of the subtree at this node
072     * @apilevel low-level
073     */
074      @SuppressWarnings({"unchecked", "cast"})
075    public WildcardExtendsType fullCopy() {
076      
077      WildcardExtendsType tree = (WildcardExtendsType) copy();
078      if (children != null) {
079        for (int i = 0; i < children.length; ++i) {
080          
081          ASTNode child = (ASTNode) children[i];
082          if(child != null) {
083            child = child.fullCopy();
084            tree.setChild(child, i);
085          }
086        }
087      }
088      return tree;
089      
090    }  /**
091       * @ast method 
092       * @aspect LookupParTypeDecl
093       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:902
094       */
095      public Access substitute(Parameterization parTypeDecl) {
096        if(!usesTypeVariable())
097          return super.substitute(parTypeDecl);
098        return new WildcardExtends(getAccess().type().substitute(parTypeDecl));
099      }
100      /**
101       * @ast method 
102       * 
103       */
104      public WildcardExtendsType() {
105        super();
106    
107    
108      }
109      /**
110       * Initializes the child array to the correct size.
111       * Initializes List and Opt nta children.
112       * @apilevel internal
113       * @ast method
114       * @ast method 
115       * 
116       */
117      public void init$Children() {
118        children = new ASTNode[3];
119        setChild(new List(), 1);
120      }
121      /**
122       * @ast method 
123       * 
124       */
125      public WildcardExtendsType(Modifiers p0, String p1, List<BodyDecl> p2, Access p3) {
126        setChild(p0, 0);
127        setID(p1);
128        setChild(p2, 1);
129        setChild(p3, 2);
130      }
131      /**
132       * @ast method 
133       * 
134       */
135      public WildcardExtendsType(Modifiers p0, beaver.Symbol p1, List<BodyDecl> p2, Access p3) {
136        setChild(p0, 0);
137        setID(p1);
138        setChild(p2, 1);
139        setChild(p3, 2);
140      }
141      /**
142       * @apilevel low-level
143       * @ast method 
144       * 
145       */
146      protected int numChildren() {
147        return 3;
148      }
149      /**
150       * @apilevel internal
151       * @ast method 
152       * 
153       */
154      public boolean mayHaveRewrite() {
155        return false;
156      }
157      /**
158       * Replaces the Modifiers child.
159       * @param node The new node to replace the Modifiers child.
160       * @apilevel high-level
161       * @ast method 
162       * 
163       */
164      public void setModifiers(Modifiers node) {
165        setChild(node, 0);
166      }
167      /**
168       * Retrieves the Modifiers child.
169       * @return The current node used as the Modifiers child.
170       * @apilevel high-level
171       * @ast method 
172       * 
173       */
174      public Modifiers getModifiers() {
175        return (Modifiers)getChild(0);
176      }
177      /**
178       * Retrieves the Modifiers child.
179       * <p><em>This method does not invoke AST transformations.</em></p>
180       * @return The current node used as the Modifiers child.
181       * @apilevel low-level
182       * @ast method 
183       * 
184       */
185      public Modifiers getModifiersNoTransform() {
186        return (Modifiers)getChildNoTransform(0);
187      }
188      /**
189       * Replaces the lexeme ID.
190       * @param value The new value for the lexeme ID.
191       * @apilevel high-level
192       * @ast method 
193       * 
194       */
195      public void setID(String value) {
196        tokenString_ID = value;
197      }
198      /**
199       * JastAdd-internal setter for lexeme ID using the Beaver parser.
200       * @apilevel internal
201       * @ast method 
202       * 
203       */
204      public void setID(beaver.Symbol symbol) {
205        if(symbol.value != null && !(symbol.value instanceof String))
206          throw new UnsupportedOperationException("setID is only valid for String lexemes");
207        tokenString_ID = (String)symbol.value;
208        IDstart = symbol.getStart();
209        IDend = symbol.getEnd();
210      }
211      /**
212       * Retrieves the value for the lexeme ID.
213       * @return The value for the lexeme ID.
214       * @apilevel high-level
215       * @ast method 
216       * 
217       */
218      public String getID() {
219        return tokenString_ID != null ? tokenString_ID : "";
220      }
221      /**
222       * Replaces the BodyDecl list.
223       * @param list The new list node to be used as the BodyDecl list.
224       * @apilevel high-level
225       * @ast method 
226       * 
227       */
228      public void setBodyDeclList(List<BodyDecl> list) {
229        setChild(list, 1);
230      }
231      /**
232       * Retrieves the number of children in the BodyDecl list.
233       * @return Number of children in the BodyDecl list.
234       * @apilevel high-level
235       * @ast method 
236       * 
237       */
238      public int getNumBodyDecl() {
239        return getBodyDeclList().getNumChild();
240      }
241      /**
242       * Retrieves the number of children in the BodyDecl list.
243       * Calling this method will not trigger rewrites..
244       * @return Number of children in the BodyDecl list.
245       * @apilevel low-level
246       * @ast method 
247       * 
248       */
249      public int getNumBodyDeclNoTransform() {
250        return getBodyDeclListNoTransform().getNumChildNoTransform();
251      }
252      /**
253       * Retrieves the element at index {@code i} in the BodyDecl list..
254       * @param i Index of the element to return.
255       * @return The element at position {@code i} in the BodyDecl list.
256       * @apilevel high-level
257       * @ast method 
258       * 
259       */
260      @SuppressWarnings({"unchecked", "cast"})
261      public BodyDecl getBodyDecl(int i) {
262        return (BodyDecl)getBodyDeclList().getChild(i);
263      }
264      /**
265       * Append an element to the BodyDecl list.
266       * @param node The element to append to the BodyDecl list.
267       * @apilevel high-level
268       * @ast method 
269       * 
270       */
271      public void addBodyDecl(BodyDecl node) {
272        List<BodyDecl> list = (parent == null || state == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
273        list.addChild(node);
274      }
275      /**
276       * @apilevel low-level
277       * @ast method 
278       * 
279       */
280      public void addBodyDeclNoTransform(BodyDecl node) {
281        List<BodyDecl> list = getBodyDeclListNoTransform();
282        list.addChild(node);
283      }
284      /**
285       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
286       * @param node The new node to replace the old list element.
287       * @param i The list index of the node to be replaced.
288       * @apilevel high-level
289       * @ast method 
290       * 
291       */
292      public void setBodyDecl(BodyDecl node, int i) {
293        List<BodyDecl> list = getBodyDeclList();
294        list.setChild(node, i);
295      }
296      /**
297       * Retrieves the BodyDecl list.
298       * @return The node representing the BodyDecl list.
299       * @apilevel high-level
300       * @ast method 
301       * 
302       */
303      public List<BodyDecl> getBodyDecls() {
304        return getBodyDeclList();
305      }
306      /**
307       * Retrieves the BodyDecl list.
308       * <p><em>This method does not invoke AST transformations.</em></p>
309       * @return The node representing the BodyDecl list.
310       * @apilevel low-level
311       * @ast method 
312       * 
313       */
314      public List<BodyDecl> getBodyDeclsNoTransform() {
315        return getBodyDeclListNoTransform();
316      }
317      /**
318       * Retrieves the BodyDecl list.
319       * @return The node representing the BodyDecl list.
320       * @apilevel high-level
321       * @ast method 
322       * 
323       */
324      @SuppressWarnings({"unchecked", "cast"})
325      public List<BodyDecl> getBodyDeclList() {
326        List<BodyDecl> list = (List<BodyDecl>)getChild(1);
327        list.getNumChild();
328        return list;
329      }
330      /**
331       * Retrieves the BodyDecl list.
332       * <p><em>This method does not invoke AST transformations.</em></p>
333       * @return The node representing the BodyDecl list.
334       * @apilevel low-level
335       * @ast method 
336       * 
337       */
338      @SuppressWarnings({"unchecked", "cast"})
339      public List<BodyDecl> getBodyDeclListNoTransform() {
340        return (List<BodyDecl>)getChildNoTransform(1);
341      }
342      /**
343       * Replaces the Access child.
344       * @param node The new node to replace the Access child.
345       * @apilevel high-level
346       * @ast method 
347       * 
348       */
349      public void setAccess(Access node) {
350        setChild(node, 2);
351      }
352      /**
353       * Retrieves the Access child.
354       * @return The current node used as the Access child.
355       * @apilevel high-level
356       * @ast method 
357       * 
358       */
359      public Access getAccess() {
360        return (Access)getChild(2);
361      }
362      /**
363       * Retrieves the Access child.
364       * <p><em>This method does not invoke AST transformations.</em></p>
365       * @return The current node used as the Access child.
366       * @apilevel low-level
367       * @ast method 
368       * 
369       */
370      public Access getAccessNoTransform() {
371        return (Access)getChildNoTransform(2);
372      }
373      /**
374       * @apilevel internal
375       */
376      protected int involvesTypeParameters_visited = -1;
377      /**
378       * @apilevel internal
379       */
380      protected boolean involvesTypeParameters_computed = false;
381      /**
382       * @apilevel internal
383       */
384      protected boolean involvesTypeParameters_initialized = false;
385      /**
386       * @apilevel internal
387       */
388      protected boolean involvesTypeParameters_value;
389      /**
390       * @attribute syn
391       * @aspect GenericMethodsInference
392       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericMethodsInference.jrag:30
393       */
394      @SuppressWarnings({"unchecked", "cast"})
395      public boolean involvesTypeParameters() {
396        if(involvesTypeParameters_computed) {
397          return involvesTypeParameters_value;
398        }
399        ASTNode$State state = state();
400        if (!involvesTypeParameters_initialized) {
401          involvesTypeParameters_initialized = true;
402          involvesTypeParameters_value = false;
403        }
404        if (!state.IN_CIRCLE) {
405          state.IN_CIRCLE = true;
406        int num = state.boundariesCrossed;
407        boolean isFinal = this.is$Final();
408          do {
409            involvesTypeParameters_visited = state.CIRCLE_INDEX;
410            state.CHANGE = false;
411            boolean new_involvesTypeParameters_value = involvesTypeParameters_compute();
412            if (new_involvesTypeParameters_value!=involvesTypeParameters_value)
413              state.CHANGE = true;
414            involvesTypeParameters_value = new_involvesTypeParameters_value; 
415            state.CIRCLE_INDEX++;
416          } while (state.CHANGE);
417            if(isFinal && num == state().boundariesCrossed) {
418          involvesTypeParameters_computed = true;
419          }
420          else {
421          state.RESET_CYCLE = true;
422          involvesTypeParameters_compute();
423          state.RESET_CYCLE = false;
424            involvesTypeParameters_computed = false;
425            involvesTypeParameters_initialized = false;
426          }
427          state.IN_CIRCLE = false; 
428              return involvesTypeParameters_value;
429        }
430        if(involvesTypeParameters_visited != state.CIRCLE_INDEX) {
431          involvesTypeParameters_visited = state.CIRCLE_INDEX;
432          if (state.RESET_CYCLE) {
433            involvesTypeParameters_computed = false;
434            involvesTypeParameters_initialized = false;
435            involvesTypeParameters_visited = -1;
436                return involvesTypeParameters_value;
437          }
438          boolean new_involvesTypeParameters_value = involvesTypeParameters_compute();
439          if (new_involvesTypeParameters_value!=involvesTypeParameters_value)
440            state.CHANGE = true;
441          involvesTypeParameters_value = new_involvesTypeParameters_value; 
442              return involvesTypeParameters_value;
443        }
444            return involvesTypeParameters_value;
445      }
446      /**
447       * @apilevel internal
448       */
449      private boolean involvesTypeParameters_compute() {  return extendsType().involvesTypeParameters();  }
450      /**
451       * @attribute syn
452       * @aspect LookupParTypeDecl
453       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:571
454       */
455      public boolean sameSignature(Access a) {
456        ASTNode$State state = state();
457        try {
458        if(a instanceof WildcardExtends)
459          return getAccess().type().sameSignature(((WildcardExtends)a).getAccess());
460        return super.sameSignature(a);
461      }
462        finally {
463        }
464      }
465      /**
466       * @apilevel internal
467       */
468      protected int usesTypeVariable_visited = -1;
469      /**
470       * @apilevel internal
471       */
472      protected boolean usesTypeVariable_computed = false;
473      /**
474       * @apilevel internal
475       */
476      protected boolean usesTypeVariable_initialized = false;
477      /**
478       * @apilevel internal
479       */
480      protected boolean usesTypeVariable_value;
481      /**
482       * @attribute syn
483       * @aspect LookupParTypeDecl
484       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:1080
485       */
486      @SuppressWarnings({"unchecked", "cast"})
487      public boolean usesTypeVariable() {
488        if(usesTypeVariable_computed) {
489          return usesTypeVariable_value;
490        }
491        ASTNode$State state = state();
492        if (!usesTypeVariable_initialized) {
493          usesTypeVariable_initialized = true;
494          usesTypeVariable_value = false;
495        }
496        if (!state.IN_CIRCLE) {
497          state.IN_CIRCLE = true;
498        int num = state.boundariesCrossed;
499        boolean isFinal = this.is$Final();
500          do {
501            usesTypeVariable_visited = state.CIRCLE_INDEX;
502            state.CHANGE = false;
503            boolean new_usesTypeVariable_value = usesTypeVariable_compute();
504            if (new_usesTypeVariable_value!=usesTypeVariable_value)
505              state.CHANGE = true;
506            usesTypeVariable_value = new_usesTypeVariable_value; 
507            state.CIRCLE_INDEX++;
508          } while (state.CHANGE);
509            if(isFinal && num == state().boundariesCrossed) {
510          usesTypeVariable_computed = true;
511          }
512          else {
513          state.RESET_CYCLE = true;
514          usesTypeVariable_compute();
515          state.RESET_CYCLE = false;
516            usesTypeVariable_computed = false;
517            usesTypeVariable_initialized = false;
518          }
519          state.IN_CIRCLE = false; 
520              return usesTypeVariable_value;
521        }
522        if(usesTypeVariable_visited != state.CIRCLE_INDEX) {
523          usesTypeVariable_visited = state.CIRCLE_INDEX;
524          if (state.RESET_CYCLE) {
525            usesTypeVariable_computed = false;
526            usesTypeVariable_initialized = false;
527            usesTypeVariable_visited = -1;
528                return usesTypeVariable_value;
529          }
530          boolean new_usesTypeVariable_value = usesTypeVariable_compute();
531          if (new_usesTypeVariable_value!=usesTypeVariable_value)
532            state.CHANGE = true;
533          usesTypeVariable_value = new_usesTypeVariable_value; 
534              return usesTypeVariable_value;
535        }
536            return usesTypeVariable_value;
537      }
538      /**
539       * @apilevel internal
540       */
541      private boolean usesTypeVariable_compute() {  return getAccess().type().usesTypeVariable();  }
542      /**
543       * @attribute syn
544       * @aspect LookupParTypeDecl
545       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:1366
546       */
547      public TypeDecl extendsType() {
548        ASTNode$State state = state();
549        try {  return getAccess().type();  }
550        finally {
551        }
552      }
553      /**
554       * @attribute syn
555       * @aspect GenericsSubtype
556       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:46
557       */
558      public boolean supertypeWildcard(WildcardType type) {
559        ASTNode$State state = state();
560        try {  return typeObject().subtype(this);  }
561        finally {
562        }
563      }
564      protected java.util.Map subtype_TypeDecl_values;
565      /**
566       * @attribute syn
567       * @aspect GenericsSubtype
568       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:56
569       */
570      @SuppressWarnings({"unchecked", "cast"})
571      public boolean subtype(TypeDecl type) {
572        Object _parameters = type;
573        if(subtype_TypeDecl_values == null) subtype_TypeDecl_values = new java.util.HashMap(4);
574        ASTNode$State.CircularValue _value;
575        if(subtype_TypeDecl_values.containsKey(_parameters)) {
576          Object _o = subtype_TypeDecl_values.get(_parameters);
577          if(!(_o instanceof ASTNode$State.CircularValue)) {
578            return ((Boolean)_o).booleanValue();
579          }
580          else
581            _value = (ASTNode$State.CircularValue)_o;
582        }
583        else {
584          _value = new ASTNode$State.CircularValue();
585          subtype_TypeDecl_values.put(_parameters, _value);
586          _value.value = Boolean.valueOf(true);
587        }
588        ASTNode$State state = state();
589        if (!state.IN_CIRCLE) {
590          state.IN_CIRCLE = true;
591          int num = state.boundariesCrossed;
592          boolean isFinal = this.is$Final();
593          boolean new_subtype_TypeDecl_value;
594          do {
595            _value.visited = new Integer(state.CIRCLE_INDEX);
596            state.CHANGE = false;
597            new_subtype_TypeDecl_value = subtype_compute(type);
598            if (new_subtype_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
599              state.CHANGE = true;
600              _value.value = Boolean.valueOf(new_subtype_TypeDecl_value);
601            }
602            state.CIRCLE_INDEX++;
603          } while (state.CHANGE);
604            if(isFinal && num == state().boundariesCrossed) {
605            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
606          }
607          else {
608            subtype_TypeDecl_values.remove(_parameters);
609          state.RESET_CYCLE = true;
610          subtype_compute(type);
611          state.RESET_CYCLE = false;
612          }
613          state.IN_CIRCLE = false; 
614          return new_subtype_TypeDecl_value;
615        }
616        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
617          _value.visited = new Integer(state.CIRCLE_INDEX);
618          boolean new_subtype_TypeDecl_value = subtype_compute(type);
619          if (state.RESET_CYCLE) {
620            subtype_TypeDecl_values.remove(_parameters);
621          }
622          else if (new_subtype_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
623            state.CHANGE = true;
624            _value.value = new_subtype_TypeDecl_value;
625          }
626          return new_subtype_TypeDecl_value;
627        }
628        return ((Boolean)_value.value).booleanValue();
629      }
630      /**
631       * @apilevel internal
632       */
633      private boolean subtype_compute(TypeDecl type) {  return type.supertypeWildcardExtends(this);  }
634      /**
635       * @attribute syn
636       * @aspect GenericsSubtype
637       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:57
638       */
639      public boolean supertypeWildcardExtends(WildcardExtendsType type) {
640        ASTNode$State state = state();
641        try {  return type.extendsType().subtype(extendsType());  }
642        finally {
643        }
644      }
645      /**
646       * @attribute syn
647       * @aspect GenericsSubtype
648       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:421
649       */
650      public boolean supertypeClassDecl(ClassDecl type) {
651        ASTNode$State state = state();
652        try {  return type.subtype(extendsType());  }
653        finally {
654        }
655      }
656      /**
657       * @attribute syn
658       * @aspect GenericsSubtype
659       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:437
660       */
661      public boolean supertypeInterfaceDecl(InterfaceDecl type) {
662        ASTNode$State state = state();
663        try {  return type.subtype(extendsType());  }
664        finally {
665        }
666      }
667      /**
668       * @attribute syn
669       * @aspect GenericsSubtype
670       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:125
671       */
672      public boolean supertypeParClassDecl(ParClassDecl type) {
673        ASTNode$State state = state();
674        try {  return type.subtype(extendsType());  }
675        finally {
676        }
677      }
678      /**
679       * @attribute syn
680       * @aspect GenericsSubtype
681       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:129
682       */
683      public boolean supertypeParInterfaceDecl(ParInterfaceDecl type) {
684        ASTNode$State state = state();
685        try {  return type.subtype(extendsType());  }
686        finally {
687        }
688      }
689      /**
690       * @attribute syn
691       * @aspect GenericsSubtype
692       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:26
693       */
694      public boolean supertypeRawClassDecl(RawClassDecl type) {
695        ASTNode$State state = state();
696        try {  return type.subtype(extendsType());  }
697        finally {
698        }
699      }
700      /**
701       * @attribute syn
702       * @aspect GenericsSubtype
703       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:30
704       */
705      public boolean supertypeRawInterfaceDecl(RawInterfaceDecl type) {
706        ASTNode$State state = state();
707        try {  return type.subtype(extendsType());  }
708        finally {
709        }
710      }
711      /**
712       * @attribute syn
713       * @aspect GenericsSubtype
714       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:291
715       */
716      public boolean supertypeTypeVariable(TypeVariable type) {
717        ASTNode$State state = state();
718        try {  return type.subtype(extendsType());  }
719        finally {
720        }
721      }
722      /**
723       * @attribute syn
724       * @aspect GenericsSubtype
725       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:450
726       */
727      public boolean supertypeArrayDecl(ArrayDecl type) {
728        ASTNode$State state = state();
729        try {  return type.subtype(extendsType());  }
730        finally {
731        }
732      }
733      protected java.util.Map containedIn_TypeDecl_values;
734      /**
735       * @attribute syn
736       * @aspect GenericsSubtype
737       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:153
738       */
739      @SuppressWarnings({"unchecked", "cast"})
740      public boolean containedIn(TypeDecl type) {
741        Object _parameters = type;
742        if(containedIn_TypeDecl_values == null) containedIn_TypeDecl_values = new java.util.HashMap(4);
743        ASTNode$State.CircularValue _value;
744        if(containedIn_TypeDecl_values.containsKey(_parameters)) {
745          Object _o = containedIn_TypeDecl_values.get(_parameters);
746          if(!(_o instanceof ASTNode$State.CircularValue)) {
747            return ((Boolean)_o).booleanValue();
748          }
749          else
750            _value = (ASTNode$State.CircularValue)_o;
751        }
752        else {
753          _value = new ASTNode$State.CircularValue();
754          containedIn_TypeDecl_values.put(_parameters, _value);
755          _value.value = Boolean.valueOf(true);
756        }
757        ASTNode$State state = state();
758        if (!state.IN_CIRCLE) {
759          state.IN_CIRCLE = true;
760          int num = state.boundariesCrossed;
761          boolean isFinal = this.is$Final();
762          boolean new_containedIn_TypeDecl_value;
763          do {
764            _value.visited = new Integer(state.CIRCLE_INDEX);
765            state.CHANGE = false;
766            new_containedIn_TypeDecl_value = containedIn_compute(type);
767            if (new_containedIn_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
768              state.CHANGE = true;
769              _value.value = Boolean.valueOf(new_containedIn_TypeDecl_value);
770            }
771            state.CIRCLE_INDEX++;
772          } while (state.CHANGE);
773            if(isFinal && num == state().boundariesCrossed) {
774            containedIn_TypeDecl_values.put(_parameters, new_containedIn_TypeDecl_value);
775          }
776          else {
777            containedIn_TypeDecl_values.remove(_parameters);
778          state.RESET_CYCLE = true;
779          containedIn_compute(type);
780          state.RESET_CYCLE = false;
781          }
782          state.IN_CIRCLE = false; 
783          return new_containedIn_TypeDecl_value;
784        }
785        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
786          _value.visited = new Integer(state.CIRCLE_INDEX);
787          boolean new_containedIn_TypeDecl_value = containedIn_compute(type);
788          if (state.RESET_CYCLE) {
789            containedIn_TypeDecl_values.remove(_parameters);
790          }
791          else if (new_containedIn_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
792            state.CHANGE = true;
793            _value.value = new_containedIn_TypeDecl_value;
794          }
795          return new_containedIn_TypeDecl_value;
796        }
797        return ((Boolean)_value.value).booleanValue();
798      }
799      /**
800       * @apilevel internal
801       */
802      private boolean containedIn_compute(TypeDecl type) {
803        if(type == this || type instanceof WildcardType) 
804          return true;
805        else if(type instanceof WildcardExtendsType)
806          return extendsType().subtype(((WildcardExtendsType)type).extendsType());
807        else 
808          return false;
809      }
810      protected java.util.Map sameStructure_TypeDecl_values;
811      /**
812       * @attribute syn
813       * @aspect GenericsSubtype
814       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:209
815       */
816      @SuppressWarnings({"unchecked", "cast"})
817      public boolean sameStructure(TypeDecl t) {
818        Object _parameters = t;
819        if(sameStructure_TypeDecl_values == null) sameStructure_TypeDecl_values = new java.util.HashMap(4);
820        ASTNode$State.CircularValue _value;
821        if(sameStructure_TypeDecl_values.containsKey(_parameters)) {
822          Object _o = sameStructure_TypeDecl_values.get(_parameters);
823          if(!(_o instanceof ASTNode$State.CircularValue)) {
824            return ((Boolean)_o).booleanValue();
825          }
826          else
827            _value = (ASTNode$State.CircularValue)_o;
828        }
829        else {
830          _value = new ASTNode$State.CircularValue();
831          sameStructure_TypeDecl_values.put(_parameters, _value);
832          _value.value = Boolean.valueOf(true);
833        }
834        ASTNode$State state = state();
835        if (!state.IN_CIRCLE) {
836          state.IN_CIRCLE = true;
837          int num = state.boundariesCrossed;
838          boolean isFinal = this.is$Final();
839          boolean new_sameStructure_TypeDecl_value;
840          do {
841            _value.visited = new Integer(state.CIRCLE_INDEX);
842            state.CHANGE = false;
843            new_sameStructure_TypeDecl_value = sameStructure_compute(t);
844            if (new_sameStructure_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
845              state.CHANGE = true;
846              _value.value = Boolean.valueOf(new_sameStructure_TypeDecl_value);
847            }
848            state.CIRCLE_INDEX++;
849          } while (state.CHANGE);
850            if(isFinal && num == state().boundariesCrossed) {
851            sameStructure_TypeDecl_values.put(_parameters, new_sameStructure_TypeDecl_value);
852          }
853          else {
854            sameStructure_TypeDecl_values.remove(_parameters);
855          state.RESET_CYCLE = true;
856          sameStructure_compute(t);
857          state.RESET_CYCLE = false;
858          }
859          state.IN_CIRCLE = false; 
860          return new_sameStructure_TypeDecl_value;
861        }
862        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
863          _value.visited = new Integer(state.CIRCLE_INDEX);
864          boolean new_sameStructure_TypeDecl_value = sameStructure_compute(t);
865          if (state.RESET_CYCLE) {
866            sameStructure_TypeDecl_values.remove(_parameters);
867          }
868          else if (new_sameStructure_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
869            state.CHANGE = true;
870            _value.value = new_sameStructure_TypeDecl_value;
871          }
872          return new_sameStructure_TypeDecl_value;
873        }
874        return ((Boolean)_value.value).booleanValue();
875      }
876      /**
877       * @apilevel internal
878       */
879      private boolean sameStructure_compute(TypeDecl t) {  return super.sameStructure(t) || 
880        t instanceof WildcardExtendsType && ((WildcardExtendsType)t).extendsType().sameStructure(extendsType());  }
881      protected java.util.Map instanceOf_TypeDecl_values;
882      /**
883       * @attribute syn
884       * @aspect GenericsSubtype
885       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:402
886       */
887      @SuppressWarnings({"unchecked", "cast"})
888      public boolean instanceOf(TypeDecl type) {
889        Object _parameters = type;
890        if(instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new java.util.HashMap(4);
891        if(instanceOf_TypeDecl_values.containsKey(_parameters)) {
892          return ((Boolean)instanceOf_TypeDecl_values.get(_parameters)).booleanValue();
893        }
894          ASTNode$State state = state();
895      int num = state.boundariesCrossed;
896      boolean isFinal = this.is$Final();
897        boolean instanceOf_TypeDecl_value = instanceOf_compute(type);
898      if(isFinal && num == state().boundariesCrossed){ instanceOf_TypeDecl_values.put(_parameters, Boolean.valueOf(instanceOf_TypeDecl_value)); }
899            return instanceOf_TypeDecl_value;
900      }
901      /**
902       * @apilevel internal
903       */
904      private boolean instanceOf_compute(TypeDecl type) {  return subtype(type);  }
905      /**
906       * @apilevel internal
907       */
908      protected boolean fieldTypeSignature_computed = false;
909      /**
910       * @apilevel internal
911       */
912      protected String fieldTypeSignature_value;
913      /**
914       * @attribute syn
915       * @aspect GenericsCodegen
916       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:447
917       */
918      @SuppressWarnings({"unchecked", "cast"})
919      public String fieldTypeSignature() {
920        if(fieldTypeSignature_computed) {
921          return fieldTypeSignature_value;
922        }
923          ASTNode$State state = state();
924      int num = state.boundariesCrossed;
925      boolean isFinal = this.is$Final();
926        fieldTypeSignature_value = fieldTypeSignature_compute();
927      if(isFinal && num == state().boundariesCrossed){ fieldTypeSignature_computed = true; }
928            return fieldTypeSignature_value;
929      }
930      /**
931       * @apilevel internal
932       */
933      private String fieldTypeSignature_compute() {  return "+" + extendsType().fieldTypeSignature();  }
934      /**
935       * @apilevel internal
936       */
937      public ASTNode rewriteTo() {
938        return super.rewriteTo();
939      }
940    }