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