001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java5/grammar/Generics.ast:27
027     * @production WildcardExtendsType : {@link AbstractWildcardType} ::= <span class="component">{@link Access}</span>;
028    
029     */
030    public class WildcardExtendsType extends AbstractWildcardType implements Cloneable {
031      /**
032       * @aspect LookupParTypeDecl
033       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1070
034       */
035      public Access substitute(Parameterization parTypeDecl) {
036        if (!usesTypeVariable()) {
037          return super.substitute(parTypeDecl);
038        }
039        return new WildcardExtends(getAccess().type().substitute(parTypeDecl));
040      }
041      /**
042       * @declaredat ASTNode:1
043       */
044      public WildcardExtendsType() {
045        super();
046      }
047      /**
048       * Initializes the child array to the correct size.
049       * Initializes List and Opt nta children.
050       * @apilevel internal
051       * @ast method
052       * @declaredat ASTNode:10
053       */
054      public void init$Children() {
055        children = new ASTNode[3];
056        setChild(new List(), 1);
057      }
058      /**
059       * @declaredat ASTNode:14
060       */
061      public WildcardExtendsType(Modifiers p0, String p1, List<BodyDecl> p2, Access p3) {
062        setChild(p0, 0);
063        setID(p1);
064        setChild(p2, 1);
065        setChild(p3, 2);
066      }
067      /**
068       * @declaredat ASTNode:20
069       */
070      public WildcardExtendsType(Modifiers p0, beaver.Symbol p1, List<BodyDecl> p2, Access p3) {
071        setChild(p0, 0);
072        setID(p1);
073        setChild(p2, 1);
074        setChild(p3, 2);
075      }
076      /**
077       * @apilevel low-level
078       * @declaredat ASTNode:29
079       */
080      protected int numChildren() {
081        return 3;
082      }
083      /**
084       * @apilevel internal
085       * @declaredat ASTNode:35
086       */
087      public boolean mayHaveRewrite() {
088        return false;
089      }
090      /**
091       * @apilevel internal
092       * @declaredat ASTNode:41
093       */
094      public void flushAttrCache() {
095        super.flushAttrCache();
096        involvesTypeParameters_reset();
097        usesTypeVariable_reset();
098        subtype_TypeDecl_reset();
099        containedIn_TypeDecl_reset();
100        sameStructure_TypeDecl_reset();
101        instanceOf_TypeDecl_reset();
102        fieldTypeSignature_reset();
103        strictSubtype_TypeDecl_reset();
104        strictContainedIn_TypeDecl_reset();
105      }
106      /**
107       * @apilevel internal
108       * @declaredat ASTNode:56
109       */
110      public void flushCollectionCache() {
111        super.flushCollectionCache();
112      }
113      /**
114       * @apilevel internal
115       * @declaredat ASTNode:62
116       */
117      public void flushRewriteCache() {
118        super.flushRewriteCache();
119      }
120      /**
121       * @apilevel internal
122       * @declaredat ASTNode:68
123       */
124      public WildcardExtendsType clone() throws CloneNotSupportedException {
125        WildcardExtendsType node = (WildcardExtendsType) super.clone();
126        return node;
127      }
128      /**
129       * @apilevel internal
130       * @declaredat ASTNode:75
131       */
132      public WildcardExtendsType copy() {
133        try {
134          WildcardExtendsType node = (WildcardExtendsType) clone();
135          node.parent = null;
136          if (children != null) {
137            node.children = (ASTNode[]) children.clone();
138          }
139          return node;
140        } catch (CloneNotSupportedException e) {
141          throw new Error("Error: clone not supported for " + getClass().getName());
142        }
143      }
144      /**
145       * Create a deep copy of the AST subtree at this node.
146       * The copy is dangling, i.e. has no parent.
147       * @return dangling copy of the subtree at this node
148       * @apilevel low-level
149       * @deprecated Please use treeCopy or treeCopyNoTransform instead
150       * @declaredat ASTNode:94
151       */
152      @Deprecated
153      public WildcardExtendsType fullCopy() {
154        return treeCopyNoTransform();
155      }
156      /**
157       * Create a deep copy of the AST subtree at this node.
158       * The copy is dangling, i.e. has no parent.
159       * @return dangling copy of the subtree at this node
160       * @apilevel low-level
161       * @declaredat ASTNode:104
162       */
163      public WildcardExtendsType treeCopyNoTransform() {
164        WildcardExtendsType tree = (WildcardExtendsType) copy();
165        if (children != null) {
166          for (int i = 0; i < children.length; ++i) {
167            ASTNode child = (ASTNode) children[i];
168            if (child != null) {
169              child = child.treeCopyNoTransform();
170              tree.setChild(child, i);
171            }
172          }
173        }
174        return tree;
175      }
176      /**
177       * Create a deep copy of the AST subtree at this node.
178       * The subtree of this node is traversed to trigger rewrites before copy.
179       * The copy is dangling, i.e. has no parent.
180       * @return dangling copy of the subtree at this node
181       * @apilevel low-level
182       * @declaredat ASTNode:124
183       */
184      public WildcardExtendsType treeCopy() {
185        doFullTraversal();
186        return treeCopyNoTransform();
187      }
188      /**
189       * @apilevel internal
190       * @declaredat ASTNode:131
191       */
192      protected boolean is$Equal(ASTNode node) {
193        return super.is$Equal(node) && (tokenString_ID == ((WildcardExtendsType)node).tokenString_ID);    
194      }
195      /**
196       * Replaces the Modifiers child.
197       * @param node The new node to replace the Modifiers child.
198       * @apilevel high-level
199       */
200      public void setModifiers(Modifiers node) {
201        setChild(node, 0);
202      }
203      /**
204       * Retrieves the Modifiers child.
205       * @return The current node used as the Modifiers child.
206       * @apilevel high-level
207       */
208      @ASTNodeAnnotation.Child(name="Modifiers")
209      public Modifiers getModifiers() {
210        return (Modifiers) getChild(0);
211      }
212      /**
213       * Retrieves the Modifiers child.
214       * <p><em>This method does not invoke AST transformations.</em></p>
215       * @return The current node used as the Modifiers child.
216       * @apilevel low-level
217       */
218      public Modifiers getModifiersNoTransform() {
219        return (Modifiers) getChildNoTransform(0);
220      }
221      /**
222       * Replaces the lexeme ID.
223       * @param value The new value for the lexeme ID.
224       * @apilevel high-level
225       */
226      public void setID(String value) {
227        tokenString_ID = value;
228      }
229      /**
230       * JastAdd-internal setter for lexeme ID using the Beaver parser.
231       * @param symbol Symbol containing the new value for the lexeme ID
232       * @apilevel internal
233       */
234      public void setID(beaver.Symbol symbol) {
235        if (symbol.value != null && !(symbol.value instanceof String))
236        throw new UnsupportedOperationException("setID is only valid for String lexemes");
237        tokenString_ID = (String)symbol.value;
238        IDstart = symbol.getStart();
239        IDend = symbol.getEnd();
240      }
241      /**
242       * Retrieves the value for the lexeme ID.
243       * @return The value for the lexeme ID.
244       * @apilevel high-level
245       */
246      @ASTNodeAnnotation.Token(name="ID")
247      public String getID() {
248        return tokenString_ID != null ? tokenString_ID : "";
249      }
250      /**
251       * Replaces the BodyDecl list.
252       * @param list The new list node to be used as the BodyDecl list.
253       * @apilevel high-level
254       */
255      public void setBodyDeclList(List<BodyDecl> list) {
256        setChild(list, 1);
257      }
258      /**
259       * Retrieves the number of children in the BodyDecl list.
260       * @return Number of children in the BodyDecl list.
261       * @apilevel high-level
262       */
263      public int getNumBodyDecl() {
264        return getBodyDeclList().getNumChild();
265      }
266      /**
267       * Retrieves the number of children in the BodyDecl list.
268       * Calling this method will not trigger rewrites.
269       * @return Number of children in the BodyDecl list.
270       * @apilevel low-level
271       */
272      public int getNumBodyDeclNoTransform() {
273        return getBodyDeclListNoTransform().getNumChildNoTransform();
274      }
275      /**
276       * Retrieves the element at index {@code i} in the BodyDecl list.
277       * @param i Index of the element to return.
278       * @return The element at position {@code i} in the BodyDecl list.
279       * @apilevel high-level
280       */
281      public BodyDecl getBodyDecl(int i) {
282        return (BodyDecl) getBodyDeclList().getChild(i);
283      }
284      /**
285       * Check whether the BodyDecl list has any children.
286       * @return {@code true} if it has at least one child, {@code false} otherwise.
287       * @apilevel high-level
288       */
289      public boolean hasBodyDecl() {
290        return getBodyDeclList().getNumChild() != 0;
291      }
292      /**
293       * Append an element to the BodyDecl list.
294       * @param node The element to append to the BodyDecl list.
295       * @apilevel high-level
296       */
297      public void addBodyDecl(BodyDecl node) {
298        List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
299        list.addChild(node);
300      }
301      /**
302       * @apilevel low-level
303       */
304      public void addBodyDeclNoTransform(BodyDecl node) {
305        List<BodyDecl> list = getBodyDeclListNoTransform();
306        list.addChild(node);
307      }
308      /**
309       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
310       * @param node The new node to replace the old list element.
311       * @param i The list index of the node to be replaced.
312       * @apilevel high-level
313       */
314      public void setBodyDecl(BodyDecl node, int i) {
315        List<BodyDecl> list = getBodyDeclList();
316        list.setChild(node, i);
317      }
318      /**
319       * Retrieves the BodyDecl list.
320       * @return The node representing the BodyDecl list.
321       * @apilevel high-level
322       */
323      @ASTNodeAnnotation.ListChild(name="BodyDecl")
324      public List<BodyDecl> getBodyDeclList() {
325        List<BodyDecl> list = (List<BodyDecl>) getChild(1);
326        return list;
327      }
328      /**
329       * Retrieves the BodyDecl list.
330       * <p><em>This method does not invoke AST transformations.</em></p>
331       * @return The node representing the BodyDecl list.
332       * @apilevel low-level
333       */
334      public List<BodyDecl> getBodyDeclListNoTransform() {
335        return (List<BodyDecl>) getChildNoTransform(1);
336      }
337      /**
338       * Retrieves the BodyDecl list.
339       * @return The node representing the BodyDecl list.
340       * @apilevel high-level
341       */
342      public List<BodyDecl> getBodyDecls() {
343        return getBodyDeclList();
344      }
345      /**
346       * Retrieves the BodyDecl list.
347       * <p><em>This method does not invoke AST transformations.</em></p>
348       * @return The node representing the BodyDecl list.
349       * @apilevel low-level
350       */
351      public List<BodyDecl> getBodyDeclsNoTransform() {
352        return getBodyDeclListNoTransform();
353      }
354      /**
355       * Replaces the Access child.
356       * @param node The new node to replace the Access child.
357       * @apilevel high-level
358       */
359      public void setAccess(Access node) {
360        setChild(node, 2);
361      }
362      /**
363       * Retrieves the Access child.
364       * @return The current node used as the Access child.
365       * @apilevel high-level
366       */
367      @ASTNodeAnnotation.Child(name="Access")
368      public Access getAccess() {
369        return (Access) getChild(2);
370      }
371      /**
372       * Retrieves the Access child.
373       * <p><em>This method does not invoke AST transformations.</em></p>
374       * @return The current node used as the Access child.
375       * @apilevel low-level
376       */
377      public Access getAccessNoTransform() {
378        return (Access) getChildNoTransform(2);
379      }
380      /**
381       * @param bound the bounded type variable
382       * @param par a parameterization of the type for which the type variable
383       * occurs in the type parameter list
384       * @return {@code true} if this type is within the bounds of the parameter type
385       * @attribute syn
386       * @aspect GenericBoundCheck
387       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:42
388       */
389      @ASTNodeAnnotation.Attribute
390      public boolean withinBounds(TypeDecl bound, Parameterization par) {
391        boolean withinBounds_TypeDecl_Parameterization_value = bound.boundOf(extendsType(), par) || extendsType().boundOf(bound, par);
392    
393        return withinBounds_TypeDecl_Parameterization_value;
394      }
395      /**
396       * @apilevel internal
397       */
398      protected int involvesTypeParameters_visited = -1;
399      /**
400       * @apilevel internal
401       */
402      private void involvesTypeParameters_reset() {
403        involvesTypeParameters_computed = false;
404        involvesTypeParameters_initialized = false;
405        involvesTypeParameters_visited = -1;
406      }
407      /**
408       * @apilevel internal
409       */
410      protected boolean involvesTypeParameters_computed = false;
411      /**
412       * @apilevel internal
413       */
414      protected boolean involvesTypeParameters_initialized = false;
415      /**
416       * @apilevel internal
417       */
418      protected boolean involvesTypeParameters_value;
419      @ASTNodeAnnotation.Attribute
420      public boolean involvesTypeParameters() {
421        if (involvesTypeParameters_computed) {
422          return involvesTypeParameters_value;
423        }
424        ASTNode$State state = state();
425        boolean new_involvesTypeParameters_value;
426        if (!involvesTypeParameters_initialized) {
427          involvesTypeParameters_initialized = true;
428          involvesTypeParameters_value = false;
429        }
430        if (!state.IN_CIRCLE) {
431          state.IN_CIRCLE = true;
432          int num = state.boundariesCrossed;
433          boolean isFinal = this.is$Final();
434          do {
435            involvesTypeParameters_visited = state.CIRCLE_INDEX;
436            state.CHANGE = false;
437            new_involvesTypeParameters_value = extendsType().involvesTypeParameters();
438            if (new_involvesTypeParameters_value != involvesTypeParameters_value) {
439              state.CHANGE = true;
440            }
441            involvesTypeParameters_value = new_involvesTypeParameters_value;
442            state.CIRCLE_INDEX++;
443          } while (state.CHANGE);
444          if (isFinal && num == state().boundariesCrossed) {
445            involvesTypeParameters_computed = true;
446          } else {
447            state.RESET_CYCLE = true;
448            boolean $tmp = extendsType().involvesTypeParameters();
449            state.RESET_CYCLE = false;
450            involvesTypeParameters_computed = false;
451            involvesTypeParameters_initialized = false;
452          }
453          state.IN_CIRCLE = false;
454          state.INTERMEDIATE_VALUE = false;
455          return involvesTypeParameters_value;
456        }
457        if (involvesTypeParameters_visited != state.CIRCLE_INDEX) {
458          involvesTypeParameters_visited = state.CIRCLE_INDEX;
459          if (state.RESET_CYCLE) {
460            involvesTypeParameters_computed = false;
461            involvesTypeParameters_initialized = false;
462            involvesTypeParameters_visited = -1;
463            return involvesTypeParameters_value;
464          }
465          new_involvesTypeParameters_value = extendsType().involvesTypeParameters();
466          if (new_involvesTypeParameters_value != involvesTypeParameters_value) {
467            state.CHANGE = true;
468          }
469          involvesTypeParameters_value = new_involvesTypeParameters_value;
470          state.INTERMEDIATE_VALUE = true;
471          return involvesTypeParameters_value;
472        }
473        state.INTERMEDIATE_VALUE = true;
474        return involvesTypeParameters_value;
475      }
476      /**
477       * @attribute syn
478       * @aspect LookupParTypeDecl
479       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:806
480       */
481      @ASTNodeAnnotation.Attribute
482      public boolean sameSignature(Access a) {
483        {
484            if (a instanceof WildcardExtends) {
485              return getAccess().type().sameSignature(((WildcardExtends) a).getAccess());
486            }
487            return super.sameSignature(a);
488          }
489      }
490      /**
491       * @apilevel internal
492       */
493      protected int usesTypeVariable_visited = -1;
494      /**
495       * @apilevel internal
496       */
497      private void usesTypeVariable_reset() {
498        usesTypeVariable_computed = false;
499        usesTypeVariable_initialized = false;
500        usesTypeVariable_visited = -1;
501      }
502      /**
503       * @apilevel internal
504       */
505      protected boolean usesTypeVariable_computed = false;
506      /**
507       * @apilevel internal
508       */
509      protected boolean usesTypeVariable_initialized = false;
510      /**
511       * @apilevel internal
512       */
513      protected boolean usesTypeVariable_value;
514      @ASTNodeAnnotation.Attribute
515      public boolean usesTypeVariable() {
516        if (usesTypeVariable_computed) {
517          return usesTypeVariable_value;
518        }
519        ASTNode$State state = state();
520        boolean new_usesTypeVariable_value;
521        if (!usesTypeVariable_initialized) {
522          usesTypeVariable_initialized = true;
523          usesTypeVariable_value = false;
524        }
525        if (!state.IN_CIRCLE) {
526          state.IN_CIRCLE = true;
527          int num = state.boundariesCrossed;
528          boolean isFinal = this.is$Final();
529          do {
530            usesTypeVariable_visited = state.CIRCLE_INDEX;
531            state.CHANGE = false;
532            new_usesTypeVariable_value = getAccess().type().usesTypeVariable();
533            if (new_usesTypeVariable_value != usesTypeVariable_value) {
534              state.CHANGE = true;
535            }
536            usesTypeVariable_value = new_usesTypeVariable_value;
537            state.CIRCLE_INDEX++;
538          } while (state.CHANGE);
539          if (isFinal && num == state().boundariesCrossed) {
540            usesTypeVariable_computed = true;
541          } else {
542            state.RESET_CYCLE = true;
543            boolean $tmp = getAccess().type().usesTypeVariable();
544            state.RESET_CYCLE = false;
545            usesTypeVariable_computed = false;
546            usesTypeVariable_initialized = false;
547          }
548          state.IN_CIRCLE = false;
549          state.INTERMEDIATE_VALUE = false;
550          return usesTypeVariable_value;
551        }
552        if (usesTypeVariable_visited != state.CIRCLE_INDEX) {
553          usesTypeVariable_visited = state.CIRCLE_INDEX;
554          if (state.RESET_CYCLE) {
555            usesTypeVariable_computed = false;
556            usesTypeVariable_initialized = false;
557            usesTypeVariable_visited = -1;
558            return usesTypeVariable_value;
559          }
560          new_usesTypeVariable_value = getAccess().type().usesTypeVariable();
561          if (new_usesTypeVariable_value != usesTypeVariable_value) {
562            state.CHANGE = true;
563          }
564          usesTypeVariable_value = new_usesTypeVariable_value;
565          state.INTERMEDIATE_VALUE = true;
566          return usesTypeVariable_value;
567        }
568        state.INTERMEDIATE_VALUE = true;
569        return usesTypeVariable_value;
570      }
571      /**
572       * @attribute syn
573       * @aspect LookupParTypeDecl
574       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1472
575       */
576      @ASTNodeAnnotation.Attribute
577      public TypeDecl extendsType() {
578        TypeDecl extendsType_value = getAccess().type();
579    
580        return extendsType_value;
581      }
582      /**
583       * @attribute syn
584       * @aspect GenericsSubtype
585       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:66
586       */
587      @ASTNodeAnnotation.Attribute
588      public boolean supertypeWildcard(WildcardType type) {
589        boolean supertypeWildcard_WildcardType_value = typeObject().subtype(this);
590    
591        return supertypeWildcard_WildcardType_value;
592      }
593      /**
594       * @apilevel internal
595       */
596      private void subtype_TypeDecl_reset() {
597        subtype_TypeDecl_values = null;
598      }
599      protected java.util.Map subtype_TypeDecl_values;
600      @ASTNodeAnnotation.Attribute
601      public boolean subtype(TypeDecl type) {
602        Object _parameters = type;
603        if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
604        ASTNode$State.CircularValue _value;
605        if (subtype_TypeDecl_values.containsKey(_parameters)) {
606          Object _o = subtype_TypeDecl_values.get(_parameters);
607          if (!(_o instanceof ASTNode$State.CircularValue)) {
608            return (Boolean) _o;
609          } else {
610            _value = (ASTNode$State.CircularValue) _o;
611          }
612        } else {
613          _value = new ASTNode$State.CircularValue();
614          subtype_TypeDecl_values.put(_parameters, _value);
615          _value.value = true;
616        }
617        ASTNode$State state = state();
618        boolean new_subtype_TypeDecl_value;
619        if (!state.IN_CIRCLE) {
620          state.IN_CIRCLE = true;
621          int num = state.boundariesCrossed;
622          boolean isFinal = this.is$Final();
623          // TODO: fixme
624          // state().CIRCLE_INDEX = 1;
625          do {
626            _value.visited = state.CIRCLE_INDEX;
627            state.CHANGE = false;
628            new_subtype_TypeDecl_value = type.supertypeWildcardExtends(this);
629            if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
630              state.CHANGE = true;
631              _value.value = new_subtype_TypeDecl_value;
632            }
633            state.CIRCLE_INDEX++;
634          } while (state.CHANGE);
635          if (isFinal && num == state().boundariesCrossed) {
636            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
637          } else {
638            subtype_TypeDecl_values.remove(_parameters);
639            state.RESET_CYCLE = true;
640            boolean $tmp = type.supertypeWildcardExtends(this);
641            state.RESET_CYCLE = false;
642          }
643          state.IN_CIRCLE = false;
644          state.INTERMEDIATE_VALUE = false;
645          return new_subtype_TypeDecl_value;
646        }
647        if (state.CIRCLE_INDEX != _value.visited) {
648          _value.visited = state.CIRCLE_INDEX;
649          new_subtype_TypeDecl_value = type.supertypeWildcardExtends(this);
650          if (state.RESET_CYCLE) {
651            subtype_TypeDecl_values.remove(_parameters);
652          }
653          else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
654            state.CHANGE = true;
655            _value.value = new_subtype_TypeDecl_value;
656          }
657          state.INTERMEDIATE_VALUE = true;
658          return new_subtype_TypeDecl_value;
659        }
660        state.INTERMEDIATE_VALUE = true;
661        return (Boolean) _value.value;
662      }
663      /**
664       * @attribute syn
665       * @aspect GenericsSubtype
666       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:73
667       */
668      @ASTNodeAnnotation.Attribute
669      public boolean supertypeWildcardExtends(WildcardExtendsType type) {
670        boolean supertypeWildcardExtends_WildcardExtendsType_value = type.extendsType().subtype(extendsType());
671    
672        return supertypeWildcardExtends_WildcardExtendsType_value;
673      }
674      /**
675       * @attribute syn
676       * @aspect GenericsSubtype
677       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:448
678       */
679      @ASTNodeAnnotation.Attribute
680      public boolean supertypeClassDecl(ClassDecl type) {
681        boolean supertypeClassDecl_ClassDecl_value = type.subtype(extendsType());
682    
683        return supertypeClassDecl_ClassDecl_value;
684      }
685      /**
686       * @attribute syn
687       * @aspect GenericsSubtype
688       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:465
689       */
690      @ASTNodeAnnotation.Attribute
691      public boolean supertypeInterfaceDecl(InterfaceDecl type) {
692        boolean supertypeInterfaceDecl_InterfaceDecl_value = type.subtype(extendsType());
693    
694        return supertypeInterfaceDecl_InterfaceDecl_value;
695      }
696      /**
697       * @attribute syn
698       * @aspect GenericsSubtype
699       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:134
700       */
701      @ASTNodeAnnotation.Attribute
702      public boolean supertypeParClassDecl(ParClassDecl type) {
703        boolean supertypeParClassDecl_ParClassDecl_value = type.subtype(extendsType());
704    
705        return supertypeParClassDecl_ParClassDecl_value;
706      }
707      /**
708       * @attribute syn
709       * @aspect GenericsSubtype
710       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:137
711       */
712      @ASTNodeAnnotation.Attribute
713      public boolean supertypeParInterfaceDecl(ParInterfaceDecl type) {
714        boolean supertypeParInterfaceDecl_ParInterfaceDecl_value = type.subtype(extendsType());
715    
716        return supertypeParInterfaceDecl_ParInterfaceDecl_value;
717      }
718      /**
719       * @attribute syn
720       * @aspect GenericsSubtype
721       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:46
722       */
723      @ASTNodeAnnotation.Attribute
724      public boolean supertypeRawClassDecl(RawClassDecl type) {
725        boolean supertypeRawClassDecl_RawClassDecl_value = type.subtype(extendsType());
726    
727        return supertypeRawClassDecl_RawClassDecl_value;
728      }
729      /**
730       * @attribute syn
731       * @aspect GenericsSubtype
732       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:50
733       */
734      @ASTNodeAnnotation.Attribute
735      public boolean supertypeRawInterfaceDecl(RawInterfaceDecl type) {
736        boolean supertypeRawInterfaceDecl_RawInterfaceDecl_value = type.subtype(extendsType());
737    
738        return supertypeRawInterfaceDecl_RawInterfaceDecl_value;
739      }
740      /**
741       * @attribute syn
742       * @aspect GenericsSubtype
743       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:321
744       */
745      @ASTNodeAnnotation.Attribute
746      public boolean supertypeTypeVariable(TypeVariable type) {
747        boolean supertypeTypeVariable_TypeVariable_value = type.subtype(extendsType());
748    
749        return supertypeTypeVariable_TypeVariable_value;
750      }
751      /**
752       * @attribute syn
753       * @aspect GenericsSubtype
754       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:480
755       */
756      @ASTNodeAnnotation.Attribute
757      public boolean supertypeArrayDecl(ArrayDecl type) {
758        boolean supertypeArrayDecl_ArrayDecl_value = type.subtype(extendsType());
759    
760        return supertypeArrayDecl_ArrayDecl_value;
761      }
762      /**
763       * @apilevel internal
764       */
765      private void containedIn_TypeDecl_reset() {
766        containedIn_TypeDecl_values = null;
767      }
768      protected java.util.Map containedIn_TypeDecl_values;
769      @ASTNodeAnnotation.Attribute
770      public boolean containedIn(TypeDecl type) {
771        Object _parameters = type;
772        if (containedIn_TypeDecl_values == null) containedIn_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
773        ASTNode$State.CircularValue _value;
774        if (containedIn_TypeDecl_values.containsKey(_parameters)) {
775          Object _o = containedIn_TypeDecl_values.get(_parameters);
776          if (!(_o instanceof ASTNode$State.CircularValue)) {
777            return (Boolean) _o;
778          } else {
779            _value = (ASTNode$State.CircularValue) _o;
780          }
781        } else {
782          _value = new ASTNode$State.CircularValue();
783          containedIn_TypeDecl_values.put(_parameters, _value);
784          _value.value = true;
785        }
786        ASTNode$State state = state();
787        boolean new_containedIn_TypeDecl_value;
788        if (!state.IN_CIRCLE) {
789          state.IN_CIRCLE = true;
790          int num = state.boundariesCrossed;
791          boolean isFinal = this.is$Final();
792          // TODO: fixme
793          // state().CIRCLE_INDEX = 1;
794          do {
795            _value.visited = state.CIRCLE_INDEX;
796            state.CHANGE = false;
797            new_containedIn_TypeDecl_value = containedIn_compute(type);
798            if (new_containedIn_TypeDecl_value != ((Boolean)_value.value)) {
799              state.CHANGE = true;
800              _value.value = new_containedIn_TypeDecl_value;
801            }
802            state.CIRCLE_INDEX++;
803          } while (state.CHANGE);
804          if (isFinal && num == state().boundariesCrossed) {
805            containedIn_TypeDecl_values.put(_parameters, new_containedIn_TypeDecl_value);
806          } else {
807            containedIn_TypeDecl_values.remove(_parameters);
808            state.RESET_CYCLE = true;
809            boolean $tmp = containedIn_compute(type);
810            state.RESET_CYCLE = false;
811          }
812          state.IN_CIRCLE = false;
813          state.INTERMEDIATE_VALUE = false;
814          return new_containedIn_TypeDecl_value;
815        }
816        if (state.CIRCLE_INDEX != _value.visited) {
817          _value.visited = state.CIRCLE_INDEX;
818          new_containedIn_TypeDecl_value = containedIn_compute(type);
819          if (state.RESET_CYCLE) {
820            containedIn_TypeDecl_values.remove(_parameters);
821          }
822          else if (new_containedIn_TypeDecl_value != ((Boolean)_value.value)) {
823            state.CHANGE = true;
824            _value.value = new_containedIn_TypeDecl_value;
825          }
826          state.INTERMEDIATE_VALUE = true;
827          return new_containedIn_TypeDecl_value;
828        }
829        state.INTERMEDIATE_VALUE = true;
830        return (Boolean) _value.value;
831      }
832      /**
833       * @apilevel internal
834       */
835      private boolean containedIn_compute(TypeDecl type) {
836          if (type == this || type instanceof WildcardType) {
837            return true;
838          } else if (type instanceof WildcardExtendsType) {
839            return extendsType().subtype(((WildcardExtendsType) type).extendsType());
840          } else {
841            return false;
842          }
843        }
844      /**
845       * @apilevel internal
846       */
847      private void sameStructure_TypeDecl_reset() {
848        sameStructure_TypeDecl_values = null;
849      }
850      protected java.util.Map sameStructure_TypeDecl_values;
851      @ASTNodeAnnotation.Attribute
852      public boolean sameStructure(TypeDecl t) {
853        Object _parameters = t;
854        if (sameStructure_TypeDecl_values == null) sameStructure_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
855        ASTNode$State.CircularValue _value;
856        if (sameStructure_TypeDecl_values.containsKey(_parameters)) {
857          Object _o = sameStructure_TypeDecl_values.get(_parameters);
858          if (!(_o instanceof ASTNode$State.CircularValue)) {
859            return (Boolean) _o;
860          } else {
861            _value = (ASTNode$State.CircularValue) _o;
862          }
863        } else {
864          _value = new ASTNode$State.CircularValue();
865          sameStructure_TypeDecl_values.put(_parameters, _value);
866          _value.value = true;
867        }
868        ASTNode$State state = state();
869        boolean new_sameStructure_TypeDecl_value;
870        if (!state.IN_CIRCLE) {
871          state.IN_CIRCLE = true;
872          int num = state.boundariesCrossed;
873          boolean isFinal = this.is$Final();
874          // TODO: fixme
875          // state().CIRCLE_INDEX = 1;
876          do {
877            _value.visited = state.CIRCLE_INDEX;
878            state.CHANGE = false;
879            new_sameStructure_TypeDecl_value = super.sameStructure(t) || t instanceof WildcardExtendsType
880                  && ((WildcardExtendsType) t).extendsType().sameStructure(extendsType());
881            if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) {
882              state.CHANGE = true;
883              _value.value = new_sameStructure_TypeDecl_value;
884            }
885            state.CIRCLE_INDEX++;
886          } while (state.CHANGE);
887          if (isFinal && num == state().boundariesCrossed) {
888            sameStructure_TypeDecl_values.put(_parameters, new_sameStructure_TypeDecl_value);
889          } else {
890            sameStructure_TypeDecl_values.remove(_parameters);
891            state.RESET_CYCLE = true;
892            boolean $tmp = super.sameStructure(t) || t instanceof WildcardExtendsType
893                  && ((WildcardExtendsType) t).extendsType().sameStructure(extendsType());
894            state.RESET_CYCLE = false;
895          }
896          state.IN_CIRCLE = false;
897          state.INTERMEDIATE_VALUE = false;
898          return new_sameStructure_TypeDecl_value;
899        }
900        if (state.CIRCLE_INDEX != _value.visited) {
901          _value.visited = state.CIRCLE_INDEX;
902          new_sameStructure_TypeDecl_value = super.sameStructure(t) || t instanceof WildcardExtendsType
903                && ((WildcardExtendsType) t).extendsType().sameStructure(extendsType());
904          if (state.RESET_CYCLE) {
905            sameStructure_TypeDecl_values.remove(_parameters);
906          }
907          else if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) {
908            state.CHANGE = true;
909            _value.value = new_sameStructure_TypeDecl_value;
910          }
911          state.INTERMEDIATE_VALUE = true;
912          return new_sameStructure_TypeDecl_value;
913        }
914        state.INTERMEDIATE_VALUE = true;
915        return (Boolean) _value.value;
916      }
917      /**
918       * @apilevel internal
919       */
920      protected java.util.Map instanceOf_TypeDecl_values;
921      /**
922       * @apilevel internal
923       */
924      private void instanceOf_TypeDecl_reset() {
925        instanceOf_TypeDecl_values = null;
926      }
927      /**
928       * @attribute syn
929       * @aspect TypeWideningAndIdentity
930       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442
931       */
932      @ASTNodeAnnotation.Attribute
933      public boolean instanceOf(TypeDecl type) {
934        Object _parameters = type;
935        if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
936        ASTNode$State state = state();
937        if (instanceOf_TypeDecl_values.containsKey(_parameters)) {
938          return (Boolean) instanceOf_TypeDecl_values.get(_parameters);
939        }
940        boolean intermediate = state.INTERMEDIATE_VALUE;
941        state.INTERMEDIATE_VALUE = false;
942        int num = state.boundariesCrossed;
943        boolean isFinal = this.is$Final();
944        boolean instanceOf_TypeDecl_value = subtype(type);
945        if (isFinal && num == state().boundariesCrossed) {
946          instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value);
947        } else {
948        }
949        state.INTERMEDIATE_VALUE |= intermediate;
950    
951        return instanceOf_TypeDecl_value;
952      }
953      /**
954       * @apilevel internal
955       */
956      protected boolean fieldTypeSignature_computed = false;
957      /**
958       * @apilevel internal
959       */
960      protected String fieldTypeSignature_value;
961      /**
962       * @apilevel internal
963       */
964      private void fieldTypeSignature_reset() {
965        fieldTypeSignature_computed = false;
966        fieldTypeSignature_value = null;
967      }
968      /**
969       * @attribute syn
970       * @aspect GenericsCodegen
971       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:467
972       */
973      @ASTNodeAnnotation.Attribute
974      public String fieldTypeSignature() {
975        ASTNode$State state = state();
976        if (fieldTypeSignature_computed) {
977          return fieldTypeSignature_value;
978        }
979        boolean intermediate = state.INTERMEDIATE_VALUE;
980        state.INTERMEDIATE_VALUE = false;
981        int num = state.boundariesCrossed;
982        boolean isFinal = this.is$Final();
983        fieldTypeSignature_value = "+" + extendsType().fieldTypeSignature();
984        if (isFinal && num == state().boundariesCrossed) {
985          fieldTypeSignature_computed = true;
986        } else {
987        }
988        state.INTERMEDIATE_VALUE |= intermediate;
989    
990        return fieldTypeSignature_value;
991      }
992      /**
993       * @attribute syn
994       * @aspect StrictSubtype
995       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:68
996       */
997      @ASTNodeAnnotation.Attribute
998      public boolean strictSupertypeWildcard(WildcardType type) {
999        boolean strictSupertypeWildcard_WildcardType_value = typeObject().strictSubtype(this);
1000    
1001        return strictSupertypeWildcard_WildcardType_value;
1002      }
1003      /**
1004       * @apilevel internal
1005       */
1006      private void strictSubtype_TypeDecl_reset() {
1007        strictSubtype_TypeDecl_values = null;
1008      }
1009      protected java.util.Map strictSubtype_TypeDecl_values;
1010      @ASTNodeAnnotation.Attribute
1011      public boolean strictSubtype(TypeDecl type) {
1012        Object _parameters = type;
1013        if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1014        ASTNode$State.CircularValue _value;
1015        if (strictSubtype_TypeDecl_values.containsKey(_parameters)) {
1016          Object _o = strictSubtype_TypeDecl_values.get(_parameters);
1017          if (!(_o instanceof ASTNode$State.CircularValue)) {
1018            return (Boolean) _o;
1019          } else {
1020            _value = (ASTNode$State.CircularValue) _o;
1021          }
1022        } else {
1023          _value = new ASTNode$State.CircularValue();
1024          strictSubtype_TypeDecl_values.put(_parameters, _value);
1025          _value.value = true;
1026        }
1027        ASTNode$State state = state();
1028        boolean new_strictSubtype_TypeDecl_value;
1029        if (!state.IN_CIRCLE) {
1030          state.IN_CIRCLE = true;
1031          int num = state.boundariesCrossed;
1032          boolean isFinal = this.is$Final();
1033          // TODO: fixme
1034          // state().CIRCLE_INDEX = 1;
1035          do {
1036            _value.visited = state.CIRCLE_INDEX;
1037            state.CHANGE = false;
1038            new_strictSubtype_TypeDecl_value = type.strictSupertypeWildcardExtends(this);
1039            if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
1040              state.CHANGE = true;
1041              _value.value = new_strictSubtype_TypeDecl_value;
1042            }
1043            state.CIRCLE_INDEX++;
1044          } while (state.CHANGE);
1045          if (isFinal && num == state().boundariesCrossed) {
1046            strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value);
1047          } else {
1048            strictSubtype_TypeDecl_values.remove(_parameters);
1049            state.RESET_CYCLE = true;
1050            boolean $tmp = type.strictSupertypeWildcardExtends(this);
1051            state.RESET_CYCLE = false;
1052          }
1053          state.IN_CIRCLE = false;
1054          state.INTERMEDIATE_VALUE = false;
1055          return new_strictSubtype_TypeDecl_value;
1056        }
1057        if (state.CIRCLE_INDEX != _value.visited) {
1058          _value.visited = state.CIRCLE_INDEX;
1059          new_strictSubtype_TypeDecl_value = type.strictSupertypeWildcardExtends(this);
1060          if (state.RESET_CYCLE) {
1061            strictSubtype_TypeDecl_values.remove(_parameters);
1062          }
1063          else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
1064            state.CHANGE = true;
1065            _value.value = new_strictSubtype_TypeDecl_value;
1066          }
1067          state.INTERMEDIATE_VALUE = true;
1068          return new_strictSubtype_TypeDecl_value;
1069        }
1070        state.INTERMEDIATE_VALUE = true;
1071        return (Boolean) _value.value;
1072      }
1073      /**
1074       * @attribute syn
1075       * @aspect StrictSubtype
1076       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:77
1077       */
1078      @ASTNodeAnnotation.Attribute
1079      public boolean strictSupertypeWildcardExtends(WildcardExtendsType type) {
1080        boolean strictSupertypeWildcardExtends_WildcardExtendsType_value = type.extendsType().strictSubtype(extendsType());
1081    
1082        return strictSupertypeWildcardExtends_WildcardExtendsType_value;
1083      }
1084      /**
1085       * @attribute syn
1086       * @aspect StrictSubtype
1087       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:370
1088       */
1089      @ASTNodeAnnotation.Attribute
1090      public boolean strictSupertypeClassDecl(ClassDecl type) {
1091        boolean strictSupertypeClassDecl_ClassDecl_value = type.strictSubtype(extendsType());
1092    
1093        return strictSupertypeClassDecl_ClassDecl_value;
1094      }
1095      /**
1096       * @attribute syn
1097       * @aspect StrictSubtype
1098       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:390
1099       */
1100      @ASTNodeAnnotation.Attribute
1101      public boolean strictSupertypeInterfaceDecl(InterfaceDecl type) {
1102        boolean strictSupertypeInterfaceDecl_InterfaceDecl_value = type.strictSubtype(extendsType());
1103    
1104        return strictSupertypeInterfaceDecl_InterfaceDecl_value;
1105      }
1106      /**
1107       * @attribute syn
1108       * @aspect StrictSubtype
1109       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:155
1110       */
1111      @ASTNodeAnnotation.Attribute
1112      public boolean strictSupertypeParClassDecl(ParClassDecl type) {
1113        boolean strictSupertypeParClassDecl_ParClassDecl_value = type.strictSubtype(extendsType());
1114    
1115        return strictSupertypeParClassDecl_ParClassDecl_value;
1116      }
1117      /**
1118       * @attribute syn
1119       * @aspect StrictSubtype
1120       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:159
1121       */
1122      @ASTNodeAnnotation.Attribute
1123      public boolean strictSupertypeParInterfaceDecl(ParInterfaceDecl type) {
1124        boolean strictSupertypeParInterfaceDecl_ParInterfaceDecl_value = type.strictSubtype(extendsType());
1125    
1126        return strictSupertypeParInterfaceDecl_ParInterfaceDecl_value;
1127      }
1128      /**
1129       * @attribute syn
1130       * @aspect StrictSubtype
1131       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:52
1132       */
1133      @ASTNodeAnnotation.Attribute
1134      public boolean strictSupertypeRawClassDecl(RawClassDecl type) {
1135        boolean strictSupertypeRawClassDecl_RawClassDecl_value = type.strictSubtype(extendsType());
1136    
1137        return strictSupertypeRawClassDecl_RawClassDecl_value;
1138      }
1139      /**
1140       * @attribute syn
1141       * @aspect StrictSubtype
1142       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:56
1143       */
1144      @ASTNodeAnnotation.Attribute
1145      public boolean strictSupertypeRawInterfaceDecl(RawInterfaceDecl type) {
1146        boolean strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value = type.strictSubtype(extendsType());
1147    
1148        return strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value;
1149      }
1150      /**
1151       * @attribute syn
1152       * @aspect StrictSubtype
1153       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:276
1154       */
1155      @ASTNodeAnnotation.Attribute
1156      public boolean strictSupertypeTypeVariable(TypeVariable type) {
1157        boolean strictSupertypeTypeVariable_TypeVariable_value = type.strictSubtype(extendsType());
1158    
1159        return strictSupertypeTypeVariable_TypeVariable_value;
1160      }
1161      /**
1162       * @attribute syn
1163       * @aspect StrictSubtype
1164       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:407
1165       */
1166      @ASTNodeAnnotation.Attribute
1167      public boolean strictSupertypeArrayDecl(ArrayDecl type) {
1168        boolean strictSupertypeArrayDecl_ArrayDecl_value = type.strictSubtype(extendsType());
1169    
1170        return strictSupertypeArrayDecl_ArrayDecl_value;
1171      }
1172      /**
1173       * @apilevel internal
1174       */
1175      private void strictContainedIn_TypeDecl_reset() {
1176        strictContainedIn_TypeDecl_values = null;
1177      }
1178      protected java.util.Map strictContainedIn_TypeDecl_values;
1179      @ASTNodeAnnotation.Attribute
1180      public boolean strictContainedIn(TypeDecl type) {
1181        Object _parameters = type;
1182        if (strictContainedIn_TypeDecl_values == null) strictContainedIn_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1183        ASTNode$State.CircularValue _value;
1184        if (strictContainedIn_TypeDecl_values.containsKey(_parameters)) {
1185          Object _o = strictContainedIn_TypeDecl_values.get(_parameters);
1186          if (!(_o instanceof ASTNode$State.CircularValue)) {
1187            return (Boolean) _o;
1188          } else {
1189            _value = (ASTNode$State.CircularValue) _o;
1190          }
1191        } else {
1192          _value = new ASTNode$State.CircularValue();
1193          strictContainedIn_TypeDecl_values.put(_parameters, _value);
1194          _value.value = true;
1195        }
1196        ASTNode$State state = state();
1197        boolean new_strictContainedIn_TypeDecl_value;
1198        if (!state.IN_CIRCLE) {
1199          state.IN_CIRCLE = true;
1200          int num = state.boundariesCrossed;
1201          boolean isFinal = this.is$Final();
1202          // TODO: fixme
1203          // state().CIRCLE_INDEX = 1;
1204          do {
1205            _value.visited = state.CIRCLE_INDEX;
1206            state.CHANGE = false;
1207            new_strictContainedIn_TypeDecl_value = strictContainedIn_compute(type);
1208            if (new_strictContainedIn_TypeDecl_value != ((Boolean)_value.value)) {
1209              state.CHANGE = true;
1210              _value.value = new_strictContainedIn_TypeDecl_value;
1211            }
1212            state.CIRCLE_INDEX++;
1213          } while (state.CHANGE);
1214          if (isFinal && num == state().boundariesCrossed) {
1215            strictContainedIn_TypeDecl_values.put(_parameters, new_strictContainedIn_TypeDecl_value);
1216          } else {
1217            strictContainedIn_TypeDecl_values.remove(_parameters);
1218            state.RESET_CYCLE = true;
1219            boolean $tmp = strictContainedIn_compute(type);
1220            state.RESET_CYCLE = false;
1221          }
1222          state.IN_CIRCLE = false;
1223          state.INTERMEDIATE_VALUE = false;
1224          return new_strictContainedIn_TypeDecl_value;
1225        }
1226        if (state.CIRCLE_INDEX != _value.visited) {
1227          _value.visited = state.CIRCLE_INDEX;
1228          new_strictContainedIn_TypeDecl_value = strictContainedIn_compute(type);
1229          if (state.RESET_CYCLE) {
1230            strictContainedIn_TypeDecl_values.remove(_parameters);
1231          }
1232          else if (new_strictContainedIn_TypeDecl_value != ((Boolean)_value.value)) {
1233            state.CHANGE = true;
1234            _value.value = new_strictContainedIn_TypeDecl_value;
1235          }
1236          state.INTERMEDIATE_VALUE = true;
1237          return new_strictContainedIn_TypeDecl_value;
1238        }
1239        state.INTERMEDIATE_VALUE = true;
1240        return (Boolean) _value.value;
1241      }
1242      /**
1243       * @apilevel internal
1244       */
1245      private boolean strictContainedIn_compute(TypeDecl type) {
1246          if (type == this || type instanceof WildcardType) {
1247            return true;
1248          } else if (type instanceof WildcardExtendsType) {
1249            return extendsType().strictSubtype(((WildcardExtendsType) type).extendsType());
1250          } else {
1251            return false;
1252          }
1253        }
1254      /**
1255       * @apilevel internal
1256       */
1257      public ASTNode rewriteTo() {
1258        return super.rewriteTo();
1259      }
1260    }