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 UnknownType : {@link ClassDecl};
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:50
017     */
018    public class UnknownType extends ClassDecl 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 UnknownType clone() throws CloneNotSupportedException {
034        UnknownType node = (UnknownType)super.clone();
035        node.instanceOf_TypeDecl_values = null;
036        node.typeDescriptor_computed = false;
037        node.typeDescriptor_value = null;
038        node.subtype_TypeDecl_values = null;
039        node.in$Circle(false);
040        node.is$Final(false);
041        return node;
042      }
043    /**
044     * @apilevel internal
045     */
046      @SuppressWarnings({"unchecked", "cast"})
047    public UnknownType copy() {
048      
049      try {
050        UnknownType node = (UnknownType) clone();
051        node.parent = null;
052        if(children != null)
053          node.children = (ASTNode[]) children.clone();
054        
055        return node;
056      } catch (CloneNotSupportedException e) {
057        throw new Error("Error: clone not supported for " + getClass().getName());
058      }
059      
060    }/**
061     * Create a deep copy of the AST subtree at this node.
062     * The copy is dangling, i.e. has no parent.
063     * @return dangling copy of the subtree at this node
064     * @apilevel low-level
065     */
066      @SuppressWarnings({"unchecked", "cast"})
067    public UnknownType fullCopy() {
068      
069      UnknownType tree = (UnknownType) copy();
070      if (children != null) {
071        for (int i = 0; i < children.length; ++i) {
072          
073          ASTNode child = (ASTNode) children[i];
074          if(child != null) {
075            child = child.fullCopy();
076            tree.setChild(child, i);
077          }
078        }
079      }
080      return tree;
081      
082    }  /**
083       * @ast method 
084       * 
085       */
086      public UnknownType() {
087        super();
088    
089    
090      }
091      /**
092       * Initializes the child array to the correct size.
093       * Initializes List and Opt nta children.
094       * @apilevel internal
095       * @ast method
096       * @ast method 
097       * 
098       */
099      public void init$Children() {
100        children = new ASTNode[4];
101        setChild(new Opt(), 1);
102        setChild(new List(), 2);
103        setChild(new List(), 3);
104      }
105      /**
106       * @ast method 
107       * 
108       */
109      public UnknownType(Modifiers p0, String p1, Opt<Access> p2, List<Access> p3, List<BodyDecl> p4) {
110        setChild(p0, 0);
111        setID(p1);
112        setChild(p2, 1);
113        setChild(p3, 2);
114        setChild(p4, 3);
115      }
116      /**
117       * @ast method 
118       * 
119       */
120      public UnknownType(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<Access> p3, List<BodyDecl> p4) {
121        setChild(p0, 0);
122        setID(p1);
123        setChild(p2, 1);
124        setChild(p3, 2);
125        setChild(p4, 3);
126      }
127      /**
128       * @apilevel low-level
129       * @ast method 
130       * 
131       */
132      protected int numChildren() {
133        return 4;
134      }
135      /**
136       * @apilevel internal
137       * @ast method 
138       * 
139       */
140      public boolean mayHaveRewrite() {
141        return false;
142      }
143      /**
144       * Replaces the Modifiers child.
145       * @param node The new node to replace the Modifiers child.
146       * @apilevel high-level
147       * @ast method 
148       * 
149       */
150      public void setModifiers(Modifiers node) {
151        setChild(node, 0);
152      }
153      /**
154       * Retrieves the Modifiers child.
155       * @return The current node used as the Modifiers child.
156       * @apilevel high-level
157       * @ast method 
158       * 
159       */
160      public Modifiers getModifiers() {
161        return (Modifiers)getChild(0);
162      }
163      /**
164       * Retrieves the Modifiers child.
165       * <p><em>This method does not invoke AST transformations.</em></p>
166       * @return The current node used as the Modifiers child.
167       * @apilevel low-level
168       * @ast method 
169       * 
170       */
171      public Modifiers getModifiersNoTransform() {
172        return (Modifiers)getChildNoTransform(0);
173      }
174      /**
175       * Replaces the lexeme ID.
176       * @param value The new value for the lexeme ID.
177       * @apilevel high-level
178       * @ast method 
179       * 
180       */
181      public void setID(String value) {
182        tokenString_ID = value;
183      }
184      /**
185       * JastAdd-internal setter for lexeme ID using the Beaver parser.
186       * @apilevel internal
187       * @ast method 
188       * 
189       */
190      public void setID(beaver.Symbol symbol) {
191        if(symbol.value != null && !(symbol.value instanceof String))
192          throw new UnsupportedOperationException("setID is only valid for String lexemes");
193        tokenString_ID = (String)symbol.value;
194        IDstart = symbol.getStart();
195        IDend = symbol.getEnd();
196      }
197      /**
198       * Retrieves the value for the lexeme ID.
199       * @return The value for the lexeme ID.
200       * @apilevel high-level
201       * @ast method 
202       * 
203       */
204      public String getID() {
205        return tokenString_ID != null ? tokenString_ID : "";
206      }
207      /**
208       * Replaces the optional node for the SuperClassAccess child. This is the {@code Opt} node containing the child SuperClassAccess, not the actual child!
209       * @param opt The new node to be used as the optional node for the SuperClassAccess child.
210       * @apilevel low-level
211       * @ast method 
212       * 
213       */
214      public void setSuperClassAccessOpt(Opt<Access> opt) {
215        setChild(opt, 1);
216      }
217      /**
218       * Check whether the optional SuperClassAccess child exists.
219       * @return {@code true} if the optional SuperClassAccess child exists, {@code false} if it does not.
220       * @apilevel high-level
221       * @ast method 
222       * 
223       */
224      public boolean hasSuperClassAccess() {
225        return getSuperClassAccessOpt().getNumChild() != 0;
226      }
227      /**
228       * Retrieves the (optional) SuperClassAccess child.
229       * @return The SuperClassAccess child, if it exists. Returns {@code null} otherwise.
230       * @apilevel low-level
231       * @ast method 
232       * 
233       */
234      @SuppressWarnings({"unchecked", "cast"})
235      public Access getSuperClassAccess() {
236        return (Access)getSuperClassAccessOpt().getChild(0);
237      }
238      /**
239       * Replaces the (optional) SuperClassAccess child.
240       * @param node The new node to be used as the SuperClassAccess child.
241       * @apilevel high-level
242       * @ast method 
243       * 
244       */
245      public void setSuperClassAccess(Access node) {
246        getSuperClassAccessOpt().setChild(node, 0);
247      }
248      /**
249       * @apilevel low-level
250       * @ast method 
251       * 
252       */
253      @SuppressWarnings({"unchecked", "cast"})
254      public Opt<Access> getSuperClassAccessOpt() {
255        return (Opt<Access>)getChild(1);
256      }
257      /**
258       * Retrieves the optional node for child SuperClassAccess. This is the {@code Opt} node containing the child SuperClassAccess, not the actual child!
259       * <p><em>This method does not invoke AST transformations.</em></p>
260       * @return The optional node for child SuperClassAccess.
261       * @apilevel low-level
262       * @ast method 
263       * 
264       */
265      @SuppressWarnings({"unchecked", "cast"})
266      public Opt<Access> getSuperClassAccessOptNoTransform() {
267        return (Opt<Access>)getChildNoTransform(1);
268      }
269      /**
270       * Replaces the Implements list.
271       * @param list The new list node to be used as the Implements list.
272       * @apilevel high-level
273       * @ast method 
274       * 
275       */
276      public void setImplementsList(List<Access> list) {
277        setChild(list, 2);
278      }
279      /**
280       * Retrieves the number of children in the Implements list.
281       * @return Number of children in the Implements list.
282       * @apilevel high-level
283       * @ast method 
284       * 
285       */
286      public int getNumImplements() {
287        return getImplementsList().getNumChild();
288      }
289      /**
290       * Retrieves the number of children in the Implements list.
291       * Calling this method will not trigger rewrites..
292       * @return Number of children in the Implements list.
293       * @apilevel low-level
294       * @ast method 
295       * 
296       */
297      public int getNumImplementsNoTransform() {
298        return getImplementsListNoTransform().getNumChildNoTransform();
299      }
300      /**
301       * Retrieves the element at index {@code i} in the Implements list..
302       * @param i Index of the element to return.
303       * @return The element at position {@code i} in the Implements list.
304       * @apilevel high-level
305       * @ast method 
306       * 
307       */
308      @SuppressWarnings({"unchecked", "cast"})
309      public Access getImplements(int i) {
310        return (Access)getImplementsList().getChild(i);
311      }
312      /**
313       * Append an element to the Implements list.
314       * @param node The element to append to the Implements list.
315       * @apilevel high-level
316       * @ast method 
317       * 
318       */
319      public void addImplements(Access node) {
320        List<Access> list = (parent == null || state == null) ? getImplementsListNoTransform() : getImplementsList();
321        list.addChild(node);
322      }
323      /**
324       * @apilevel low-level
325       * @ast method 
326       * 
327       */
328      public void addImplementsNoTransform(Access node) {
329        List<Access> list = getImplementsListNoTransform();
330        list.addChild(node);
331      }
332      /**
333       * Replaces the Implements list element at index {@code i} with the new node {@code node}.
334       * @param node The new node to replace the old list element.
335       * @param i The list index of the node to be replaced.
336       * @apilevel high-level
337       * @ast method 
338       * 
339       */
340      public void setImplements(Access node, int i) {
341        List<Access> list = getImplementsList();
342        list.setChild(node, i);
343      }
344      /**
345       * Retrieves the Implements list.
346       * @return The node representing the Implements list.
347       * @apilevel high-level
348       * @ast method 
349       * 
350       */
351      public List<Access> getImplementss() {
352        return getImplementsList();
353      }
354      /**
355       * Retrieves the Implements list.
356       * <p><em>This method does not invoke AST transformations.</em></p>
357       * @return The node representing the Implements list.
358       * @apilevel low-level
359       * @ast method 
360       * 
361       */
362      public List<Access> getImplementssNoTransform() {
363        return getImplementsListNoTransform();
364      }
365      /**
366       * Retrieves the Implements list.
367       * @return The node representing the Implements list.
368       * @apilevel high-level
369       * @ast method 
370       * 
371       */
372      @SuppressWarnings({"unchecked", "cast"})
373      public List<Access> getImplementsList() {
374        List<Access> list = (List<Access>)getChild(2);
375        list.getNumChild();
376        return list;
377      }
378      /**
379       * Retrieves the Implements list.
380       * <p><em>This method does not invoke AST transformations.</em></p>
381       * @return The node representing the Implements list.
382       * @apilevel low-level
383       * @ast method 
384       * 
385       */
386      @SuppressWarnings({"unchecked", "cast"})
387      public List<Access> getImplementsListNoTransform() {
388        return (List<Access>)getChildNoTransform(2);
389      }
390      /**
391       * Replaces the BodyDecl list.
392       * @param list The new list node to be used as the BodyDecl list.
393       * @apilevel high-level
394       * @ast method 
395       * 
396       */
397      public void setBodyDeclList(List<BodyDecl> list) {
398        setChild(list, 3);
399      }
400      /**
401       * Retrieves the number of children in the BodyDecl list.
402       * @return Number of children in the BodyDecl list.
403       * @apilevel high-level
404       * @ast method 
405       * 
406       */
407      public int getNumBodyDecl() {
408        return getBodyDeclList().getNumChild();
409      }
410      /**
411       * Retrieves the number of children in the BodyDecl list.
412       * Calling this method will not trigger rewrites..
413       * @return Number of children in the BodyDecl list.
414       * @apilevel low-level
415       * @ast method 
416       * 
417       */
418      public int getNumBodyDeclNoTransform() {
419        return getBodyDeclListNoTransform().getNumChildNoTransform();
420      }
421      /**
422       * Retrieves the element at index {@code i} in the BodyDecl list..
423       * @param i Index of the element to return.
424       * @return The element at position {@code i} in the BodyDecl list.
425       * @apilevel high-level
426       * @ast method 
427       * 
428       */
429      @SuppressWarnings({"unchecked", "cast"})
430      public BodyDecl getBodyDecl(int i) {
431        return (BodyDecl)getBodyDeclList().getChild(i);
432      }
433      /**
434       * Append an element to the BodyDecl list.
435       * @param node The element to append to the BodyDecl list.
436       * @apilevel high-level
437       * @ast method 
438       * 
439       */
440      public void addBodyDecl(BodyDecl node) {
441        List<BodyDecl> list = (parent == null || state == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
442        list.addChild(node);
443      }
444      /**
445       * @apilevel low-level
446       * @ast method 
447       * 
448       */
449      public void addBodyDeclNoTransform(BodyDecl node) {
450        List<BodyDecl> list = getBodyDeclListNoTransform();
451        list.addChild(node);
452      }
453      /**
454       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
455       * @param node The new node to replace the old list element.
456       * @param i The list index of the node to be replaced.
457       * @apilevel high-level
458       * @ast method 
459       * 
460       */
461      public void setBodyDecl(BodyDecl node, int i) {
462        List<BodyDecl> list = getBodyDeclList();
463        list.setChild(node, i);
464      }
465      /**
466       * Retrieves the BodyDecl list.
467       * @return The node representing the BodyDecl list.
468       * @apilevel high-level
469       * @ast method 
470       * 
471       */
472      public List<BodyDecl> getBodyDecls() {
473        return getBodyDeclList();
474      }
475      /**
476       * Retrieves the BodyDecl list.
477       * <p><em>This method does not invoke AST transformations.</em></p>
478       * @return The node representing the BodyDecl list.
479       * @apilevel low-level
480       * @ast method 
481       * 
482       */
483      public List<BodyDecl> getBodyDeclsNoTransform() {
484        return getBodyDeclListNoTransform();
485      }
486      /**
487       * Retrieves the BodyDecl list.
488       * @return The node representing the BodyDecl list.
489       * @apilevel high-level
490       * @ast method 
491       * 
492       */
493      @SuppressWarnings({"unchecked", "cast"})
494      public List<BodyDecl> getBodyDeclList() {
495        List<BodyDecl> list = (List<BodyDecl>)getChild(3);
496        list.getNumChild();
497        return list;
498      }
499      /**
500       * Retrieves the BodyDecl list.
501       * <p><em>This method does not invoke AST transformations.</em></p>
502       * @return The node representing the BodyDecl list.
503       * @apilevel low-level
504       * @ast method 
505       * 
506       */
507      @SuppressWarnings({"unchecked", "cast"})
508      public List<BodyDecl> getBodyDeclListNoTransform() {
509        return (List<BodyDecl>)getChildNoTransform(3);
510      }
511      /**
512       * @attribute syn
513       * @aspect TypeAnalysis
514       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:165
515       */
516      public boolean isReferenceType() {
517        ASTNode$State state = state();
518        try {  return true;  }
519        finally {
520        }
521      }
522      /**
523       * @attribute syn
524       * @aspect TypeAnalysis
525       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:168
526       */
527      public boolean isPrimitiveType() {
528        ASTNode$State state = state();
529        try {  return true;  }
530        finally {
531        }
532      }
533      /**
534       * @attribute syn
535       * @aspect TypeAnalysis
536       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:173
537       */
538      public boolean isNumericType() {
539        ASTNode$State state = state();
540        try {  return true;  }
541        finally {
542        }
543      }
544      /**
545       * @attribute syn
546       * @aspect TypeAnalysis
547       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:177
548       */
549      public boolean isIntegralType() {
550        ASTNode$State state = state();
551        try {  return true;  }
552        finally {
553        }
554      }
555      /**
556       * @attribute syn
557       * @aspect TypeAnalysis
558       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:181
559       */
560      public boolean isBoolean() {
561        ASTNode$State state = state();
562        try {  return true;  }
563        finally {
564        }
565      }
566      /**
567       * @attribute syn
568       * @aspect TypeAnalysis
569       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:191
570       */
571      public boolean isInt() {
572        ASTNode$State state = state();
573        try {  return true;  }
574        finally {
575        }
576      }
577      /**
578       * @attribute syn
579       * @aspect TypeAnalysis
580       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:230
581       */
582      public boolean isUnknown() {
583        ASTNode$State state = state();
584        try {  return true;  }
585        finally {
586        }
587      }
588      protected java.util.Map instanceOf_TypeDecl_values;
589      /**
590       * @attribute syn
591       * @aspect GenericsSubtype
592       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:393
593       */
594      @SuppressWarnings({"unchecked", "cast"})
595      public boolean instanceOf(TypeDecl type) {
596        Object _parameters = type;
597        if(instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new java.util.HashMap(4);
598        if(instanceOf_TypeDecl_values.containsKey(_parameters)) {
599          return ((Boolean)instanceOf_TypeDecl_values.get(_parameters)).booleanValue();
600        }
601          ASTNode$State state = state();
602      int num = state.boundariesCrossed;
603      boolean isFinal = this.is$Final();
604        boolean instanceOf_TypeDecl_value = instanceOf_compute(type);
605      if(isFinal && num == state().boundariesCrossed){ instanceOf_TypeDecl_values.put(_parameters, Boolean.valueOf(instanceOf_TypeDecl_value)); }
606            return instanceOf_TypeDecl_value;
607      }
608      /**
609       * @apilevel internal
610       */
611      private boolean instanceOf_compute(TypeDecl type) { return subtype(type); }
612      /**
613       * @attribute syn
614       * @aspect TypeWideningAndIdentity
615       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:423
616       */
617      public boolean isSupertypeOfClassDecl(ClassDecl type) {
618        ASTNode$State state = state();
619        try {  return true;  }
620        finally {
621        }
622      }
623      /**
624       * @attribute syn
625       * @aspect TypeWideningAndIdentity
626       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:440
627       */
628      public boolean isSupertypeOfInterfaceDecl(InterfaceDecl type) {
629        ASTNode$State state = state();
630        try {  return true;  }
631        finally {
632        }
633      }
634      /**
635       * @attribute syn
636       * @aspect TypeWideningAndIdentity
637       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:453
638       */
639      public boolean isSupertypeOfArrayDecl(ArrayDecl type) {
640        ASTNode$State state = state();
641        try {  return true;  }
642        finally {
643        }
644      }
645      /**
646       * @attribute syn
647       * @aspect TypeWideningAndIdentity
648       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:475
649       */
650      public boolean isSupertypeOfPrimitiveType(PrimitiveType type) {
651        ASTNode$State state = state();
652        try {  return true;  }
653        finally {
654        }
655      }
656      /**
657       * @attribute syn
658       * @aspect TypeWideningAndIdentity
659       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:482
660       */
661      public boolean isSupertypeOfNullType(NullType type) {
662        ASTNode$State state = state();
663        try {  return true;  }
664        finally {
665        }
666      }
667      /**
668       * @apilevel internal
669       */
670      protected boolean typeDescriptor_computed = false;
671      /**
672       * @apilevel internal
673       */
674      protected String typeDescriptor_value;
675      /**
676       * @attribute syn
677       * @aspect ConstantPoolNames
678       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/ConstantPoolNames.jrag:32
679       */
680      @SuppressWarnings({"unchecked", "cast"})
681      public String typeDescriptor() {
682        if(typeDescriptor_computed) {
683          return typeDescriptor_value;
684        }
685          ASTNode$State state = state();
686      int num = state.boundariesCrossed;
687      boolean isFinal = this.is$Final();
688        typeDescriptor_value = typeDescriptor_compute();
689      if(isFinal && num == state().boundariesCrossed){ typeDescriptor_computed = true; }
690            return typeDescriptor_value;
691      }
692      /**
693       * @apilevel internal
694       */
695      private String typeDescriptor_compute() { throw new Error("Trying to make a typeDescriptor() of Unknown"); }
696      /**
697       * @attribute syn
698       * @aspect NumericPromotion
699       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:146
700       */
701      public TypeDecl unaryNumericPromotion() {
702        ASTNode$State state = state();
703        try {  return this;  }
704        finally {
705        }
706      }
707      /**
708       * @attribute syn
709       * @aspect NumericPromotion
710       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:154
711       */
712      public TypeDecl binaryNumericPromotion(TypeDecl type) {
713        ASTNode$State state = state();
714        try {  return this;  }
715        finally {
716        }
717      }
718      protected java.util.Map subtype_TypeDecl_values;
719      /**
720       * @attribute syn
721       * @aspect GenericsSubtype
722       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:414
723       */
724      @SuppressWarnings({"unchecked", "cast"})
725      public boolean subtype(TypeDecl type) {
726        Object _parameters = type;
727        if(subtype_TypeDecl_values == null) subtype_TypeDecl_values = new java.util.HashMap(4);
728        ASTNode$State.CircularValue _value;
729        if(subtype_TypeDecl_values.containsKey(_parameters)) {
730          Object _o = subtype_TypeDecl_values.get(_parameters);
731          if(!(_o instanceof ASTNode$State.CircularValue)) {
732            return ((Boolean)_o).booleanValue();
733          }
734          else
735            _value = (ASTNode$State.CircularValue)_o;
736        }
737        else {
738          _value = new ASTNode$State.CircularValue();
739          subtype_TypeDecl_values.put(_parameters, _value);
740          _value.value = Boolean.valueOf(true);
741        }
742        ASTNode$State state = state();
743        if (!state.IN_CIRCLE) {
744          state.IN_CIRCLE = true;
745          int num = state.boundariesCrossed;
746          boolean isFinal = this.is$Final();
747          boolean new_subtype_TypeDecl_value;
748          do {
749            _value.visited = new Integer(state.CIRCLE_INDEX);
750            state.CHANGE = false;
751            new_subtype_TypeDecl_value = subtype_compute(type);
752            if (new_subtype_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
753              state.CHANGE = true;
754              _value.value = Boolean.valueOf(new_subtype_TypeDecl_value);
755            }
756            state.CIRCLE_INDEX++;
757          } while (state.CHANGE);
758            if(isFinal && num == state().boundariesCrossed) {
759            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
760          }
761          else {
762            subtype_TypeDecl_values.remove(_parameters);
763          state.RESET_CYCLE = true;
764          subtype_compute(type);
765          state.RESET_CYCLE = false;
766          }
767          state.IN_CIRCLE = false; 
768          return new_subtype_TypeDecl_value;
769        }
770        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
771          _value.visited = new Integer(state.CIRCLE_INDEX);
772          boolean new_subtype_TypeDecl_value = subtype_compute(type);
773          if (state.RESET_CYCLE) {
774            subtype_TypeDecl_values.remove(_parameters);
775          }
776          else if (new_subtype_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
777            state.CHANGE = true;
778            _value.value = new_subtype_TypeDecl_value;
779          }
780          return new_subtype_TypeDecl_value;
781        }
782        return ((Boolean)_value.value).booleanValue();
783      }
784      /**
785       * @apilevel internal
786       */
787      private boolean subtype_compute(TypeDecl type) {  return true;  }
788      /**
789       * @attribute syn
790       * @aspect GenericsSubtype
791       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:421
792       */
793      public boolean supertypeClassDecl(ClassDecl type) {
794        ASTNode$State state = state();
795        try {  return true;  }
796        finally {
797        }
798      }
799      /**
800       * @attribute syn
801       * @aspect GenericsSubtype
802       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:437
803       */
804      public boolean supertypeInterfaceDecl(InterfaceDecl type) {
805        ASTNode$State state = state();
806        try {  return true;  }
807        finally {
808        }
809      }
810      /**
811       * @attribute syn
812       * @aspect GenericsSubtype
813       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:450
814       */
815      public boolean supertypeArrayDecl(ArrayDecl type) {
816        ASTNode$State state = state();
817        try {  return true;  }
818        finally {
819        }
820      }
821      /**
822       * @attribute syn
823       * @aspect GenericsSubtype
824       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:472
825       */
826      public boolean supertypePrimitiveType(PrimitiveType type) {
827        ASTNode$State state = state();
828        try {  return true;  }
829        finally {
830        }
831      }
832      /**
833       * @attribute syn
834       * @aspect GenericsSubtype
835       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:479
836       */
837      public boolean supertypeNullType(NullType type) {
838        ASTNode$State state = state();
839        try {  return true;  }
840        finally {
841        }
842      }
843      /**
844       * @apilevel internal
845       */
846      public ASTNode rewriteTo() {
847        return super.rewriteTo();
848      }
849    }