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/java4/grammar/Java.ast:38
027     * @production TypeDecl : {@link ASTNode} ::= <span class="component">{@link Modifiers}</span> <span class="component">&lt;ID:String&gt;</span> <span class="component">{@link BodyDecl}*</span>;
028    
029     */
030    public abstract class TypeDecl extends ASTNode<ASTNode> implements Cloneable, SimpleSet, Iterator, VariableScope {
031      /**
032       * @aspect AnonymousClasses
033       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:50
034       */
035      public int anonymousIndex = 0;
036      /**
037       * @aspect AnonymousClasses
038       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:70
039       */
040      public int nextAnonymousIndex() {
041        if (isNestedType()) {
042          return enclosingType().nextAnonymousIndex();
043        }
044        return anonymousIndex++;
045      }
046      /**
047       * @aspect BoundNames
048       * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:45
049       */
050      public MethodDecl addMemberMethod(MethodDecl m) {
051        addBodyDecl(m);
052        return (MethodDecl) getBodyDecl(getNumBodyDecl()-1);
053        /*
054        HashMap map = methodsNameMap();
055        ArrayList list = (ArrayList) map.get(m.name());
056        if (list == null) {
057          list = new ArrayList(4);
058          map.put(m.name(), list);
059        }
060        list.add(m);
061        if (!memberMethods(m.name()).contains(m)) {
062          throw new Error("The method " + m.signature() + " added to " + typeName() + " can not be found using lookupMemberMethod");
063        }
064        */
065      }
066      /**
067       * @aspect BoundNames
068       * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:62
069       */
070      public ConstructorDecl addConstructor(ConstructorDecl c) {
071        addBodyDecl(c);
072        return (ConstructorDecl) getBodyDecl(getNumBodyDecl()-1);
073      }
074      /**
075       * @aspect BoundNames
076       * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:67
077       */
078      public ClassDecl addMemberClass(ClassDecl c) {
079        addBodyDecl(new MemberClassDecl(c));
080        return ((MemberClassDecl) getBodyDecl(getNumBodyDecl()-1)).getClassDecl();
081      }
082      /**
083       * @aspect BoundNames
084       * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:74
085       */
086      public FieldDeclaration addMemberField(FieldDeclaration f) {
087        addBodyDecl(f);
088        return (FieldDeclaration) getBodyDecl(getNumBodyDecl()-1);
089      }
090      /**
091       * @aspect BoundNames
092       * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:110
093       */
094      public TypeAccess createBoundAccess() {
095        return new BoundTypeAccess("", name(), this);
096      }
097      /**
098       * @aspect DataStructures
099       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:159
100       */
101      public SimpleSet add(Object o) {
102        return new SimpleSetImpl().add(this).add(o);
103      }
104      /**
105       * @aspect DataStructures
106       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:163
107       */
108      public boolean isSingleton() { return true; }
109      /**
110       * @aspect DataStructures
111       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:164
112       */
113      public boolean isSingleton(Object o) { return contains(o); }
114      /**
115       * @aspect DataStructures
116       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:167
117       */
118      private TypeDecl iterElem;
119      /**
120       * @aspect DataStructures
121       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:168
122       */
123      public Iterator iterator() { iterElem = this; return this; }
124      /**
125       * @aspect DataStructures
126       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:169
127       */
128      public boolean hasNext() { return iterElem != null; }
129      /**
130       * @aspect DataStructures
131       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:170
132       */
133      public Object next() { Object o = iterElem; iterElem = null; return o; }
134      /**
135       * @aspect DataStructures
136       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:171
137       */
138      public void remove() { throw new UnsupportedOperationException(); }
139      /**
140       * @aspect DeclareBeforeUse
141       * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:53
142       */
143      public boolean declaredBeforeUse(Variable decl, ASTNode use) {
144        int indexDecl = ((ASTNode) decl).varChildIndex(this);
145        int indexUse = use.varChildIndex(this);
146        return indexDecl < indexUse;
147      }
148      /**
149       * @aspect DeclareBeforeUse
150       * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:59
151       */
152      public boolean declaredBeforeUse(Variable decl, int indexUse) {
153        int indexDecl = ((ASTNode) decl).varChildIndex(this);
154        return indexDecl < indexUse;
155      }
156      /**
157       * @aspect DocumentationComments
158       * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:37
159       */
160      public String docComment = "";
161      /**
162       * @aspect ConstructorLookup
163       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:117
164       */
165      public ConstructorDecl lookupConstructor(ConstructorDecl signature) {
166        for (Iterator iter = constructors().iterator(); iter.hasNext(); ) {
167          ConstructorDecl decl = (ConstructorDecl) iter.next();
168          if (decl.sameSignature(signature)) {
169            return decl;
170          }
171        }
172        return null;
173      }
174      /**
175       * @return true if the method access may access the method
176       * @aspect MethodDecl
177       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:284
178       */
179      public boolean mayAccess(MethodAccess access, MethodDecl method) {
180        if (instanceOf(method.hostType())
181            && access.qualifier().type().instanceOf(this)) {
182          return true;
183        }
184    
185        if (isNestedType()) {
186          return enclosingType().mayAccess(access, method);
187        } else {
188          return false;
189        }
190      }
191      /**
192       * Iterate over all local methods in the type.
193       * @return method iterator
194       * @aspect MemberMethods
195       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:346
196       */
197      public Iterator<MethodDecl> localMethodsIterator() {
198        return new Iterator<MethodDecl>() {
199          private Iterator<SimpleSet> outer = localMethodsSignatureMap().values().iterator();
200          private Iterator inner = null;
201          public boolean hasNext() {
202            if ((inner == null || !inner.hasNext()) && outer.hasNext()) {
203              inner = outer.next().iterator();
204            }
205            return inner == null ? false : inner.hasNext();
206          }
207          public MethodDecl next() {
208            return (MethodDecl) inner.next();
209          }
210          public void remove() { throw new UnsupportedOperationException(); }
211        };
212      }
213      /**
214       * @return iterator for iterating over all method declarations in implemented
215       * interfaces
216       * @aspect MemberMethods
217       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:389
218       */
219      public Iterator<MethodDecl> interfacesMethodsIterator() {
220        return new Iterator<MethodDecl>() {
221          private Iterator<SimpleSet> outer = interfacesMethodsSignatureMap().values().iterator();
222          private Iterator inner = null;
223          public boolean hasNext() {
224            if ((inner == null || !inner.hasNext()) && outer.hasNext()) {
225              inner = outer.next().iterator();
226            }
227            return inner == null ? false : inner.hasNext();
228          }
229          public MethodDecl next() {
230            return (MethodDecl) inner.next();
231          }
232          public void remove() { throw new UnsupportedOperationException(); }
233        };
234      }
235      /**
236       * Iterate over all member methods in the type.
237       * @return method iterator
238       * @aspect MemberMethods
239       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:440
240       */
241      public Iterator<MethodDecl> methodsIterator() {
242        return new Iterator<MethodDecl>() {
243          private Iterator<SimpleSet> outer = methodsSignatureMap().values().iterator();
244          private Iterator inner = null;
245          public boolean hasNext() {
246            if ((inner == null || !inner.hasNext()) && outer.hasNext()) {
247              inner = outer.next().iterator();
248            }
249            return inner != null ? inner.hasNext() : false;
250          }
251          public MethodDecl next() {
252            return (MethodDecl) inner.next();
253          }
254          public void remove() { throw new UnsupportedOperationException(); }
255        };
256      }
257      /**
258       * @aspect MemberMethods
259       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:519
260       */
261      protected boolean allMethodsAbstract(SimpleSet set) {
262        if (set == null) {
263          return true;
264        }
265        for (Iterator iter = set.iterator(); iter.hasNext(); ) {
266          MethodDecl m = (MethodDecl) iter.next();
267          if (!m.isAbstract()) {
268            return false;
269          }
270        }
271        return true;
272      }
273      /**
274       * @return true if the expression may access the field
275       * @aspect VariableScope
276       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:307
277       */
278      public boolean mayAccess(Expr expr, FieldDeclaration field) {
279        if (instanceOf(field.hostType())) {
280          if (!field.isInstanceVariable()
281              || expr.isSuperAccess()
282              || expr.type().instanceOf(this)) {
283            return true;
284          }
285        }
286    
287        if (isNestedType()) {
288          return enclosingType().mayAccess(expr, field);
289        } else {
290          return false;
291        }
292      }
293      /**
294       * @aspect Fields
295       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:418
296       */
297      public Iterator fieldsIterator() {
298        return new Iterator() {
299          private Iterator outer = memberFieldsMap().values().iterator();
300          private Iterator inner = null;
301          public boolean hasNext() {
302            if ((inner == null || !inner.hasNext()) && outer.hasNext()) {
303              inner = ((SimpleSet) outer.next()).iterator();
304            }
305            return inner != null ? inner.hasNext() : false;
306          }
307          public Object next() {
308            return inner.next();
309          }
310          public void remove() { throw new UnsupportedOperationException(); }
311        };
312      }
313      /**
314       * @aspect Modifiers
315       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:91
316       */
317      public void refined_Modifiers_TypeDecl_checkModifiers() {
318        super.checkModifiers();
319        // 8.1.1
320        if (isPublic() && !isTopLevelType() && !isMemberType()) {
321          error("public pertains only to top level types and member types");
322        }
323    
324        // 8.1.1
325        if ((isProtected() || isPrivate()) && !(isMemberType() && enclosingType().isClassDecl())) {
326          error("protected and private may only be used on member types within a directly enclosing class declaration");
327        }
328    
329        // 8.1.1
330        if (isStatic() && !isMemberType()) {
331          error("static pertains only to member types");
332        }
333    
334    
335        // 8.4.3.1
336        // 8.1.1.1
337        if (!isAbstract() && hasAbstract()) {
338          StringBuilder sb = new StringBuilder();
339          sb.append("" + name() + " is not declared abstract but contains abstract members: \n");
340          for (Iterator iter = unimplementedMethods().iterator(); iter.hasNext(); ) {
341            MethodDecl m = (MethodDecl) iter.next();
342            sb.append("  " + m.signature() + " in " + m.hostType().typeName() + "\n");
343          }
344          error(sb.toString());
345        }
346      }
347      /**
348       * @aspect NameCheck
349       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:316
350       */
351      public void nameCheck() {
352        if (isTopLevelType() && lookupType(packageName(), name()) != this) {
353          errorf("duplicate type %s in package %s", name(), packageName());
354        }
355    
356        if (!isTopLevelType() && !isAnonymous() && !isLocalClass() && extractSingleType(enclosingType().memberTypes(name())) != this) {
357          errorf("duplicate member type %s in type %s", name(), enclosingType().typeName());
358        }
359    
360        // 14.3
361        if (isLocalClass()) {
362          TypeDecl typeDecl = extractSingleType(lookupType(name()));
363          if (typeDecl != null && typeDecl != this && typeDecl.isLocalClass() && enclosingBlock() == typeDecl.enclosingBlock()) {
364            errorf("local class named %s may not be redeclared as a local class in the same block",
365                name());
366          }
367        }
368    
369        if (!packageName().equals("") && hasPackage(fullName())) {
370          errorf("type name conflicts with a package using the same name: %s", name());
371        }
372    
373        // 8.1 & 9.1
374        if (hasEnclosingTypeDecl(name())) {
375          error("type may not have the same simple name as an enclosing type declaration");
376        }
377      }
378      /**
379       * @aspect CreateQualifiedAccesses
380       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:110
381       */
382      public Access createQualifiedAccess() {
383        if (isLocalClass() || isAnonymous()) {
384          return new TypeAccess(name());
385        } else if (!isTopLevelType()) {
386          return enclosingType().createQualifiedAccess().qualifiesAccess(new TypeAccess(name()));
387        } else {
388          return new TypeAccess(packageName(), name());
389        }
390      }
391      /**
392       * @aspect TypeAnalysis
393       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:258
394       */
395      public FieldDeclaration findSingleVariable(String name) {
396        return (FieldDeclaration) memberFields(name).iterator().next();
397      }
398      /**
399       * Iterate over interfaces which this type implements.
400       * @return interface iterator
401       * @aspect SuperClasses
402       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:671
403       */
404      public Iterator<TypeDecl> interfacesIterator() {
405        return new Iterator<TypeDecl>() {
406          @Override
407          public boolean hasNext() {
408            return false;
409          }
410          @Override
411          public TypeDecl next() {
412            throw new NoSuchElementException("empty iterator");
413          }
414          @Override
415          public void remove() {
416            throw new UnsupportedOperationException("empty iterator");
417          }
418        };
419      }
420      /**
421       * @aspect TypeHierarchyCheck
422       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:206
423       */
424      public void refined_TypeHierarchyCheck_TypeDecl_typeCheck() {
425        // 8.4.6.4 & 9.4.1
426        for (Iterator iter1 = localMethodsIterator(); iter1.hasNext(); ) {
427          MethodDecl m = (MethodDecl) iter1.next();
428          ASTNode target = m.hostType() == this ? (ASTNode) m : (ASTNode) this;
429    
430          for (Iterator i2 = ancestorMethods(m.signature()).iterator(); i2.hasNext(); ) {
431            MethodDecl decl = (MethodDecl) i2.next();
432            if (m.overrides(decl)) {
433              // 8.4.6.1
434              if (!m.isStatic() && decl.isStatic()) {
435                target.error("an instance method may not override a static method");
436              }
437    
438              // regardless of overriding
439              // 8.4.6.3
440              if (!m.mayOverride(decl)) {
441                target.errorf("the return type of method %s in %s does not match the return type of"
442                    + " method %s in %s and may thus not be overridden",
443                    m.fullSignature(), m.hostType().typeName(), decl.fullSignature(),
444                    decl.hostType().typeName());
445              }
446    
447              // regardless of overriding
448              // 8.4.4
449              for (Access e: m.getExceptionList()) {
450                if (e.type().isCheckedException()) {
451                  boolean found = false;
452                  for (Access declException: decl.getExceptionList()) {
453                    if (e.type().instanceOf(declException.type())) {
454                      found = true;
455                      break;
456                    }
457                  }
458                  if (!found) {
459                    target.errorf("%s in %s may not throw more checked exceptions than"
460                        + " overridden method %s in %s",
461                        m.fullSignature(), m.hostType().typeName(), decl.fullSignature(),
462                        decl.hostType().typeName());
463                  }
464                }
465              }
466    
467              // 8.4.6.3
468              if (decl.isPublic() && !m.isPublic()) {
469                target.error("overriding access modifier error");
470              }
471              // 8.4.6.3
472              if (decl.isProtected() && !(m.isPublic() || m.isProtected())) {
473                target.error("overriding access modifier error");
474              }
475              // 8.4.6.3
476              if ((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate()) {
477                target.error("overriding access modifier error");
478              }
479              // regardless of overriding
480              if (decl.isFinal()) {
481                target.errorf("method %s in %s can not override final method %s in %s",
482                    m.fullSignature(), hostType().typeName(), decl.fullSignature(),
483                    decl.hostType().typeName());
484              }
485            }
486            if (m.hides(decl)) {
487              // 8.4.6.2
488              if (m.isStatic() && !decl.isStatic()) {
489                target.error("a static method may not hide an instance method");
490              }
491              // 8.4.6.3
492              if (!m.mayOverride(decl)) {
493                target.error("can not hide a method with a different return type");
494              }
495              // 8.4.4
496              for (int i = 0; i < m.getNumException(); i++) {
497                Access e = m.getException(i);
498                boolean found = false;
499                for (int j = 0; !found && j < decl.getNumException(); j++) {
500                  if (e.type().instanceOf(decl.getException(j).type())) {
501                    found = true;
502                  }
503                }
504                if (!found) {
505                  target.error("may not throw more checked exceptions than hidden method");
506                }
507              }
508              // 8.4.6.3
509              if (decl.isPublic() && !m.isPublic()) {
510                target.errorf("hiding access modifier error:"
511                    + " public method %s in %s is hidden by non public method %s in %s",
512                    decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(),
513                    m.hostType().typeName());
514              }
515              // 8.4.6.3
516              if (decl.isProtected() && !(m.isPublic() || m.isProtected())) {
517                target.errorf("hiding access modifier error:"
518                    + " protected method %s in %s is hidden by non (public|protected) method %s in %s",
519                    decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(),
520                    m.hostType().typeName());
521              }
522              // 8.4.6.3
523              if ((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate()) {
524                target.errorf("hiding access modifier error:"
525                    + " default method %s in %s is hidden by private method %s in %s",
526                    decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(),
527                    m.hostType().typeName());
528              }
529              if (decl.isFinal()) {
530                target.errorf("method %s in %s can not hide final method %s in %s",
531                    m.fullSignature(), hostType().typeName(), decl.fullSignature(),
532                    decl.hostType().typeName());
533              }
534            }
535          }
536        }
537      }
538      /**
539       * Error-check two interface method declarations.
540       * @aspect TypeHierarchyCheck
541       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:486
542       */
543      protected void refined_TypeHierarchyCheck_TypeDecl_checkAbstractMethodDecls(MethodDecl m1, MethodDecl m2) {
544        if (!m1.mayOverride(m2) && !m2.mayOverride(m1)) {
545          StringBuilder err = new StringBuilder();
546          TypeDecl host1 = m1.hostType();
547          TypeDecl host2 = m2.hostType();
548          if (host1 != this || host2 != this) {
549            err.append("inherited ");
550          }
551          err.append("method " + m1.fullSignature() + " is multiply declared "
552              + "with incompatible return types in " + fullName());
553          error(err.toString());
554        }
555      }
556      /**
557       * @aspect Attributes
558       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:80
559       */
560      public int addConstant(ConstantPool p, Constant c)     {
561        if (isString()) {
562          return p.addConstant(c.stringValue());
563        }
564        throw new Error("Not supported");
565      }
566      /**
567       * @aspect CodeGeneration
568       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:169
569       */
570      public void emitPushConstant(CodeGeneration gen, int value) { }
571      /**
572       * @aspect CodeGeneration
573       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:240
574       */
575      public void emitReturn(CodeGeneration gen)      { error(); }
576      /**
577       * @aspect CodeGeneration
578       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:262
579       */
580      public void emitLoadLocal(CodeGeneration gen, int pos) {error();}
581      /**
582       * @aspect CodeGeneration
583       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:405
584       */
585      public void emitStoreLocal(CodeGeneration gen, int pos) {error();}
586      /**
587       * @aspect CodeGeneration
588       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:481
589       */
590      public void emitDup(CodeGeneration gen)      { gen.emit(Bytecode.DUP); }
591      /**
592       * @aspect CodeGeneration
593       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:486
594       */
595      public void emitDup_x1(CodeGeneration gen)   { gen.emit(Bytecode.DUP_X1); }
596      /**
597       * @aspect CodeGeneration
598       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:491
599       */
600      public void emitDup_x2(CodeGeneration gen)   { gen.emit(Bytecode.DUP_X2); }
601      /**
602       * @aspect CodeGeneration
603       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:496
604       */
605      public void emitPop(CodeGeneration gen)      { gen.emit(Bytecode.POP); }
606      /**
607       * @aspect CodeGeneration
608       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:567
609       */
610      public void emitNew(CodeGeneration gen) {
611        int index = gen.constantPool().addClass(constantPoolName());
612        gen.emit(Bytecode.NEW).add2(index);
613      }
614      /**
615       * @aspect CodeGenerationConversions
616       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:579
617       */
618      void emitCastTo(CodeGeneration gen, TypeDecl type) { throw new Error("CastTo not implemented for " + getClass().getName()); }
619      /**
620       * @aspect CodeGenerationConversions
621       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:591
622       */
623      void intToThis(CodeGeneration gen) { throw new Error("intToThis not implemented for " + getClass().getName()); }
624      /**
625       * @aspect CodeGenerationConversions
626       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:600
627       */
628      void floatToThis(CodeGeneration gen) { throw new Error("floatToThis not implemented for " + getClass().getName()); }
629      /**
630       * @aspect CodeGenerationConversions
631       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:609
632       */
633      void doubleToThis(CodeGeneration gen) { throw new Error("doubleToThis not implemented for " + getClass().getName()); }
634      /**
635       * @aspect CodeGenerationConversions
636       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:618
637       */
638      void longToThis(CodeGeneration gen) { throw new Error("longToThis not implemented for " + getClass().getName()); }
639      /**
640       * @aspect CodeGenerationConversions
641       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:627
642       */
643      void byteToThis(CodeGeneration gen) { throw new Error("byteToThis not implemented for " + getClass().getName()); }
644      /**
645       * @aspect CodeGenerationConversions
646       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:634
647       */
648      void charToThis(CodeGeneration gen) { throw new Error("charToThis not implemented for " + getClass().getName()); }
649      /**
650       * @aspect CodeGenerationConversions
651       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:642
652       */
653      void shortToThis(CodeGeneration gen) { throw new Error("shortToThis not implemented for " + getClass().getName()); }
654      /**
655       * @aspect CodeGenerationBinaryOperations
656       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:675
657       */
658      void neg(CodeGeneration gen) { error(); }
659      /**
660       * @aspect CodeGenerationBinaryOperations
661       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:681
662       */
663      void bitNot(CodeGeneration gen) { error(); }
664      /**
665       * @aspect CodeGenerationBinaryOperations
666       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:685
667       */
668      void logNot(CodeGeneration gen) { error();}
669      /**
670       * @aspect CodeGenerationBinaryOperations
671       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:688
672       */
673      void add(CodeGeneration gen) {error();}
674      /**
675       * @aspect CodeGenerationBinaryOperations
676       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:694
677       */
678      void sub(CodeGeneration gen) {error();}
679      /**
680       * @aspect CodeGenerationBinaryOperations
681       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:700
682       */
683      void mul(CodeGeneration gen) {error();}
684      /**
685       * @aspect CodeGenerationBinaryOperations
686       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:706
687       */
688      void div(CodeGeneration gen) {error();}
689      /**
690       * @aspect CodeGenerationBinaryOperations
691       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:712
692       */
693      void rem(CodeGeneration gen) {error();}
694      /**
695       * @aspect CodeGenerationBinaryOperations
696       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:718
697       */
698      void shl(CodeGeneration gen) {error();}
699      /**
700       * @aspect CodeGenerationBinaryOperations
701       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:722
702       */
703      void shr(CodeGeneration gen) {error();}
704      /**
705       * @aspect CodeGenerationBinaryOperations
706       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:726
707       */
708      void ushr(CodeGeneration gen) {error();}
709      /**
710       * @aspect CodeGenerationBinaryOperations
711       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:730
712       */
713      void bitand(CodeGeneration gen) {error();}
714      /**
715       * @aspect CodeGenerationBinaryOperations
716       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:735
717       */
718      void bitor(CodeGeneration gen) {error();}
719      /**
720       * @aspect CodeGenerationBinaryOperations
721       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:740
722       */
723      void bitxor(CodeGeneration gen) {error();}
724      /**
725       * @aspect CodeGenerationBranch
726       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:747
727       */
728      public void branchLT(CodeGeneration gen, int label) { throw new Error("branchLT not supported for " + getClass().getName()); }
729      /**
730       * @aspect CodeGenerationBranch
731       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:753
732       */
733      public void branchLTInv(CodeGeneration gen, int label)   { branchLT(gen, label); }
734      /**
735       * @aspect CodeGenerationBranch
736       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:757
737       */
738      public void branchLE(CodeGeneration gen, int label) { throw new Error("branchLE not supported for " + getClass().getName()); }
739      /**
740       * @aspect CodeGenerationBranch
741       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:763
742       */
743      public void branchLEInv(CodeGeneration gen, int label)   { branchLE(gen, label); }
744      /**
745       * @aspect CodeGenerationBranch
746       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:767
747       */
748      public void branchGE(CodeGeneration gen, int label) { throw new Error("branchGE not supported for " + getClass().getName()); }
749      /**
750       * @aspect CodeGenerationBranch
751       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:773
752       */
753      public void branchGEInv(CodeGeneration gen, int label)   { branchGE(gen, label); }
754      /**
755       * @aspect CodeGenerationBranch
756       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:777
757       */
758      public void branchGT(CodeGeneration gen, int label) { throw new Error("branchGT not supported for " + getClass().getName()); }
759      /**
760       * @aspect CodeGenerationBranch
761       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:783
762       */
763      public void branchGTInv(CodeGeneration gen, int label)   { branchGT(gen, label); }
764      /**
765       * @aspect CodeGenerationBranch
766       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:787
767       */
768      public void branchEQ(CodeGeneration gen, int label) { throw new Error("branchEQ not supported for " + getClass().getName()); }
769      /**
770       * @aspect CodeGenerationBranch
771       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:796
772       */
773      public void branchNE(CodeGeneration gen, int label) { throw new Error("branchNE not supported for " + getClass().getName()); }
774      /**
775       * @aspect CreateBCode
776       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:79
777       */
778      private void generateBytecodes(CodeGeneration gen) {
779        for (int i = 0; i < getNumBodyDecl(); i++) {
780          BodyDecl b = getBodyDecl(i);
781          if (b instanceof FieldDeclaration && b.isBytecodeField()) {
782            FieldDeclaration f = (FieldDeclaration) b;
783            f.emitStaticInitializer(gen, this);
784          } else if (b instanceof StaticInitializer) {
785            b.createBCode(gen);
786          }
787        }
788        gen.emitReturn();
789      }
790      /**
791       * @aspect Flags
792       * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:49
793       */
794      public int mangledFlags(int flags) {
795        boolean privateFlag = (flags & Modifiers.ACC_PRIVATE) != 0;
796        boolean protectedFlag = (flags & Modifiers.ACC_PROTECTED) != 0;
797        flags &= ~ Modifiers.ACC_PRIVATE;
798        flags &= ~ Modifiers.ACC_PROTECTED;
799        if (protectedFlag) {
800          flags |= Modifiers.ACC_PUBLIC;
801        }
802        return flags;
803      }
804      /**
805       * @aspect GenerateClassfile
806       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:48
807       */
808      public void generateClassfile() {
809        for (Iterator iter = nestedTypes.iterator(); iter.hasNext(); ) {
810          TypeDecl typeDecl = (TypeDecl) iter.next();
811          typeDecl.generateClassfile();
812        }
813      }
814      /**
815       * @aspect GenerateClassfile
816       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:389
817       */
818      public boolean clear() {
819        bytecodes(constantPool()).clearCodeGeneration();
820        for (int i = 0; i < getNumBodyDecl(); i++) {
821          getBodyDecl(i).clear();
822        }
823        attributes_computed = false;
824        attributes_value = null;
825        clinit_attributes_computed = false;
826        clinit_attributes_value = null;
827        constantPool_computed = false;
828        constantPool_value = null;
829        bytecodes_ConstantPool_values = null;
830        return false;
831      }
832      /**
833       * @aspect InnerClasses
834       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:33
835       */
836      public boolean hasField(String name) {
837        if (!memberFields(name).isEmpty()) {
838          return true;
839        }
840        for (int i = 0; i < getNumBodyDecl(); i++) {
841          if (getBodyDecl(i) instanceof FieldDeclaration) {
842            FieldDeclaration decl = (FieldDeclaration) getBodyDecl(i);
843            if (decl.name().equals(name)) {
844              return true;
845            }
846          }
847        }
848        return false;
849      }
850      /**
851       * @aspect InnerClasses
852       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:62
853       */
854      public boolean hasMethod(String id) {
855        if (!memberMethods(id).isEmpty()) {
856          return true;
857        }
858        for (int i = 0; i < getNumBodyDecl(); i++) {
859          if (getBodyDecl(i) instanceof MethodDecl) {
860            MethodDecl decl = (MethodDecl) getBodyDecl(i);
861            if (decl.name().equals(id)) {
862              return true;
863            }
864          }
865        }
866        return false;
867      }
868      /**
869       * @aspect InnerClasses
870       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:158
871       */
872      public Collection<TypeDecl> nestedTypes =
873          new RobustLinkedList<TypeDecl>();
874      /**
875       * @aspect InnerClasses
876       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:161
877       */
878      public void addNestedType(TypeDecl typeDecl) {
879        if (typeDecl != this) {
880          nestedTypes.add(typeDecl);
881        }
882      }
883      /**
884       * @aspect InnerClasses
885       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:168
886       */
887      public Collection<TypeDecl> usedNestedTypes =
888          new RobustLinkedList<TypeDecl>();
889      /**
890       * @aspect InnerClasses
891       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:171
892       */
893      public void addUsedNestedType(TypeDecl typeDecl) {
894        usedNestedTypes.add(typeDecl);
895      }
896      /**
897       * @aspect InnerClasses
898       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:206
899       */
900      public int accessorCounter = 0;
901      /**
902       * @aspect InnerClasses
903       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:208
904       */
905      private HashMap accessorMap = null;
906      /**
907       * @aspect InnerClasses
908       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:209
909       */
910      public ASTNode getAccessor(ASTNode source, String name) {
911        ArrayList key = new ArrayList(2);
912        key.add(source);
913        key.add(name);
914        if (accessorMap == null || !accessorMap.containsKey(key)) {
915          return null;
916        }
917        return (ASTNode) accessorMap.get(key);
918      }
919      /**
920       * @aspect InnerClasses
921       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:219
922       */
923      public void addAccessor(ASTNode source, String name, ASTNode accessor) {
924        ArrayList key = new ArrayList(2);
925        key.add(source);
926        key.add(name);
927        if (accessorMap == null) {
928          accessorMap = new HashMap();
929        }
930        accessorMap.put(key, accessor);
931      }
932      /**
933       * @aspect InnerClasses
934       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:229
935       */
936      public ASTNode getAccessorSource(ASTNode accessor) {
937        Iterator i = accessorMap.entrySet().iterator();
938        while (i.hasNext()) {
939          Map.Entry entry = (Map.Entry) i.next();
940          if (entry.getValue() == accessor) {
941            return (ASTNode) ((ArrayList) entry.getKey()).get(0);
942          }
943        }
944        return null;
945      }
946      /**
947       * @aspect InnerClasses
948       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:509
949       */
950      private boolean addEnclosingVariables = true;
951      /**
952       * @aspect InnerClasses
953       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:510
954       */
955      public void addEnclosingVariables() {
956        if (!addEnclosingVariables) {
957          return;
958        }
959        addEnclosingVariables = false;
960        for (Iterator iter = enclosingVariables().iterator(); iter.hasNext(); ) {
961          Variable v = (Variable) iter.next();
962          Modifiers m = new Modifiers();
963          m.addModifier(new Modifier("public"));
964          m.addModifier(new Modifier("synthetic"));
965          m.addModifier(new Modifier("final"));
966          addMemberField(new FieldDeclaration(m, v.type().createQualifiedAccess(), "val$" + v.name(), new Opt()));
967        }
968      }
969      /**
970       * @aspect Java2Rewrites
971       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:32
972       */
973      int uniqueIndexCounter = 1;
974      /**
975       * @aspect Java2Rewrites
976       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:89
977       */
978      private FieldDeclaration createAssertionsDisabled = null;
979      /**
980       * @aspect Java2Rewrites
981       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:90
982       */
983      public FieldDeclaration createAssertionsDisabled() {
984        if (createAssertionsDisabled != null) {
985          return createAssertionsDisabled;
986        }
987        // static final boolean $assertionsDisabled = !TypeName.class.desiredAssertionStatus();
988        createAssertionsDisabled = new FieldDeclaration(
989          new Modifiers(new List().add(new Modifier("public")).add(new Modifier("static")).add(new Modifier("final"))),
990          new PrimitiveTypeAccess("boolean"),
991          "$assertionsDisabled",
992          new Opt(
993              new LogNotExpr(
994                topLevelType().createQualifiedAccess().qualifiesAccess(
995                  new ClassAccess().qualifiesAccess(
996                    new MethodAccess(
997                      "desiredAssertionStatus",
998                      new List()
999                    )
1000                  )
1001                )
1002              )
1003          )
1004        );
1005        getBodyDeclList().insertChild(createAssertionsDisabled, 0);
1006        // TODO remove this!
1007        // explicit read to trigger possible rewrites
1008        createAssertionsDisabled = (FieldDeclaration) getBodyDeclList().getChild(0);
1009        // transform the generated initalization, e.g., the ClassAccess construct
1010        createAssertionsDisabled.transformation();
1011        return createAssertionsDisabled;
1012      }
1013      /**
1014       * @aspect Java2Rewrites
1015       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:146
1016       */
1017      private HashMap createStaticClassField = null;
1018      /**
1019       * @aspect Java2Rewrites
1020       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:147
1021       */
1022      public FieldDeclaration createStaticClassField(String name) {
1023        if (createStaticClassField == null) {
1024          createStaticClassField = new HashMap();
1025        }
1026        if (createStaticClassField.containsKey(name)) {
1027          return (FieldDeclaration) createStaticClassField.get(name);
1028        }
1029        // static synthetic Class class$java$lang$String;
1030        FieldDeclaration f = new FieldDeclaration(
1031          new Modifiers(new List().add(new Modifier("public")).add(new Modifier("static"))),
1032          lookupType("java.lang", "Class").createQualifiedAccess(),
1033          name,
1034          new Opt()
1035        ) {
1036          public boolean isConstant() {
1037            return true;
1038          }
1039        };
1040        createStaticClassField.put(name, f);
1041        return addMemberField(f);
1042      }
1043      /**
1044       * @aspect Java2Rewrites
1045       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:170
1046       */
1047      private MethodDecl createStaticClassMethod = null;
1048      /**
1049       * @aspect Java2Rewrites
1050       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:171
1051       */
1052      public MethodDecl createStaticClassMethod() {
1053        if (createStaticClassMethod != null) {
1054          return createStaticClassMethod;
1055        }
1056        // static synthetic Class class$(String name) {
1057        //   try {
1058        //     return java.lang.Class.forName(name);
1059        //   } catch(java.lang.ClassNotFoundException e) {
1060        //     throw new java.lang.NoClassDefFoundError(e.getMessage());
1061        //   }
1062        // }
1063        createStaticClassMethod = new MethodDecl(
1064          new Modifiers(new List().add(new Modifier("public")).add(new Modifier("static"))),
1065          lookupType("java.lang", "Class").createQualifiedAccess(),
1066          "class$",
1067          new List().add(
1068            new ParameterDeclaration(
1069              new Modifiers(new List()),
1070              lookupType("java.lang", "String").createQualifiedAccess(),
1071              "name"
1072            )
1073          ),
1074          new List(),
1075          new Opt(
1076            new Block(
1077              new List().add(
1078                new TryStmt(
1079                  new Block(
1080                    new List().add(
1081                      new ReturnStmt(
1082                        new Opt(
1083                          lookupType("java.lang", "Class").createQualifiedAccess().qualifiesAccess(
1084                            new MethodAccess(
1085                              "forName",
1086                              new List().add(
1087                                new VarAccess("name")
1088                              )
1089                            )
1090                          )
1091                        )
1092                      )
1093                    )
1094                  ),
1095                  new List().add(
1096                    new BasicCatch(
1097                      new ParameterDeclaration(
1098                        new Modifiers(new List()),
1099                        lookupType("java.lang", "ClassNotFoundException").createQualifiedAccess(),
1100                        "e"
1101                      ),
1102                      new Block(
1103                        new List().add(
1104                          new ThrowStmt(
1105                            new ClassInstanceExpr(
1106                              lookupType("java.lang", "NoClassDefFoundError").createQualifiedAccess(),
1107                              new List().add(
1108                                new VarAccess("e").qualifiesAccess(
1109                                  new MethodAccess(
1110                                    "getMessage",
1111                                    new List()
1112                                  )
1113                                )
1114                              ),
1115                              new Opt()
1116                            )
1117                          )
1118                        )
1119                      )
1120                    )
1121                  ),
1122                  new Opt()
1123                )
1124              )
1125            )
1126          )
1127        ) {
1128          public boolean isConstant() {
1129            return true;
1130          }
1131        };
1132        return addMemberMethod(createStaticClassMethod);
1133      }
1134      /**
1135       * @aspect Transformations
1136       * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:48
1137       */
1138      public void transformation() {
1139        addEnclosingVariables();
1140        super.transformation();
1141        if (isNestedType()) {
1142          enclosingType().addNestedType(this);
1143        }
1144      }
1145      /**
1146       * @aspect Enums
1147       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:511
1148       */
1149      protected void checkEnum(EnumDecl enumDecl) {
1150        // non-EnumDecl TypeDecls should not check enum stuff
1151      }
1152      /**
1153       * @aspect Generics
1154       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:227
1155       */
1156      public TypeDecl makeGeneric(Signatures.ClassSignature s) {
1157        return this;
1158      }
1159      /**
1160       * Merge the source map into the destination map.
1161       * @param dest destination map
1162       * @param src source map
1163       * @aspect GenericsTypeCheck
1164       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:554
1165       */
1166      protected void mergeMap(Map<String,SimpleSet> dest, Map<String,SimpleSet> src) {
1167        for (Map.Entry<String,SimpleSet> entry: src.entrySet()) {
1168          String signature = entry.getKey();
1169          for (Iterator iter = entry.getValue().iterator(); iter.hasNext(); ) {
1170            putSimpleSetElement(dest, signature, (SimpleSet) iter.next());
1171          }
1172        }
1173      }
1174      /**
1175       * @aspect LookupParTypeDecl
1176       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:952
1177       */
1178      public TypeDecl substitute(TypeVariable typeVariable) {
1179        if (isTopLevelType()) {
1180          return typeVariable;
1181        }
1182        return enclosingType().substitute(typeVariable);
1183      }
1184      /**
1185       * @aspect LookupParTypeDecl
1186       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1025
1187       */
1188      public Access substitute(Parameterization parTypeDecl) {
1189        if (parTypeDecl instanceof ParTypeDecl && ((ParTypeDecl) parTypeDecl).genericDecl() == this) {
1190          return ((TypeDecl) parTypeDecl).createBoundAccess();
1191        }
1192        if (isTopLevelType()) {
1193          return createBoundAccess();
1194        }
1195        return enclosingType().substitute(parTypeDecl).qualifiesAccess(new TypeAccess(name()));
1196      }
1197      /**
1198       * @aspect LookupParTypeDecl
1199       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1084
1200       */
1201      public Access substituteReturnType(Parameterization parTypeDecl) {
1202        return substitute(parTypeDecl);
1203      }
1204      /**
1205       * @aspect LookupParTypeDecl
1206       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1137
1207       */
1208      public Access substituteParameterType(Parameterization parTypeDecl) {
1209        return substitute(parTypeDecl);
1210      }
1211      /**
1212       * Add an annotation parameter constant to the constant pool.
1213       * @see AST.TypeDecl#addConstant(ConstantPool, Constant) TypeDecl.addConstant(ConstantPool, Constant)
1214       * @aspect AnnotationsCodegen
1215       * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:208
1216       */
1217      public int addAnnotConstant(ConstantPool p, Constant c)     {
1218        if (isString()) {
1219          return p.addUtf8(c.stringValue());
1220        }
1221        throw new Error("Not supported");
1222      }
1223      /**
1224       * @aspect AutoBoxingCodegen
1225       * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:115
1226       */
1227      protected void emitBoxingOperation(CodeGeneration gen) {
1228        // Box the value on the stack into this Reference type
1229        String classname = constantPoolName();
1230        String desc = "(" + unboxed().typeDescriptor() + ")" + typeDescriptor();
1231        String name = "valueOf";
1232        int index = gen.constantPool().addMethodref(classname, name, desc);
1233        gen.emit(Bytecode.INVOKESTATIC, variableSize() - unboxed().variableSize()).add2(index);
1234      }
1235      /**
1236       * @aspect AutoBoxingCodegen
1237       * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:133
1238       */
1239      protected void emitUnboxingOperation(CodeGeneration gen) {
1240        // Unbox the value on the stack from this Reference type
1241        String classname = constantPoolName();
1242        String desc = "(" + ")" + unboxed().typeDescriptor();
1243        String name = unboxed().name() + "Value";
1244        int index = gen.constantPool().addMethodref(classname, name, desc);
1245        gen.emit(Bytecode.INVOKEVIRTUAL, unboxed().variableSize() - 1).add2(index);
1246      }
1247      /**
1248       * @aspect EnumsCodegen
1249       * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:106
1250       */
1251      private HashMap createEnumIndexMap = null;
1252      /**
1253       * @aspect Java8NameCheck
1254       * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:289
1255       */
1256      protected void checkInterfaceMethodDecls(MethodDecl m1, MethodDecl m2) {
1257        if (m1.isAbstract() && m2.isAbstract()) {
1258          checkAbstractMethodDecls(m1, m2);
1259          return;
1260        } else {
1261          TypeDecl host1 = m1.hostType();
1262          TypeDecl host2 = m2.hostType();
1263          String inh1 = "";
1264          String inh2 = "";
1265          if (host1 != this) {
1266            inh1 = "inherited ";
1267          }
1268          if (host2 != this) {
1269            inh2 = "inherited ";
1270          }
1271    
1272          //9.4
1273          errorf("%smethod %s and %smethod %s are multiply declared in %s",
1274              inh1, m1.fullSignature(), inh2, m2.fullSignature(), fullName());
1275        }
1276      }
1277      /**
1278       * @declaredat ASTNode:1
1279       */
1280      public TypeDecl() {
1281        super();
1282      }
1283      /**
1284       * Initializes the child array to the correct size.
1285       * Initializes List and Opt nta children.
1286       * @apilevel internal
1287       * @ast method
1288       * @declaredat ASTNode:10
1289       */
1290      public void init$Children() {
1291        children = new ASTNode[2];
1292        setChild(new List(), 1);
1293      }
1294      /**
1295       * @declaredat ASTNode:14
1296       */
1297      public TypeDecl(Modifiers p0, String p1, List<BodyDecl> p2) {
1298        setChild(p0, 0);
1299        setID(p1);
1300        setChild(p2, 1);
1301      }
1302      /**
1303       * @declaredat ASTNode:19
1304       */
1305      public TypeDecl(Modifiers p0, beaver.Symbol p1, List<BodyDecl> p2) {
1306        setChild(p0, 0);
1307        setID(p1);
1308        setChild(p2, 1);
1309      }
1310      /**
1311       * @apilevel low-level
1312       * @declaredat ASTNode:27
1313       */
1314      protected int numChildren() {
1315        return 2;
1316      }
1317      /**
1318       * @apilevel internal
1319       * @declaredat ASTNode:33
1320       */
1321      public boolean mayHaveRewrite() {
1322        return false;
1323      }
1324      /**
1325       * @apilevel internal
1326       * @declaredat ASTNode:39
1327       */
1328      public void flushAttrCache() {
1329        super.flushAttrCache();
1330        accessibleFromPackage_String_reset();
1331        accessibleFromExtend_TypeDecl_reset();
1332        accessibleFrom_TypeDecl_reset();
1333        dimension_reset();
1334        elementType_reset();
1335        arrayType_reset();
1336        isException_reset();
1337        isCheckedException_reset();
1338        isUncheckedException_reset();
1339        mayCatch_TypeDecl_reset();
1340        constructors_reset();
1341        unqualifiedLookupMethod_String_reset();
1342        methodsNameMap_reset();
1343        localMethodsSignatureMap_reset();
1344        interfacesMethodsSignatureMap_reset();
1345        methodsSignatureMap_reset();
1346        ancestorMethods_String_reset();
1347        localTypeDecls_String_reset();
1348        memberTypes_String_reset();
1349        localFields_String_reset();
1350        localFieldsMap_reset();
1351        memberFieldsMap_reset();
1352        memberFields_String_reset();
1353        hasAbstract_reset();
1354        unimplementedMethods_reset();
1355        isPublic_reset();
1356        isStatic_reset();
1357        fullName_reset();
1358        typeName_reset();
1359        narrowingConversionTo_TypeDecl_reset();
1360        methodInvocationConversionTo_TypeDecl_reset();
1361        castingConversionTo_TypeDecl_reset();
1362        isString_reset();
1363        isObject_reset();
1364        instanceOf_TypeDecl_reset();
1365        isCircular_reset();
1366        innerClassesAttributeEntries_reset();
1367        attributes_reset();
1368        clinit_attributes_reset();
1369        constantPool_reset();
1370        constantPoolName_reset();
1371        uniqueName_reset();
1372        typeDescriptor_reset();
1373        destinationPath_reset();
1374        hasClinit_reset();
1375        bytecodes_ConstantPool_reset();
1376        flags_reset();
1377        bcFields_reset();
1378        enclosingVariables_reset();
1379        needsEnclosing_reset();
1380        needsSuperEnclosing_reset();
1381        uniqueIndex_reset();
1382        jvmName_reset();
1383        boxed_reset();
1384        unboxed_reset();
1385        isIterable_reset();
1386        involvesTypeParameters_reset();
1387        erasure_reset();
1388        erasedAncestorMethodsMap_reset();
1389        implementedInterfaces_reset();
1390        usesTypeVariable_reset();
1391        sourceTypeDecl_reset();
1392        containedIn_TypeDecl_reset();
1393        sameStructure_TypeDecl_reset();
1394        subtype_TypeDecl_reset();
1395        createEnumMethod_TypeDecl_reset();
1396        createEnumIndex_EnumConstant_reset();
1397        createEnumArray_TypeDecl_reset();
1398        needsSignatureAttribute_reset();
1399        classSignature_reset();
1400        fieldTypeSignature_reset();
1401        classTypeSignature_reset();
1402        isFunctionalInterface_reset();
1403        strictContainedIn_TypeDecl_reset();
1404        strictSubtype_TypeDecl_reset();
1405        componentType_reset();
1406        isDAbefore_Variable_reset();
1407        isDUbefore_Variable_reset();
1408        typeException_reset();
1409        typeRuntimeException_reset();
1410        typeError_reset();
1411        lookupMethod_String_reset();
1412        typeObject_reset();
1413        lookupType_String_reset();
1414        lookupVariable_String_reset();
1415        packageName_reset();
1416        isAnonymous_reset();
1417        unknownType_reset();
1418        inExplicitConstructorInvocation_reset();
1419        inStaticContext_reset();
1420      }
1421      /**
1422       * @apilevel internal
1423       * @declaredat ASTNode:135
1424       */
1425      public void flushCollectionCache() {
1426        super.flushCollectionCache();
1427      }
1428      /**
1429       * @apilevel internal
1430       * @declaredat ASTNode:141
1431       */
1432      public void flushRewriteCache() {
1433        super.flushRewriteCache();
1434      }
1435      /**
1436       * @apilevel internal
1437       * @declaredat ASTNode:147
1438       */
1439      public TypeDecl clone() throws CloneNotSupportedException {
1440        TypeDecl node = (TypeDecl) super.clone();
1441        return node;
1442      }
1443      /**
1444       * Create a deep copy of the AST subtree at this node.
1445       * The copy is dangling, i.e. has no parent.
1446       * @return dangling copy of the subtree at this node
1447       * @apilevel low-level
1448       * @deprecated Please use treeCopy or treeCopyNoTransform instead
1449       * @declaredat ASTNode:158
1450       */
1451      @Deprecated
1452      public abstract TypeDecl fullCopy();
1453      /**
1454       * Create a deep copy of the AST subtree at this node.
1455       * The copy is dangling, i.e. has no parent.
1456       * @return dangling copy of the subtree at this node
1457       * @apilevel low-level
1458       * @declaredat ASTNode:166
1459       */
1460      public abstract TypeDecl treeCopyNoTransform();
1461      /**
1462       * Create a deep copy of the AST subtree at this node.
1463       * The subtree of this node is traversed to trigger rewrites before copy.
1464       * The copy is dangling, i.e. has no parent.
1465       * @return dangling copy of the subtree at this node
1466       * @apilevel low-level
1467       * @declaredat ASTNode:174
1468       */
1469      public abstract TypeDecl treeCopy();
1470      /**
1471       * Replaces the Modifiers child.
1472       * @param node The new node to replace the Modifiers child.
1473       * @apilevel high-level
1474       */
1475      public void setModifiers(Modifiers node) {
1476        setChild(node, 0);
1477      }
1478      /**
1479       * Retrieves the Modifiers child.
1480       * @return The current node used as the Modifiers child.
1481       * @apilevel high-level
1482       */
1483      @ASTNodeAnnotation.Child(name="Modifiers")
1484      public Modifiers getModifiers() {
1485        return (Modifiers) getChild(0);
1486      }
1487      /**
1488       * Retrieves the Modifiers child.
1489       * <p><em>This method does not invoke AST transformations.</em></p>
1490       * @return The current node used as the Modifiers child.
1491       * @apilevel low-level
1492       */
1493      public Modifiers getModifiersNoTransform() {
1494        return (Modifiers) getChildNoTransform(0);
1495      }
1496      /**
1497       * Replaces the lexeme ID.
1498       * @param value The new value for the lexeme ID.
1499       * @apilevel high-level
1500       */
1501      public void setID(String value) {
1502        tokenString_ID = value;
1503      }
1504      /**
1505       * @apilevel internal
1506       */
1507      protected String tokenString_ID;
1508      /**
1509       */
1510      public int IDstart;
1511      /**
1512       */
1513      public int IDend;
1514      /**
1515       * JastAdd-internal setter for lexeme ID using the Beaver parser.
1516       * @param symbol Symbol containing the new value for the lexeme ID
1517       * @apilevel internal
1518       */
1519      public void setID(beaver.Symbol symbol) {
1520        if (symbol.value != null && !(symbol.value instanceof String))
1521        throw new UnsupportedOperationException("setID is only valid for String lexemes");
1522        tokenString_ID = (String)symbol.value;
1523        IDstart = symbol.getStart();
1524        IDend = symbol.getEnd();
1525      }
1526      /**
1527       * Retrieves the value for the lexeme ID.
1528       * @return The value for the lexeme ID.
1529       * @apilevel high-level
1530       */
1531      @ASTNodeAnnotation.Token(name="ID")
1532      public String getID() {
1533        return tokenString_ID != null ? tokenString_ID : "";
1534      }
1535      /**
1536       * Replaces the BodyDecl list.
1537       * @param list The new list node to be used as the BodyDecl list.
1538       * @apilevel high-level
1539       */
1540      public void setBodyDeclList(List<BodyDecl> list) {
1541        setChild(list, 1);
1542      }
1543      /**
1544       * Retrieves the number of children in the BodyDecl list.
1545       * @return Number of children in the BodyDecl list.
1546       * @apilevel high-level
1547       */
1548      public int getNumBodyDecl() {
1549        return getBodyDeclList().getNumChild();
1550      }
1551      /**
1552       * Retrieves the number of children in the BodyDecl list.
1553       * Calling this method will not trigger rewrites.
1554       * @return Number of children in the BodyDecl list.
1555       * @apilevel low-level
1556       */
1557      public int getNumBodyDeclNoTransform() {
1558        return getBodyDeclListNoTransform().getNumChildNoTransform();
1559      }
1560      /**
1561       * Retrieves the element at index {@code i} in the BodyDecl list.
1562       * @param i Index of the element to return.
1563       * @return The element at position {@code i} in the BodyDecl list.
1564       * @apilevel high-level
1565       */
1566      public BodyDecl getBodyDecl(int i) {
1567        return (BodyDecl) getBodyDeclList().getChild(i);
1568      }
1569      /**
1570       * Check whether the BodyDecl list has any children.
1571       * @return {@code true} if it has at least one child, {@code false} otherwise.
1572       * @apilevel high-level
1573       */
1574      public boolean hasBodyDecl() {
1575        return getBodyDeclList().getNumChild() != 0;
1576      }
1577      /**
1578       * Append an element to the BodyDecl list.
1579       * @param node The element to append to the BodyDecl list.
1580       * @apilevel high-level
1581       */
1582      public void addBodyDecl(BodyDecl node) {
1583        List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
1584        list.addChild(node);
1585      }
1586      /**
1587       * @apilevel low-level
1588       */
1589      public void addBodyDeclNoTransform(BodyDecl node) {
1590        List<BodyDecl> list = getBodyDeclListNoTransform();
1591        list.addChild(node);
1592      }
1593      /**
1594       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
1595       * @param node The new node to replace the old list element.
1596       * @param i The list index of the node to be replaced.
1597       * @apilevel high-level
1598       */
1599      public void setBodyDecl(BodyDecl node, int i) {
1600        List<BodyDecl> list = getBodyDeclList();
1601        list.setChild(node, i);
1602      }
1603      /**
1604       * Retrieves the BodyDecl list.
1605       * @return The node representing the BodyDecl list.
1606       * @apilevel high-level
1607       */
1608      @ASTNodeAnnotation.ListChild(name="BodyDecl")
1609      public List<BodyDecl> getBodyDeclList() {
1610        List<BodyDecl> list = (List<BodyDecl>) getChild(1);
1611        return list;
1612      }
1613      /**
1614       * Retrieves the BodyDecl list.
1615       * <p><em>This method does not invoke AST transformations.</em></p>
1616       * @return The node representing the BodyDecl list.
1617       * @apilevel low-level
1618       */
1619      public List<BodyDecl> getBodyDeclListNoTransform() {
1620        return (List<BodyDecl>) getChildNoTransform(1);
1621      }
1622      /**
1623       * Retrieves the BodyDecl list.
1624       * @return The node representing the BodyDecl list.
1625       * @apilevel high-level
1626       */
1627      public List<BodyDecl> getBodyDecls() {
1628        return getBodyDeclList();
1629      }
1630      /**
1631       * Retrieves the BodyDecl list.
1632       * <p><em>This method does not invoke AST transformations.</em></p>
1633       * @return The node representing the BodyDecl list.
1634       * @apilevel low-level
1635       */
1636      public List<BodyDecl> getBodyDeclsNoTransform() {
1637        return getBodyDeclListNoTransform();
1638      }
1639      /**
1640       * @aspect Modifiers
1641       * @declaredat /home/jesper/git/extendj/java8/frontend/Modifiers.jrag:113
1642       */
1643       
1644      public void checkModifiers() {
1645        refined_Modifiers_TypeDecl_checkModifiers();
1646        if (getModifiers().numModifier("default") != 0) {
1647          error("the default modifier is only legal for interface method declarations");
1648        }
1649      }
1650      /**
1651       * @aspect AutoBoxingCodegen
1652       * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:339
1653       */
1654        void emitAssignConvTo(CodeGeneration gen, TypeDecl type) {
1655        if (!type.isIntegralType() || !isIntegralType() || type.isLong() || type.isReferenceType() || isReferenceType()) {
1656          emitCastTo(gen, type);
1657        }
1658      }
1659      /**
1660       * @aspect GenericsTypeCheck
1661       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:456
1662       */
1663        public void refined_GenericsTypeCheck_TypeDecl_typeCheck() {
1664        refined_TypeHierarchyCheck_TypeDecl_typeCheck();
1665        ArrayList<InterfaceDecl> interfaceList = new ArrayList<InterfaceDecl>();
1666        interfaceList.addAll(implementedInterfaces());
1667        for (InterfaceDecl decl: interfaceList) {
1668          if (decl instanceof ParInterfaceDecl) {
1669            ParInterfaceDecl p = (ParInterfaceDecl) decl;
1670            for (InterfaceDecl decl2: interfaceList) {
1671              if (decl2 instanceof ParInterfaceDecl) {
1672                ParInterfaceDecl q = (ParInterfaceDecl) decl2;
1673                if (p != q && p.genericDecl() == q.genericDecl() && !p.sameArgument(q)) {
1674                  errorf("%s cannot be inherited with different type arguments: %s and %s",
1675                      p.genericDecl().name(), p.typeName(), q.typeName());
1676                }
1677              }
1678            }
1679          }
1680        }
1681    
1682        // Check if a method has same signature as another in a supertype but does not override it.
1683        Map<String,SimpleSet> map = erasedAncestorMethodsMap();
1684        for (Iterator iter1 = localMethodsIterator(); iter1.hasNext(); ) {
1685          MethodDecl localMethod = (MethodDecl) iter1.next();
1686    
1687          String signature = localMethod.signature();
1688    
1689          SimpleSet set = map.get(signature);
1690          if (set != null) {
1691            for (Iterator i2 = set.iterator(); i2.hasNext(); ) {
1692              MethodDecl decl = (MethodDecl) i2.next();
1693              if (!decl.signature().equals(signature)) {
1694                localMethod.errorf("method %s in %s has the same erased signature as"
1695                    + " %s declared in %s but does not override it",
1696                    signature, typeName(), decl.signature(), decl.hostType().typeName());
1697              }
1698            }
1699          }
1700        }
1701      }
1702      /**
1703       * @aspect TypeCheck
1704       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:163
1705       */
1706        protected void refined_TypeCheck_TypeDecl_checkAbstractMethodDecls(MethodDecl m1, MethodDecl m2) {
1707    
1708        if (!m1.sameSignature(m2)) {
1709          errorf("method declarations %s and %s in interface %s are incompatible",
1710              m1.fullSignature(), m2.fullSignature(), fullName());
1711        } else {
1712          refined_TypeHierarchyCheck_TypeDecl_checkAbstractMethodDecls(m1, m2);
1713        }
1714      }
1715      /**
1716       * @aspect Java8TypeHierarchyCheck
1717       * @declaredat /home/jesper/git/extendj/java8/frontend/TypeHierarchyCheck.jrag:30
1718       */
1719       
1720      public void typeCheck() {
1721      // 8.4.6.4 & 9.4.1
1722        for (Iterator iter1 = localMethodsIterator(); iter1.hasNext(); ) {
1723          MethodDecl m = (MethodDecl)iter1.next();
1724          ASTNode target = m.hostType() == this ? (ASTNode)m : (ASTNode)this;
1725    
1726          for (Iterator i2 = ancestorMethods(m.signature()).iterator(); i2.hasNext(); ) {
1727            MethodDecl decl = (MethodDecl)i2.next();
1728            if (m.overrides(decl)) {
1729              // 8.4.6.1
1730              if (!decl.hostType().isInterfaceDecl() && !m.isStatic() && decl.isStatic()) {
1731                target.error("an instance method may not override a static method");
1732              }
1733    
1734              // regardless of overriding
1735              // 8.4.6.3
1736              if (!m.mayOverride(decl)) {
1737                // 9.4.3
1738                if (m.isDefault() && decl.hostType() == m.type().typeObject() && !decl.isPrivate()) {
1739                  target.error("default methods may not override methods in Object");
1740                } else {
1741                  target.errorf("the return type of method %s in %s does not match the return type of"
1742                      + " method %s in %s and may thus not be overridden",
1743                      m.fullSignature(), m.hostType().typeName(), decl.fullSignature(),
1744                      decl.hostType().typeName());
1745                }
1746              }
1747    
1748              // regardless of overriding
1749              // 8.4.4
1750              for (Access e: m.getExceptionList()) {
1751                if (e.type().isCheckedException()) {
1752                  boolean found = false;
1753                  for (Access declException: decl.getExceptionList()) {
1754                    if (e.type().instanceOf(declException.type())) {
1755                      found = true;
1756                      break;
1757                    }
1758                  }
1759                  if (!found) {
1760                    target.errorf("%s in %s may not throw more checked exceptions than"
1761                        + " overridden method %s in %s",
1762                        m.fullSignature(), m.hostType().typeName(), decl.fullSignature(),
1763                        decl.hostType().typeName());
1764                  }
1765                }
1766              }
1767    
1768              // 8.4.6.3
1769              if (decl.isPublic() && !m.isPublic()) {
1770                target.error("overriding access modifier error");
1771              }
1772              // 8.4.6.3
1773              if (decl.isProtected() && !(m.isPublic() || m.isProtected())) {
1774                target.error("overriding access modifier error");
1775              }
1776              // 8.4.6.3
1777              if ((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate()) {
1778                target.error("overriding access modifier error");
1779              }
1780              // regardless of overriding
1781              if (decl.isFinal()) {
1782                target.errorf("method %s in %s can not override final method %s in %s",
1783                    m.fullSignature(), hostType().typeName(), decl.fullSignature(),
1784                    decl.hostType().typeName());
1785              }
1786            }
1787            if (m.hides(decl)) {
1788              // 8.4.6.2
1789              if (m.isStatic() && !decl.isStatic()) {
1790                target.error("a static method may not hide an instance method");
1791              }
1792              // 8.4.6.3
1793              if (!m.mayOverride(decl)) {
1794                target.error("can not hide a method with a different return type");
1795              }
1796              // 8.4.4
1797              for (int i = 0; i < m.getNumException(); i++) {
1798                Access e = m.getException(i);
1799                boolean found = false;
1800                for (int j = 0; !found && j < decl.getNumException(); j++) {
1801                  if (e.type().instanceOf(decl.getException(j).type())) {
1802                    found = true;
1803                  }
1804                }
1805                if (!found) {
1806                  target.error("may not throw more checked exceptions than hidden method");
1807                }
1808              }
1809              // 8.4.6.3
1810              if (decl.isPublic() && !m.isPublic()) {
1811                target.errorf("hiding access modifier: public method %s in %s is hidden by"
1812                    + " non public method %s in %s",
1813                    decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(),
1814                    m.hostType().typeName());
1815              }
1816              // 8.4.6.3
1817              if (decl.isProtected() && !(m.isPublic() || m.isProtected())) {
1818                target.errorf("hiding access modifier: protected method %s in %s is hidden by"
1819                    + " non (public|protected) method %s in %s",
1820                    decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(),
1821                    m.hostType().typeName());
1822              }
1823              // 8.4.6.3
1824              if ((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate()) {
1825                target.errorf("hiding access modifier: default method %s in %s is hidden by"
1826                    + " private method %s in %s",
1827                    decl.fullSignature(), decl.hostType().typeName(), m.fullSignature(),
1828                    m.hostType().typeName());
1829              }
1830              if (decl.isFinal()) {
1831                target.errorf("method %s in %s can not hide final method %s in %s",
1832                    m.fullSignature(), hostType().typeName(), decl.fullSignature(),
1833                    decl.hostType().typeName());
1834              }
1835            }
1836          }
1837        }
1838    
1839    
1840        // different parameterizations of the same generic interface may not be implemented
1841        ArrayList list = new ArrayList();
1842        list.addAll(implementedInterfaces());
1843        for (int i = 0; i < list.size(); i++) {
1844          InterfaceDecl decl = (InterfaceDecl)list.get(i);
1845          if (decl instanceof ParInterfaceDecl) {
1846            ParInterfaceDecl p = (ParInterfaceDecl)decl;
1847            for (Iterator i2 = list.listIterator(i); i2.hasNext(); ) {
1848              InterfaceDecl decl2 = (InterfaceDecl)i2.next();
1849              if (decl2 instanceof ParInterfaceDecl) {
1850                ParInterfaceDecl q = (ParInterfaceDecl)decl2;
1851                if (p != q && p.genericDecl() == q.genericDecl() && !p.sameArgument(q)) {
1852                  errorf("%s cannot be inherited with different type arguments: %s and %s",
1853                      p.genericDecl().name(), p.typeName(), q.typeName());
1854                }
1855              }
1856            }
1857          }
1858        }
1859      }
1860      /**
1861       * @aspect Java8NameCheck
1862       * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:256
1863       */
1864       
1865      protected void checkAbstractMethodDecls(MethodDecl m1, MethodDecl m2) {
1866        if (!m1.subsignatureTo(m2) && !m2.subsignatureTo(m1)) {
1867          TypeDecl host1 = m1.hostType();
1868          TypeDecl host2 = m2.hostType();
1869          String inh1 = "";
1870          String inh2 = "";
1871          if (host1 != this) {
1872            inh1 = "inherited ";
1873          }
1874          if (host2 != this) {
1875            inh2 = "inherited ";
1876          }
1877    
1878          //8.4.8.3
1879          errorf("%smethod %s and %smethod %s are multiply declared with"
1880              + " the same erasure but not override-equivalent signatures in %s",
1881              inh1, m1.fullSignature(), inh2, m2.fullSignature(), fullName());
1882        }
1883        // DON'T FORGET TO CHECK THIS, REALLY OK TO CHECK BOTH WAYS???
1884        if (!m1.returnTypeSubstitutableFor(m2) && !m2.returnTypeSubstitutableFor(m1)) {
1885          String inh1 = "";
1886          TypeDecl host1 = m1.hostType();
1887          TypeDecl host2 = m2.hostType();
1888          if (host1 != this || host2 != this) {
1889            inh1 = "inherited ";
1890          }
1891    
1892          errorf("%smethod %s is multiply declared with incompatible return types in %s",
1893              m1.fullSignature(), fullName());
1894        }
1895      }
1896      /**
1897       * @aspect TypeConversion
1898       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:86
1899       */
1900      private boolean refined_TypeConversion_TypeDecl_assignConversionTo_TypeDecl_Expr(TypeDecl type, Expr expr)
1901    {
1902        //System.out.println("@@@ " + fullName() + " assign conversion to " + type.fullName() + ", expr: " + expr);
1903        boolean sourceIsConstant = expr != null ? expr.isConstant() : false;
1904        //System.out.println("@@@ sourceIsConstant: " + sourceIsConstant);
1905        if (identityConversionTo(type) || wideningConversionTo(type)) {
1906          return true;
1907        }
1908        //System.out.println("@@@ narrowing conversion needed");
1909        //System.out.println("@@@ value: " + expr.value());
1910        if (sourceIsConstant && (isInt() || isChar() || isShort() || isByte()) &&
1911            (type.isByte() || type.isShort() || type.isChar()) &&
1912            narrowingConversionTo(type) && expr.representableIn(type))
1913          return true;
1914        //System.out.println("@@@ false");
1915        return false;
1916      }
1917      /**
1918       * @aspect TypeConversion
1919       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:104
1920       */
1921      private boolean refined_TypeConversion_TypeDecl_methodInvocationConversionTo_TypeDecl(TypeDecl type)
1922    {
1923        return identityConversionTo(type) || wideningConversionTo(type);
1924      }
1925      /**
1926       * @aspect TypeConversion
1927       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:109
1928       */
1929      private boolean refined_TypeConversion_TypeDecl_castingConversionTo_TypeDecl(TypeDecl type)
1930    { return identityConversionTo(type) ||
1931        wideningConversionTo(type) || narrowingConversionTo(type); }
1932      /**
1933       * @aspect Attributes
1934       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:191
1935       */
1936      private Collection refined_Attributes_TypeDecl_attributes()
1937    {
1938        Collection c = new ArrayList();
1939        if (!innerClassesAttributeEntries().isEmpty()) {
1940          c.add(new InnerClassesAttribute(this));
1941        }
1942        if (isSynthetic()) {
1943          c.add(new SyntheticAttribute(constantPool()));
1944        }
1945        if (compilationUnit().fromSource()) {
1946          String relativeName = compilationUnit().relativeName();
1947          if (relativeName != null) {
1948            String splitToken = java.io.File.separator;
1949            if (splitToken.equals("\\")) {
1950              splitToken = "\\\\";
1951            }
1952            String[] strings = relativeName.split(splitToken);
1953            c.add(new SourceFileAttribute(constantPool(), strings[strings.length-1]));
1954          }
1955        }
1956        return c;
1957      }
1958      /**
1959       * @aspect AnnotationsCodegen
1960       * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:32
1961       */
1962      private Collection refined_AnnotationsCodegen_TypeDecl_attributes()
1963    {
1964        Collection c = refined_Attributes_TypeDecl_attributes();
1965        getModifiers().addRuntimeVisibleAnnotationsAttribute(c);
1966        getModifiers().addRuntimeInvisibleAnnotationsAttribute(c);
1967        return c;
1968      }
1969      /**
1970       * @aspect GenericsCodegen
1971       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:313
1972       */
1973      private Collection refined_GenericsCodegen_TypeDecl_attributes()
1974    {
1975        Collection c = refined_AnnotationsCodegen_TypeDecl_attributes();
1976        if (needsSignatureAttribute()) {
1977          c.add(new SignatureAttribute(constantPool(), classSignature()));
1978        }
1979        return c;
1980      }
1981      /**
1982       * @apilevel internal
1983       */
1984      protected java.util.Map accessibleFromPackage_String_values;
1985      /**
1986       * @apilevel internal
1987       */
1988      private void accessibleFromPackage_String_reset() {
1989        accessibleFromPackage_String_values = null;
1990      }
1991      /**
1992       * @attribute syn
1993       * @aspect AccessControl
1994       * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:36
1995       */
1996      @ASTNodeAnnotation.Attribute
1997      public boolean accessibleFromPackage(String packageName) {
1998        Object _parameters = packageName;
1999        if (accessibleFromPackage_String_values == null) accessibleFromPackage_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2000        ASTNode$State state = state();
2001        if (accessibleFromPackage_String_values.containsKey(_parameters)) {
2002          return (Boolean) accessibleFromPackage_String_values.get(_parameters);
2003        }
2004        boolean intermediate = state.INTERMEDIATE_VALUE;
2005        state.INTERMEDIATE_VALUE = false;
2006        int num = state.boundariesCrossed;
2007        boolean isFinal = this.is$Final();
2008        boolean accessibleFromPackage_String_value = !isPrivate() && (isPublic() || hostPackage().equals(packageName));
2009        if (isFinal && num == state().boundariesCrossed) {
2010          accessibleFromPackage_String_values.put(_parameters, accessibleFromPackage_String_value);
2011        } else {
2012        }
2013        state.INTERMEDIATE_VALUE |= intermediate;
2014    
2015        return accessibleFromPackage_String_value;
2016      }
2017      /**
2018       * @apilevel internal
2019       */
2020      protected java.util.Map accessibleFromExtend_TypeDecl_values;
2021      /**
2022       * @apilevel internal
2023       */
2024      private void accessibleFromExtend_TypeDecl_reset() {
2025        accessibleFromExtend_TypeDecl_values = null;
2026      }
2027      /**
2028       * @attribute syn
2029       * @aspect AccessControl
2030       * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:41
2031       */
2032      @ASTNodeAnnotation.Attribute
2033      public boolean accessibleFromExtend(TypeDecl type) {
2034        Object _parameters = type;
2035        if (accessibleFromExtend_TypeDecl_values == null) accessibleFromExtend_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2036        ASTNode$State state = state();
2037        if (accessibleFromExtend_TypeDecl_values.containsKey(_parameters)) {
2038          return (Boolean) accessibleFromExtend_TypeDecl_values.get(_parameters);
2039        }
2040        boolean intermediate = state.INTERMEDIATE_VALUE;
2041        state.INTERMEDIATE_VALUE = false;
2042        int num = state.boundariesCrossed;
2043        boolean isFinal = this.is$Final();
2044        boolean accessibleFromExtend_TypeDecl_value = accessibleFromExtend_compute(type);
2045        if (isFinal && num == state().boundariesCrossed) {
2046          accessibleFromExtend_TypeDecl_values.put(_parameters, accessibleFromExtend_TypeDecl_value);
2047        } else {
2048        }
2049        state.INTERMEDIATE_VALUE |= intermediate;
2050    
2051        return accessibleFromExtend_TypeDecl_value;
2052      }
2053      /**
2054       * @apilevel internal
2055       */
2056      private boolean accessibleFromExtend_compute(TypeDecl type) {
2057          if (type == this) {
2058            return true;
2059          }
2060          if (isInnerType()) {
2061            if (!enclosingType().accessibleFrom(type)) {
2062              return false;
2063            }
2064          }
2065          if (isPublic()) {
2066            return true;
2067          } else if (isProtected()) {
2068            // isProtected implies a nested type
2069            if (hostPackage().equals(type.hostPackage())) {
2070              return true;
2071            }
2072            if (type.isNestedType() && type.enclosingType().withinBodyThatSubclasses(enclosingType()) != null) {
2073              return true;
2074            }
2075            return false;
2076          } else if (isPrivate()) {
2077            return topLevelType() == type.topLevelType();
2078          } else {
2079            return hostPackage().equals(type.hostPackage());
2080          }
2081        }
2082      /**
2083       * @apilevel internal
2084       */
2085      protected java.util.Map accessibleFrom_TypeDecl_values;
2086      /**
2087       * @apilevel internal
2088       */
2089      private void accessibleFrom_TypeDecl_reset() {
2090        accessibleFrom_TypeDecl_values = null;
2091      }
2092      /**
2093       * @attribute syn
2094       * @aspect AccessControl
2095       * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:68
2096       */
2097      @ASTNodeAnnotation.Attribute
2098      public boolean accessibleFrom(TypeDecl type) {
2099        Object _parameters = type;
2100        if (accessibleFrom_TypeDecl_values == null) accessibleFrom_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2101        ASTNode$State state = state();
2102        if (accessibleFrom_TypeDecl_values.containsKey(_parameters)) {
2103          return (Boolean) accessibleFrom_TypeDecl_values.get(_parameters);
2104        }
2105        boolean intermediate = state.INTERMEDIATE_VALUE;
2106        state.INTERMEDIATE_VALUE = false;
2107        int num = state.boundariesCrossed;
2108        boolean isFinal = this.is$Final();
2109        boolean accessibleFrom_TypeDecl_value = accessibleFrom_compute(type);
2110        if (isFinal && num == state().boundariesCrossed) {
2111          accessibleFrom_TypeDecl_values.put(_parameters, accessibleFrom_TypeDecl_value);
2112        } else {
2113        }
2114        state.INTERMEDIATE_VALUE |= intermediate;
2115    
2116        return accessibleFrom_TypeDecl_value;
2117      }
2118      /**
2119       * @apilevel internal
2120       */
2121      private boolean accessibleFrom_compute(TypeDecl type) {
2122          if (type == this) {
2123            return true;
2124          }
2125          if (isInnerType()) {
2126            if (!enclosingType().accessibleFrom(type)) {
2127              return false;
2128            }
2129          }
2130          if (isPublic()) {
2131            return true;
2132          } else if (isProtected()) {
2133            if (hostPackage().equals(type.hostPackage())) {
2134              return true;
2135            }
2136            if (isMemberType()) {
2137              TypeDecl typeDecl = type;
2138              while (typeDecl != null && !typeDecl.instanceOf(enclosingType())) {
2139                typeDecl = typeDecl.enclosingType();
2140              }
2141              if (typeDecl != null) {
2142                return true;
2143              }
2144            }
2145            return false;
2146          } else if (isPrivate()) {
2147            return topLevelType() == type.topLevelType();
2148          } else {
2149            return hostPackage().equals(type.hostPackage());
2150          }
2151        }
2152      /**
2153       * @apilevel internal
2154       */
2155      protected boolean dimension_computed = false;
2156      /**
2157       * @apilevel internal
2158       */
2159      protected int dimension_value;
2160      /**
2161       * @apilevel internal
2162       */
2163      private void dimension_reset() {
2164        dimension_computed = false;
2165      }
2166      /**
2167       * @attribute syn
2168       * @aspect Arrays
2169       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:32
2170       */
2171      @ASTNodeAnnotation.Attribute
2172      public int dimension() {
2173        ASTNode$State state = state();
2174        if (dimension_computed) {
2175          return dimension_value;
2176        }
2177        boolean intermediate = state.INTERMEDIATE_VALUE;
2178        state.INTERMEDIATE_VALUE = false;
2179        int num = state.boundariesCrossed;
2180        boolean isFinal = this.is$Final();
2181        dimension_value = 0;
2182        if (isFinal && num == state().boundariesCrossed) {
2183          dimension_computed = true;
2184        } else {
2185        }
2186        state.INTERMEDIATE_VALUE |= intermediate;
2187    
2188        return dimension_value;
2189      }
2190      /**
2191       * @apilevel internal
2192       */
2193      protected boolean elementType_computed = false;
2194      /**
2195       * @apilevel internal
2196       */
2197      protected TypeDecl elementType_value;
2198      /**
2199       * @apilevel internal
2200       */
2201      private void elementType_reset() {
2202        elementType_computed = false;
2203        elementType_value = null;
2204      }
2205      /**
2206       * @attribute syn
2207       * @aspect Arrays
2208       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:36
2209       */
2210      @ASTNodeAnnotation.Attribute
2211      public TypeDecl elementType() {
2212        ASTNode$State state = state();
2213        if (elementType_computed) {
2214          return elementType_value;
2215        }
2216        boolean intermediate = state.INTERMEDIATE_VALUE;
2217        state.INTERMEDIATE_VALUE = false;
2218        int num = state.boundariesCrossed;
2219        boolean isFinal = this.is$Final();
2220        elementType_value = this;
2221        if (isFinal && num == state().boundariesCrossed) {
2222          elementType_computed = true;
2223        } else {
2224        }
2225        state.INTERMEDIATE_VALUE |= intermediate;
2226    
2227        return elementType_value;
2228      }
2229      /**
2230       * @apilevel internal
2231       */
2232      protected boolean arrayType_computed = false;
2233      /**
2234       * @apilevel internal
2235       */
2236      protected TypeDecl arrayType_value;
2237      /**
2238       * @apilevel internal
2239       */
2240      private void arrayType_reset() {
2241        arrayType_computed = false;
2242        arrayType_value = null;
2243      }
2244      /**
2245       * @attribute syn
2246       * @aspect Arrays
2247       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:44
2248       */
2249      @ASTNodeAnnotation.Attribute
2250      public TypeDecl arrayType() {
2251        ASTNode$State state = state();
2252        if (arrayType_computed) {
2253          return arrayType_value;
2254        }
2255        boolean intermediate = state.INTERMEDIATE_VALUE;
2256        state.INTERMEDIATE_VALUE = false;
2257        int num = state.boundariesCrossed;
2258        boolean isFinal = this.is$Final();
2259        arrayType_value = arrayType_compute();
2260        arrayType_value.setParent(this);
2261        arrayType_value.is$Final = true;
2262        if (true) {
2263          arrayType_computed = true;
2264        } else {
2265        }
2266        state.INTERMEDIATE_VALUE |= intermediate;
2267    
2268        return arrayType_value;
2269      }
2270      /**
2271       * @apilevel internal
2272       */
2273      private TypeDecl arrayType_compute() {
2274          String name = name() + "[]";
2275      
2276          List body = new List();
2277          body.add(
2278            new FieldDeclaration(
2279              new Modifiers(new List().add(new Modifier("public")).add(new Modifier("final"))),
2280              new PrimitiveTypeAccess("int"),
2281              "length",
2282              new Opt() // [Init:Expr]
2283            )
2284          );
2285          MethodDecl clone = null;
2286          TypeDecl typeObject = typeObject();
2287          for (int i = 0; clone == null && i < typeObject.getNumBodyDecl(); i++) {
2288            if (typeObject.getBodyDecl(i) instanceof MethodDecl) {
2289              MethodDecl m = (MethodDecl) typeObject.getBodyDecl(i);
2290              if (m.name().equals("clone")) {
2291                clone = m;
2292              }
2293            }
2294          }
2295          if (clone != null) {
2296            body.add(
2297                // we create a substituted method that substitutes the clone method in object
2298                // this has the following two consequences: the return value will be cast to the
2299                // expected return type rather than object, and the invoked method will be the
2300                // method in object rather in the array
2301                new MethodDeclSubstituted(
2302                  new Modifiers(new List().add(new Modifier("public"))),
2303                  new ArrayTypeAccess(createQualifiedAccess()),
2304                  "clone",
2305                  new List(),
2306                  new List(),
2307                  new Opt(new Block()),
2308                  (MethodDecl) typeObject().memberMethods("clone").iterator().next()
2309                )
2310            );
2311          }
2312          TypeDecl typeDecl = new ArrayDecl(
2313              new Modifiers(new List().add(new Modifier("public"))),
2314              name,
2315              new Opt(typeObject().createQualifiedAccess()), // [SuperClass]
2316              new List().add(typeCloneable().createQualifiedAccess()).add(typeSerializable().createQualifiedAccess()), // Implements*
2317              body // BodyDecl*
2318            );
2319          return typeDecl;
2320        }
2321      /**
2322       * @attribute syn
2323       * @aspect ConstantExpression
2324       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:72
2325       */
2326      @ASTNodeAnnotation.Attribute
2327      public Constant cast(Constant c) {
2328        {
2329            throw new UnsupportedOperationException("ConstantExpression operation cast"
2330                + " not supported for type " + getClass().getName());
2331          }
2332      }
2333      /**
2334       * @attribute syn
2335       * @aspect ConstantExpression
2336       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:86
2337       */
2338      @ASTNodeAnnotation.Attribute
2339      public Constant plus(Constant c) {
2340        {
2341            throw new UnsupportedOperationException("ConstantExpression operation plus"
2342                + " not supported for type " + getClass().getName());
2343          }
2344      }
2345      /**
2346       * @attribute syn
2347       * @aspect ConstantExpression
2348       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:95
2349       */
2350      @ASTNodeAnnotation.Attribute
2351      public Constant minus(Constant c) {
2352        {
2353            throw new UnsupportedOperationException("ConstantExpression operation minus"
2354                + " not supported for type " + getClass().getName());
2355          }
2356      }
2357      /**
2358       * @attribute syn
2359       * @aspect ConstantExpression
2360       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:104
2361       */
2362      @ASTNodeAnnotation.Attribute
2363      public Constant bitNot(Constant c) {
2364        {
2365            throw new UnsupportedOperationException("ConstantExpression operation bitNot"
2366                + " not supported for type " + getClass().getName());
2367          }
2368      }
2369      /**
2370       * @attribute syn
2371       * @aspect ConstantExpression
2372       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:111
2373       */
2374      @ASTNodeAnnotation.Attribute
2375      public Constant mul(Constant c1, Constant c2) {
2376        {
2377            throw new UnsupportedOperationException("ConstantExpression operation mul"
2378                + " not supported for type " + getClass().getName());
2379          }
2380      }
2381      /**
2382       * @attribute syn
2383       * @aspect ConstantExpression
2384       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:120
2385       */
2386      @ASTNodeAnnotation.Attribute
2387      public Constant div(Constant c1, Constant c2) {
2388        {
2389            throw new UnsupportedOperationException("ConstantExpression operation div"
2390                + " not supported for type " + getClass().getName());
2391          }
2392      }
2393      /**
2394       * @attribute syn
2395       * @aspect ConstantExpression
2396       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:129
2397       */
2398      @ASTNodeAnnotation.Attribute
2399      public Constant mod(Constant c1, Constant c2) {
2400        {
2401            throw new UnsupportedOperationException("ConstantExpression operation mod"
2402                + " not supported for type " + getClass().getName());
2403          }
2404      }
2405      /**
2406       * @attribute syn
2407       * @aspect ConstantExpression
2408       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:138
2409       */
2410      @ASTNodeAnnotation.Attribute
2411      public Constant add(Constant c1, Constant c2) {
2412        {
2413            throw new UnsupportedOperationException("ConstantExpression operation add"
2414                + " not supported for type " + getClass().getName());
2415          }
2416      }
2417      /**
2418       * @attribute syn
2419       * @aspect ConstantExpression
2420       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:148
2421       */
2422      @ASTNodeAnnotation.Attribute
2423      public Constant sub(Constant c1, Constant c2) {
2424        {
2425            throw new UnsupportedOperationException("ConstantExpression operation sub"
2426                + " not supported for type " + getClass().getName());
2427          }
2428      }
2429      /**
2430       * @attribute syn
2431       * @aspect ConstantExpression
2432       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:157
2433       */
2434      @ASTNodeAnnotation.Attribute
2435      public Constant lshift(Constant c1, Constant c2) {
2436        {
2437            throw new UnsupportedOperationException("ConstantExpression operation lshift"
2438                + " not supported for type " + getClass().getName());
2439          }
2440      }
2441      /**
2442       * @attribute syn
2443       * @aspect ConstantExpression
2444       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:164
2445       */
2446      @ASTNodeAnnotation.Attribute
2447      public Constant rshift(Constant c1, Constant c2) {
2448        {
2449            throw new UnsupportedOperationException("ConstantExpression operation rshift"
2450                + " not supported for type " + getClass().getName());
2451          }
2452      }
2453      /**
2454       * @attribute syn
2455       * @aspect ConstantExpression
2456       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:171
2457       */
2458      @ASTNodeAnnotation.Attribute
2459      public Constant urshift(Constant c1, Constant c2) {
2460        {
2461            throw new UnsupportedOperationException("ConstantExpression operation urshift"
2462                + " not supported for type " + getClass().getName());
2463          }
2464      }
2465      /**
2466       * @attribute syn
2467       * @aspect ConstantExpression
2468       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:178
2469       */
2470      @ASTNodeAnnotation.Attribute
2471      public Constant andBitwise(Constant c1, Constant c2) {
2472        {
2473            throw new UnsupportedOperationException("ConstantExpression operation andBitwise"
2474                + " not supported for type " + getClass().getName());
2475          }
2476      }
2477      /**
2478       * @attribute syn
2479       * @aspect ConstantExpression
2480       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:186
2481       */
2482      @ASTNodeAnnotation.Attribute
2483      public Constant xorBitwise(Constant c1, Constant c2) {
2484        {
2485            throw new UnsupportedOperationException("ConstantExpression operation xorBitwise"
2486                + " not supported for type " + getClass().getName());
2487          }
2488      }
2489      /**
2490       * @attribute syn
2491       * @aspect ConstantExpression
2492       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:194
2493       */
2494      @ASTNodeAnnotation.Attribute
2495      public Constant orBitwise(Constant c1, Constant c2) {
2496        {
2497            throw new UnsupportedOperationException("ConstantExpression operation orBitwise"
2498                + " not supported for type " + getClass().getName());
2499          }
2500      }
2501      /**
2502       * @attribute syn
2503       * @aspect ConstantExpression
2504       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:202
2505       */
2506      @ASTNodeAnnotation.Attribute
2507      public Constant questionColon(Constant cond, Constant c1, Constant c2) {
2508        {
2509            throw new UnsupportedOperationException("ConstantExpression operation questionColon"
2510                + " not supported for type " + getClass().getName());
2511          }
2512      }
2513      /**
2514       * @attribute syn
2515       * @aspect ConstantExpression
2516       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:326
2517       */
2518      @ASTNodeAnnotation.Attribute
2519      public boolean eqIsTrue(Expr left, Expr right) {
2520        {
2521            System.err.println("Evaluation eqIsTrue for unknown type: " + getClass().getName());
2522            return false;
2523          }
2524      }
2525      /**
2526       * @attribute syn
2527       * @aspect ConstantExpression
2528       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:337
2529       */
2530      @ASTNodeAnnotation.Attribute
2531      public boolean ltIsTrue(Expr left, Expr right) {
2532        boolean ltIsTrue_Expr_Expr_value = false;
2533    
2534        return ltIsTrue_Expr_Expr_value;
2535      }
2536      /**
2537       * @attribute syn
2538       * @aspect ConstantExpression
2539       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:343
2540       */
2541      @ASTNodeAnnotation.Attribute
2542      public boolean leIsTrue(Expr left, Expr right) {
2543        boolean leIsTrue_Expr_Expr_value = false;
2544    
2545        return leIsTrue_Expr_Expr_value;
2546      }
2547      /**
2548       * @attribute syn
2549       * @aspect DataStructures
2550       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:157
2551       */
2552      @ASTNodeAnnotation.Attribute
2553      public int size() {
2554        int size_value = 1;
2555    
2556        return size_value;
2557      }
2558      /**
2559       * @attribute syn
2560       * @aspect DataStructures
2561       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:158
2562       */
2563      @ASTNodeAnnotation.Attribute
2564      public boolean isEmpty() {
2565        boolean isEmpty_value = false;
2566    
2567        return isEmpty_value;
2568      }
2569      /**
2570       * @attribute syn
2571       * @aspect DataStructures
2572       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:162
2573       */
2574      @ASTNodeAnnotation.Attribute
2575      public boolean contains(Object o) {
2576        boolean contains_Object_value = this == o;
2577    
2578        return contains_Object_value;
2579      }
2580      /**
2581       * @attribute syn
2582       * @aspect DocumentationComments
2583       * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:39
2584       */
2585      @ASTNodeAnnotation.Attribute
2586      public String docComment() {
2587        String docComment_value = docComment;
2588    
2589        return docComment_value;
2590      }
2591      /**
2592       * @attribute syn
2593       * @aspect DocumentationComments
2594       * @declaredat /home/jesper/git/extendj/java4/frontend/DocumentationComments.jadd:43
2595       */
2596      @ASTNodeAnnotation.Attribute
2597      public boolean hasDocComment() {
2598        boolean hasDocComment_value = !docComment.isEmpty();
2599    
2600        return hasDocComment_value;
2601      }
2602      /**
2603       * @apilevel internal
2604       */
2605      protected boolean isException_computed = false;
2606      /**
2607       * @apilevel internal
2608       */
2609      protected boolean isException_value;
2610      /**
2611       * @apilevel internal
2612       */
2613      private void isException_reset() {
2614        isException_computed = false;
2615      }
2616      /**
2617       * @attribute syn
2618       * @aspect ExceptionHandling
2619       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:51
2620       */
2621      @ASTNodeAnnotation.Attribute
2622      public boolean isException() {
2623        ASTNode$State state = state();
2624        if (isException_computed) {
2625          return isException_value;
2626        }
2627        boolean intermediate = state.INTERMEDIATE_VALUE;
2628        state.INTERMEDIATE_VALUE = false;
2629        int num = state.boundariesCrossed;
2630        boolean isFinal = this.is$Final();
2631        isException_value = instanceOf(typeException());
2632        if (isFinal && num == state().boundariesCrossed) {
2633          isException_computed = true;
2634        } else {
2635        }
2636        state.INTERMEDIATE_VALUE |= intermediate;
2637    
2638        return isException_value;
2639      }
2640      /**
2641       * @apilevel internal
2642       */
2643      protected boolean isCheckedException_computed = false;
2644      /**
2645       * @apilevel internal
2646       */
2647      protected boolean isCheckedException_value;
2648      /**
2649       * @apilevel internal
2650       */
2651      private void isCheckedException_reset() {
2652        isCheckedException_computed = false;
2653      }
2654      /**
2655       * Checked exceptions must be declared thrown or caught in
2656       * an enclosing try-statement.
2657       * 
2658       * Note that this attribute is the opposite of isUncheckedException, i.e.
2659       * the type is not tested for being a subclass of java.lang.Exception.
2660       * 
2661       * @return {@code true} if this type is not a subtype of java.lang.RuntimException
2662       * or java.lang.Error
2663       * @attribute syn
2664       * @aspect ExceptionHandling
2665       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:63
2666       */
2667      @ASTNodeAnnotation.Attribute
2668      public boolean isCheckedException() {
2669        ASTNode$State state = state();
2670        if (isCheckedException_computed) {
2671          return isCheckedException_value;
2672        }
2673        boolean intermediate = state.INTERMEDIATE_VALUE;
2674        state.INTERMEDIATE_VALUE = false;
2675        int num = state.boundariesCrossed;
2676        boolean isFinal = this.is$Final();
2677        isCheckedException_value = !(instanceOf(typeRuntimeException()) || instanceOf(typeError()));
2678        if (isFinal && num == state().boundariesCrossed) {
2679          isCheckedException_computed = true;
2680        } else {
2681        }
2682        state.INTERMEDIATE_VALUE |= intermediate;
2683    
2684        return isCheckedException_value;
2685      }
2686      /**
2687       * @apilevel internal
2688       */
2689      protected boolean isUncheckedException_computed = false;
2690      /**
2691       * @apilevel internal
2692       */
2693      protected boolean isUncheckedException_value;
2694      /**
2695       * @apilevel internal
2696       */
2697      private void isUncheckedException_reset() {
2698        isUncheckedException_computed = false;
2699      }
2700      /**
2701       * Unchecked exceptions need not be declared thrown or caught in
2702       * an enclosing try-statement.
2703       * 
2704       * @return {@code true} if this type is a subtype of java.lang.RuntimException
2705       * or java.lang.Error
2706       * @attribute syn
2707       * @aspect ExceptionHandling
2708       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:73
2709       */
2710      @ASTNodeAnnotation.Attribute
2711      public boolean isUncheckedException() {
2712        ASTNode$State state = state();
2713        if (isUncheckedException_computed) {
2714          return isUncheckedException_value;
2715        }
2716        boolean intermediate = state.INTERMEDIATE_VALUE;
2717        state.INTERMEDIATE_VALUE = false;
2718        int num = state.boundariesCrossed;
2719        boolean isFinal = this.is$Final();
2720        isUncheckedException_value = instanceOf(typeRuntimeException()) || instanceOf(typeError());
2721        if (isFinal && num == state().boundariesCrossed) {
2722          isUncheckedException_computed = true;
2723        } else {
2724        }
2725        state.INTERMEDIATE_VALUE |= intermediate;
2726    
2727        return isUncheckedException_value;
2728      }
2729      /**
2730       * @apilevel internal
2731       */
2732      protected java.util.Map mayCatch_TypeDecl_values;
2733      /**
2734       * @apilevel internal
2735       */
2736      private void mayCatch_TypeDecl_reset() {
2737        mayCatch_TypeDecl_values = null;
2738      }
2739      /**
2740       * @attribute syn
2741       * @aspect ExceptionHandling
2742       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:305
2743       */
2744      @ASTNodeAnnotation.Attribute
2745      public boolean mayCatch(TypeDecl thrownType) {
2746        Object _parameters = thrownType;
2747        if (mayCatch_TypeDecl_values == null) mayCatch_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2748        ASTNode$State state = state();
2749        if (mayCatch_TypeDecl_values.containsKey(_parameters)) {
2750          return (Boolean) mayCatch_TypeDecl_values.get(_parameters);
2751        }
2752        boolean intermediate = state.INTERMEDIATE_VALUE;
2753        state.INTERMEDIATE_VALUE = false;
2754        int num = state.boundariesCrossed;
2755        boolean isFinal = this.is$Final();
2756        boolean mayCatch_TypeDecl_value = thrownType.instanceOf(this) || this.instanceOf(thrownType);
2757        if (isFinal && num == state().boundariesCrossed) {
2758          mayCatch_TypeDecl_values.put(_parameters, mayCatch_TypeDecl_value);
2759        } else {
2760        }
2761        state.INTERMEDIATE_VALUE |= intermediate;
2762    
2763        return mayCatch_TypeDecl_value;
2764      }
2765      /**
2766       * @attribute syn
2767       * @aspect ConstructScope
2768       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:42
2769       */
2770      @ASTNodeAnnotation.Attribute
2771      public Collection lookupSuperConstructor() {
2772        Collection lookupSuperConstructor_value = Collections.EMPTY_LIST;
2773    
2774        return lookupSuperConstructor_value;
2775      }
2776      /**
2777       * @apilevel internal
2778       */
2779      protected boolean constructors_computed = false;
2780      /**
2781       * @apilevel internal
2782       */
2783      protected Collection<ConstructorDecl> constructors_value;
2784      /**
2785       * @apilevel internal
2786       */
2787      private void constructors_reset() {
2788        constructors_computed = false;
2789        constructors_value = null;
2790      }
2791      /**
2792       * @attribute syn
2793       * @aspect ConstructorLookup
2794       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:127
2795       */
2796      @ASTNodeAnnotation.Attribute
2797      public Collection<ConstructorDecl> constructors() {
2798        ASTNode$State state = state();
2799        if (constructors_computed) {
2800          return constructors_value;
2801        }
2802        boolean intermediate = state.INTERMEDIATE_VALUE;
2803        state.INTERMEDIATE_VALUE = false;
2804        int num = state.boundariesCrossed;
2805        boolean isFinal = this.is$Final();
2806        constructors_value = constructors_compute();
2807        if (isFinal && num == state().boundariesCrossed) {
2808          constructors_computed = true;
2809        } else {
2810        }
2811        state.INTERMEDIATE_VALUE |= intermediate;
2812    
2813        return constructors_value;
2814      }
2815      /**
2816       * @apilevel internal
2817       */
2818      private Collection<ConstructorDecl> constructors_compute() {
2819          Collection<ConstructorDecl> c = new ArrayList();
2820          for (int i = 0; i < getNumBodyDecl(); i++) {
2821            if (getBodyDecl(i) instanceof ConstructorDecl) {
2822              c.add((ConstructorDecl) getBodyDecl(i));
2823            }
2824          }
2825          return c;
2826        }
2827      /**
2828       * @apilevel internal
2829       */
2830      protected java.util.Map unqualifiedLookupMethod_String_values;
2831      /**
2832       * @apilevel internal
2833       */
2834      private void unqualifiedLookupMethod_String_reset() {
2835        unqualifiedLookupMethod_String_values = null;
2836      }
2837      /**
2838       * @attribute syn
2839       * @aspect LookupMethod
2840       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:58
2841       */
2842      @ASTNodeAnnotation.Attribute
2843      public Collection unqualifiedLookupMethod(String name) {
2844        Object _parameters = name;
2845        if (unqualifiedLookupMethod_String_values == null) unqualifiedLookupMethod_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2846        ASTNode$State state = state();
2847        if (unqualifiedLookupMethod_String_values.containsKey(_parameters)) {
2848          return (Collection) unqualifiedLookupMethod_String_values.get(_parameters);
2849        }
2850        boolean intermediate = state.INTERMEDIATE_VALUE;
2851        state.INTERMEDIATE_VALUE = false;
2852        int num = state.boundariesCrossed;
2853        boolean isFinal = this.is$Final();
2854        Collection unqualifiedLookupMethod_String_value = unqualifiedLookupMethod_compute(name);
2855        if (isFinal && num == state().boundariesCrossed) {
2856          unqualifiedLookupMethod_String_values.put(_parameters, unqualifiedLookupMethod_String_value);
2857        } else {
2858        }
2859        state.INTERMEDIATE_VALUE |= intermediate;
2860    
2861        return unqualifiedLookupMethod_String_value;
2862      }
2863      /**
2864       * @apilevel internal
2865       */
2866      private Collection unqualifiedLookupMethod_compute(String name) {
2867          Collection c = memberMethods(name);
2868          if (!c.isEmpty()) {
2869            return c;
2870          }
2871          if (isInnerType()) {
2872            return lookupMethod(name);
2873          }
2874          return removeInstanceMethods(lookupMethod(name));
2875        }
2876      /**
2877       * @attribute syn
2878       * @aspect MemberMethods
2879       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:317
2880       */
2881      @ASTNodeAnnotation.Attribute
2882      public Collection<MethodDecl> memberMethods(String name) {
2883        {
2884            Collection<MethodDecl> c = methodsNameMap().get(name);
2885            if (c != null) {
2886              return c;
2887            } else {
2888              return Collections.emptyList();
2889            }
2890          }
2891      }
2892      /**
2893       * @apilevel internal
2894       */
2895      protected boolean methodsNameMap_computed = false;
2896      /**
2897       * @apilevel internal
2898       */
2899      protected Map<String,Collection<MethodDecl>> methodsNameMap_value;
2900      /**
2901       * @apilevel internal
2902       */
2903      private void methodsNameMap_reset() {
2904        methodsNameMap_computed = false;
2905        methodsNameMap_value = null;
2906      }
2907      /**
2908       * @return map from method name to method declarations
2909       * @attribute syn
2910       * @aspect MemberMethods
2911       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:328
2912       */
2913      @ASTNodeAnnotation.Attribute
2914      public Map<String,Collection<MethodDecl>> methodsNameMap() {
2915        ASTNode$State state = state();
2916        if (methodsNameMap_computed) {
2917          return methodsNameMap_value;
2918        }
2919        boolean intermediate = state.INTERMEDIATE_VALUE;
2920        state.INTERMEDIATE_VALUE = false;
2921        int num = state.boundariesCrossed;
2922        boolean isFinal = this.is$Final();
2923        methodsNameMap_value = methodsNameMap_compute();
2924        if (isFinal && num == state().boundariesCrossed) {
2925          methodsNameMap_computed = true;
2926        } else {
2927        }
2928        state.INTERMEDIATE_VALUE |= intermediate;
2929    
2930        return methodsNameMap_value;
2931      }
2932      /**
2933       * @apilevel internal
2934       */
2935      private Map<String,Collection<MethodDecl>> methodsNameMap_compute() {
2936          Map<String,Collection<MethodDecl>> map = new HashMap<String,Collection<MethodDecl>>();
2937          for (Iterator<MethodDecl> iter = methodsIterator(); iter.hasNext(); ) {
2938            MethodDecl m = iter.next();
2939            Collection<MethodDecl> methods = map.get(m.name());
2940            if (methods == null) {
2941              methods = new ArrayList<MethodDecl>(4);
2942              map.put(m.name(), methods);
2943            }
2944            methods.add(m);
2945          }
2946          return map;
2947        }
2948      /**
2949       * @attribute syn
2950       * @aspect MemberMethods
2951       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:363
2952       */
2953      @ASTNodeAnnotation.Attribute
2954      public SimpleSet localMethodsSignature(String signature) {
2955        {
2956            SimpleSet set = localMethodsSignatureMap().get(signature);
2957            if (set != null) {
2958              return set;
2959            }
2960            return SimpleSet.emptySet;
2961          }
2962      }
2963      /**
2964       * @apilevel internal
2965       */
2966      protected boolean localMethodsSignatureMap_computed = false;
2967      /**
2968       * @apilevel internal
2969       */
2970      protected Map<String,SimpleSet> localMethodsSignatureMap_value;
2971      /**
2972       * @apilevel internal
2973       */
2974      private void localMethodsSignatureMap_reset() {
2975        localMethodsSignatureMap_computed = false;
2976        localMethodsSignatureMap_value = null;
2977      }
2978      /**
2979       * @return a mapping of method signature to method declaration
2980       * @attribute syn
2981       * @aspect MemberMethods
2982       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:374
2983       */
2984      @ASTNodeAnnotation.Attribute
2985      public Map<String,SimpleSet> localMethodsSignatureMap() {
2986        ASTNode$State state = state();
2987        if (localMethodsSignatureMap_computed) {
2988          return localMethodsSignatureMap_value;
2989        }
2990        boolean intermediate = state.INTERMEDIATE_VALUE;
2991        state.INTERMEDIATE_VALUE = false;
2992        int num = state.boundariesCrossed;
2993        boolean isFinal = this.is$Final();
2994        localMethodsSignatureMap_value = localMethodsSignatureMap_compute();
2995        if (isFinal && num == state().boundariesCrossed) {
2996          localMethodsSignatureMap_computed = true;
2997        } else {
2998        }
2999        state.INTERMEDIATE_VALUE |= intermediate;
3000    
3001        return localMethodsSignatureMap_value;
3002      }
3003      /**
3004       * @apilevel internal
3005       */
3006      private Map<String,SimpleSet> localMethodsSignatureMap_compute() {
3007          Map<String,SimpleSet> map = new HashMap<String,SimpleSet>(getNumBodyDecl());
3008          for (int i = 0; i < getNumBodyDecl(); i++) {
3009            if (getBodyDecl(i) instanceof MethodDecl) {
3010              MethodDecl decl = (MethodDecl) getBodyDecl(i);
3011              putSimpleSetElement(map, decl.signature(), decl);
3012            }
3013          }
3014          return map;
3015        }
3016      /**
3017       * @apilevel internal
3018       */
3019      protected boolean interfacesMethodsSignatureMap_computed = false;
3020      /**
3021       * @apilevel internal
3022       */
3023      protected Map<String,SimpleSet> interfacesMethodsSignatureMap_value;
3024      /**
3025       * @apilevel internal
3026       */
3027      private void interfacesMethodsSignatureMap_reset() {
3028        interfacesMethodsSignatureMap_computed = false;
3029        interfacesMethodsSignatureMap_value = null;
3030      }
3031      /**
3032       * Map signature to set of method declarations.
3033       * @attribute syn
3034       * @aspect MemberMethods
3035       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:418
3036       */
3037      @ASTNodeAnnotation.Attribute
3038      public Map<String,SimpleSet> interfacesMethodsSignatureMap() {
3039        ASTNode$State state = state();
3040        if (interfacesMethodsSignatureMap_computed) {
3041          return interfacesMethodsSignatureMap_value;
3042        }
3043        boolean intermediate = state.INTERMEDIATE_VALUE;
3044        state.INTERMEDIATE_VALUE = false;
3045        int num = state.boundariesCrossed;
3046        boolean isFinal = this.is$Final();
3047        interfacesMethodsSignatureMap_value = interfacesMethodsSignatureMap_compute();
3048        if (isFinal && num == state().boundariesCrossed) {
3049          interfacesMethodsSignatureMap_computed = true;
3050        } else {
3051        }
3052        state.INTERMEDIATE_VALUE |= intermediate;
3053    
3054        return interfacesMethodsSignatureMap_value;
3055      }
3056      /**
3057       * @apilevel internal
3058       */
3059      private Map<String,SimpleSet> interfacesMethodsSignatureMap_compute() {
3060          Map<String,SimpleSet> map = new HashMap<String,SimpleSet>();
3061          for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) {
3062            InterfaceDecl iface = (InterfaceDecl) iter.next();
3063            for (Iterator<MethodDecl> i2 = iface.localMethodsIterator(); i2.hasNext(); ) {
3064              MethodDecl m = i2.next();
3065              putSimpleSetElement(map, m.signature(), m);
3066            }
3067            for (SimpleSet set: iface.interfacesMethodsSignatureMap().values()) {
3068              for (Iterator i2 = set.iterator(); i2.hasNext(); ) {
3069                MethodDecl m = (MethodDecl) i2.next();
3070                putSimpleSetElement(map, m.signature(), m);
3071              }
3072            }
3073          }
3074          return map;
3075        }
3076      /**
3077       * @attribute syn
3078       * @aspect MemberMethods
3079       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:457
3080       */
3081      @ASTNodeAnnotation.Attribute
3082      public SimpleSet methodsSignature(String signature) {
3083        {
3084            SimpleSet set = (SimpleSet) methodsSignatureMap().get(signature);
3085            if (set != null) {
3086              return set;
3087            }
3088            return SimpleSet.emptySet;
3089          }
3090      }
3091      /**
3092       * @apilevel internal
3093       */
3094      protected boolean methodsSignatureMap_computed = false;
3095      /**
3096       * @apilevel internal
3097       */
3098      protected Map<String,SimpleSet> methodsSignatureMap_value;
3099      /**
3100       * @apilevel internal
3101       */
3102      private void methodsSignatureMap_reset() {
3103        methodsSignatureMap_computed = false;
3104        methodsSignatureMap_value = null;
3105      }
3106      /**
3107       * @attribute syn
3108       * @aspect MemberMethods
3109       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:466
3110       */
3111      @ASTNodeAnnotation.Attribute
3112      public Map<String,SimpleSet> methodsSignatureMap() {
3113        ASTNode$State state = state();
3114        if (methodsSignatureMap_computed) {
3115          return methodsSignatureMap_value;
3116        }
3117        boolean intermediate = state.INTERMEDIATE_VALUE;
3118        state.INTERMEDIATE_VALUE = false;
3119        int num = state.boundariesCrossed;
3120        boolean isFinal = this.is$Final();
3121        methodsSignatureMap_value = localMethodsSignatureMap();
3122        if (isFinal && num == state().boundariesCrossed) {
3123          methodsSignatureMap_computed = true;
3124        } else {
3125        }
3126        state.INTERMEDIATE_VALUE |= intermediate;
3127    
3128        return methodsSignatureMap_value;
3129      }
3130      /**
3131       * @apilevel internal
3132       */
3133      protected java.util.Map ancestorMethods_String_values;
3134      /**
3135       * @apilevel internal
3136       */
3137      private void ancestorMethods_String_reset() {
3138        ancestorMethods_String_values = null;
3139      }
3140      /**
3141       * @attribute syn
3142       * @aspect AncestorMethods
3143       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:536
3144       */
3145      @ASTNodeAnnotation.Attribute
3146      public SimpleSet ancestorMethods(String signature) {
3147        Object _parameters = signature;
3148        if (ancestorMethods_String_values == null) ancestorMethods_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
3149        ASTNode$State state = state();
3150        if (ancestorMethods_String_values.containsKey(_parameters)) {
3151          return (SimpleSet) ancestorMethods_String_values.get(_parameters);
3152        }
3153        boolean intermediate = state.INTERMEDIATE_VALUE;
3154        state.INTERMEDIATE_VALUE = false;
3155        int num = state.boundariesCrossed;
3156        boolean isFinal = this.is$Final();
3157        SimpleSet ancestorMethods_String_value = SimpleSet.emptySet;
3158        if (isFinal && num == state().boundariesCrossed) {
3159          ancestorMethods_String_values.put(_parameters, ancestorMethods_String_value);
3160        } else {
3161        }
3162        state.INTERMEDIATE_VALUE |= intermediate;
3163    
3164        return ancestorMethods_String_value;
3165      }
3166      /**
3167       * @return a set containing this type, unless this is the unknown type in
3168       * which case an empty set is returned
3169       * @attribute syn
3170       * @aspect TypeScopePropagation
3171       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:300
3172       */
3173      @ASTNodeAnnotation.Attribute
3174      public SimpleSet asSet() {
3175        SimpleSet asSet_value = this;
3176    
3177        return asSet_value;
3178      }
3179      /**
3180       * @attribute syn
3181       * @aspect TypeScopePropagation
3182       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:476
3183       */
3184      @ASTNodeAnnotation.Attribute
3185      public SimpleSet localLookupType(String name) {
3186        {
3187            SimpleSet c = memberTypes(name);
3188            if (!c.isEmpty()) {
3189              return c;
3190            }
3191            if (name().equals(name)) {
3192              return SimpleSet.emptySet.add(this);
3193            }
3194        
3195            c = lookupType(name);
3196            // 8.5.2
3197            if (isClassDecl() && isStatic() && !isTopLevelType()) {
3198              SimpleSet newSet = SimpleSet.emptySet;
3199              for (Iterator iter = c.iterator(); iter.hasNext(); ) {
3200                TypeDecl d = (TypeDecl) iter.next();
3201                //if (d.isStatic() || d.isTopLevelType() || this.instanceOf(d.enclosingType())) {
3202                  newSet = newSet.add(d);
3203                //}
3204              }
3205              c = newSet;
3206            }
3207            return c;
3208          }
3209      }
3210      /**
3211       * @attribute syn
3212       * @aspect TypeScopePropagation
3213       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:598
3214       */
3215      @ASTNodeAnnotation.Attribute
3216      public boolean hasType(String name) {
3217        boolean hasType_String_value = !memberTypes(name).isEmpty();
3218    
3219        return hasType_String_value;
3220      }
3221      /**
3222       * @apilevel internal
3223       */
3224      protected java.util.Map localTypeDecls_String_values;
3225      /**
3226       * @apilevel internal
3227       */
3228      private void localTypeDecls_String_reset() {
3229        localTypeDecls_String_values = null;
3230      }
3231      /**
3232       * @attribute syn
3233       * @aspect TypeScopePropagation
3234       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:609
3235       */
3236      @ASTNodeAnnotation.Attribute
3237      public SimpleSet localTypeDecls(String name) {
3238        Object _parameters = name;
3239        if (localTypeDecls_String_values == null) localTypeDecls_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
3240        ASTNode$State state = state();
3241        if (localTypeDecls_String_values.containsKey(_parameters)) {
3242          return (SimpleSet) localTypeDecls_String_values.get(_parameters);
3243        }
3244        boolean intermediate = state.INTERMEDIATE_VALUE;
3245        state.INTERMEDIATE_VALUE = false;
3246        int num = state.boundariesCrossed;
3247        boolean isFinal = this.is$Final();
3248        SimpleSet localTypeDecls_String_value = localTypeDecls_compute(name);
3249        if (isFinal && num == state().boundariesCrossed) {
3250          localTypeDecls_String_values.put(_parameters, localTypeDecls_String_value);
3251        } else {
3252        }
3253        state.INTERMEDIATE_VALUE |= intermediate;
3254    
3255        return localTypeDecls_String_value;
3256      }
3257      /**
3258       * @apilevel internal
3259       */
3260      private SimpleSet localTypeDecls_compute(String name) {
3261          SimpleSet set = SimpleSet.emptySet;
3262          for (int i = 0; i < getNumBodyDecl(); i++) {
3263            if (getBodyDecl(i).declaresType(name)) {
3264              set = set.add(getBodyDecl(i).type(name));
3265            }
3266          }
3267          return set;
3268        }
3269      /**
3270       * @apilevel internal
3271       */
3272      protected java.util.Map memberTypes_String_values;
3273      /**
3274       * @apilevel internal
3275       */
3276      private void memberTypes_String_reset() {
3277        memberTypes_String_values = null;
3278      }
3279      /**
3280       * @attribute syn
3281       * @aspect TypeScopePropagation
3282       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:619
3283       */
3284      @ASTNodeAnnotation.Attribute
3285      public SimpleSet memberTypes(String name) {
3286        Object _parameters = name;
3287        if (memberTypes_String_values == null) memberTypes_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
3288        ASTNode$State state = state();
3289        if (memberTypes_String_values.containsKey(_parameters)) {
3290          return (SimpleSet) memberTypes_String_values.get(_parameters);
3291        }
3292        boolean intermediate = state.INTERMEDIATE_VALUE;
3293        state.INTERMEDIATE_VALUE = false;
3294        int num = state.boundariesCrossed;
3295        boolean isFinal = this.is$Final();
3296        SimpleSet memberTypes_String_value = SimpleSet.emptySet;
3297        if (isFinal && num == state().boundariesCrossed) {
3298          memberTypes_String_values.put(_parameters, memberTypes_String_value);
3299        } else {
3300        }
3301        state.INTERMEDIATE_VALUE |= intermediate;
3302    
3303        return memberTypes_String_value;
3304      }
3305      /**
3306       * @apilevel internal
3307       */
3308      protected java.util.Map localFields_String_values;
3309      /**
3310       * @apilevel internal
3311       */
3312      private void localFields_String_reset() {
3313        localFields_String_values = null;
3314      }
3315      /**
3316       * @attribute syn
3317       * @aspect Fields
3318       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:363
3319       */
3320      @ASTNodeAnnotation.Attribute
3321      public SimpleSet localFields(String name) {
3322        Object _parameters = name;
3323        if (localFields_String_values == null) localFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
3324        ASTNode$State state = state();
3325        if (localFields_String_values.containsKey(_parameters)) {
3326          return (SimpleSet) localFields_String_values.get(_parameters);
3327        }
3328        boolean intermediate = state.INTERMEDIATE_VALUE;
3329        state.INTERMEDIATE_VALUE = false;
3330        int num = state.boundariesCrossed;
3331        boolean isFinal = this.is$Final();
3332        SimpleSet localFields_String_value = localFieldsMap().containsKey(name)
3333              ? (SimpleSet) localFieldsMap().get(name)
3334              : SimpleSet.emptySet;
3335        if (isFinal && num == state().boundariesCrossed) {
3336          localFields_String_values.put(_parameters, localFields_String_value);
3337        } else {
3338        }
3339        state.INTERMEDIATE_VALUE |= intermediate;
3340    
3341        return localFields_String_value;
3342      }
3343      /**
3344       * @apilevel internal
3345       */
3346      protected boolean localFieldsMap_computed = false;
3347      /**
3348       * @apilevel internal
3349       */
3350      protected HashMap localFieldsMap_value;
3351      /**
3352       * @apilevel internal
3353       */
3354      private void localFieldsMap_reset() {
3355        localFieldsMap_computed = false;
3356        localFieldsMap_value = null;
3357      }
3358      /**
3359       * @attribute syn
3360       * @aspect Fields
3361       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:368
3362       */
3363      @ASTNodeAnnotation.Attribute
3364      public HashMap localFieldsMap() {
3365        ASTNode$State state = state();
3366        if (localFieldsMap_computed) {
3367          return localFieldsMap_value;
3368        }
3369        boolean intermediate = state.INTERMEDIATE_VALUE;
3370        state.INTERMEDIATE_VALUE = false;
3371        int num = state.boundariesCrossed;
3372        boolean isFinal = this.is$Final();
3373        localFieldsMap_value = localFieldsMap_compute();
3374        if (isFinal && num == state().boundariesCrossed) {
3375          localFieldsMap_computed = true;
3376        } else {
3377        }
3378        state.INTERMEDIATE_VALUE |= intermediate;
3379    
3380        return localFieldsMap_value;
3381      }
3382      /**
3383       * @apilevel internal
3384       */
3385      private HashMap localFieldsMap_compute() {
3386          HashMap map = new HashMap();
3387          for (int i = 0; i < getNumBodyDecl(); i++) {
3388            if (getBodyDecl(i) instanceof FieldDeclaration) {
3389              FieldDeclaration decl = (FieldDeclaration) getBodyDecl(i);
3390              SimpleSet fields = (SimpleSet) map.get(decl.name());
3391              if (fields == null) {
3392                fields = SimpleSet.emptySet;
3393              }
3394              fields = fields.add(decl);
3395              map.put(decl.name(), fields);
3396            }
3397          }
3398          return map;
3399        }
3400      /**
3401       * @apilevel internal
3402       */
3403      protected boolean memberFieldsMap_computed = false;
3404      /**
3405       * @apilevel internal
3406       */
3407      protected HashMap memberFieldsMap_value;
3408      /**
3409       * @apilevel internal
3410       */
3411      private void memberFieldsMap_reset() {
3412        memberFieldsMap_computed = false;
3413        memberFieldsMap_value = null;
3414      }
3415      /**
3416       * @attribute syn
3417       * @aspect Fields
3418       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:383
3419       */
3420      @ASTNodeAnnotation.Attribute
3421      public HashMap memberFieldsMap() {
3422        ASTNode$State state = state();
3423        if (memberFieldsMap_computed) {
3424          return memberFieldsMap_value;
3425        }
3426        boolean intermediate = state.INTERMEDIATE_VALUE;
3427        state.INTERMEDIATE_VALUE = false;
3428        int num = state.boundariesCrossed;
3429        boolean isFinal = this.is$Final();
3430        memberFieldsMap_value = localFieldsMap();
3431        if (isFinal && num == state().boundariesCrossed) {
3432          memberFieldsMap_computed = true;
3433        } else {
3434        }
3435        state.INTERMEDIATE_VALUE |= intermediate;
3436    
3437        return memberFieldsMap_value;
3438      }
3439      /**
3440       * @apilevel internal
3441       */
3442      protected java.util.Map memberFields_String_values;
3443      /**
3444       * @apilevel internal
3445       */
3446      private void memberFields_String_reset() {
3447        memberFields_String_values = null;
3448      }
3449      /**
3450       * @attribute syn
3451       * @aspect Fields
3452       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:435
3453       */
3454      @ASTNodeAnnotation.Attribute
3455      public SimpleSet memberFields(String name) {
3456        Object _parameters = name;
3457        if (memberFields_String_values == null) memberFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
3458        ASTNode$State state = state();
3459        if (memberFields_String_values.containsKey(_parameters)) {
3460          return (SimpleSet) memberFields_String_values.get(_parameters);
3461        }
3462        boolean intermediate = state.INTERMEDIATE_VALUE;
3463        state.INTERMEDIATE_VALUE = false;
3464        int num = state.boundariesCrossed;
3465        boolean isFinal = this.is$Final();
3466        SimpleSet memberFields_String_value = localFields(name);
3467        if (isFinal && num == state().boundariesCrossed) {
3468          memberFields_String_values.put(_parameters, memberFields_String_value);
3469        } else {
3470        }
3471        state.INTERMEDIATE_VALUE |= intermediate;
3472    
3473        return memberFields_String_value;
3474      }
3475      /**
3476       * @apilevel internal
3477       */
3478      protected boolean hasAbstract_computed = false;
3479      /**
3480       * @apilevel internal
3481       */
3482      protected boolean hasAbstract_value;
3483      /**
3484       * @apilevel internal
3485       */
3486      private void hasAbstract_reset() {
3487        hasAbstract_computed = false;
3488      }
3489      /**
3490       * @attribute syn
3491       * @aspect Modifiers
3492       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:35
3493       */
3494      @ASTNodeAnnotation.Attribute
3495      public boolean hasAbstract() {
3496        ASTNode$State state = state();
3497        if (hasAbstract_computed) {
3498          return hasAbstract_value;
3499        }
3500        boolean intermediate = state.INTERMEDIATE_VALUE;
3501        state.INTERMEDIATE_VALUE = false;
3502        int num = state.boundariesCrossed;
3503        boolean isFinal = this.is$Final();
3504        hasAbstract_value = false;
3505        if (isFinal && num == state().boundariesCrossed) {
3506          hasAbstract_computed = true;
3507        } else {
3508        }
3509        state.INTERMEDIATE_VALUE |= intermediate;
3510    
3511        return hasAbstract_value;
3512      }
3513      /**
3514       * @apilevel internal
3515       */
3516      protected boolean unimplementedMethods_computed = false;
3517      /**
3518       * @apilevel internal
3519       */
3520      protected Collection unimplementedMethods_value;
3521      /**
3522       * @apilevel internal
3523       */
3524      private void unimplementedMethods_reset() {
3525        unimplementedMethods_computed = false;
3526        unimplementedMethods_value = null;
3527      }
3528      /**
3529       * @attribute syn
3530       * @aspect Modifiers
3531       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:37
3532       */
3533      @ASTNodeAnnotation.Attribute
3534      public Collection unimplementedMethods() {
3535        ASTNode$State state = state();
3536        if (unimplementedMethods_computed) {
3537          return unimplementedMethods_value;
3538        }
3539        boolean intermediate = state.INTERMEDIATE_VALUE;
3540        state.INTERMEDIATE_VALUE = false;
3541        int num = state.boundariesCrossed;
3542        boolean isFinal = this.is$Final();
3543        unimplementedMethods_value = Collections.EMPTY_LIST;
3544        if (isFinal && num == state().boundariesCrossed) {
3545          unimplementedMethods_computed = true;
3546        } else {
3547        }
3548        state.INTERMEDIATE_VALUE |= intermediate;
3549    
3550        return unimplementedMethods_value;
3551      }
3552      /**
3553       * @apilevel internal
3554       */
3555      protected boolean isPublic_computed = false;
3556      /**
3557       * @apilevel internal
3558       */
3559      protected boolean isPublic_value;
3560      /**
3561       * @apilevel internal
3562       */
3563      private void isPublic_reset() {
3564        isPublic_computed = false;
3565      }
3566      /**
3567       * @attribute syn
3568       * @aspect Modifiers
3569       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:241
3570       */
3571      @ASTNodeAnnotation.Attribute
3572      public boolean isPublic() {
3573        ASTNode$State state = state();
3574        if (isPublic_computed) {
3575          return isPublic_value;
3576        }
3577        boolean intermediate = state.INTERMEDIATE_VALUE;
3578        state.INTERMEDIATE_VALUE = false;
3579        int num = state.boundariesCrossed;
3580        boolean isFinal = this.is$Final();
3581        isPublic_value = getModifiers().isPublic() || isMemberType() && enclosingType().isInterfaceDecl();
3582        if (isFinal && num == state().boundariesCrossed) {
3583          isPublic_computed = true;
3584        } else {
3585        }
3586        state.INTERMEDIATE_VALUE |= intermediate;
3587    
3588        return isPublic_value;
3589      }
3590      /**
3591       * @attribute syn
3592       * @aspect Modifiers
3593       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:243
3594       */
3595      @ASTNodeAnnotation.Attribute
3596      public boolean isPrivate() {
3597        boolean isPrivate_value = getModifiers().isPrivate();
3598    
3599        return isPrivate_value;
3600      }
3601      /**
3602       * @attribute syn
3603       * @aspect Modifiers
3604       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:244
3605       */
3606      @ASTNodeAnnotation.Attribute
3607      public boolean isProtected() {
3608        boolean isProtected_value = getModifiers().isProtected();
3609    
3610        return isProtected_value;
3611      }
3612      /**
3613       * @attribute syn
3614       * @aspect Modifiers
3615       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:245
3616       */
3617      @ASTNodeAnnotation.Attribute
3618      public boolean isAbstract() {
3619        boolean isAbstract_value = getModifiers().isAbstract();
3620    
3621        return isAbstract_value;
3622      }
3623      /**
3624       * @apilevel internal
3625       */
3626      protected boolean isStatic_computed = false;
3627      /**
3628       * @apilevel internal
3629       */
3630      protected boolean isStatic_value;
3631      /**
3632       * @apilevel internal
3633       */
3634      private void isStatic_reset() {
3635        isStatic_computed = false;
3636      }
3637      /**
3638       * @attribute syn
3639       * @aspect Modifiers
3640       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:247
3641       */
3642      @ASTNodeAnnotation.Attribute
3643      public boolean isStatic() {
3644        ASTNode$State state = state();
3645        if (isStatic_computed) {
3646          return isStatic_value;
3647        }
3648        boolean intermediate = state.INTERMEDIATE_VALUE;
3649        state.INTERMEDIATE_VALUE = false;
3650        int num = state.boundariesCrossed;
3651        boolean isFinal = this.is$Final();
3652        isStatic_value = getModifiers().isStatic() || isMemberType() && enclosingType().isInterfaceDecl();
3653        if (isFinal && num == state().boundariesCrossed) {
3654          isStatic_computed = true;
3655        } else {
3656        }
3657        state.INTERMEDIATE_VALUE |= intermediate;
3658    
3659        return isStatic_value;
3660      }
3661      /**
3662       * @attribute syn
3663       * @aspect Modifiers
3664       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:250
3665       */
3666      @ASTNodeAnnotation.Attribute
3667      public boolean isFinal() {
3668        boolean isFinal_value = getModifiers().isFinal();
3669    
3670        return isFinal_value;
3671      }
3672      /**
3673       * @attribute syn
3674       * @aspect Modifiers
3675       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:251
3676       */
3677      @ASTNodeAnnotation.Attribute
3678      public boolean isStrictfp() {
3679        boolean isStrictfp_value = getModifiers().isStrictfp();
3680    
3681        return isStrictfp_value;
3682      }
3683      /**
3684       * @attribute syn
3685       * @aspect Modifiers
3686       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:253
3687       */
3688      @ASTNodeAnnotation.Attribute
3689      public boolean isSynthetic() {
3690        boolean isSynthetic_value = getModifiers().isSynthetic();
3691    
3692        return isSynthetic_value;
3693      }
3694      /**
3695       * @attribute syn
3696       * @aspect NameCheck
3697       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:344
3698       */
3699      @ASTNodeAnnotation.Attribute
3700      public boolean hasEnclosingTypeDecl(String name) {
3701        {
3702            TypeDecl enclosingType = enclosingType();
3703            if (enclosingType != null) {
3704              return enclosingType.name().equals(name) || enclosingType.hasEnclosingTypeDecl(name);
3705            }
3706            return false;
3707          }
3708      }
3709      /**
3710       * @attribute syn
3711       * @aspect NameCheck
3712       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:508
3713       */
3714      @ASTNodeAnnotation.Attribute
3715      public boolean assignableToInt() {
3716        boolean assignableToInt_value = false;
3717    
3718        return assignableToInt_value;
3719      }
3720      /**
3721       * @attribute syn
3722       * @aspect TypeName
3723       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:78
3724       */
3725      @ASTNodeAnnotation.Attribute
3726      public String name() {
3727        String name_value = getID();
3728    
3729        return name_value;
3730      }
3731      /**
3732       * @apilevel internal
3733       */
3734      protected boolean fullName_computed = false;
3735      /**
3736       * @apilevel internal
3737       */
3738      protected String fullName_value;
3739      /**
3740       * @apilevel internal
3741       */
3742      private void fullName_reset() {
3743        fullName_computed = false;
3744        fullName_value = null;
3745      }
3746      /**
3747       * @attribute syn
3748       * @aspect TypeName
3749       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:80
3750       */
3751      @ASTNodeAnnotation.Attribute
3752      public String fullName() {
3753        ASTNode$State state = state();
3754        if (fullName_computed) {
3755          return fullName_value;
3756        }
3757        boolean intermediate = state.INTERMEDIATE_VALUE;
3758        state.INTERMEDIATE_VALUE = false;
3759        int num = state.boundariesCrossed;
3760        boolean isFinal = this.is$Final();
3761        fullName_value = fullName_compute();
3762        if (isFinal && num == state().boundariesCrossed) {
3763          fullName_computed = true;
3764        } else {
3765        }
3766        state.INTERMEDIATE_VALUE |= intermediate;
3767    
3768        return fullName_value;
3769      }
3770      /**
3771       * @apilevel internal
3772       */
3773      private String fullName_compute() {
3774          if (isNestedType()) {
3775            return enclosingType().fullName() + "." + name();
3776          }
3777          String packageName = packageName();
3778          if (packageName.equals("")) {
3779            return name();
3780          }
3781          return packageName + "." + name();
3782        }
3783      /**
3784       * @apilevel internal
3785       */
3786      protected boolean typeName_computed = false;
3787      /**
3788       * @apilevel internal
3789       */
3790      protected String typeName_value;
3791      /**
3792       * @apilevel internal
3793       */
3794      private void typeName_reset() {
3795        typeName_computed = false;
3796        typeName_value = null;
3797      }
3798      /**
3799       * @attribute syn
3800       * @aspect TypeName
3801       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:91
3802       */
3803      @ASTNodeAnnotation.Attribute
3804      public String typeName() {
3805        ASTNode$State state = state();
3806        if (typeName_computed) {
3807          return typeName_value;
3808        }
3809        boolean intermediate = state.INTERMEDIATE_VALUE;
3810        state.INTERMEDIATE_VALUE = false;
3811        int num = state.boundariesCrossed;
3812        boolean isFinal = this.is$Final();
3813        typeName_value = typeName_compute();
3814        if (isFinal && num == state().boundariesCrossed) {
3815          typeName_computed = true;
3816        } else {
3817        }
3818        state.INTERMEDIATE_VALUE |= intermediate;
3819    
3820        return typeName_value;
3821      }
3822      /**
3823       * @apilevel internal
3824       */
3825      private String typeName_compute() {
3826          if (isNestedType()) {
3827            return enclosingType().typeName() + "." + name();
3828          }
3829          String packageName = packageName();
3830          if (packageName.equals("") || packageName.equals(PRIMITIVE_PACKAGE_NAME)) {
3831            return name();
3832          }
3833          return packageName + "." + name();
3834        }
3835      /**
3836       * @attribute syn
3837       * @aspect TypeConversion
3838       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:36
3839       */
3840      @ASTNodeAnnotation.Attribute
3841      public boolean identityConversionTo(TypeDecl type) {
3842        boolean identityConversionTo_TypeDecl_value = this == type;
3843    
3844        return identityConversionTo_TypeDecl_value;
3845      }
3846      /**
3847       * @attribute syn
3848       * @aspect TypeConversion
3849       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:38
3850       */
3851      @ASTNodeAnnotation.Attribute
3852      public boolean wideningConversionTo(TypeDecl type) {
3853        boolean wideningConversionTo_TypeDecl_value = instanceOf(type);
3854    
3855        return wideningConversionTo_TypeDecl_value;
3856      }
3857      /**
3858       * @apilevel internal
3859       */
3860      protected java.util.Map narrowingConversionTo_TypeDecl_values;
3861      /**
3862       * @apilevel internal
3863       */
3864      private void narrowingConversionTo_TypeDecl_reset() {
3865        narrowingConversionTo_TypeDecl_values = null;
3866      }
3867      /**
3868       * @attribute syn
3869       * @aspect TypeConversion
3870       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:39
3871       */
3872      @ASTNodeAnnotation.Attribute
3873      public boolean narrowingConversionTo(TypeDecl type) {
3874        Object _parameters = type;
3875        if (narrowingConversionTo_TypeDecl_values == null) narrowingConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
3876        ASTNode$State state = state();
3877        if (narrowingConversionTo_TypeDecl_values.containsKey(_parameters)) {
3878          return (Boolean) narrowingConversionTo_TypeDecl_values.get(_parameters);
3879        }
3880        boolean intermediate = state.INTERMEDIATE_VALUE;
3881        state.INTERMEDIATE_VALUE = false;
3882        int num = state.boundariesCrossed;
3883        boolean isFinal = this.is$Final();
3884        boolean narrowingConversionTo_TypeDecl_value = instanceOf(type);
3885        if (isFinal && num == state().boundariesCrossed) {
3886          narrowingConversionTo_TypeDecl_values.put(_parameters, narrowingConversionTo_TypeDecl_value);
3887        } else {
3888        }
3889        state.INTERMEDIATE_VALUE |= intermediate;
3890    
3891        return narrowingConversionTo_TypeDecl_value;
3892      }
3893      /**
3894       * @attribute syn
3895       * @aspect TypeConversion
3896       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:82
3897       */
3898      @ASTNodeAnnotation.Attribute
3899      public boolean stringConversion() {
3900        boolean stringConversion_value = true;
3901    
3902        return stringConversion_value;
3903      }
3904      /**
3905       * @attribute syn
3906       * @aspect TypeConversion
3907       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:86
3908       */
3909      @ASTNodeAnnotation.Attribute
3910      public boolean assignConversionTo(TypeDecl type, Expr expr) {
3911        {
3912            if (refined_TypeConversion_TypeDecl_assignConversionTo_TypeDecl_Expr(type, expr)) {
3913              return true;
3914            }
3915            boolean canBoxThis = this instanceof PrimitiveType;
3916            boolean canBoxType = type instanceof PrimitiveType;
3917            boolean canUnboxThis = !unboxed().isUnknown();
3918            boolean canUnboxType = !type.unboxed().isUnknown();
3919            TypeDecl t = !canUnboxThis && canUnboxType ? type.unboxed() : type;
3920            boolean sourceIsConstant = expr != null ? expr.isConstant() : false;
3921            if (sourceIsConstant && (isInt() || isChar() || isShort() || isByte()) &&
3922                (t.isByte() || t.isShort() || t.isChar()) &&
3923                narrowingConversionTo(t) && expr.representableIn(t))
3924              return true;
3925            if (canBoxThis && !canBoxType && boxed().wideningConversionTo(type)) {
3926              return true;
3927            } else if (canUnboxThis && !canUnboxType && unboxed().wideningConversionTo(type)) {
3928              return true;
3929            }
3930        
3931            return false;
3932          }
3933      }
3934      /**
3935       * @apilevel internal
3936       */
3937      protected java.util.Map methodInvocationConversionTo_TypeDecl_values;
3938      /**
3939       * @apilevel internal
3940       */
3941      private void methodInvocationConversionTo_TypeDecl_reset() {
3942        methodInvocationConversionTo_TypeDecl_values = null;
3943      }
3944      /**
3945       * @attribute syn
3946       * @aspect TypeConversion
3947       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:104
3948       */
3949      @ASTNodeAnnotation.Attribute
3950      public boolean methodInvocationConversionTo(TypeDecl type) {
3951        Object _parameters = type;
3952        if (methodInvocationConversionTo_TypeDecl_values == null) methodInvocationConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
3953        ASTNode$State state = state();
3954        if (methodInvocationConversionTo_TypeDecl_values.containsKey(_parameters)) {
3955          return (Boolean) methodInvocationConversionTo_TypeDecl_values.get(_parameters);
3956        }
3957        boolean intermediate = state.INTERMEDIATE_VALUE;
3958        state.INTERMEDIATE_VALUE = false;
3959        int num = state.boundariesCrossed;
3960        boolean isFinal = this.is$Final();
3961        boolean methodInvocationConversionTo_TypeDecl_value = methodInvocationConversionTo_compute(type);
3962        if (isFinal && num == state().boundariesCrossed) {
3963          methodInvocationConversionTo_TypeDecl_values.put(_parameters, methodInvocationConversionTo_TypeDecl_value);
3964        } else {
3965        }
3966        state.INTERMEDIATE_VALUE |= intermediate;
3967    
3968        return methodInvocationConversionTo_TypeDecl_value;
3969      }
3970      /**
3971       * @apilevel internal
3972       */
3973      private boolean methodInvocationConversionTo_compute(TypeDecl type) {
3974          if (refined_TypeConversion_TypeDecl_methodInvocationConversionTo_TypeDecl(type)) {
3975            return true;
3976          }
3977          boolean canBoxThis = this instanceof PrimitiveType;
3978          boolean canBoxType = type instanceof PrimitiveType;
3979          boolean canUnboxThis = !unboxed().isUnknown();
3980          boolean canUnboxType = !type.unboxed().isUnknown();
3981          if (canBoxThis && !canBoxType) {
3982            return boxed().wideningConversionTo(type);
3983          } else if (canUnboxThis && !canUnboxType) {
3984            return unboxed().wideningConversionTo(type);
3985          }
3986          return false;
3987        }
3988      /**
3989       * @apilevel internal
3990       */
3991      protected java.util.Map castingConversionTo_TypeDecl_values;
3992      /**
3993       * @apilevel internal
3994       */
3995      private void castingConversionTo_TypeDecl_reset() {
3996        castingConversionTo_TypeDecl_values = null;
3997      }
3998      /**
3999       * @attribute syn
4000       * @aspect TypeConversion
4001       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:109
4002       */
4003      @ASTNodeAnnotation.Attribute
4004      public boolean castingConversionTo(TypeDecl type) {
4005        Object _parameters = type;
4006        if (castingConversionTo_TypeDecl_values == null) castingConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
4007        ASTNode$State state = state();
4008        if (castingConversionTo_TypeDecl_values.containsKey(_parameters)) {
4009          return (Boolean) castingConversionTo_TypeDecl_values.get(_parameters);
4010        }
4011        boolean intermediate = state.INTERMEDIATE_VALUE;
4012        state.INTERMEDIATE_VALUE = false;
4013        int num = state.boundariesCrossed;
4014        boolean isFinal = this.is$Final();
4015        boolean castingConversionTo_TypeDecl_value = castingConversionTo_compute(type);
4016        if (isFinal && num == state().boundariesCrossed) {
4017          castingConversionTo_TypeDecl_values.put(_parameters, castingConversionTo_TypeDecl_value);
4018        } else {
4019        }
4020        state.INTERMEDIATE_VALUE |= intermediate;
4021    
4022        return castingConversionTo_TypeDecl_value;
4023      }
4024      /**
4025       * @apilevel internal
4026       */
4027      private boolean castingConversionTo_compute(TypeDecl type) {
4028          if (refined_TypeConversion_TypeDecl_castingConversionTo_TypeDecl(type)) {
4029            return true;
4030          }
4031          boolean canBoxThis = this instanceof PrimitiveType;
4032          boolean canBoxType = type instanceof PrimitiveType;
4033          boolean canUnboxThis = !unboxed().isUnknown();
4034          boolean canUnboxType = !type.unboxed().isUnknown();
4035          if (canBoxThis && !canBoxType) {
4036            return boxed().wideningConversionTo(type);
4037          } else if (canUnboxThis && !canUnboxType) {
4038            return unboxed().wideningConversionTo(type);
4039          }
4040          return false;
4041          /*
4042          else if (boxingConversionTo(type)) {
4043            return true;
4044          } else if (unboxingConversionTo(type)) {
4045            return true;
4046          }
4047          return false;
4048          */
4049        }
4050      /**
4051       * @attribute syn
4052       * @aspect NumericPromotion
4053       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:167
4054       */
4055      @ASTNodeAnnotation.Attribute
4056      public TypeDecl unaryNumericPromotion() {
4057        TypeDecl unaryNumericPromotion_value = this;
4058    
4059        return unaryNumericPromotion_value;
4060      }
4061      /**
4062       * @attribute syn
4063       * @aspect NumericPromotion
4064       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:175
4065       */
4066      @ASTNodeAnnotation.Attribute
4067      public TypeDecl binaryNumericPromotion(TypeDecl type) {
4068        TypeDecl binaryNumericPromotion_TypeDecl_value = unknownType();
4069    
4070        return binaryNumericPromotion_TypeDecl_value;
4071      }
4072      /**
4073       * @attribute syn
4074       * @aspect TypeAnalysis
4075       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:187
4076       */
4077      @ASTNodeAnnotation.Attribute
4078      public boolean isReferenceType() {
4079        boolean isReferenceType_value = false;
4080    
4081        return isReferenceType_value;
4082      }
4083      /**
4084       * @attribute syn
4085       * @aspect TypeAnalysis
4086       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:190
4087       */
4088      @ASTNodeAnnotation.Attribute
4089      public boolean isPrimitiveType() {
4090        boolean isPrimitiveType_value = false;
4091    
4092        return isPrimitiveType_value;
4093      }
4094      /**
4095       * @attribute syn
4096       * @aspect TypeAnalysis
4097       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:195
4098       */
4099      @ASTNodeAnnotation.Attribute
4100      public boolean isNumericType() {
4101        boolean isNumericType_value = false;
4102    
4103        return isNumericType_value;
4104      }
4105      /**
4106       * @attribute syn
4107       * @aspect TypeAnalysis
4108       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:199
4109       */
4110      @ASTNodeAnnotation.Attribute
4111      public boolean isIntegralType() {
4112        boolean isIntegralType_value = false;
4113    
4114        return isIntegralType_value;
4115      }
4116      /**
4117       * @attribute syn
4118       * @aspect TypeAnalysis
4119       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:203
4120       */
4121      @ASTNodeAnnotation.Attribute
4122      public boolean isBoolean() {
4123        boolean isBoolean_value = false;
4124    
4125        return isBoolean_value;
4126      }
4127      /**
4128       * @attribute syn
4129       * @aspect TypeAnalysis
4130       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:207
4131       */
4132      @ASTNodeAnnotation.Attribute
4133      public boolean isByte() {
4134        boolean isByte_value = false;
4135    
4136        return isByte_value;
4137      }
4138      /**
4139       * @attribute syn
4140       * @aspect TypeAnalysis
4141       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:209
4142       */
4143      @ASTNodeAnnotation.Attribute
4144      public boolean isChar() {
4145        boolean isChar_value = false;
4146    
4147        return isChar_value;
4148      }
4149      /**
4150       * @attribute syn
4151       * @aspect TypeAnalysis
4152       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:211
4153       */
4154      @ASTNodeAnnotation.Attribute
4155      public boolean isShort() {
4156        boolean isShort_value = false;
4157    
4158        return isShort_value;
4159      }
4160      /**
4161       * @attribute syn
4162       * @aspect TypeAnalysis
4163       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:213
4164       */
4165      @ASTNodeAnnotation.Attribute
4166      public boolean isInt() {
4167        boolean isInt_value = false;
4168    
4169        return isInt_value;
4170      }
4171      /**
4172       * @attribute syn
4173       * @aspect TypeAnalysis
4174       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:217
4175       */
4176      @ASTNodeAnnotation.Attribute
4177      public boolean isFloat() {
4178        boolean isFloat_value = false;
4179    
4180        return isFloat_value;
4181      }
4182      /**
4183       * @attribute syn
4184       * @aspect TypeAnalysis
4185       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:219
4186       */
4187      @ASTNodeAnnotation.Attribute
4188      public boolean isLong() {
4189        boolean isLong_value = false;
4190    
4191        return isLong_value;
4192      }
4193      /**
4194       * @attribute syn
4195       * @aspect TypeAnalysis
4196       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:221
4197       */
4198      @ASTNodeAnnotation.Attribute
4199      public boolean isDouble() {
4200        boolean isDouble_value = false;
4201    
4202        return isDouble_value;
4203      }
4204      /**
4205       * @attribute syn
4206       * @aspect TypeAnalysis
4207       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:224
4208       */
4209      @ASTNodeAnnotation.Attribute
4210      public boolean isVoid() {
4211        boolean isVoid_value = false;
4212    
4213        return isVoid_value;
4214      }
4215      /**
4216       * @attribute syn
4217       * @aspect TypeAnalysis
4218       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:227
4219       */
4220      @ASTNodeAnnotation.Attribute
4221      public boolean isNull() {
4222        boolean isNull_value = false;
4223    
4224        return isNull_value;
4225      }
4226      /**
4227       * @attribute syn
4228       * @aspect TypeAnalysis
4229       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:231
4230       */
4231      @ASTNodeAnnotation.Attribute
4232      public boolean isClassDecl() {
4233        boolean isClassDecl_value = false;
4234    
4235        return isClassDecl_value;
4236      }
4237      /**
4238       * @attribute syn
4239       * @aspect TypeAnalysis
4240       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:235
4241       */
4242      @ASTNodeAnnotation.Attribute
4243      public boolean isInterfaceDecl() {
4244        boolean isInterfaceDecl_value = false;
4245    
4246        return isInterfaceDecl_value;
4247      }
4248      /**
4249       * @attribute syn
4250       * @aspect TypeAnalysis
4251       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:237
4252       */
4253      @ASTNodeAnnotation.Attribute
4254      public boolean isArrayDecl() {
4255        boolean isArrayDecl_value = false;
4256    
4257        return isArrayDecl_value;
4258      }
4259      /**
4260       * @attribute syn
4261       * @aspect TypeAnalysis
4262       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:245
4263       */
4264      @ASTNodeAnnotation.Attribute
4265      public boolean isPrimitive() {
4266        boolean isPrimitive_value = false;
4267    
4268        return isPrimitive_value;
4269      }
4270      /**
4271       * @apilevel internal
4272       */
4273      protected boolean isString_computed = false;
4274      /**
4275       * @apilevel internal
4276       */
4277      protected boolean isString_value;
4278      /**
4279       * @apilevel internal
4280       */
4281      private void isString_reset() {
4282        isString_computed = false;
4283      }
4284      /**
4285       * @attribute syn
4286       * @aspect TypeAnalysis
4287       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:248
4288       */
4289      @ASTNodeAnnotation.Attribute
4290      public boolean isString() {
4291        ASTNode$State state = state();
4292        if (isString_computed) {
4293          return isString_value;
4294        }
4295        boolean intermediate = state.INTERMEDIATE_VALUE;
4296        state.INTERMEDIATE_VALUE = false;
4297        int num = state.boundariesCrossed;
4298        boolean isFinal = this.is$Final();
4299        isString_value = false;
4300        if (isFinal && num == state().boundariesCrossed) {
4301          isString_computed = true;
4302        } else {
4303        }
4304        state.INTERMEDIATE_VALUE |= intermediate;
4305    
4306        return isString_value;
4307      }
4308      /**
4309       * @apilevel internal
4310       */
4311      protected boolean isObject_computed = false;
4312      /**
4313       * @apilevel internal
4314       */
4315      protected boolean isObject_value;
4316      /**
4317       * @apilevel internal
4318       */
4319      private void isObject_reset() {
4320        isObject_computed = false;
4321      }
4322      /**
4323       * @attribute syn
4324       * @aspect TypeAnalysis
4325       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:251
4326       */
4327      @ASTNodeAnnotation.Attribute
4328      public boolean isObject() {
4329        ASTNode$State state = state();
4330        if (isObject_computed) {
4331          return isObject_value;
4332        }
4333        boolean intermediate = state.INTERMEDIATE_VALUE;
4334        state.INTERMEDIATE_VALUE = false;
4335        int num = state.boundariesCrossed;
4336        boolean isFinal = this.is$Final();
4337        isObject_value = false;
4338        if (isFinal && num == state().boundariesCrossed) {
4339          isObject_computed = true;
4340        } else {
4341        }
4342        state.INTERMEDIATE_VALUE |= intermediate;
4343    
4344        return isObject_value;
4345      }
4346      /**
4347       * @attribute syn
4348       * @aspect TypeAnalysis
4349       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:254
4350       */
4351      @ASTNodeAnnotation.Attribute
4352      public boolean isUnknown() {
4353        boolean isUnknown_value = false;
4354    
4355        return isUnknown_value;
4356      }
4357      /**
4358       * @apilevel internal
4359       */
4360      protected java.util.Map instanceOf_TypeDecl_values;
4361      /**
4362       * @apilevel internal
4363       */
4364      private void instanceOf_TypeDecl_reset() {
4365        instanceOf_TypeDecl_values = null;
4366      }
4367      /**
4368       * @attribute syn
4369       * @aspect TypeWideningAndIdentity
4370       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442
4371       */
4372      @ASTNodeAnnotation.Attribute
4373      public boolean instanceOf(TypeDecl type) {
4374        Object _parameters = type;
4375        if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
4376        ASTNode$State state = state();
4377        if (instanceOf_TypeDecl_values.containsKey(_parameters)) {
4378          return (Boolean) instanceOf_TypeDecl_values.get(_parameters);
4379        }
4380        boolean intermediate = state.INTERMEDIATE_VALUE;
4381        state.INTERMEDIATE_VALUE = false;
4382        int num = state.boundariesCrossed;
4383        boolean isFinal = this.is$Final();
4384        boolean instanceOf_TypeDecl_value = instanceOf_compute(type);
4385        if (isFinal && num == state().boundariesCrossed) {
4386          instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value);
4387        } else {
4388        }
4389        state.INTERMEDIATE_VALUE |= intermediate;
4390    
4391        return instanceOf_TypeDecl_value;
4392      }
4393      /**
4394       * @apilevel internal
4395       */
4396      private boolean instanceOf_compute(TypeDecl type) { return subtype(type); }
4397      /**
4398       * @attribute syn
4399       * @aspect TypeWideningAndIdentity
4400       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:458
4401       */
4402      @ASTNodeAnnotation.Attribute
4403      public boolean isSupertypeOfClassDecl(ClassDecl type) {
4404        boolean isSupertypeOfClassDecl_ClassDecl_value = type == this;
4405    
4406        return isSupertypeOfClassDecl_ClassDecl_value;
4407      }
4408      /**
4409       * @attribute syn
4410       * @aspect TypeWideningAndIdentity
4411       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:478
4412       */
4413      @ASTNodeAnnotation.Attribute
4414      public boolean isSupertypeOfInterfaceDecl(InterfaceDecl type) {
4415        boolean isSupertypeOfInterfaceDecl_InterfaceDecl_value = type == this;
4416    
4417        return isSupertypeOfInterfaceDecl_InterfaceDecl_value;
4418      }
4419      /**
4420       * @attribute syn
4421       * @aspect TypeWideningAndIdentity
4422       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:493
4423       */
4424      @ASTNodeAnnotation.Attribute
4425      public boolean isSupertypeOfArrayDecl(ArrayDecl type) {
4426        boolean isSupertypeOfArrayDecl_ArrayDecl_value = this == type;
4427    
4428        return isSupertypeOfArrayDecl_ArrayDecl_value;
4429      }
4430      /**
4431       * @attribute syn
4432       * @aspect TypeWideningAndIdentity
4433       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:519
4434       */
4435      @ASTNodeAnnotation.Attribute
4436      public boolean isSupertypeOfPrimitiveType(PrimitiveType type) {
4437        boolean isSupertypeOfPrimitiveType_PrimitiveType_value = type == this;
4438    
4439        return isSupertypeOfPrimitiveType_PrimitiveType_value;
4440      }
4441      /**
4442       * @attribute syn
4443       * @aspect TypeWideningAndIdentity
4444       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:527
4445       */
4446      @ASTNodeAnnotation.Attribute
4447      public boolean isSupertypeOfNullType(NullType type) {
4448        boolean isSupertypeOfNullType_NullType_value = false;
4449    
4450        return isSupertypeOfNullType_NullType_value;
4451      }
4452      /**
4453       * @attribute syn
4454       * @aspect TypeWideningAndIdentity
4455       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:531
4456       */
4457      @ASTNodeAnnotation.Attribute
4458      public boolean isSupertypeOfVoidType(VoidType type) {
4459        boolean isSupertypeOfVoidType_VoidType_value = false;
4460    
4461        return isSupertypeOfVoidType_VoidType_value;
4462      }
4463      /**
4464       * @attribute syn
4465       * @aspect NestedTypes
4466       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:545
4467       */
4468      @ASTNodeAnnotation.Attribute
4469      public TypeDecl topLevelType() {
4470        {
4471            if (isTopLevelType()) {
4472              return this;
4473            }
4474            return enclosingType().topLevelType();
4475          }
4476      }
4477      /**
4478       * @attribute syn
4479       * @aspect NestedTypes
4480       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:574
4481       */
4482      @ASTNodeAnnotation.Attribute
4483      public boolean isTopLevelType() {
4484        boolean isTopLevelType_value = !isNestedType();
4485    
4486        return isTopLevelType_value;
4487      }
4488      /**
4489       * @attribute syn
4490       * @aspect NestedTypes
4491       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:585
4492       */
4493      @ASTNodeAnnotation.Attribute
4494      public boolean isInnerClass() {
4495        boolean isInnerClass_value = false;
4496    
4497        return isInnerClass_value;
4498      }
4499      /**
4500       * @attribute syn
4501       * @aspect NestedTypes
4502       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:587
4503       */
4504      @ASTNodeAnnotation.Attribute
4505      public boolean isInnerType() {
4506        boolean isInnerType_value = (isLocalClass() || isAnonymous() || (isMemberType() && !isStatic())) && !inStaticContext();
4507    
4508        return isInnerType_value;
4509      }
4510      /**
4511       * @attribute syn
4512       * @aspect NestedTypes
4513       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:589
4514       */
4515      @ASTNodeAnnotation.Attribute
4516      public boolean isInnerTypeOf(TypeDecl typeDecl) {
4517        boolean isInnerTypeOf_TypeDecl_value = typeDecl == this || (isInnerType() && enclosingType().isInnerTypeOf(typeDecl));
4518    
4519        return isInnerTypeOf_TypeDecl_value;
4520      }
4521      /**
4522       * @attribute syn
4523       * @aspect NestedTypes
4524       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:596
4525       */
4526      @ASTNodeAnnotation.Attribute
4527      public TypeDecl withinBodyThatSubclasses(TypeDecl type) {
4528        {
4529            if (instanceOf(type)) {
4530              return this;
4531            }
4532            if (!isTopLevelType()) {
4533              return enclosingType().withinBodyThatSubclasses(type);
4534            }
4535            return null;
4536          }
4537      }
4538      /**
4539       * @attribute syn
4540       * @aspect NestedTypes
4541       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:606
4542       */
4543      @ASTNodeAnnotation.Attribute
4544      public boolean encloses(TypeDecl type) {
4545        boolean encloses_TypeDecl_value = type.enclosedBy(this);
4546    
4547        return encloses_TypeDecl_value;
4548      }
4549      /**
4550       * @attribute syn
4551       * @aspect NestedTypes
4552       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:608
4553       */
4554      @ASTNodeAnnotation.Attribute
4555      public boolean enclosedBy(TypeDecl type) {
4556        {
4557            if (this == type) {
4558              return true;
4559            }
4560            if (isTopLevelType()) {
4561              return false;
4562            }
4563            return enclosingType().enclosedBy(type);
4564          }
4565      }
4566      /**
4567       * @attribute syn
4568       * @aspect NestedTypes
4569       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:624
4570       */
4571      @ASTNodeAnnotation.Attribute
4572      public TypeDecl hostType() {
4573        TypeDecl hostType_value = this;
4574    
4575        return hostType_value;
4576      }
4577      /**
4578       * @apilevel internal
4579       */
4580      protected int isCircular_visited = -1;
4581      /**
4582       * @apilevel internal
4583       */
4584      private void isCircular_reset() {
4585        isCircular_computed = false;
4586        isCircular_initialized = false;
4587        isCircular_visited = -1;
4588      }
4589      /**
4590       * @apilevel internal
4591       */
4592      protected boolean isCircular_computed = false;
4593      /**
4594       * @apilevel internal
4595       */
4596      protected boolean isCircular_initialized = false;
4597      /**
4598       * @apilevel internal
4599       */
4600      protected boolean isCircular_value;
4601      @ASTNodeAnnotation.Attribute
4602      public boolean isCircular() {
4603        if (isCircular_computed) {
4604          return isCircular_value;
4605        }
4606        ASTNode$State state = state();
4607        boolean new_isCircular_value;
4608        if (!isCircular_initialized) {
4609          isCircular_initialized = true;
4610          isCircular_value = true;
4611        }
4612        if (!state.IN_CIRCLE) {
4613          state.IN_CIRCLE = true;
4614          int num = state.boundariesCrossed;
4615          boolean isFinal = this.is$Final();
4616          do {
4617            isCircular_visited = state.CIRCLE_INDEX;
4618            state.CHANGE = false;
4619            new_isCircular_value = false;
4620            if (new_isCircular_value != isCircular_value) {
4621              state.CHANGE = true;
4622            }
4623            isCircular_value = new_isCircular_value;
4624            state.CIRCLE_INDEX++;
4625          } while (state.CHANGE);
4626          if (isFinal && num == state().boundariesCrossed) {
4627            isCircular_computed = true;
4628          } else {
4629            state.RESET_CYCLE = true;
4630            boolean $tmp = false;
4631            state.RESET_CYCLE = false;
4632            isCircular_computed = false;
4633            isCircular_initialized = false;
4634          }
4635          state.IN_CIRCLE = false;
4636          state.INTERMEDIATE_VALUE = false;
4637          return isCircular_value;
4638        }
4639        if (isCircular_visited != state.CIRCLE_INDEX) {
4640          isCircular_visited = state.CIRCLE_INDEX;
4641          if (state.RESET_CYCLE) {
4642            isCircular_computed = false;
4643            isCircular_initialized = false;
4644            isCircular_visited = -1;
4645            return isCircular_value;
4646          }
4647          new_isCircular_value = false;
4648          if (new_isCircular_value != isCircular_value) {
4649            state.CHANGE = true;
4650          }
4651          isCircular_value = new_isCircular_value;
4652          state.INTERMEDIATE_VALUE = true;
4653          return isCircular_value;
4654        }
4655        state.INTERMEDIATE_VALUE = true;
4656        return isCircular_value;
4657      }
4658      /**
4659       * @apilevel internal
4660       */
4661      protected boolean innerClassesAttributeEntries_computed = false;
4662      /**
4663       * @apilevel internal
4664       */
4665      protected Collection innerClassesAttributeEntries_value;
4666      /**
4667       * @apilevel internal
4668       */
4669      private void innerClassesAttributeEntries_reset() {
4670        innerClassesAttributeEntries_computed = false;
4671        innerClassesAttributeEntries_value = null;
4672      }
4673      /**
4674       * @attribute syn
4675       * @aspect Attributes
4676       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:107
4677       */
4678      @ASTNodeAnnotation.Attribute
4679      public Collection innerClassesAttributeEntries() {
4680        ASTNode$State state = state();
4681        if (innerClassesAttributeEntries_computed) {
4682          return innerClassesAttributeEntries_value;
4683        }
4684        boolean intermediate = state.INTERMEDIATE_VALUE;
4685        state.INTERMEDIATE_VALUE = false;
4686        int num = state.boundariesCrossed;
4687        boolean isFinal = this.is$Final();
4688        innerClassesAttributeEntries_value = innerClassesAttributeEntries_compute();
4689        if (isFinal && num == state().boundariesCrossed) {
4690          innerClassesAttributeEntries_computed = true;
4691        } else {
4692        }
4693        state.INTERMEDIATE_VALUE |= intermediate;
4694    
4695        return innerClassesAttributeEntries_value;
4696      }
4697      /**
4698       * @apilevel internal
4699       */
4700      private Collection innerClassesAttributeEntries_compute() {
4701          HashSet list = new HashSet();
4702          if (isNestedType()) {
4703            list.add(this);
4704          }
4705          for (Iterator iter = nestedTypes.iterator(); iter.hasNext(); ) {
4706            list.add(iter.next());
4707          }
4708          for (Iterator iter = usedNestedTypes.iterator(); iter.hasNext(); ) {
4709            list.add(iter.next());
4710          }
4711          return list;
4712        }
4713      /**
4714       * @apilevel internal
4715       */
4716      protected boolean attributes_computed = false;
4717      /**
4718       * @apilevel internal
4719       */
4720      protected Collection attributes_value;
4721      /**
4722       * @apilevel internal
4723       */
4724      private void attributes_reset() {
4725        attributes_computed = false;
4726        attributes_value = null;
4727      }
4728      /**
4729       * @attribute syn
4730       * @aspect Attributes
4731       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:191
4732       */
4733      @ASTNodeAnnotation.Attribute
4734      public Collection attributes() {
4735        ASTNode$State state = state();
4736        if (attributes_computed) {
4737          return attributes_value;
4738        }
4739        boolean intermediate = state.INTERMEDIATE_VALUE;
4740        state.INTERMEDIATE_VALUE = false;
4741        int num = state.boundariesCrossed;
4742        boolean isFinal = this.is$Final();
4743        attributes_value = attributes_compute();
4744        if (isFinal && num == state().boundariesCrossed) {
4745          attributes_computed = true;
4746        } else {
4747        }
4748        state.INTERMEDIATE_VALUE |= intermediate;
4749    
4750        return attributes_value;
4751      }
4752      /**
4753       * @apilevel internal
4754       */
4755      private Collection attributes_compute() {
4756          Collection c = refined_GenericsCodegen_TypeDecl_attributes();
4757          if (isLocalClass() || isAnonymous()) {
4758            c.add(new EnclosingMethod(constantPool(), this));
4759          }
4760          return c;
4761        }
4762      /**
4763       * @apilevel internal
4764       */
4765      protected boolean clinit_attributes_computed = false;
4766      /**
4767       * @apilevel internal
4768       */
4769      protected Collection clinit_attributes_value;
4770      /**
4771       * @apilevel internal
4772       */
4773      private void clinit_attributes_reset() {
4774        clinit_attributes_computed = false;
4775        clinit_attributes_value = null;
4776      }
4777      /**
4778       * @attribute syn
4779       * @aspect Attributes
4780       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:247
4781       */
4782      @ASTNodeAnnotation.Attribute
4783      public Collection clinit_attributes() {
4784        ASTNode$State state = state();
4785        if (clinit_attributes_computed) {
4786          return clinit_attributes_value;
4787        }
4788        boolean intermediate = state.INTERMEDIATE_VALUE;
4789        state.INTERMEDIATE_VALUE = false;
4790        int num = state.boundariesCrossed;
4791        boolean isFinal = this.is$Final();
4792        clinit_attributes_value = clinit_attributes_compute();
4793        if (isFinal && num == state().boundariesCrossed) {
4794          clinit_attributes_computed = true;
4795        } else {
4796        }
4797        state.INTERMEDIATE_VALUE |= intermediate;
4798    
4799        return clinit_attributes_value;
4800      }
4801      /**
4802       * @apilevel internal
4803       */
4804      private Collection clinit_attributes_compute() {
4805          ArrayList l = new ArrayList();
4806          l.add(new CodeAttribute(bytecodes(constantPool()), null));
4807          return l;
4808        }
4809      /**
4810       * @attribute syn
4811       * @aspect CodeGeneration
4812       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:249
4813       */
4814      @ASTNodeAnnotation.Attribute
4815      public byte arrayLoad() {
4816        {
4817            throw new Error("Cannot create array load for TypeDecl");
4818          }
4819      }
4820      /**
4821       * @attribute syn
4822       * @aspect CodeGeneration
4823       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:380
4824       */
4825      @ASTNodeAnnotation.Attribute
4826      public byte arrayStore() {
4827        {
4828            throw new Error("Cannot create array load for TypeDecl");
4829          }
4830      }
4831      /**
4832       * @apilevel internal
4833       */
4834      protected boolean constantPool_computed = false;
4835      /**
4836       * @apilevel internal
4837       */
4838      protected ConstantPool constantPool_value;
4839      /**
4840       * @apilevel internal
4841       */
4842      private void constantPool_reset() {
4843        constantPool_computed = false;
4844        constantPool_value = null;
4845      }
4846      /**
4847       * @attribute syn
4848       * @aspect ConstantPool
4849       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPool.jrag:36
4850       */
4851      @ASTNodeAnnotation.Attribute
4852      public ConstantPool constantPool() {
4853        ASTNode$State state = state();
4854        if (constantPool_computed) {
4855          return constantPool_value;
4856        }
4857        boolean intermediate = state.INTERMEDIATE_VALUE;
4858        state.INTERMEDIATE_VALUE = false;
4859        int num = state.boundariesCrossed;
4860        boolean isFinal = this.is$Final();
4861        constantPool_value = new ConstantPool(this);
4862        if (isFinal && num == state().boundariesCrossed) {
4863          constantPool_computed = true;
4864        } else {
4865        }
4866        state.INTERMEDIATE_VALUE |= intermediate;
4867    
4868        return constantPool_value;
4869      }
4870      /**
4871       * @apilevel internal
4872       */
4873      protected boolean constantPoolName_computed = false;
4874      /**
4875       * @apilevel internal
4876       */
4877      protected String constantPoolName_value;
4878      /**
4879       * @apilevel internal
4880       */
4881      private void constantPoolName_reset() {
4882        constantPoolName_computed = false;
4883        constantPoolName_value = null;
4884      }
4885      /**
4886       * For a top-level type the constant pool name of the type is the same as the
4887       * canonical name but with dots replaced by solidus.
4888       * 
4889       * <p>For nested types the constant pool name is based on the enclosing top-level
4890       * types constant pool name followed by a dollar sign and a unique index and/or
4891       * the type name.
4892       * 
4893       * @return constant pool name of this type
4894       * @attribute syn
4895       * @aspect ConstantPoolNames
4896       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:44
4897       */
4898      @ASTNodeAnnotation.Attribute
4899      public String constantPoolName() {
4900        ASTNode$State state = state();
4901        if (constantPoolName_computed) {
4902          return constantPoolName_value;
4903        }
4904        boolean intermediate = state.INTERMEDIATE_VALUE;
4905        state.INTERMEDIATE_VALUE = false;
4906        int num = state.boundariesCrossed;
4907        boolean isFinal = this.is$Final();
4908        constantPoolName_value = constantPoolName_compute();
4909        if (isFinal && num == state().boundariesCrossed) {
4910          constantPoolName_computed = true;
4911        } else {
4912        }
4913        state.INTERMEDIATE_VALUE |= intermediate;
4914    
4915        return constantPoolName_value;
4916      }
4917      /**
4918       * @apilevel internal
4919       */
4920      private String constantPoolName_compute() {
4921          String packageName = packageName();
4922          if (!packageName.equals("")) {
4923            packageName = packageName.replace('.', '/') + "/";
4924          }
4925          return packageName + uniqueName();
4926        }
4927      /**
4928       * @apilevel internal
4929       */
4930      protected boolean uniqueName_computed = false;
4931      /**
4932       * @apilevel internal
4933       */
4934      protected String uniqueName_value;
4935      /**
4936       * @apilevel internal
4937       */
4938      private void uniqueName_reset() {
4939        uniqueName_computed = false;
4940        uniqueName_value = null;
4941      }
4942      /**
4943       * Computes a unique name for this type in the enclosing package.
4944       * <p>For top-level types the unique name is just the type name.  For nested
4945       * types it is the enclosing types unique name followed by a dollar sign and
4946       * a unique index and/or the type name.
4947       * 
4948       * @return a name for this type that is unique in the enclosing package
4949       * @attribute syn
4950       * @aspect ConstantPoolNames
4951       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:60
4952       */
4953      @ASTNodeAnnotation.Attribute
4954      public String uniqueName() {
4955        ASTNode$State state = state();
4956        if (uniqueName_computed) {
4957          return uniqueName_value;
4958        }
4959        boolean intermediate = state.INTERMEDIATE_VALUE;
4960        state.INTERMEDIATE_VALUE = false;
4961        int num = state.boundariesCrossed;
4962        boolean isFinal = this.is$Final();
4963        uniqueName_value = uniqueName_compute();
4964        if (isFinal && num == state().boundariesCrossed) {
4965          uniqueName_computed = true;
4966        } else {
4967        }
4968        state.INTERMEDIATE_VALUE |= intermediate;
4969    
4970        return uniqueName_value;
4971      }
4972      /**
4973       * @apilevel internal
4974       */
4975      private String uniqueName_compute() {
4976          if (!isNestedType()) {
4977            return getID();
4978          } else {
4979            String prefix = enclosingType().uniqueName();
4980            if (isAnonymous()) {
4981              return prefix + "$" + uniqueIndex();
4982            } else if (isLocalClass()) {
4983              return prefix + "$" + uniqueIndex() + getID();
4984            } else {
4985              return prefix + "$" + getID();
4986            }
4987          }
4988        }
4989      /**
4990       * @apilevel internal
4991       */
4992      protected boolean typeDescriptor_computed = false;
4993      /**
4994       * @apilevel internal
4995       */
4996      protected String typeDescriptor_value;
4997      /**
4998       * @apilevel internal
4999       */
5000      private void typeDescriptor_reset() {
5001        typeDescriptor_computed = false;
5002        typeDescriptor_value = null;
5003      }
5004      /**
5005       * @attribute syn
5006       * @aspect ConstantPoolNames
5007       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77
5008       */
5009      @ASTNodeAnnotation.Attribute
5010      public String typeDescriptor() {
5011        ASTNode$State state = state();
5012        if (typeDescriptor_computed) {
5013          return typeDescriptor_value;
5014        }
5015        boolean intermediate = state.INTERMEDIATE_VALUE;
5016        state.INTERMEDIATE_VALUE = false;
5017        int num = state.boundariesCrossed;
5018        boolean isFinal = this.is$Final();
5019        typeDescriptor_value = typeDescriptor_compute();
5020        if (isFinal && num == state().boundariesCrossed) {
5021          typeDescriptor_computed = true;
5022        } else {
5023        }
5024        state.INTERMEDIATE_VALUE |= intermediate;
5025    
5026        return typeDescriptor_value;
5027      }
5028      /**
5029       * @apilevel internal
5030       */
5031      private String typeDescriptor_compute() {
5032          throw new Error("Can not compute typeDescriptor for " + getClass().getName());
5033        }
5034      /**
5035       * @apilevel internal
5036       */
5037      protected boolean destinationPath_computed = false;
5038      /**
5039       * @apilevel internal
5040       */
5041      protected String destinationPath_value;
5042      /**
5043       * @apilevel internal
5044       */
5045      private void destinationPath_reset() {
5046        destinationPath_computed = false;
5047        destinationPath_value = null;
5048      }
5049      /**
5050       * @return The path to the classfiles that should be generated for this type.
5051       * @attribute syn
5052       * @aspect ConstantPoolNames
5053       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:158
5054       */
5055      @ASTNodeAnnotation.Attribute
5056      public String destinationPath() {
5057        ASTNode$State state = state();
5058        if (destinationPath_computed) {
5059          return destinationPath_value;
5060        }
5061        boolean intermediate = state.INTERMEDIATE_VALUE;
5062        state.INTERMEDIATE_VALUE = false;
5063        int num = state.boundariesCrossed;
5064        boolean isFinal = this.is$Final();
5065        destinationPath_value = destinationPath_compute();
5066        if (isFinal && num == state().boundariesCrossed) {
5067          destinationPath_computed = true;
5068        } else {
5069        }
5070        state.INTERMEDIATE_VALUE |= intermediate;
5071    
5072        return destinationPath_value;
5073      }
5074      /**
5075       * @apilevel internal
5076       */
5077      private String destinationPath_compute() {
5078          if (program().options().hasValueForOption("-d")) {
5079            return program().options().getValueForOption("-d") + File.separator
5080                + constantPoolName() + ".class";
5081          } else {
5082            return compilationUnit().destinationPath() + File.separator
5083                + uniqueName() + ".class";
5084          }
5085        }
5086      /**
5087       * @apilevel internal
5088       */
5089      protected boolean hasClinit_computed = false;
5090      /**
5091       * @apilevel internal
5092       */
5093      protected boolean hasClinit_value;
5094      /**
5095       * @apilevel internal
5096       */
5097      private void hasClinit_reset() {
5098        hasClinit_computed = false;
5099      }
5100      /**
5101       * @attribute syn
5102       * @aspect CreateBCode
5103       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:50
5104       */
5105      @ASTNodeAnnotation.Attribute
5106      public boolean hasClinit() {
5107        ASTNode$State state = state();
5108        if (hasClinit_computed) {
5109          return hasClinit_value;
5110        }
5111        boolean intermediate = state.INTERMEDIATE_VALUE;
5112        state.INTERMEDIATE_VALUE = false;
5113        int num = state.boundariesCrossed;
5114        boolean isFinal = this.is$Final();
5115        hasClinit_value = hasClinit_compute();
5116        if (isFinal && num == state().boundariesCrossed) {
5117          hasClinit_computed = true;
5118        } else {
5119        }
5120        state.INTERMEDIATE_VALUE |= intermediate;
5121    
5122        return hasClinit_value;
5123      }
5124      /**
5125       * @apilevel internal
5126       */
5127      private boolean hasClinit_compute() {
5128          for (int i = 0; i < getNumBodyDecl(); i++) {
5129            BodyDecl b = getBodyDecl(i);
5130            if (b instanceof FieldDeclaration) {
5131              FieldDeclaration f = (FieldDeclaration) b;
5132              if (f.isStatic() && f.hasInit()) {
5133                return true;
5134              }
5135            } else if (b instanceof StaticInitializer) {
5136              return true;
5137            }
5138          }
5139          return false;
5140        }
5141      /**
5142       * @apilevel internal
5143       */
5144      protected java.util.Map bytecodes_ConstantPool_values;
5145      /**
5146       * @apilevel internal
5147       */
5148      private void bytecodes_ConstantPool_reset() {
5149        bytecodes_ConstantPool_values = null;
5150      }
5151      /**
5152       * @attribute syn
5153       * @aspect CreateBCode
5154       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:65
5155       */
5156      @ASTNodeAnnotation.Attribute
5157      public CodeGeneration bytecodes(ConstantPool constantPool) {
5158        Object _parameters = constantPool;
5159        if (bytecodes_ConstantPool_values == null) bytecodes_ConstantPool_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
5160        ASTNode$State state = state();
5161        if (bytecodes_ConstantPool_values.containsKey(_parameters)) {
5162          return (CodeGeneration) bytecodes_ConstantPool_values.get(_parameters);
5163        }
5164        boolean intermediate = state.INTERMEDIATE_VALUE;
5165        state.INTERMEDIATE_VALUE = false;
5166        int num = state.boundariesCrossed;
5167        boolean isFinal = this.is$Final();
5168        CodeGeneration bytecodes_ConstantPool_value = bytecodes_compute(constantPool);
5169        if (isFinal && num == state().boundariesCrossed) {
5170          bytecodes_ConstantPool_values.put(_parameters, bytecodes_ConstantPool_value);
5171        } else {
5172        }
5173        state.INTERMEDIATE_VALUE |= intermediate;
5174    
5175        return bytecodes_ConstantPool_value;
5176      }
5177      /**
5178       * @apilevel internal
5179       */
5180      private CodeGeneration bytecodes_compute(ConstantPool constantPool) {
5181          CodeGeneration gen = new CodeGeneration(constantPool);
5182          generateBytecodes(gen);
5183          if (!gen.numberFormatError()) {
5184            return gen;
5185          }
5186          gen = new CodeGeneration(constantPool, true);
5187          generateBytecodes(gen);
5188          if (!gen.numberFormatError()) {
5189            return gen;
5190          }
5191          throw new Error("Could not generate code for initializers in " + hostType().typeName());
5192        }
5193      /**
5194       * @attribute syn
5195       * @aspect CreateBCode
5196       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:550
5197       */
5198      @ASTNodeAnnotation.Attribute
5199      public boolean needsAccessorFor(Variable v) {
5200        {
5201            if (!(v instanceof FieldDeclaration)) {
5202              return false;
5203            }
5204            FieldDeclaration f = (FieldDeclaration) v;
5205            if (f.isConstant() && (f.type().isPrimitive() || f.type().isString())) {
5206              return false;
5207            }
5208            return f.isPrivate() && !hasField(v.name());
5209          }
5210      }
5211      /**
5212       * @attribute syn
5213       * @aspect CreateBCode
5214       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:900
5215       */
5216      @ASTNodeAnnotation.Attribute
5217      public String arrayTypeDescriptor() {
5218        { throw new Error("Operation not supported"); }
5219      }
5220      /**
5221       * @attribute syn
5222       * @aspect CreateBCode
5223       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:905
5224       */
5225      @ASTNodeAnnotation.Attribute
5226      public int arrayPrimitiveTypeDescriptor() {
5227        { error(); return -1; }
5228      }
5229      /**
5230       * @apilevel internal
5231       */
5232      protected boolean flags_computed = false;
5233      /**
5234       * @apilevel internal
5235       */
5236      protected int flags_value;
5237      /**
5238       * @apilevel internal
5239       */
5240      private void flags_reset() {
5241        flags_computed = false;
5242      }
5243      /**
5244       * @attribute syn
5245       * @aspect Flags
5246       * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:110
5247       */
5248      @ASTNodeAnnotation.Attribute
5249      public int flags() {
5250        ASTNode$State state = state();
5251        if (flags_computed) {
5252          return flags_value;
5253        }
5254        boolean intermediate = state.INTERMEDIATE_VALUE;
5255        state.INTERMEDIATE_VALUE = false;
5256        int num = state.boundariesCrossed;
5257        boolean isFinal = this.is$Final();
5258        flags_value = flags_compute();
5259        if (isFinal && num == state().boundariesCrossed) {
5260          flags_computed = true;
5261        } else {
5262        }
5263        state.INTERMEDIATE_VALUE |= intermediate;
5264    
5265        return flags_value;
5266      }
5267      /**
5268       * @apilevel internal
5269       */
5270      private int flags_compute() {
5271          int res = 0;
5272          if (isPublic()) {
5273            res |= Modifiers.ACC_PUBLIC;
5274          }
5275          if (isPrivate()) {
5276            res |= Modifiers.ACC_PRIVATE;
5277          }
5278          if (isProtected()) {
5279            res |= Modifiers.ACC_PROTECTED;
5280          }
5281          if (isStatic()) {
5282            res |= Modifiers.ACC_STATIC;
5283          }
5284          if (isFinal()) {
5285            res |= Modifiers.ACC_FINAL;
5286          }
5287          // ACC_INTERFACE handled in InterfaceDecl
5288          if (isAbstract()) {
5289            res |= Modifiers.ACC_ABSTRACT;
5290          }
5291          return res;
5292        }
5293      /**
5294       * @attribute syn
5295       * @aspect GenerateClassfile
5296       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:55
5297       */
5298      @ASTNodeAnnotation.Attribute
5299      public int magicHeader() {
5300        int magicHeader_value = 0xCAFEBABE;
5301    
5302        return magicHeader_value;
5303      }
5304      /**
5305       * @attribute syn
5306       * @aspect GenerateClassfile
5307       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:56
5308       */
5309      @ASTNodeAnnotation.Attribute
5310      public int minorVersion() {
5311        int minorVersion_value = 0;
5312    
5313        return minorVersion_value;
5314      }
5315      /**
5316       * @attribute syn
5317       * @aspect GenerateClassfile
5318       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:57
5319       */
5320      @ASTNodeAnnotation.Attribute
5321      public int majorVersion() {
5322        {
5323            return 49;
5324          }
5325      }
5326      /**
5327       * @apilevel internal
5328       */
5329      protected boolean bcFields_computed = false;
5330      /**
5331       * @apilevel internal
5332       */
5333      protected Collection bcFields_value;
5334      /**
5335       * @apilevel internal
5336       */
5337      private void bcFields_reset() {
5338        bcFields_computed = false;
5339        bcFields_value = null;
5340      }
5341      /**
5342       * @attribute syn
5343       * @aspect GenerateClassfile
5344       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:317
5345       */
5346      @ASTNodeAnnotation.Attribute
5347      public Collection bcFields() {
5348        ASTNode$State state = state();
5349        if (bcFields_computed) {
5350          return bcFields_value;
5351        }
5352        boolean intermediate = state.INTERMEDIATE_VALUE;
5353        state.INTERMEDIATE_VALUE = false;
5354        int num = state.boundariesCrossed;
5355        boolean isFinal = this.is$Final();
5356        bcFields_value = new ArrayList();
5357        if (isFinal && num == state().boundariesCrossed) {
5358          bcFields_computed = true;
5359        } else {
5360        }
5361        state.INTERMEDIATE_VALUE |= intermediate;
5362    
5363        return bcFields_value;
5364      }
5365      /**
5366       * @attribute syn
5367       * @aspect GenerateClassfile
5368       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:379
5369       */
5370      @ASTNodeAnnotation.Attribute
5371      public boolean flush() {
5372        boolean flush_value = false;
5373    
5374        return flush_value;
5375      }
5376      /**
5377       * @attribute syn
5378       * @aspect InnerClasses
5379       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:113
5380       */
5381      @ASTNodeAnnotation.Attribute
5382      public TypeDecl stringPromotion() {
5383        TypeDecl stringPromotion_value = this;
5384    
5385        return stringPromotion_value;
5386      }
5387      /**
5388       * @attribute syn
5389       * @aspect InnerClasses
5390       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:125
5391       */
5392      @ASTNodeAnnotation.Attribute
5393      public MethodDecl methodWithArgs(String name, TypeDecl[] args) {
5394        {
5395            for (Iterator iter = memberMethods(name).iterator(); iter.hasNext(); ) {
5396              MethodDecl m = (MethodDecl) iter.next();
5397              if (m.getNumParameter() == args.length) {
5398                for (int i = 0; i < args.length; i++) {
5399                  if (m.getParameter(i).type() == args[i]) {
5400                    return m;
5401                  }
5402                }
5403              }
5404            }
5405            return null;
5406          }
5407      }
5408      /**
5409       * @apilevel internal
5410       */
5411      protected boolean enclosingVariables_computed = false;
5412      /**
5413       * @apilevel internal
5414       */
5415      protected Collection enclosingVariables_value;
5416      /**
5417       * @apilevel internal
5418       */
5419      private void enclosingVariables_reset() {
5420        enclosingVariables_computed = false;
5421        enclosingVariables_value = null;
5422      }
5423      /**
5424       * @attribute syn
5425       * @aspect InnerClasses
5426       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:176
5427       */
5428      @ASTNodeAnnotation.Attribute
5429      public Collection enclosingVariables() {
5430        ASTNode$State state = state();
5431        if (enclosingVariables_computed) {
5432          return enclosingVariables_value;
5433        }
5434        boolean intermediate = state.INTERMEDIATE_VALUE;
5435        state.INTERMEDIATE_VALUE = false;
5436        int num = state.boundariesCrossed;
5437        boolean isFinal = this.is$Final();
5438        enclosingVariables_value = enclosingVariables_compute();
5439        if (isFinal && num == state().boundariesCrossed) {
5440          enclosingVariables_computed = true;
5441        } else {
5442        }
5443        state.INTERMEDIATE_VALUE |= intermediate;
5444    
5445        return enclosingVariables_value;
5446      }
5447      /**
5448       * @apilevel internal
5449       */
5450      private Collection enclosingVariables_compute() {
5451          HashSet set = new HashSet();
5452          for (TypeDecl e = this; e != null; e = e.enclosingType()) {
5453            if (e.isLocalClass() || e.isAnonymous()) {
5454              collectEnclosingVariables(set, e.enclosingType());
5455            }
5456          }
5457          if (isClassDecl()) {
5458            ClassDecl classDecl = (ClassDecl) this;
5459            if (classDecl.isNestedType() && classDecl.hasSuperclass()) {
5460              set.addAll(classDecl.superclass().enclosingVariables());
5461            }
5462          }
5463          return set;
5464        }
5465      /**
5466       * @attribute syn
5467       * @aspect InnerClasses
5468       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:456
5469       */
5470      @ASTNodeAnnotation.Attribute
5471      public boolean isAnonymousInNonStaticContext() {
5472        {
5473            return isAnonymous() &&
5474                   !((ClassInstanceExpr) getParent().getParent()).unqualifiedScope().inStaticContext()
5475                   && (!inExplicitConstructorInvocation() || enclosingBodyDecl().hostType().isInnerType());
5476          }
5477      }
5478      /**
5479       * @apilevel internal
5480       */
5481      protected boolean needsEnclosing_computed = false;
5482      /**
5483       * @apilevel internal
5484       */
5485      protected boolean needsEnclosing_value;
5486      /**
5487       * @apilevel internal
5488       */
5489      private void needsEnclosing_reset() {
5490        needsEnclosing_computed = false;
5491      }
5492      /**
5493       * @attribute syn
5494       * @aspect InnerClasses
5495       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:462
5496       */
5497      @ASTNodeAnnotation.Attribute
5498      public boolean needsEnclosing() {
5499        ASTNode$State state = state();
5500        if (needsEnclosing_computed) {
5501          return needsEnclosing_value;
5502        }
5503        boolean intermediate = state.INTERMEDIATE_VALUE;
5504        state.INTERMEDIATE_VALUE = false;
5505        int num = state.boundariesCrossed;
5506        boolean isFinal = this.is$Final();
5507        needsEnclosing_value = needsEnclosing_compute();
5508        if (isFinal && num == state().boundariesCrossed) {
5509          needsEnclosing_computed = true;
5510        } else {
5511        }
5512        state.INTERMEDIATE_VALUE |= intermediate;
5513    
5514        return needsEnclosing_value;
5515      }
5516      /**
5517       * @apilevel internal
5518       */
5519      private boolean needsEnclosing_compute() {
5520          if (isAnonymous()) {
5521            return isAnonymousInNonStaticContext();
5522          } else if (isLocalClass()) {
5523            return !inStaticContext();
5524          } else if (isInnerType()) {
5525            return true;
5526          }
5527          return false;
5528        }
5529      /**
5530       * @apilevel internal
5531       */
5532      protected boolean needsSuperEnclosing_computed = false;
5533      /**
5534       * @apilevel internal
5535       */
5536      protected boolean needsSuperEnclosing_value;
5537      /**
5538       * @apilevel internal
5539       */
5540      private void needsSuperEnclosing_reset() {
5541        needsSuperEnclosing_computed = false;
5542      }
5543      /**
5544       * @attribute syn
5545       * @aspect InnerClasses
5546       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:473
5547       */
5548      @ASTNodeAnnotation.Attribute
5549      public boolean needsSuperEnclosing() {
5550        ASTNode$State state = state();
5551        if (needsSuperEnclosing_computed) {
5552          return needsSuperEnclosing_value;
5553        }
5554        boolean intermediate = state.INTERMEDIATE_VALUE;
5555        state.INTERMEDIATE_VALUE = false;
5556        int num = state.boundariesCrossed;
5557        boolean isFinal = this.is$Final();
5558        needsSuperEnclosing_value = needsSuperEnclosing_compute();
5559        if (isFinal && num == state().boundariesCrossed) {
5560          needsSuperEnclosing_computed = true;
5561        } else {
5562        }
5563        state.INTERMEDIATE_VALUE |= intermediate;
5564    
5565        return needsSuperEnclosing_value;
5566      }
5567      /**
5568       * @apilevel internal
5569       */
5570      private boolean needsSuperEnclosing_compute() {
5571          if (!isAnonymous()) {
5572            return false;
5573          }
5574          TypeDecl superClass = ((ClassDecl) this).superclass();
5575          if (superClass.isLocalClass()) {
5576            return !superClass.inStaticContext();
5577          } else if (superClass.isInnerType()) {
5578            return true;
5579          } if (needsEnclosing() && enclosing() == superEnclosing()) {
5580            return false;
5581          }
5582          return false;
5583        }
5584      /**
5585       * @attribute syn
5586       * @aspect InnerClasses
5587       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:488
5588       */
5589      @ASTNodeAnnotation.Attribute
5590      public TypeDecl enclosing() {
5591        {
5592            if (!needsEnclosing()) {
5593              return null;
5594            }
5595            TypeDecl typeDecl = enclosingType();
5596            if (isAnonymous() && inExplicitConstructorInvocation()) {
5597              typeDecl = typeDecl.enclosingType();
5598            }
5599            return typeDecl;
5600          }
5601      }
5602      /**
5603       * @attribute syn
5604       * @aspect InnerClasses
5605       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:499
5606       */
5607      @ASTNodeAnnotation.Attribute
5608      public TypeDecl superEnclosing() {
5609        TypeDecl superEnclosing_value = null;
5610    
5611        return superEnclosing_value;
5612      }
5613      /**
5614       * @apilevel internal
5615       */
5616      protected boolean uniqueIndex_computed = false;
5617      /**
5618       * @apilevel internal
5619       */
5620      protected int uniqueIndex_value;
5621      /**
5622       * @apilevel internal
5623       */
5624      private void uniqueIndex_reset() {
5625        uniqueIndex_computed = false;
5626      }
5627      /**
5628       * @attribute syn
5629       * @aspect Java2Rewrites
5630       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:33
5631       */
5632      @ASTNodeAnnotation.Attribute
5633      public int uniqueIndex() {
5634        ASTNode$State state = state();
5635        if (uniqueIndex_computed) {
5636          return uniqueIndex_value;
5637        }
5638        boolean intermediate = state.INTERMEDIATE_VALUE;
5639        state.INTERMEDIATE_VALUE = false;
5640        int num = state.boundariesCrossed;
5641        boolean isFinal = this.is$Final();
5642        uniqueIndex_value = topLevelType().uniqueIndexCounter++;
5643        if (isFinal && num == state().boundariesCrossed) {
5644          uniqueIndex_computed = true;
5645        } else {
5646        }
5647        state.INTERMEDIATE_VALUE |= intermediate;
5648    
5649        return uniqueIndex_value;
5650      }
5651      /**
5652       * @apilevel internal
5653       */
5654      protected boolean jvmName_computed = false;
5655      /**
5656       * @apilevel internal
5657       */
5658      protected String jvmName_value;
5659      /**
5660       * @apilevel internal
5661       */
5662      private void jvmName_reset() {
5663        jvmName_computed = false;
5664        jvmName_value = null;
5665      }
5666      /**
5667       * @attribute syn
5668       * @aspect Java2Rewrites
5669       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:36
5670       */
5671      @ASTNodeAnnotation.Attribute
5672      public String jvmName() {
5673        ASTNode$State state = state();
5674        if (jvmName_computed) {
5675          return jvmName_value;
5676        }
5677        boolean intermediate = state.INTERMEDIATE_VALUE;
5678        state.INTERMEDIATE_VALUE = false;
5679        int num = state.boundariesCrossed;
5680        boolean isFinal = this.is$Final();
5681        jvmName_value = jvmName_compute();
5682        if (isFinal && num == state().boundariesCrossed) {
5683          jvmName_computed = true;
5684        } else {
5685        }
5686        state.INTERMEDIATE_VALUE |= intermediate;
5687    
5688        return jvmName_value;
5689      }
5690      /**
5691       * @apilevel internal
5692       */
5693      private String jvmName_compute() {
5694          throw new Error("Jvm name only supported for reference types and not " + getClass().getName());
5695        }
5696      /**
5697       * @attribute syn
5698       * @aspect Java2Rewrites
5699       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:68
5700       */
5701      @ASTNodeAnnotation.Attribute
5702      public String primitiveClassName() {
5703        {
5704            throw new Error("primitiveClassName not supported for " + name() + " of type " + getClass().getName());
5705          }
5706      }
5707      /**
5708       * @attribute syn
5709       * @aspect Java2Rewrites
5710       * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:81
5711       */
5712      @ASTNodeAnnotation.Attribute
5713      public String referenceClassFieldName() {
5714        {
5715            throw new Error("referenceClassFieldName not supported for " + name() + " of type " + getClass().getName());
5716          }
5717      }
5718      /**
5719       * @attribute syn
5720       * @aspect LocalNum
5721       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:199
5722       */
5723      @ASTNodeAnnotation.Attribute
5724      public int variableSize() {
5725        int variableSize_value = 0;
5726    
5727        return variableSize_value;
5728      }
5729      /**
5730       * @attribute syn
5731       * @aspect Annotations
5732       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:151
5733       */
5734      @ASTNodeAnnotation.Attribute
5735      public boolean isValidAnnotationMethodReturnType() {
5736        boolean isValidAnnotationMethodReturnType_value = false;
5737    
5738        return isValidAnnotationMethodReturnType_value;
5739      }
5740      /**
5741       * @attribute syn
5742       * @aspect Annotations
5743       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:289
5744       */
5745      @ASTNodeAnnotation.Attribute
5746      public boolean isType(String packageName, String name) {
5747        boolean isType_String_String_value = getID().equals(name) && packageName().equals(packageName);
5748    
5749        return isType_String_String_value;
5750      }
5751      /**
5752       * @attribute syn
5753       * @aspect Annotations
5754       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:292
5755       */
5756      @ASTNodeAnnotation.Attribute
5757      public Annotation annotation(TypeDecl typeDecl) {
5758        Annotation annotation_TypeDecl_value = getModifiers().annotation(typeDecl);
5759    
5760        return annotation_TypeDecl_value;
5761      }
5762      /**
5763       * @attribute syn
5764       * @aspect Annotations
5765       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:355
5766       */
5767      @ASTNodeAnnotation.Attribute
5768      public boolean hasAnnotationSuppressWarnings(String annot) {
5769        boolean hasAnnotationSuppressWarnings_String_value = getModifiers().hasAnnotationSuppressWarnings(annot);
5770    
5771        return hasAnnotationSuppressWarnings_String_value;
5772      }
5773      /**
5774       * @attribute syn
5775       * @aspect Annotations
5776       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:397
5777       */
5778      @ASTNodeAnnotation.Attribute
5779      public boolean isDeprecated() {
5780        boolean isDeprecated_value = getModifiers().hasDeprecatedAnnotation();
5781    
5782        return isDeprecated_value;
5783      }
5784      /**
5785       * @attribute syn
5786       * @aspect Annotations
5787       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:557
5788       */
5789      @ASTNodeAnnotation.Attribute
5790      public boolean commensurateWith(ElementValue value) {
5791        boolean commensurateWith_ElementValue_value = value.commensurateWithTypeDecl(this);
5792    
5793        return commensurateWith_ElementValue_value;
5794      }
5795      /**
5796       * @attribute syn
5797       * @aspect Annotations
5798       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:642
5799       */
5800      @ASTNodeAnnotation.Attribute
5801      public boolean isAnnotationDecl() {
5802        boolean isAnnotationDecl_value = false;
5803    
5804        return isAnnotationDecl_value;
5805      }
5806      /**
5807       * @attribute syn
5808       * @aspect AutoBoxing
5809       * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:52
5810       */
5811      @ASTNodeAnnotation.Attribute
5812      public boolean boxingConversionTo(TypeDecl typeDecl) {
5813        boolean boxingConversionTo_TypeDecl_value = false;
5814    
5815        return boxingConversionTo_TypeDecl_value;
5816      }
5817      /**
5818       * @apilevel internal
5819       */
5820      protected boolean boxed_computed = false;
5821      /**
5822       * @apilevel internal
5823       */
5824      protected TypeDecl boxed_value;
5825      /**
5826       * @apilevel internal
5827       */
5828      private void boxed_reset() {
5829        boxed_computed = false;
5830        boxed_value = null;
5831      }
5832      /**
5833       * @attribute syn
5834       * @aspect AutoBoxing
5835       * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:56
5836       */
5837      @ASTNodeAnnotation.Attribute
5838      public TypeDecl boxed() {
5839        ASTNode$State state = state();
5840        if (boxed_computed) {
5841          return boxed_value;
5842        }
5843        boolean intermediate = state.INTERMEDIATE_VALUE;
5844        state.INTERMEDIATE_VALUE = false;
5845        int num = state.boundariesCrossed;
5846        boolean isFinal = this.is$Final();
5847        boxed_value = unknownType();
5848        if (isFinal && num == state().boundariesCrossed) {
5849          boxed_computed = true;
5850        } else {
5851        }
5852        state.INTERMEDIATE_VALUE |= intermediate;
5853    
5854        return boxed_value;
5855      }
5856      /**
5857       * @attribute syn
5858       * @aspect AutoBoxing
5859       * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:68
5860       */
5861      @ASTNodeAnnotation.Attribute
5862      public boolean unboxingConversionTo(TypeDecl typeDecl) {
5863        boolean unboxingConversionTo_TypeDecl_value = false;
5864    
5865        return unboxingConversionTo_TypeDecl_value;
5866      }
5867      /**
5868       * @apilevel internal
5869       */
5870      protected boolean unboxed_computed = false;
5871      /**
5872       * @apilevel internal
5873       */
5874      protected TypeDecl unboxed_value;
5875      /**
5876       * @apilevel internal
5877       */
5878      private void unboxed_reset() {
5879        unboxed_computed = false;
5880        unboxed_value = null;
5881      }
5882      /**
5883       * @attribute syn
5884       * @aspect AutoBoxing
5885       * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:72
5886       */
5887      @ASTNodeAnnotation.Attribute
5888      public TypeDecl unboxed() {
5889        ASTNode$State state = state();
5890        if (unboxed_computed) {
5891          return unboxed_value;
5892        }
5893        boolean intermediate = state.INTERMEDIATE_VALUE;
5894        state.INTERMEDIATE_VALUE = false;
5895        int num = state.boundariesCrossed;
5896        boolean isFinal = this.is$Final();
5897        unboxed_value = unknownType();
5898        if (isFinal && num == state().boundariesCrossed) {
5899          unboxed_computed = true;
5900        } else {
5901        }
5902        state.INTERMEDIATE_VALUE |= intermediate;
5903    
5904        return unboxed_value;
5905      }
5906      /**
5907       * @apilevel internal
5908       */
5909      protected boolean isIterable_computed = false;
5910      /**
5911       * @apilevel internal
5912       */
5913      protected boolean isIterable_value;
5914      /**
5915       * @apilevel internal
5916       */
5917      private void isIterable_reset() {
5918        isIterable_computed = false;
5919      }
5920      /**
5921       * True if type is java.lang.Iterable or subtypeAs long as we use the 1.4 API we check for java.util.Collection instead.
5922       * @attribute syn
5923       * @aspect EnhancedFor
5924       * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:63
5925       */
5926      @ASTNodeAnnotation.Attribute
5927      public boolean isIterable() {
5928        ASTNode$State state = state();
5929        if (isIterable_computed) {
5930          return isIterable_value;
5931        }
5932        boolean intermediate = state.INTERMEDIATE_VALUE;
5933        state.INTERMEDIATE_VALUE = false;
5934        int num = state.boundariesCrossed;
5935        boolean isFinal = this.is$Final();
5936        isIterable_value = instanceOf(lookupType("java.lang", "Iterable"));
5937        if (isFinal && num == state().boundariesCrossed) {
5938          isIterable_computed = true;
5939        } else {
5940        }
5941        state.INTERMEDIATE_VALUE |= intermediate;
5942    
5943        return isIterable_value;
5944      }
5945      /**
5946       * @attribute syn
5947       * @aspect Enums
5948       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:37
5949       */
5950      @ASTNodeAnnotation.Attribute
5951      public boolean isEnumDecl() {
5952        boolean isEnumDecl_value = false;
5953    
5954        return isEnumDecl_value;
5955      }
5956      /**
5957       * @param bound the bounded type variable
5958       * @param par a parameterization of the type for which the type variable
5959       * occurs in the type parameter list
5960       * @return {@code true} if this type is within the bounds of the parameter type
5961       * @attribute syn
5962       * @aspect GenericBoundCheck
5963       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:42
5964       */
5965      @ASTNodeAnnotation.Attribute
5966      public boolean withinBounds(TypeDecl bound, Parameterization par) {
5967        boolean withinBounds_TypeDecl_Parameterization_value = bound.boundOf(this, par);
5968    
5969        return withinBounds_TypeDecl_Parameterization_value;
5970      }
5971      /**
5972       * Check if a type is in the bound of this type, given a specific
5973       * parameterization of this type.
5974       * 
5975       * See JLS SE7 $4.5
5976       * 
5977       * @param argument argument type
5978       * @param par a parameterization
5979       * @return {@code true} if the argument type is in the bound of this type
5980       * @attribute syn
5981       * @aspect GenericBoundCheck
5982       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:63
5983       */
5984      @ASTNodeAnnotation.Attribute
5985      public boolean boundOf(TypeDecl argument, Parameterization par) {
5986        boolean boundOf_TypeDecl_Parameterization_value = false;
5987    
5988        return boundOf_TypeDecl_Parameterization_value;
5989      }
5990      /**
5991       * @attribute syn
5992       * @aspect GenericBoundCheck
5993       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:80
5994       */
5995      @ASTNodeAnnotation.Attribute
5996      public boolean boundOfWildcard(WildcardType type) {
5997        boolean boundOfWildcard_WildcardType_value = false;
5998    
5999        return boundOfWildcard_WildcardType_value;
6000      }
6001      /**
6002       * @attribute syn
6003       * @aspect GenericBoundCheck
6004       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:83
6005       */
6006      @ASTNodeAnnotation.Attribute
6007      public boolean boundOfWildcardExtends(WildcardExtendsType type) {
6008        boolean boundOfWildcardExtends_WildcardExtendsType_value = false;
6009    
6010        return boundOfWildcardExtends_WildcardExtendsType_value;
6011      }
6012      /**
6013       * @attribute syn
6014       * @aspect GenericBoundCheck
6015       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:87
6016       */
6017      @ASTNodeAnnotation.Attribute
6018      public boolean boundOfWildcardSuper(WildcardSuperType type) {
6019        boolean boundOfWildcardSuper_WildcardSuperType_value = false;
6020    
6021        return boundOfWildcardSuper_WildcardSuperType_value;
6022      }
6023      /**
6024       * @attribute syn
6025       * @aspect GenericMethodsInference
6026       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:34
6027       */
6028      @ASTNodeAnnotation.Attribute
6029      public boolean isUnboxedPrimitive() {
6030        boolean isUnboxedPrimitive_value = this instanceof PrimitiveType && isPrimitive();
6031    
6032        return isUnboxedPrimitive_value;
6033      }
6034      /**
6035       * @apilevel internal
6036       */
6037      protected int involvesTypeParameters_visited = -1;
6038      /**
6039       * @apilevel internal
6040       */
6041      private void involvesTypeParameters_reset() {
6042        involvesTypeParameters_computed = false;
6043        involvesTypeParameters_initialized = false;
6044        involvesTypeParameters_visited = -1;
6045      }
6046      /**
6047       * @apilevel internal
6048       */
6049      protected boolean involvesTypeParameters_computed = false;
6050      /**
6051       * @apilevel internal
6052       */
6053      protected boolean involvesTypeParameters_initialized = false;
6054      /**
6055       * @apilevel internal
6056       */
6057      protected boolean involvesTypeParameters_value;
6058      @ASTNodeAnnotation.Attribute
6059      public boolean involvesTypeParameters() {
6060        if (involvesTypeParameters_computed) {
6061          return involvesTypeParameters_value;
6062        }
6063        ASTNode$State state = state();
6064        boolean new_involvesTypeParameters_value;
6065        if (!involvesTypeParameters_initialized) {
6066          involvesTypeParameters_initialized = true;
6067          involvesTypeParameters_value = false;
6068        }
6069        if (!state.IN_CIRCLE) {
6070          state.IN_CIRCLE = true;
6071          int num = state.boundariesCrossed;
6072          boolean isFinal = this.is$Final();
6073          do {
6074            involvesTypeParameters_visited = state.CIRCLE_INDEX;
6075            state.CHANGE = false;
6076            new_involvesTypeParameters_value = false;
6077            if (new_involvesTypeParameters_value != involvesTypeParameters_value) {
6078              state.CHANGE = true;
6079            }
6080            involvesTypeParameters_value = new_involvesTypeParameters_value;
6081            state.CIRCLE_INDEX++;
6082          } while (state.CHANGE);
6083          if (isFinal && num == state().boundariesCrossed) {
6084            involvesTypeParameters_computed = true;
6085          } else {
6086            state.RESET_CYCLE = true;
6087            boolean $tmp = false;
6088            state.RESET_CYCLE = false;
6089            involvesTypeParameters_computed = false;
6090            involvesTypeParameters_initialized = false;
6091          }
6092          state.IN_CIRCLE = false;
6093          state.INTERMEDIATE_VALUE = false;
6094          return involvesTypeParameters_value;
6095        }
6096        if (involvesTypeParameters_visited != state.CIRCLE_INDEX) {
6097          involvesTypeParameters_visited = state.CIRCLE_INDEX;
6098          if (state.RESET_CYCLE) {
6099            involvesTypeParameters_computed = false;
6100            involvesTypeParameters_initialized = false;
6101            involvesTypeParameters_visited = -1;
6102            return involvesTypeParameters_value;
6103          }
6104          new_involvesTypeParameters_value = false;
6105          if (new_involvesTypeParameters_value != involvesTypeParameters_value) {
6106            state.CHANGE = true;
6107          }
6108          involvesTypeParameters_value = new_involvesTypeParameters_value;
6109          state.INTERMEDIATE_VALUE = true;
6110          return involvesTypeParameters_value;
6111        }
6112        state.INTERMEDIATE_VALUE = true;
6113        return involvesTypeParameters_value;
6114      }
6115      /**
6116       * @attribute syn
6117       * @aspect Generics
6118       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:221
6119       */
6120      @ASTNodeAnnotation.Attribute
6121      public boolean isGenericType() {
6122        boolean isGenericType_value = false;
6123    
6124        return isGenericType_value;
6125      }
6126      /**
6127       * @attribute syn
6128       * @aspect Generics
6129       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:316
6130       */
6131      @ASTNodeAnnotation.Attribute
6132      public boolean isParameterizedType() {
6133        boolean isParameterizedType_value = false;
6134    
6135        return isParameterizedType_value;
6136      }
6137      /**
6138       * @attribute syn
6139       * @aspect Generics
6140       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:319
6141       */
6142      @ASTNodeAnnotation.Attribute
6143      public boolean isRawType() {
6144        boolean isRawType_value = isNestedType() && enclosingType().isRawType();
6145    
6146        return isRawType_value;
6147      }
6148      /**
6149       * @apilevel internal
6150       */
6151      protected boolean erasure_computed = false;
6152      /**
6153       * @apilevel internal
6154       */
6155      protected TypeDecl erasure_value;
6156      /**
6157       * @apilevel internal
6158       */
6159      private void erasure_reset() {
6160        erasure_computed = false;
6161        erasure_value = null;
6162      }
6163      /**
6164       * @attribute syn
6165       * @aspect GenericsErasure
6166       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:422
6167       */
6168      @ASTNodeAnnotation.Attribute
6169      public TypeDecl erasure() {
6170        ASTNode$State state = state();
6171        if (erasure_computed) {
6172          return erasure_value;
6173        }
6174        boolean intermediate = state.INTERMEDIATE_VALUE;
6175        state.INTERMEDIATE_VALUE = false;
6176        int num = state.boundariesCrossed;
6177        boolean isFinal = this.is$Final();
6178        erasure_value = erasure_compute();
6179        if (isFinal && num == state().boundariesCrossed) {
6180          erasure_computed = true;
6181        } else {
6182        }
6183        state.INTERMEDIATE_VALUE |= intermediate;
6184    
6185        return erasure_value;
6186      }
6187      /**
6188       * @apilevel internal
6189       */
6190      private TypeDecl erasure_compute() {
6191          if (isAnonymous() || isLocalClass()) {
6192            return this;
6193          }
6194          if (!isNestedType()) {
6195            return this;
6196          }
6197          return extractSingleType(enclosingType().erasure().memberTypes(name()));
6198        }
6199      /**
6200       * @apilevel internal
6201       */
6202      protected boolean erasedAncestorMethodsMap_computed = false;
6203      /**
6204       * @apilevel internal
6205       */
6206      protected Map<String,SimpleSet> erasedAncestorMethodsMap_value;
6207      /**
6208       * @apilevel internal
6209       */
6210      private void erasedAncestorMethodsMap_reset() {
6211        erasedAncestorMethodsMap_computed = false;
6212        erasedAncestorMethodsMap_value = null;
6213      }
6214      /**
6215       * @attribute syn
6216       * @aspect GenericsTypeCheck
6217       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:496
6218       */
6219      @ASTNodeAnnotation.Attribute
6220      public Map<String,SimpleSet> erasedAncestorMethodsMap() {
6221        ASTNode$State state = state();
6222        if (erasedAncestorMethodsMap_computed) {
6223          return erasedAncestorMethodsMap_value;
6224        }
6225        boolean intermediate = state.INTERMEDIATE_VALUE;
6226        state.INTERMEDIATE_VALUE = false;
6227        int num = state.boundariesCrossed;
6228        boolean isFinal = this.is$Final();
6229        erasedAncestorMethodsMap_value = original().localMethodsSignatureMap();
6230        if (isFinal && num == state().boundariesCrossed) {
6231          erasedAncestorMethodsMap_computed = true;
6232        } else {
6233        }
6234        state.INTERMEDIATE_VALUE |= intermediate;
6235    
6236        return erasedAncestorMethodsMap_value;
6237      }
6238      /**
6239       * @apilevel internal
6240       */
6241      protected boolean implementedInterfaces_computed = false;
6242      /**
6243       * @apilevel internal
6244       */
6245      protected HashSet<InterfaceDecl> implementedInterfaces_value;
6246      /**
6247       * @apilevel internal
6248       */
6249      private void implementedInterfaces_reset() {
6250        implementedInterfaces_computed = false;
6251        implementedInterfaces_value = null;
6252      }
6253      /**
6254       * @attribute syn
6255       * @aspect GenericsTypeCheck
6256       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:614
6257       */
6258      @ASTNodeAnnotation.Attribute
6259      public HashSet<InterfaceDecl> implementedInterfaces() {
6260        ASTNode$State state = state();
6261        if (implementedInterfaces_computed) {
6262          return implementedInterfaces_value;
6263        }
6264        boolean intermediate = state.INTERMEDIATE_VALUE;
6265        state.INTERMEDIATE_VALUE = false;
6266        int num = state.boundariesCrossed;
6267        boolean isFinal = this.is$Final();
6268        implementedInterfaces_value = new HashSet<InterfaceDecl>();
6269        if (isFinal && num == state().boundariesCrossed) {
6270          implementedInterfaces_computed = true;
6271        } else {
6272        }
6273        state.INTERMEDIATE_VALUE |= intermediate;
6274    
6275        return implementedInterfaces_value;
6276      }
6277      /**
6278       * @attribute syn
6279       * @aspect LookupParTypeDecl
6280       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:806
6281       */
6282      @ASTNodeAnnotation.Attribute
6283      public boolean sameSignature(Access a) {
6284        {
6285            if (a instanceof ParTypeAccess) {
6286              return false;
6287            }
6288            if (a instanceof AbstractWildcard) {
6289              return false;
6290            }
6291            return this == a.type();
6292          }
6293      }
6294      /**
6295       * @apilevel internal
6296       */
6297      protected int usesTypeVariable_visited = -1;
6298      /**
6299       * @apilevel internal
6300       */
6301      private void usesTypeVariable_reset() {
6302        usesTypeVariable_computed = false;
6303        usesTypeVariable_initialized = false;
6304        usesTypeVariable_visited = -1;
6305      }
6306      /**
6307       * @apilevel internal
6308       */
6309      protected boolean usesTypeVariable_computed = false;
6310      /**
6311       * @apilevel internal
6312       */
6313      protected boolean usesTypeVariable_initialized = false;
6314      /**
6315       * @apilevel internal
6316       */
6317      protected boolean usesTypeVariable_value;
6318      @ASTNodeAnnotation.Attribute
6319      public boolean usesTypeVariable() {
6320        if (usesTypeVariable_computed) {
6321          return usesTypeVariable_value;
6322        }
6323        ASTNode$State state = state();
6324        boolean new_usesTypeVariable_value;
6325        if (!usesTypeVariable_initialized) {
6326          usesTypeVariable_initialized = true;
6327          usesTypeVariable_value = false;
6328        }
6329        if (!state.IN_CIRCLE) {
6330          state.IN_CIRCLE = true;
6331          int num = state.boundariesCrossed;
6332          boolean isFinal = this.is$Final();
6333          do {
6334            usesTypeVariable_visited = state.CIRCLE_INDEX;
6335            state.CHANGE = false;
6336            new_usesTypeVariable_value = isNestedType() && enclosingType().usesTypeVariable();
6337            if (new_usesTypeVariable_value != usesTypeVariable_value) {
6338              state.CHANGE = true;
6339            }
6340            usesTypeVariable_value = new_usesTypeVariable_value;
6341            state.CIRCLE_INDEX++;
6342          } while (state.CHANGE);
6343          if (isFinal && num == state().boundariesCrossed) {
6344            usesTypeVariable_computed = true;
6345          } else {
6346            state.RESET_CYCLE = true;
6347            boolean $tmp = isNestedType() && enclosingType().usesTypeVariable();
6348            state.RESET_CYCLE = false;
6349            usesTypeVariable_computed = false;
6350            usesTypeVariable_initialized = false;
6351          }
6352          state.IN_CIRCLE = false;
6353          state.INTERMEDIATE_VALUE = false;
6354          return usesTypeVariable_value;
6355        }
6356        if (usesTypeVariable_visited != state.CIRCLE_INDEX) {
6357          usesTypeVariable_visited = state.CIRCLE_INDEX;
6358          if (state.RESET_CYCLE) {
6359            usesTypeVariable_computed = false;
6360            usesTypeVariable_initialized = false;
6361            usesTypeVariable_visited = -1;
6362            return usesTypeVariable_value;
6363          }
6364          new_usesTypeVariable_value = isNestedType() && enclosingType().usesTypeVariable();
6365          if (new_usesTypeVariable_value != usesTypeVariable_value) {
6366            state.CHANGE = true;
6367          }
6368          usesTypeVariable_value = new_usesTypeVariable_value;
6369          state.INTERMEDIATE_VALUE = true;
6370          return usesTypeVariable_value;
6371        }
6372        state.INTERMEDIATE_VALUE = true;
6373        return usesTypeVariable_value;
6374      }
6375      /**
6376       * @attribute syn
6377       * @aspect LookupParTypeDecl
6378       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1417
6379       */
6380      @ASTNodeAnnotation.Attribute
6381      public TypeDecl original() {
6382        TypeDecl original_value = this;
6383    
6384        return original_value;
6385      }
6386      /**
6387       * @attribute syn
6388       * @aspect LookupParTypeDecl
6389       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1504
6390       */
6391      @ASTNodeAnnotation.Attribute
6392      public TypeDecl asWildcardExtends() {
6393        TypeDecl asWildcardExtends_value = lookupWildcardExtends(this);
6394    
6395        return asWildcardExtends_value;
6396      }
6397      /**
6398       * @attribute syn
6399       * @aspect LookupParTypeDecl
6400       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1518
6401       */
6402      @ASTNodeAnnotation.Attribute
6403      public TypeDecl asWildcardSuper() {
6404        TypeDecl asWildcardSuper_value = lookupWildcardSuper(this);
6405    
6406        return asWildcardSuper_value;
6407      }
6408      /**
6409       * @apilevel internal
6410       */
6411      protected boolean sourceTypeDecl_computed = false;
6412      /**
6413       * @apilevel internal
6414       */
6415      protected TypeDecl sourceTypeDecl_value;
6416      /**
6417       * @apilevel internal
6418       */
6419      private void sourceTypeDecl_reset() {
6420        sourceTypeDecl_computed = false;
6421        sourceTypeDecl_value = null;
6422      }
6423      /**
6424       * @attribute syn
6425       * @aspect SourceDeclarations
6426       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1618
6427       */
6428      @ASTNodeAnnotation.Attribute
6429      public TypeDecl sourceTypeDecl() {
6430        ASTNode$State state = state();
6431        if (sourceTypeDecl_computed) {
6432          return sourceTypeDecl_value;
6433        }
6434        boolean intermediate = state.INTERMEDIATE_VALUE;
6435        state.INTERMEDIATE_VALUE = false;
6436        int num = state.boundariesCrossed;
6437        boolean isFinal = this.is$Final();
6438        sourceTypeDecl_value = this;
6439        if (isFinal && num == state().boundariesCrossed) {
6440          sourceTypeDecl_computed = true;
6441        } else {
6442        }
6443        state.INTERMEDIATE_VALUE |= intermediate;
6444    
6445        return sourceTypeDecl_value;
6446      }
6447      /**
6448       * @attribute syn
6449       * @aspect GenericsParTypeDecl
6450       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:96
6451       */
6452      @ASTNodeAnnotation.Attribute
6453      public boolean isTypeVariable() {
6454        boolean isTypeVariable_value = false;
6455    
6456        return isTypeVariable_value;
6457      }
6458      /**
6459       * @attribute syn
6460       * @aspect GenericsSubtype
6461       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:35
6462       */
6463      @ASTNodeAnnotation.Attribute
6464      public boolean supertypeGenericClassDecl(GenericClassDecl type) {
6465        boolean supertypeGenericClassDecl_GenericClassDecl_value = supertypeClassDecl(type);
6466    
6467        return supertypeGenericClassDecl_GenericClassDecl_value;
6468      }
6469      /**
6470       * @attribute syn
6471       * @aspect GenericsSubtype
6472       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:40
6473       */
6474      @ASTNodeAnnotation.Attribute
6475      public boolean supertypeGenericInterfaceDecl(GenericInterfaceDecl type) {
6476        boolean supertypeGenericInterfaceDecl_GenericInterfaceDecl_value = this == type || supertypeInterfaceDecl(type);
6477    
6478        return supertypeGenericInterfaceDecl_GenericInterfaceDecl_value;
6479      }
6480      /**
6481       * @attribute syn
6482       * @aspect GenericsSubtype
6483       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:46
6484       */
6485      @ASTNodeAnnotation.Attribute
6486      public boolean supertypeRawClassDecl(RawClassDecl type) {
6487        boolean supertypeRawClassDecl_RawClassDecl_value = supertypeParClassDecl(type);
6488    
6489        return supertypeRawClassDecl_RawClassDecl_value;
6490      }
6491      /**
6492       * @attribute syn
6493       * @aspect GenericsSubtype
6494       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:50
6495       */
6496      @ASTNodeAnnotation.Attribute
6497      public boolean supertypeRawInterfaceDecl(RawInterfaceDecl type) {
6498        boolean supertypeRawInterfaceDecl_RawInterfaceDecl_value = supertypeParInterfaceDecl(type);
6499    
6500        return supertypeRawInterfaceDecl_RawInterfaceDecl_value;
6501      }
6502      /**
6503       * @attribute syn
6504       * @aspect GenericsSubtype
6505       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:66
6506       */
6507      @ASTNodeAnnotation.Attribute
6508      public boolean supertypeWildcard(WildcardType type) {
6509        boolean supertypeWildcard_WildcardType_value = false;
6510    
6511        return supertypeWildcard_WildcardType_value;
6512      }
6513      /**
6514       * @attribute syn
6515       * @aspect GenericsSubtype
6516       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:73
6517       */
6518      @ASTNodeAnnotation.Attribute
6519      public boolean supertypeWildcardExtends(WildcardExtendsType type) {
6520        boolean supertypeWildcardExtends_WildcardExtendsType_value = false;
6521    
6522        return supertypeWildcardExtends_WildcardExtendsType_value;
6523      }
6524      /**
6525       * @attribute syn
6526       * @aspect GenericsSubtype
6527       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:81
6528       */
6529      @ASTNodeAnnotation.Attribute
6530      public boolean supertypeWildcardSuper(WildcardSuperType type) {
6531        boolean supertypeWildcardSuper_WildcardSuperType_value = false;
6532    
6533        return supertypeWildcardSuper_WildcardSuperType_value;
6534      }
6535      /**
6536       * @attribute syn
6537       * @aspect GenericsSubtype
6538       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:115
6539       */
6540      @ASTNodeAnnotation.Attribute
6541      public boolean isWildcard() {
6542        boolean isWildcard_value = false;
6543    
6544        return isWildcard_value;
6545      }
6546      /**
6547       * @attribute syn
6548       * @aspect GenericsSubtype
6549       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:134
6550       */
6551      @ASTNodeAnnotation.Attribute
6552      public boolean supertypeParClassDecl(ParClassDecl type) {
6553        boolean supertypeParClassDecl_ParClassDecl_value = supertypeClassDecl(type);
6554    
6555        return supertypeParClassDecl_ParClassDecl_value;
6556      }
6557      /**
6558       * @attribute syn
6559       * @aspect GenericsSubtype
6560       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:137
6561       */
6562      @ASTNodeAnnotation.Attribute
6563      public boolean supertypeParInterfaceDecl(ParInterfaceDecl type) {
6564        boolean supertypeParInterfaceDecl_ParInterfaceDecl_value = supertypeInterfaceDecl(type);
6565    
6566        return supertypeParInterfaceDecl_ParInterfaceDecl_value;
6567      }
6568      /**
6569       * @apilevel internal
6570       */
6571      private void containedIn_TypeDecl_reset() {
6572        containedIn_TypeDecl_values = null;
6573      }
6574      protected java.util.Map containedIn_TypeDecl_values;
6575      @ASTNodeAnnotation.Attribute
6576      public boolean containedIn(TypeDecl type) {
6577        Object _parameters = type;
6578        if (containedIn_TypeDecl_values == null) containedIn_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
6579        ASTNode$State.CircularValue _value;
6580        if (containedIn_TypeDecl_values.containsKey(_parameters)) {
6581          Object _o = containedIn_TypeDecl_values.get(_parameters);
6582          if (!(_o instanceof ASTNode$State.CircularValue)) {
6583            return (Boolean) _o;
6584          } else {
6585            _value = (ASTNode$State.CircularValue) _o;
6586          }
6587        } else {
6588          _value = new ASTNode$State.CircularValue();
6589          containedIn_TypeDecl_values.put(_parameters, _value);
6590          _value.value = true;
6591        }
6592        ASTNode$State state = state();
6593        boolean new_containedIn_TypeDecl_value;
6594        if (!state.IN_CIRCLE) {
6595          state.IN_CIRCLE = true;
6596          int num = state.boundariesCrossed;
6597          boolean isFinal = this.is$Final();
6598          // TODO: fixme
6599          // state().CIRCLE_INDEX = 1;
6600          do {
6601            _value.visited = state.CIRCLE_INDEX;
6602            state.CHANGE = false;
6603            new_containedIn_TypeDecl_value = containedIn_compute(type);
6604            if (new_containedIn_TypeDecl_value != ((Boolean)_value.value)) {
6605              state.CHANGE = true;
6606              _value.value = new_containedIn_TypeDecl_value;
6607            }
6608            state.CIRCLE_INDEX++;
6609          } while (state.CHANGE);
6610          if (isFinal && num == state().boundariesCrossed) {
6611            containedIn_TypeDecl_values.put(_parameters, new_containedIn_TypeDecl_value);
6612          } else {
6613            containedIn_TypeDecl_values.remove(_parameters);
6614            state.RESET_CYCLE = true;
6615            boolean $tmp = containedIn_compute(type);
6616            state.RESET_CYCLE = false;
6617          }
6618          state.IN_CIRCLE = false;
6619          state.INTERMEDIATE_VALUE = false;
6620          return new_containedIn_TypeDecl_value;
6621        }
6622        if (state.CIRCLE_INDEX != _value.visited) {
6623          _value.visited = state.CIRCLE_INDEX;
6624          new_containedIn_TypeDecl_value = containedIn_compute(type);
6625          if (state.RESET_CYCLE) {
6626            containedIn_TypeDecl_values.remove(_parameters);
6627          }
6628          else if (new_containedIn_TypeDecl_value != ((Boolean)_value.value)) {
6629            state.CHANGE = true;
6630            _value.value = new_containedIn_TypeDecl_value;
6631          }
6632          state.INTERMEDIATE_VALUE = true;
6633          return new_containedIn_TypeDecl_value;
6634        }
6635        state.INTERMEDIATE_VALUE = true;
6636        return (Boolean) _value.value;
6637      }
6638      /**
6639       * @apilevel internal
6640       */
6641      private boolean containedIn_compute(TypeDecl type) {
6642          if (type == this || type instanceof WildcardType) {
6643            return true;
6644          } else if (type instanceof WildcardExtendsType) {
6645            return this.subtype(((WildcardExtendsType) type).extendsType());
6646          } else if (type instanceof WildcardSuperType) {
6647            return ((WildcardSuperType) type).superType().subtype(this);
6648          } else if (type instanceof TypeVariable) {
6649            return subtype(type);
6650          }
6651          return sameStructure(type);
6652          //return false;
6653        }
6654      /**
6655       * @apilevel internal
6656       */
6657      private void sameStructure_TypeDecl_reset() {
6658        sameStructure_TypeDecl_values = null;
6659      }
6660      protected java.util.Map sameStructure_TypeDecl_values;
6661      @ASTNodeAnnotation.Attribute
6662      public boolean sameStructure(TypeDecl t) {
6663        Object _parameters = t;
6664        if (sameStructure_TypeDecl_values == null) sameStructure_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
6665        ASTNode$State.CircularValue _value;
6666        if (sameStructure_TypeDecl_values.containsKey(_parameters)) {
6667          Object _o = sameStructure_TypeDecl_values.get(_parameters);
6668          if (!(_o instanceof ASTNode$State.CircularValue)) {
6669            return (Boolean) _o;
6670          } else {
6671            _value = (ASTNode$State.CircularValue) _o;
6672          }
6673        } else {
6674          _value = new ASTNode$State.CircularValue();
6675          sameStructure_TypeDecl_values.put(_parameters, _value);
6676          _value.value = true;
6677        }
6678        ASTNode$State state = state();
6679        boolean new_sameStructure_TypeDecl_value;
6680        if (!state.IN_CIRCLE) {
6681          state.IN_CIRCLE = true;
6682          int num = state.boundariesCrossed;
6683          boolean isFinal = this.is$Final();
6684          // TODO: fixme
6685          // state().CIRCLE_INDEX = 1;
6686          do {
6687            _value.visited = state.CIRCLE_INDEX;
6688            state.CHANGE = false;
6689            new_sameStructure_TypeDecl_value = t == this;
6690            if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) {
6691              state.CHANGE = true;
6692              _value.value = new_sameStructure_TypeDecl_value;
6693            }
6694            state.CIRCLE_INDEX++;
6695          } while (state.CHANGE);
6696          if (isFinal && num == state().boundariesCrossed) {
6697            sameStructure_TypeDecl_values.put(_parameters, new_sameStructure_TypeDecl_value);
6698          } else {
6699            sameStructure_TypeDecl_values.remove(_parameters);
6700            state.RESET_CYCLE = true;
6701            boolean $tmp = t == this;
6702            state.RESET_CYCLE = false;
6703          }
6704          state.IN_CIRCLE = false;
6705          state.INTERMEDIATE_VALUE = false;
6706          return new_sameStructure_TypeDecl_value;
6707        }
6708        if (state.CIRCLE_INDEX != _value.visited) {
6709          _value.visited = state.CIRCLE_INDEX;
6710          new_sameStructure_TypeDecl_value = t == this;
6711          if (state.RESET_CYCLE) {
6712            sameStructure_TypeDecl_values.remove(_parameters);
6713          }
6714          else if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) {
6715            state.CHANGE = true;
6716            _value.value = new_sameStructure_TypeDecl_value;
6717          }
6718          state.INTERMEDIATE_VALUE = true;
6719          return new_sameStructure_TypeDecl_value;
6720        }
6721        state.INTERMEDIATE_VALUE = true;
6722        return (Boolean) _value.value;
6723      }
6724      /**
6725       * @attribute syn
6726       * @aspect GenericsSubtype
6727       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:321
6728       */
6729      @ASTNodeAnnotation.Attribute
6730      public boolean supertypeTypeVariable(TypeVariable type) {
6731        {
6732            if (type == this) {
6733              return true;
6734            }
6735            for (int i = 0; i < type.getNumTypeBound(); i++)
6736              if (type.getTypeBound(i).type().subtype(this)) {
6737                return true;
6738              }
6739            return false;
6740          }
6741      }
6742      /**
6743       * @attribute syn
6744       * @aspect GenericsSubtype
6745       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:376
6746       */
6747      @ASTNodeAnnotation.Attribute
6748      public boolean supertypeLUBType(LUBType type) {
6749        {
6750            for (int i = 0; i < type.getNumTypeBound(); i++)
6751              if (!type.getTypeBound(i).type().subtype(this)) {
6752                return false;
6753              }
6754            return true;
6755          }
6756      }
6757      /**
6758       * @attribute syn
6759       * @aspect GenericsSubtype
6760       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:394
6761       */
6762      @ASTNodeAnnotation.Attribute
6763      public boolean supertypeGLBType(GLBType type) {
6764        {
6765            // T1 && .. && Tn <: this, if exists  0 < i <= n Ti <: this
6766            for (int i = 0; i < type.getNumTypeBound(); i++)
6767              if (type.getTypeBound(i).type().subtype(this)) {
6768                return true;
6769              }
6770            return false;
6771          }
6772      }
6773      /**
6774       * @apilevel internal
6775       */
6776      private void subtype_TypeDecl_reset() {
6777        subtype_TypeDecl_values = null;
6778      }
6779      protected java.util.Map subtype_TypeDecl_values;
6780      @ASTNodeAnnotation.Attribute
6781      public boolean subtype(TypeDecl type) {
6782        Object _parameters = type;
6783        if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
6784        ASTNode$State.CircularValue _value;
6785        if (subtype_TypeDecl_values.containsKey(_parameters)) {
6786          Object _o = subtype_TypeDecl_values.get(_parameters);
6787          if (!(_o instanceof ASTNode$State.CircularValue)) {
6788            return (Boolean) _o;
6789          } else {
6790            _value = (ASTNode$State.CircularValue) _o;
6791          }
6792        } else {
6793          _value = new ASTNode$State.CircularValue();
6794          subtype_TypeDecl_values.put(_parameters, _value);
6795          _value.value = true;
6796        }
6797        ASTNode$State state = state();
6798        boolean new_subtype_TypeDecl_value;
6799        if (!state.IN_CIRCLE) {
6800          state.IN_CIRCLE = true;
6801          int num = state.boundariesCrossed;
6802          boolean isFinal = this.is$Final();
6803          // TODO: fixme
6804          // state().CIRCLE_INDEX = 1;
6805          do {
6806            _value.visited = state.CIRCLE_INDEX;
6807            state.CHANGE = false;
6808            new_subtype_TypeDecl_value = type == this;
6809            if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
6810              state.CHANGE = true;
6811              _value.value = new_subtype_TypeDecl_value;
6812            }
6813            state.CIRCLE_INDEX++;
6814          } while (state.CHANGE);
6815          if (isFinal && num == state().boundariesCrossed) {
6816            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
6817          } else {
6818            subtype_TypeDecl_values.remove(_parameters);
6819            state.RESET_CYCLE = true;
6820            boolean $tmp = type == this;
6821            state.RESET_CYCLE = false;
6822          }
6823          state.IN_CIRCLE = false;
6824          state.INTERMEDIATE_VALUE = false;
6825          return new_subtype_TypeDecl_value;
6826        }
6827        if (state.CIRCLE_INDEX != _value.visited) {
6828          _value.visited = state.CIRCLE_INDEX;
6829          new_subtype_TypeDecl_value = type == this;
6830          if (state.RESET_CYCLE) {
6831            subtype_TypeDecl_values.remove(_parameters);
6832          }
6833          else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
6834            state.CHANGE = true;
6835            _value.value = new_subtype_TypeDecl_value;
6836          }
6837          state.INTERMEDIATE_VALUE = true;
6838          return new_subtype_TypeDecl_value;
6839        }
6840        state.INTERMEDIATE_VALUE = true;
6841        return (Boolean) _value.value;
6842      }
6843      /**
6844       * @attribute syn
6845       * @aspect GenericsSubtype
6846       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:448
6847       */
6848      @ASTNodeAnnotation.Attribute
6849      public boolean supertypeClassDecl(ClassDecl type) {
6850        boolean supertypeClassDecl_ClassDecl_value = type == this;
6851    
6852        return supertypeClassDecl_ClassDecl_value;
6853      }
6854      /**
6855       * @attribute syn
6856       * @aspect GenericsSubtype
6857       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:465
6858       */
6859      @ASTNodeAnnotation.Attribute
6860      public boolean supertypeInterfaceDecl(InterfaceDecl type) {
6861        boolean supertypeInterfaceDecl_InterfaceDecl_value = type == this;
6862    
6863        return supertypeInterfaceDecl_InterfaceDecl_value;
6864      }
6865      /**
6866       * @attribute syn
6867       * @aspect GenericsSubtype
6868       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:480
6869       */
6870      @ASTNodeAnnotation.Attribute
6871      public boolean supertypeArrayDecl(ArrayDecl type) {
6872        boolean supertypeArrayDecl_ArrayDecl_value = this == type;
6873    
6874        return supertypeArrayDecl_ArrayDecl_value;
6875      }
6876      /**
6877       * @attribute syn
6878       * @aspect GenericsSubtype
6879       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:506
6880       */
6881      @ASTNodeAnnotation.Attribute
6882      public boolean supertypePrimitiveType(PrimitiveType type) {
6883        boolean supertypePrimitiveType_PrimitiveType_value = type == this;
6884    
6885        return supertypePrimitiveType_PrimitiveType_value;
6886      }
6887      /**
6888       * @attribute syn
6889       * @aspect GenericsSubtype
6890       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:514
6891       */
6892      @ASTNodeAnnotation.Attribute
6893      public boolean supertypeNullType(NullType type) {
6894        boolean supertypeNullType_NullType_value = false;
6895    
6896        return supertypeNullType_NullType_value;
6897      }
6898      /**
6899       * @attribute syn
6900       * @aspect GenericsSubtype
6901       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:518
6902       */
6903      @ASTNodeAnnotation.Attribute
6904      public boolean supertypeVoidType(VoidType type) {
6905        boolean supertypeVoidType_VoidType_value = false;
6906    
6907        return supertypeVoidType_VoidType_value;
6908      }
6909      /**
6910       * @attribute syn
6911       * @aspect GenericsSubtype
6912       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:527
6913       */
6914      @ASTNodeAnnotation.Attribute
6915      public boolean supertypeClassDeclSubstituted(ClassDeclSubstituted type) {
6916        boolean supertypeClassDeclSubstituted_ClassDeclSubstituted_value = type.original() == this || supertypeClassDecl(type);
6917    
6918        return supertypeClassDeclSubstituted_ClassDeclSubstituted_value;
6919      }
6920      /**
6921       * @attribute syn
6922       * @aspect GenericsSubtype
6923       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:538
6924       */
6925      @ASTNodeAnnotation.Attribute
6926      public boolean supertypeInterfaceDeclSubstituted(InterfaceDeclSubstituted type) {
6927        boolean supertypeInterfaceDeclSubstituted_InterfaceDeclSubstituted_value = type.original() == this || supertypeInterfaceDecl(type);
6928    
6929        return supertypeInterfaceDeclSubstituted_InterfaceDeclSubstituted_value;
6930      }
6931      /**
6932       * @attribute syn
6933       * @aspect GenericsSubtype
6934       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:548
6935       */
6936      @ASTNodeAnnotation.Attribute
6937      public boolean supertypeGenericClassDeclSubstituted(GenericClassDeclSubstituted type) {
6938        boolean supertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value = type.original() == this || supertypeGenericClassDecl(type);
6939    
6940        return supertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value;
6941      }
6942      /**
6943       * @attribute syn
6944       * @aspect GenericsSubtype
6945       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:559
6946       */
6947      @ASTNodeAnnotation.Attribute
6948      public boolean supertypeGenericInterfaceDeclSubstituted(GenericInterfaceDeclSubstituted type) {
6949        boolean supertypeGenericInterfaceDeclSubstituted_GenericInterfaceDeclSubstituted_value = type.original() == this || supertypeGenericInterfaceDecl(type);
6950    
6951        return supertypeGenericInterfaceDeclSubstituted_GenericInterfaceDeclSubstituted_value;
6952      }
6953      /**
6954       * A type is reifiable if it either refers to a non-parameterized type,
6955       * is a raw type, is a parameterized type with only unbound wildcard
6956       * parameters or is an array type with a reifiable type parameter.
6957       * 
6958       * @see "JLS SE7 &sect;4.7"
6959       * @attribute syn
6960       * @aspect ReifiableTypes
6961       * @declaredat /home/jesper/git/extendj/java5/frontend/ReifiableTypes.jrag:39
6962       */
6963      @ASTNodeAnnotation.Attribute
6964      public boolean isReifiable() {
6965        boolean isReifiable_value = true;
6966    
6967        return isReifiable_value;
6968      }
6969      /**
6970       * @apilevel internal
6971       */
6972      protected java.util.Map createEnumMethod_TypeDecl_values;
6973      /**
6974       * @apilevel internal
6975       */
6976      private void createEnumMethod_TypeDecl_reset() {
6977        createEnumMethod_TypeDecl_values = null;
6978      }
6979      /**
6980       * @attribute syn
6981       * @aspect EnumsCodegen
6982       * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:63
6983       */
6984      @ASTNodeAnnotation.Attribute
6985      public MethodDecl createEnumMethod(TypeDecl enumDecl) {
6986        Object _parameters = enumDecl;
6987        if (createEnumMethod_TypeDecl_values == null) createEnumMethod_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
6988        ASTNode$State state = state();
6989        if (createEnumMethod_TypeDecl_values.containsKey(_parameters)) {
6990          return (MethodDecl) createEnumMethod_TypeDecl_values.get(_parameters);
6991        }
6992        boolean intermediate = state.INTERMEDIATE_VALUE;
6993        state.INTERMEDIATE_VALUE = false;
6994        int num = state.boundariesCrossed;
6995        boolean isFinal = this.is$Final();
6996        MethodDecl createEnumMethod_TypeDecl_value = createEnumMethod_compute(enumDecl);
6997        if (isFinal && num == state().boundariesCrossed) {
6998          createEnumMethod_TypeDecl_values.put(_parameters, createEnumMethod_TypeDecl_value);
6999        } else {
7000        }
7001        state.INTERMEDIATE_VALUE |= intermediate;
7002    
7003        return createEnumMethod_TypeDecl_value;
7004      }
7005      /**
7006       * @apilevel internal
7007       */
7008      private MethodDecl createEnumMethod_compute(TypeDecl enumDecl) {
7009          MethodDecl m = new MethodDecl(
7010            new Modifiers(new List().add(new Modifier("static")).add(new Modifier("final")).add(new Modifier("private"))),
7011            typeInt().arrayType().createQualifiedAccess(),
7012            "$SwitchMap$" + enumDecl.fullName().replace('.', '$'),
7013            new List(),
7014            new List(),
7015            new Opt(
7016              new Block(
7017                new List().add(
7018                  new IfStmt(
7019                    new EQExpr(
7020                      createEnumArray(enumDecl).createBoundFieldAccess(),
7021                      new NullLiteral("null")
7022                    ),
7023                    AssignExpr.asStmt(
7024                      createEnumArray(enumDecl).createBoundFieldAccess(),
7025                      new ArrayCreationExpr(
7026                        new ArrayTypeWithSizeAccess(
7027                          typeInt().createQualifiedAccess(),
7028                          enumDecl.createQualifiedAccess().qualifiesAccess(
7029                              new MethodAccess("values", new List())).qualifiesAccess(
7030                              new VarAccess("length"))
7031                        ),
7032                        new Opt()
7033                      )
7034                    ),
7035                    new Opt()
7036                  )
7037                ).add(
7038                  new ReturnStmt(
7039                    createEnumArray(enumDecl).createBoundFieldAccess()
7040                  )
7041                )
7042              )
7043            )
7044          );
7045          // add method declaration as a body declaration
7046          getBodyDeclList().insertChild(m, 1);
7047          // trigger possible rewrites
7048          return (MethodDecl) getBodyDeclList().getChild(1);
7049        }
7050      /**
7051       * @apilevel internal
7052       */
7053      protected java.util.Map createEnumIndex_EnumConstant_values;
7054      /**
7055       * @apilevel internal
7056       */
7057      private void createEnumIndex_EnumConstant_reset() {
7058        createEnumIndex_EnumConstant_values = null;
7059      }
7060      /**
7061       * @attribute syn
7062       * @aspect EnumsCodegen
7063       * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:107
7064       */
7065      @ASTNodeAnnotation.Attribute
7066      public int createEnumIndex(EnumConstant e) {
7067        Object _parameters = e;
7068        if (createEnumIndex_EnumConstant_values == null) createEnumIndex_EnumConstant_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
7069        ASTNode$State state = state();
7070        if (createEnumIndex_EnumConstant_values.containsKey(_parameters)) {
7071          return (Integer) createEnumIndex_EnumConstant_values.get(_parameters);
7072        }
7073        boolean intermediate = state.INTERMEDIATE_VALUE;
7074        state.INTERMEDIATE_VALUE = false;
7075        int num = state.boundariesCrossed;
7076        boolean isFinal = this.is$Final();
7077        int createEnumIndex_EnumConstant_value = createEnumIndex_compute(e);
7078        if (isFinal && num == state().boundariesCrossed) {
7079          createEnumIndex_EnumConstant_values.put(_parameters, createEnumIndex_EnumConstant_value);
7080        } else {
7081        }
7082        state.INTERMEDIATE_VALUE |= intermediate;
7083    
7084        return createEnumIndex_EnumConstant_value;
7085      }
7086      /**
7087       * @apilevel internal
7088       */
7089      private int createEnumIndex_compute(EnumConstant e) {
7090          if (createEnumIndexMap == null) {
7091            createEnumIndexMap = new HashMap();
7092          }
7093          if (!createEnumIndexMap.containsKey(e.hostType())) {
7094            createEnumIndexMap.put(e.hostType(), new Integer(0));
7095          }
7096          Integer i = (Integer) createEnumIndexMap.get(e.hostType());
7097          i = new Integer(i.intValue() + 1);
7098          createEnumIndexMap.put(e.hostType(), i);
7099      
7100          MethodDecl m = createEnumMethod(e.hostType());
7101          List list = m.getBlock().getStmtList();
7102          list.insertChild(
7103            new TryStmt(
7104              new Block(
7105                new List().add(
7106                  AssignExpr.asStmt(
7107                    createEnumArray(e.hostType()).createBoundFieldAccess().qualifiesAccess(
7108                      new ArrayAccess(
7109                        e.createBoundFieldAccess().qualifiesAccess(new MethodAccess("ordinal", new List()))
7110                      )
7111                    ),
7112                    Literal.buildIntegerLiteral(i.intValue())
7113                  )
7114                )
7115              ),
7116              new List().add(
7117                new BasicCatch(
7118                  new ParameterDeclaration(
7119                    lookupType("java.lang", "NoSuchFieldError").createQualifiedAccess(),
7120                    "e"
7121                  ),
7122                  new Block(
7123                    new List()
7124                  )
7125                )
7126              ),
7127              new Opt()
7128            ),
7129            list.getNumChild()-1
7130          );
7131          return i.intValue();
7132        }
7133      /**
7134       * @apilevel internal
7135       */
7136      protected java.util.Map createEnumArray_TypeDecl_values;
7137      /**
7138       * @apilevel internal
7139       */
7140      private void createEnumArray_TypeDecl_reset() {
7141        createEnumArray_TypeDecl_values = null;
7142      }
7143      /**
7144       * @attribute syn
7145       * @aspect EnumsCodegen
7146       * @declaredat /home/jesper/git/extendj/java5/backend/EnumsCodegen.jrag:152
7147       */
7148      @ASTNodeAnnotation.Attribute
7149      public FieldDeclaration createEnumArray(TypeDecl enumDecl) {
7150        Object _parameters = enumDecl;
7151        if (createEnumArray_TypeDecl_values == null) createEnumArray_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
7152        ASTNode$State state = state();
7153        if (createEnumArray_TypeDecl_values.containsKey(_parameters)) {
7154          return (FieldDeclaration) createEnumArray_TypeDecl_values.get(_parameters);
7155        }
7156        boolean intermediate = state.INTERMEDIATE_VALUE;
7157        state.INTERMEDIATE_VALUE = false;
7158        int num = state.boundariesCrossed;
7159        boolean isFinal = this.is$Final();
7160        FieldDeclaration createEnumArray_TypeDecl_value = createEnumArray_compute(enumDecl);
7161        if (isFinal && num == state().boundariesCrossed) {
7162          createEnumArray_TypeDecl_values.put(_parameters, createEnumArray_TypeDecl_value);
7163        } else {
7164        }
7165        state.INTERMEDIATE_VALUE |= intermediate;
7166    
7167        return createEnumArray_TypeDecl_value;
7168      }
7169      /**
7170       * @apilevel internal
7171       */
7172      private FieldDeclaration createEnumArray_compute(TypeDecl enumDecl) {
7173          FieldDeclaration f = new FieldDeclaration(
7174            new Modifiers(new List().add(new Modifier("static")).add(new Modifier("final")).add(new Modifier("private"))),
7175            typeInt().arrayType().createQualifiedAccess(),
7176            "$SwitchMap$" + enumDecl.fullName().replace('.', '$'),
7177            new Opt()
7178          );
7179          // add field declaration as a body declaration
7180          getBodyDeclList().insertChild(f, 0);
7181          // trigger possible rewrites
7182          return (FieldDeclaration) getBodyDeclList().getChild(0);
7183        }
7184      /**
7185       * @attribute syn
7186       * @aspect GenericsCodegen
7187       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:228
7188       */
7189      @ASTNodeAnnotation.Attribute
7190      public SimpleSet bridgeCandidates(String signature) {
7191        SimpleSet bridgeCandidates_String_value = SimpleSet.emptySet;
7192    
7193        return bridgeCandidates_String_value;
7194      }
7195      /**
7196       * @apilevel internal
7197       */
7198      protected boolean needsSignatureAttribute_computed = false;
7199      /**
7200       * @apilevel internal
7201       */
7202      protected boolean needsSignatureAttribute_value;
7203      /**
7204       * @apilevel internal
7205       */
7206      private void needsSignatureAttribute_reset() {
7207        needsSignatureAttribute_computed = false;
7208      }
7209      /**
7210       * @attribute syn
7211       * @aspect GenericsCodegen
7212       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:345
7213       */
7214      @ASTNodeAnnotation.Attribute
7215      public boolean needsSignatureAttribute() {
7216        ASTNode$State state = state();
7217        if (needsSignatureAttribute_computed) {
7218          return needsSignatureAttribute_value;
7219        }
7220        boolean intermediate = state.INTERMEDIATE_VALUE;
7221        state.INTERMEDIATE_VALUE = false;
7222        int num = state.boundariesCrossed;
7223        boolean isFinal = this.is$Final();
7224        needsSignatureAttribute_value = false;
7225        if (isFinal && num == state().boundariesCrossed) {
7226          needsSignatureAttribute_computed = true;
7227        } else {
7228        }
7229        state.INTERMEDIATE_VALUE |= intermediate;
7230    
7231        return needsSignatureAttribute_value;
7232      }
7233      /**
7234       * @apilevel internal
7235       */
7236      protected boolean classSignature_computed = false;
7237      /**
7238       * @apilevel internal
7239       */
7240      protected String classSignature_value;
7241      /**
7242       * @apilevel internal
7243       */
7244      private void classSignature_reset() {
7245        classSignature_computed = false;
7246        classSignature_value = null;
7247      }
7248      /**
7249       * @attribute syn
7250       * @aspect GenericsCodegen
7251       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:401
7252       */
7253      @ASTNodeAnnotation.Attribute
7254      public String classSignature() {
7255        ASTNode$State state = state();
7256        if (classSignature_computed) {
7257          return classSignature_value;
7258        }
7259        boolean intermediate = state.INTERMEDIATE_VALUE;
7260        state.INTERMEDIATE_VALUE = false;
7261        int num = state.boundariesCrossed;
7262        boolean isFinal = this.is$Final();
7263        classSignature_value = "";
7264        if (isFinal && num == state().boundariesCrossed) {
7265          classSignature_computed = true;
7266        } else {
7267        }
7268        state.INTERMEDIATE_VALUE |= intermediate;
7269    
7270        return classSignature_value;
7271      }
7272      /**
7273       * @apilevel internal
7274       */
7275      protected boolean fieldTypeSignature_computed = false;
7276      /**
7277       * @apilevel internal
7278       */
7279      protected String fieldTypeSignature_value;
7280      /**
7281       * @apilevel internal
7282       */
7283      private void fieldTypeSignature_reset() {
7284        fieldTypeSignature_computed = false;
7285        fieldTypeSignature_value = null;
7286      }
7287      /**
7288       * @attribute syn
7289       * @aspect GenericsCodegen
7290       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:467
7291       */
7292      @ASTNodeAnnotation.Attribute
7293      public String fieldTypeSignature() {
7294        ASTNode$State state = state();
7295        if (fieldTypeSignature_computed) {
7296          return fieldTypeSignature_value;
7297        }
7298        boolean intermediate = state.INTERMEDIATE_VALUE;
7299        state.INTERMEDIATE_VALUE = false;
7300        int num = state.boundariesCrossed;
7301        boolean isFinal = this.is$Final();
7302        fieldTypeSignature_value = classTypeSignature();
7303        if (isFinal && num == state().boundariesCrossed) {
7304          fieldTypeSignature_computed = true;
7305        } else {
7306        }
7307        state.INTERMEDIATE_VALUE |= intermediate;
7308    
7309        return fieldTypeSignature_value;
7310      }
7311      /**
7312       * @apilevel internal
7313       */
7314      protected boolean classTypeSignature_computed = false;
7315      /**
7316       * @apilevel internal
7317       */
7318      protected String classTypeSignature_value;
7319      /**
7320       * @apilevel internal
7321       */
7322      private void classTypeSignature_reset() {
7323        classTypeSignature_computed = false;
7324        classTypeSignature_value = null;
7325      }
7326      /**
7327       * @attribute syn
7328       * @aspect GenericsCodegen
7329       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:476
7330       */
7331      @ASTNodeAnnotation.Attribute
7332      public String classTypeSignature() {
7333        ASTNode$State state = state();
7334        if (classTypeSignature_computed) {
7335          return classTypeSignature_value;
7336        }
7337        boolean intermediate = state.INTERMEDIATE_VALUE;
7338        state.INTERMEDIATE_VALUE = false;
7339        int num = state.boundariesCrossed;
7340        boolean isFinal = this.is$Final();
7341        classTypeSignature_value = "L" + classTypeSignatureContents() + ";";
7342        if (isFinal && num == state().boundariesCrossed) {
7343          classTypeSignature_computed = true;
7344        } else {
7345        }
7346        state.INTERMEDIATE_VALUE |= intermediate;
7347    
7348        return classTypeSignature_value;
7349      }
7350      /**
7351       * @attribute syn
7352       * @aspect GenericsCodegen
7353       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:482
7354       */
7355      @ASTNodeAnnotation.Attribute
7356      public String classTypeSignatureContents() {
7357        {
7358            StringBuilder buf = new StringBuilder();
7359            if (isTopLevelType()) {
7360              if (!packageName().equals("")) {
7361                buf.append(packageName().replace('.', '/') + "/");
7362              }
7363            } else {
7364              buf.append(enclosingType().classTypeSignatureContents() + ".");
7365            }
7366            buf.append(name());
7367            buf.append(typeArgumentsOpt());
7368            return buf.toString();
7369          }
7370      }
7371      /**
7372       * @attribute syn
7373       * @aspect GenericsCodegen
7374       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:495
7375       */
7376      @ASTNodeAnnotation.Attribute
7377      public String typeArgumentsOpt() {
7378        String typeArgumentsOpt_value = "";
7379    
7380        return typeArgumentsOpt_value;
7381      }
7382      /**
7383       * @return true if the modifier list includes the SafeVarargs annotation
7384       * @attribute syn
7385       * @aspect SafeVarargs
7386       * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:37
7387       */
7388      @ASTNodeAnnotation.Attribute
7389      public boolean hasAnnotationSafeVarargs() {
7390        boolean hasAnnotationSafeVarargs_value = getModifiers().hasAnnotationSafeVarargs();
7391    
7392        return hasAnnotationSafeVarargs_value;
7393      }
7394      /**
7395       * An unchecked conversion occurs when converting from a
7396       * raw type G to a generic type G<T1, ..., Tn>.
7397       * @attribute syn
7398       * @aspect UncheckedConversion
7399       * @declaredat /home/jesper/git/extendj/java7/frontend/UncheckedConversion.jrag:76
7400       */
7401      @ASTNodeAnnotation.Attribute
7402      public boolean isUncheckedConversionTo(TypeDecl dest) {
7403        boolean isUncheckedConversionTo_TypeDecl_value = (!dest.isRawType()) && this.isRawType();
7404    
7405        return isUncheckedConversionTo_TypeDecl_value;
7406      }
7407      /**
7408       * @attribute syn
7409       * @aspect PreciseRethrow
7410       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:41
7411       */
7412      @ASTNodeAnnotation.Attribute
7413      public boolean modifiedInScope(Variable var) {
7414        {
7415            for (int i = 0; i < getNumBodyDecl(); i++) {
7416              BodyDecl body = getBodyDecl(i);
7417              if (body.modifiedInScope(var)) {
7418                return true;
7419              }
7420            }
7421            return false;
7422          }
7423      }
7424      /**
7425       * @apilevel internal
7426       */
7427      protected boolean isFunctionalInterface_computed = false;
7428      /**
7429       * @apilevel internal
7430       */
7431      protected boolean isFunctionalInterface_value;
7432      /**
7433       * @apilevel internal
7434       */
7435      private void isFunctionalInterface_reset() {
7436        isFunctionalInterface_computed = false;
7437      }
7438      /**
7439       * @attribute syn
7440       * @aspect FunctionalInterface
7441       * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionalInterface.jrag:30
7442       */
7443      @ASTNodeAnnotation.Attribute
7444      public boolean isFunctionalInterface() {
7445        ASTNode$State state = state();
7446        if (isFunctionalInterface_computed) {
7447          return isFunctionalInterface_value;
7448        }
7449        boolean intermediate = state.INTERMEDIATE_VALUE;
7450        state.INTERMEDIATE_VALUE = false;
7451        int num = state.boundariesCrossed;
7452        boolean isFinal = this.is$Final();
7453        isFunctionalInterface_value = false;
7454        if (isFinal && num == state().boundariesCrossed) {
7455          isFunctionalInterface_computed = true;
7456        } else {
7457        }
7458        state.INTERMEDIATE_VALUE |= intermediate;
7459    
7460        return isFunctionalInterface_value;
7461      }
7462      /**
7463       * @attribute syn
7464       * @aspect StrictSubtype
7465       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:39
7466       */
7467      @ASTNodeAnnotation.Attribute
7468      public boolean strictSupertypeGenericClassDecl(GenericClassDecl type) {
7469        boolean strictSupertypeGenericClassDecl_GenericClassDecl_value = strictSupertypeClassDecl(type);
7470    
7471        return strictSupertypeGenericClassDecl_GenericClassDecl_value;
7472      }
7473      /**
7474       * @attribute syn
7475       * @aspect StrictSubtype
7476       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:46
7477       */
7478      @ASTNodeAnnotation.Attribute
7479      public boolean strictSupertypeGenericInterfaceDecl(GenericInterfaceDecl type) {
7480        boolean strictSupertypeGenericInterfaceDecl_GenericInterfaceDecl_value = this == type || strictSupertypeInterfaceDecl(type);
7481    
7482        return strictSupertypeGenericInterfaceDecl_GenericInterfaceDecl_value;
7483      }
7484      /**
7485       * @attribute syn
7486       * @aspect StrictSubtype
7487       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:52
7488       */
7489      @ASTNodeAnnotation.Attribute
7490      public boolean strictSupertypeRawClassDecl(RawClassDecl type) {
7491        boolean strictSupertypeRawClassDecl_RawClassDecl_value = strictSupertypeParClassDecl(type);
7492    
7493        return strictSupertypeRawClassDecl_RawClassDecl_value;
7494      }
7495      /**
7496       * @attribute syn
7497       * @aspect StrictSubtype
7498       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:56
7499       */
7500      @ASTNodeAnnotation.Attribute
7501      public boolean strictSupertypeRawInterfaceDecl(RawInterfaceDecl type) {
7502        boolean strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value = strictSupertypeParInterfaceDecl(type);
7503    
7504        return strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value;
7505      }
7506      /**
7507       * @attribute syn
7508       * @aspect StrictSubtype
7509       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:68
7510       */
7511      @ASTNodeAnnotation.Attribute
7512      public boolean strictSupertypeWildcard(WildcardType type) {
7513        boolean strictSupertypeWildcard_WildcardType_value = false;
7514    
7515        return strictSupertypeWildcard_WildcardType_value;
7516      }
7517      /**
7518       * @attribute syn
7519       * @aspect StrictSubtype
7520       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:77
7521       */
7522      @ASTNodeAnnotation.Attribute
7523      public boolean strictSupertypeWildcardExtends(WildcardExtendsType type) {
7524        boolean strictSupertypeWildcardExtends_WildcardExtendsType_value = false;
7525    
7526        return strictSupertypeWildcardExtends_WildcardExtendsType_value;
7527      }
7528      /**
7529       * @attribute syn
7530       * @aspect StrictSubtype
7531       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:85
7532       */
7533      @ASTNodeAnnotation.Attribute
7534      public boolean strictSupertypeWildcardSuper(WildcardSuperType type) {
7535        boolean strictSupertypeWildcardSuper_WildcardSuperType_value = false;
7536    
7537        return strictSupertypeWildcardSuper_WildcardSuperType_value;
7538      }
7539      /**
7540       * @attribute syn
7541       * @aspect StrictSubtype
7542       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:155
7543       */
7544      @ASTNodeAnnotation.Attribute
7545      public boolean strictSupertypeParClassDecl(ParClassDecl type) {
7546        boolean strictSupertypeParClassDecl_ParClassDecl_value = strictSupertypeClassDecl(type);
7547    
7548        return strictSupertypeParClassDecl_ParClassDecl_value;
7549      }
7550      /**
7551       * @attribute syn
7552       * @aspect StrictSubtype
7553       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:159
7554       */
7555      @ASTNodeAnnotation.Attribute
7556      public boolean strictSupertypeParInterfaceDecl(ParInterfaceDecl type) {
7557        boolean strictSupertypeParInterfaceDecl_ParInterfaceDecl_value = strictSupertypeInterfaceDecl(type);
7558    
7559        return strictSupertypeParInterfaceDecl_ParInterfaceDecl_value;
7560      }
7561      /**
7562       * @apilevel internal
7563       */
7564      private void strictContainedIn_TypeDecl_reset() {
7565        strictContainedIn_TypeDecl_values = null;
7566      }
7567      protected java.util.Map strictContainedIn_TypeDecl_values;
7568      @ASTNodeAnnotation.Attribute
7569      public boolean strictContainedIn(TypeDecl type) {
7570        Object _parameters = type;
7571        if (strictContainedIn_TypeDecl_values == null) strictContainedIn_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
7572        ASTNode$State.CircularValue _value;
7573        if (strictContainedIn_TypeDecl_values.containsKey(_parameters)) {
7574          Object _o = strictContainedIn_TypeDecl_values.get(_parameters);
7575          if (!(_o instanceof ASTNode$State.CircularValue)) {
7576            return (Boolean) _o;
7577          } else {
7578            _value = (ASTNode$State.CircularValue) _o;
7579          }
7580        } else {
7581          _value = new ASTNode$State.CircularValue();
7582          strictContainedIn_TypeDecl_values.put(_parameters, _value);
7583          _value.value = true;
7584        }
7585        ASTNode$State state = state();
7586        boolean new_strictContainedIn_TypeDecl_value;
7587        if (!state.IN_CIRCLE) {
7588          state.IN_CIRCLE = true;
7589          int num = state.boundariesCrossed;
7590          boolean isFinal = this.is$Final();
7591          // TODO: fixme
7592          // state().CIRCLE_INDEX = 1;
7593          do {
7594            _value.visited = state.CIRCLE_INDEX;
7595            state.CHANGE = false;
7596            new_strictContainedIn_TypeDecl_value = strictContainedIn_compute(type);
7597            if (new_strictContainedIn_TypeDecl_value != ((Boolean)_value.value)) {
7598              state.CHANGE = true;
7599              _value.value = new_strictContainedIn_TypeDecl_value;
7600            }
7601            state.CIRCLE_INDEX++;
7602          } while (state.CHANGE);
7603          if (isFinal && num == state().boundariesCrossed) {
7604            strictContainedIn_TypeDecl_values.put(_parameters, new_strictContainedIn_TypeDecl_value);
7605          } else {
7606            strictContainedIn_TypeDecl_values.remove(_parameters);
7607            state.RESET_CYCLE = true;
7608            boolean $tmp = strictContainedIn_compute(type);
7609            state.RESET_CYCLE = false;
7610          }
7611          state.IN_CIRCLE = false;
7612          state.INTERMEDIATE_VALUE = false;
7613          return new_strictContainedIn_TypeDecl_value;
7614        }
7615        if (state.CIRCLE_INDEX != _value.visited) {
7616          _value.visited = state.CIRCLE_INDEX;
7617          new_strictContainedIn_TypeDecl_value = strictContainedIn_compute(type);
7618          if (state.RESET_CYCLE) {
7619            strictContainedIn_TypeDecl_values.remove(_parameters);
7620          }
7621          else if (new_strictContainedIn_TypeDecl_value != ((Boolean)_value.value)) {
7622            state.CHANGE = true;
7623            _value.value = new_strictContainedIn_TypeDecl_value;
7624          }
7625          state.INTERMEDIATE_VALUE = true;
7626          return new_strictContainedIn_TypeDecl_value;
7627        }
7628        state.INTERMEDIATE_VALUE = true;
7629        return (Boolean) _value.value;
7630      }
7631      /**
7632       * @apilevel internal
7633       */
7634      private boolean strictContainedIn_compute(TypeDecl type) {
7635          if (type == this || type instanceof WildcardType) {
7636            return true;
7637          } else if (type instanceof WildcardExtendsType) {
7638            return this.strictSubtype(((WildcardExtendsType) type).extendsType());
7639          } else if (type instanceof WildcardSuperType) {
7640            return ((WildcardSuperType) type).superType().strictSubtype(this);
7641          } else if (type instanceof TypeVariable) {
7642            return strictSubtype(type);
7643          }
7644          return sameStructure(type);
7645        }
7646      /**
7647       * @attribute syn
7648       * @aspect StrictSubtype
7649       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:276
7650       */
7651      @ASTNodeAnnotation.Attribute
7652      public boolean strictSupertypeTypeVariable(TypeVariable type) {
7653        {
7654            if (type == this) {
7655              return true;
7656            }
7657            for (int i = 0; i < type.getNumTypeBound(); i++) {
7658              if (type.getTypeBound(i).type().strictSubtype(this)) {
7659                return true;
7660              }
7661            }
7662            return false;
7663          }
7664      }
7665      /**
7666       * @attribute syn
7667       * @aspect StrictSubtype
7668       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:316
7669       */
7670      @ASTNodeAnnotation.Attribute
7671      public boolean strictSupertypeLUBType(LUBType type) {
7672        {
7673            for (int i = 0; i < type.getNumTypeBound(); i++) {
7674              if (!type.getTypeBound(i).type().strictSubtype(this)) {
7675                return false;
7676              }
7677            }
7678            return true;
7679          }
7680      }
7681      /**
7682       * @attribute syn
7683       * @aspect StrictSubtype
7684       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:336
7685       */
7686      @ASTNodeAnnotation.Attribute
7687      public boolean strictSupertypeGLBType(GLBType type) {
7688        {
7689            // T1 && .. && Tn <: this, if exists  0 < i <= n Ti <: this
7690            for (int i = 0; i < type.getNumTypeBound(); i++) {
7691              if (type.getTypeBound(i).type().strictSubtype(this)) {
7692                return true;
7693              }
7694            }
7695            return false;
7696          }
7697      }
7698      /**
7699       * @apilevel internal
7700       */
7701      private void strictSubtype_TypeDecl_reset() {
7702        strictSubtype_TypeDecl_values = null;
7703      }
7704      protected java.util.Map strictSubtype_TypeDecl_values;
7705      @ASTNodeAnnotation.Attribute
7706      public boolean strictSubtype(TypeDecl type) {
7707        Object _parameters = type;
7708        if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
7709        ASTNode$State.CircularValue _value;
7710        if (strictSubtype_TypeDecl_values.containsKey(_parameters)) {
7711          Object _o = strictSubtype_TypeDecl_values.get(_parameters);
7712          if (!(_o instanceof ASTNode$State.CircularValue)) {
7713            return (Boolean) _o;
7714          } else {
7715            _value = (ASTNode$State.CircularValue) _o;
7716          }
7717        } else {
7718          _value = new ASTNode$State.CircularValue();
7719          strictSubtype_TypeDecl_values.put(_parameters, _value);
7720          _value.value = true;
7721        }
7722        ASTNode$State state = state();
7723        boolean new_strictSubtype_TypeDecl_value;
7724        if (!state.IN_CIRCLE) {
7725          state.IN_CIRCLE = true;
7726          int num = state.boundariesCrossed;
7727          boolean isFinal = this.is$Final();
7728          // TODO: fixme
7729          // state().CIRCLE_INDEX = 1;
7730          do {
7731            _value.visited = state.CIRCLE_INDEX;
7732            state.CHANGE = false;
7733            new_strictSubtype_TypeDecl_value = type == this;
7734            if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
7735              state.CHANGE = true;
7736              _value.value = new_strictSubtype_TypeDecl_value;
7737            }
7738            state.CIRCLE_INDEX++;
7739          } while (state.CHANGE);
7740          if (isFinal && num == state().boundariesCrossed) {
7741            strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value);
7742          } else {
7743            strictSubtype_TypeDecl_values.remove(_parameters);
7744            state.RESET_CYCLE = true;
7745            boolean $tmp = type == this;
7746            state.RESET_CYCLE = false;
7747          }
7748          state.IN_CIRCLE = false;
7749          state.INTERMEDIATE_VALUE = false;
7750          return new_strictSubtype_TypeDecl_value;
7751        }
7752        if (state.CIRCLE_INDEX != _value.visited) {
7753          _value.visited = state.CIRCLE_INDEX;
7754          new_strictSubtype_TypeDecl_value = type == this;
7755          if (state.RESET_CYCLE) {
7756            strictSubtype_TypeDecl_values.remove(_parameters);
7757          }
7758          else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
7759            state.CHANGE = true;
7760            _value.value = new_strictSubtype_TypeDecl_value;
7761          }
7762          state.INTERMEDIATE_VALUE = true;
7763          return new_strictSubtype_TypeDecl_value;
7764        }
7765        state.INTERMEDIATE_VALUE = true;
7766        return (Boolean) _value.value;
7767      }
7768      /**
7769       * @attribute syn
7770       * @aspect StrictSubtype
7771       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:370
7772       */
7773      @ASTNodeAnnotation.Attribute
7774      public boolean strictSupertypeClassDecl(ClassDecl type) {
7775        boolean strictSupertypeClassDecl_ClassDecl_value = type == this;
7776    
7777        return strictSupertypeClassDecl_ClassDecl_value;
7778      }
7779      /**
7780       * @attribute syn
7781       * @aspect StrictSubtype
7782       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:390
7783       */
7784      @ASTNodeAnnotation.Attribute
7785      public boolean strictSupertypeInterfaceDecl(InterfaceDecl type) {
7786        boolean strictSupertypeInterfaceDecl_InterfaceDecl_value = type == this;
7787    
7788        return strictSupertypeInterfaceDecl_InterfaceDecl_value;
7789      }
7790      /**
7791       * @attribute syn
7792       * @aspect StrictSubtype
7793       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:407
7794       */
7795      @ASTNodeAnnotation.Attribute
7796      public boolean strictSupertypeArrayDecl(ArrayDecl type) {
7797        boolean strictSupertypeArrayDecl_ArrayDecl_value = this == type;
7798    
7799        return strictSupertypeArrayDecl_ArrayDecl_value;
7800      }
7801      /**
7802       * @attribute syn
7803       * @aspect StrictSubtype
7804       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:437
7805       */
7806      @ASTNodeAnnotation.Attribute
7807      public boolean strictSupertypePrimitiveType(PrimitiveType type) {
7808        boolean strictSupertypePrimitiveType_PrimitiveType_value = type == this;
7809    
7810        return strictSupertypePrimitiveType_PrimitiveType_value;
7811      }
7812      /**
7813       * @attribute syn
7814       * @aspect StrictSubtype
7815       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:446
7816       */
7817      @ASTNodeAnnotation.Attribute
7818      public boolean strictSupertypeNullType(NullType type) {
7819        boolean strictSupertypeNullType_NullType_value = false;
7820    
7821        return strictSupertypeNullType_NullType_value;
7822      }
7823      /**
7824       * @attribute syn
7825       * @aspect StrictSubtype
7826       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:450
7827       */
7828      @ASTNodeAnnotation.Attribute
7829      public boolean strictSupertypeVoidType(VoidType type) {
7830        boolean strictSupertypeVoidType_VoidType_value = false;
7831    
7832        return strictSupertypeVoidType_VoidType_value;
7833      }
7834      /**
7835       * @attribute syn
7836       * @aspect StrictSubtype
7837       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:455
7838       */
7839      @ASTNodeAnnotation.Attribute
7840      public boolean strictSupertypeClassDeclSubstituted(ClassDeclSubstituted type) {
7841        boolean strictSupertypeClassDeclSubstituted_ClassDeclSubstituted_value = type.original() == this || strictSupertypeClassDecl(type);
7842    
7843        return strictSupertypeClassDeclSubstituted_ClassDeclSubstituted_value;
7844      }
7845      /**
7846       * @attribute syn
7847       * @aspect StrictSubtype
7848       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:466
7849       */
7850      @ASTNodeAnnotation.Attribute
7851      public boolean strictSupertypeInterfaceDeclSubstituted(InterfaceDeclSubstituted type) {
7852        boolean strictSupertypeInterfaceDeclSubstituted_InterfaceDeclSubstituted_value = type.original() == this || strictSupertypeInterfaceDecl(type);
7853    
7854        return strictSupertypeInterfaceDeclSubstituted_InterfaceDeclSubstituted_value;
7855      }
7856      /**
7857       * @attribute syn
7858       * @aspect StrictSubtype
7859       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:478
7860       */
7861      @ASTNodeAnnotation.Attribute
7862      public boolean strictSupertypeGenericClassDeclSubstituted(GenericClassDeclSubstituted type) {
7863        boolean strictSupertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value = type.original() == this || strictSupertypeGenericClassDecl(type);
7864    
7865        return strictSupertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value;
7866      }
7867      /**
7868       * @attribute syn
7869       * @aspect StrictSubtype
7870       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:492
7871       */
7872      @ASTNodeAnnotation.Attribute
7873      public boolean strictSupertypeGenericInterfaceDeclSubstituted(GenericInterfaceDeclSubstituted type) {
7874        boolean strictSupertypeGenericInterfaceDeclSubstituted_GenericInterfaceDeclSubstituted_value = type.original() == this || strictSupertypeGenericInterfaceDecl(type);
7875    
7876        return strictSupertypeGenericInterfaceDeclSubstituted_GenericInterfaceDeclSubstituted_value;
7877      }
7878      /**
7879       * @attribute inh
7880       * @aspect Arrays
7881       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:42
7882       */
7883      /**
7884       * @attribute inh
7885       * @aspect Arrays
7886       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:42
7887       */
7888      @ASTNodeAnnotation.Attribute
7889      public TypeDecl componentType() {
7890        ASTNode$State state = state();
7891        if (componentType_computed) {
7892          return componentType_value;
7893        }
7894        boolean intermediate = state.INTERMEDIATE_VALUE;
7895        state.INTERMEDIATE_VALUE = false;
7896        int num = state.boundariesCrossed;
7897        boolean isFinal = this.is$Final();
7898        componentType_value = getParent().Define_componentType(this, null);
7899        if (isFinal && num == state().boundariesCrossed) {
7900          componentType_computed = true;
7901        } else {
7902        }
7903        state.INTERMEDIATE_VALUE |= intermediate;
7904    
7905        return componentType_value;
7906      }
7907      /**
7908       * @apilevel internal
7909       */
7910      protected boolean componentType_computed = false;
7911      /**
7912       * @apilevel internal
7913       */
7914      protected TypeDecl componentType_value;
7915      /**
7916       * @apilevel internal
7917       */
7918      private void componentType_reset() {
7919        componentType_computed = false;
7920        componentType_value = null;
7921      }
7922      /**
7923       * @attribute inh
7924       * @aspect Arrays
7925       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:70
7926       */
7927      /**
7928       * @attribute inh
7929       * @aspect Arrays
7930       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:70
7931       */
7932      @ASTNodeAnnotation.Attribute
7933      public TypeDecl typeCloneable() {
7934        TypeDecl typeCloneable_value = getParent().Define_typeCloneable(this, null);
7935    
7936        return typeCloneable_value;
7937      }
7938      /**
7939       * @attribute inh
7940       * @aspect Arrays
7941       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:71
7942       */
7943      /**
7944       * @attribute inh
7945       * @aspect Arrays
7946       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:71
7947       */
7948      @ASTNodeAnnotation.Attribute
7949      public TypeDecl typeSerializable() {
7950        TypeDecl typeSerializable_value = getParent().Define_typeSerializable(this, null);
7951    
7952        return typeSerializable_value;
7953      }
7954      /**
7955       * @attribute inh
7956       * @aspect ClassPath
7957       * @declaredat /home/jesper/git/extendj/java4/frontend/ClassPath.jrag:78
7958       */
7959      /**
7960       * @attribute inh
7961       * @aspect ClassPath
7962       * @declaredat /home/jesper/git/extendj/java4/frontend/ClassPath.jrag:78
7963       */
7964      @ASTNodeAnnotation.Attribute
7965      public CompilationUnit compilationUnit() {
7966        CompilationUnit compilationUnit_value = getParent().Define_compilationUnit(this, null);
7967    
7968        return compilationUnit_value;
7969      }
7970      /**
7971       * @attribute inh
7972       * @aspect DA
7973       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:264
7974       */
7975      /**
7976       * @attribute inh
7977       * @aspect DA
7978       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:264
7979       */
7980      @ASTNodeAnnotation.Attribute
7981      public boolean isDAbefore(Variable v) {
7982        Object _parameters = v;
7983        if (isDAbefore_Variable_values == null) isDAbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
7984        ASTNode$State state = state();
7985        if (isDAbefore_Variable_values.containsKey(_parameters)) {
7986          return (Boolean) isDAbefore_Variable_values.get(_parameters);
7987        }
7988        boolean intermediate = state.INTERMEDIATE_VALUE;
7989        state.INTERMEDIATE_VALUE = false;
7990        int num = state.boundariesCrossed;
7991        boolean isFinal = this.is$Final();
7992        boolean isDAbefore_Variable_value = getParent().Define_isDAbefore(this, null, v);
7993        if (isFinal && num == state().boundariesCrossed) {
7994          isDAbefore_Variable_values.put(_parameters, isDAbefore_Variable_value);
7995        } else {
7996        }
7997        state.INTERMEDIATE_VALUE |= intermediate;
7998    
7999        return isDAbefore_Variable_value;
8000      }
8001      /**
8002       * @apilevel internal
8003       */
8004      protected java.util.Map isDAbefore_Variable_values;
8005      /**
8006       * @apilevel internal
8007       */
8008      private void isDAbefore_Variable_reset() {
8009        isDAbefore_Variable_values = null;
8010      }
8011      /**
8012       * @attribute inh
8013       * @aspect DU
8014       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:794
8015       */
8016      /**
8017       * @attribute inh
8018       * @aspect DU
8019       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:794
8020       */
8021      @ASTNodeAnnotation.Attribute
8022      public boolean isDUbefore(Variable v) {
8023        Object _parameters = v;
8024        if (isDUbefore_Variable_values == null) isDUbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
8025        ASTNode$State state = state();
8026        if (isDUbefore_Variable_values.containsKey(_parameters)) {
8027          return (Boolean) isDUbefore_Variable_values.get(_parameters);
8028        }
8029        boolean intermediate = state.INTERMEDIATE_VALUE;
8030        state.INTERMEDIATE_VALUE = false;
8031        int num = state.boundariesCrossed;
8032        boolean isFinal = this.is$Final();
8033        boolean isDUbefore_Variable_value = getParent().Define_isDUbefore(this, null, v);
8034        if (isFinal && num == state().boundariesCrossed) {
8035          isDUbefore_Variable_values.put(_parameters, isDUbefore_Variable_value);
8036        } else {
8037        }
8038        state.INTERMEDIATE_VALUE |= intermediate;
8039    
8040        return isDUbefore_Variable_value;
8041      }
8042      /**
8043       * @apilevel internal
8044       */
8045      protected java.util.Map isDUbefore_Variable_values;
8046      /**
8047       * @apilevel internal
8048       */
8049      private void isDUbefore_Variable_reset() {
8050        isDUbefore_Variable_values = null;
8051      }
8052      /**
8053       * @attribute inh
8054       * @aspect ExceptionHandling
8055       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:41
8056       */
8057      /**
8058       * @attribute inh
8059       * @aspect ExceptionHandling
8060       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:41
8061       */
8062      @ASTNodeAnnotation.Attribute
8063      public TypeDecl typeException() {
8064        ASTNode$State state = state();
8065        if (typeException_computed) {
8066          return typeException_value;
8067        }
8068        boolean intermediate = state.INTERMEDIATE_VALUE;
8069        state.INTERMEDIATE_VALUE = false;
8070        int num = state.boundariesCrossed;
8071        boolean isFinal = this.is$Final();
8072        typeException_value = getParent().Define_typeException(this, null);
8073        if (isFinal && num == state().boundariesCrossed) {
8074          typeException_computed = true;
8075        } else {
8076        }
8077        state.INTERMEDIATE_VALUE |= intermediate;
8078    
8079        return typeException_value;
8080      }
8081      /**
8082       * @apilevel internal
8083       */
8084      protected boolean typeException_computed = false;
8085      /**
8086       * @apilevel internal
8087       */
8088      protected TypeDecl typeException_value;
8089      /**
8090       * @apilevel internal
8091       */
8092      private void typeException_reset() {
8093        typeException_computed = false;
8094        typeException_value = null;
8095      }
8096      /**
8097       * @attribute inh
8098       * @aspect ExceptionHandling
8099       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:43
8100       */
8101      /**
8102       * @attribute inh
8103       * @aspect ExceptionHandling
8104       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:43
8105       */
8106      @ASTNodeAnnotation.Attribute
8107      public TypeDecl typeRuntimeException() {
8108        ASTNode$State state = state();
8109        if (typeRuntimeException_computed) {
8110          return typeRuntimeException_value;
8111        }
8112        boolean intermediate = state.INTERMEDIATE_VALUE;
8113        state.INTERMEDIATE_VALUE = false;
8114        int num = state.boundariesCrossed;
8115        boolean isFinal = this.is$Final();
8116        typeRuntimeException_value = getParent().Define_typeRuntimeException(this, null);
8117        if (isFinal && num == state().boundariesCrossed) {
8118          typeRuntimeException_computed = true;
8119        } else {
8120        }
8121        state.INTERMEDIATE_VALUE |= intermediate;
8122    
8123        return typeRuntimeException_value;
8124      }
8125      /**
8126       * @apilevel internal
8127       */
8128      protected boolean typeRuntimeException_computed = false;
8129      /**
8130       * @apilevel internal
8131       */
8132      protected TypeDecl typeRuntimeException_value;
8133      /**
8134       * @apilevel internal
8135       */
8136      private void typeRuntimeException_reset() {
8137        typeRuntimeException_computed = false;
8138        typeRuntimeException_value = null;
8139      }
8140      /**
8141       * @attribute inh
8142       * @aspect ExceptionHandling
8143       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:45
8144       */
8145      /**
8146       * @attribute inh
8147       * @aspect ExceptionHandling
8148       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:45
8149       */
8150      @ASTNodeAnnotation.Attribute
8151      public TypeDecl typeError() {
8152        ASTNode$State state = state();
8153        if (typeError_computed) {
8154          return typeError_value;
8155        }
8156        boolean intermediate = state.INTERMEDIATE_VALUE;
8157        state.INTERMEDIATE_VALUE = false;
8158        int num = state.boundariesCrossed;
8159        boolean isFinal = this.is$Final();
8160        typeError_value = getParent().Define_typeError(this, null);
8161        if (isFinal && num == state().boundariesCrossed) {
8162          typeError_computed = true;
8163        } else {
8164        }
8165        state.INTERMEDIATE_VALUE |= intermediate;
8166    
8167        return typeError_value;
8168      }
8169      /**
8170       * @apilevel internal
8171       */
8172      protected boolean typeError_computed = false;
8173      /**
8174       * @apilevel internal
8175       */
8176      protected TypeDecl typeError_value;
8177      /**
8178       * @apilevel internal
8179       */
8180      private void typeError_reset() {
8181        typeError_computed = false;
8182        typeError_value = null;
8183      }
8184      /**
8185       * @attribute inh
8186       * @aspect LookupMethod
8187       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:48
8188       */
8189      /**
8190       * @attribute inh
8191       * @aspect LookupMethod
8192       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:48
8193       */
8194      @ASTNodeAnnotation.Attribute
8195      public Collection lookupMethod(String name) {
8196        Object _parameters = name;
8197        if (lookupMethod_String_values == null) lookupMethod_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
8198        ASTNode$State state = state();
8199        if (lookupMethod_String_values.containsKey(_parameters)) {
8200          return (Collection) lookupMethod_String_values.get(_parameters);
8201        }
8202        boolean intermediate = state.INTERMEDIATE_VALUE;
8203        state.INTERMEDIATE_VALUE = false;
8204        int num = state.boundariesCrossed;
8205        boolean isFinal = this.is$Final();
8206        Collection lookupMethod_String_value = getParent().Define_lookupMethod(this, null, name);
8207        if (isFinal && num == state().boundariesCrossed) {
8208          lookupMethod_String_values.put(_parameters, lookupMethod_String_value);
8209        } else {
8210        }
8211        state.INTERMEDIATE_VALUE |= intermediate;
8212    
8213        return lookupMethod_String_value;
8214      }
8215      /**
8216       * @apilevel internal
8217       */
8218      protected java.util.Map lookupMethod_String_values;
8219      /**
8220       * @apilevel internal
8221       */
8222      private void lookupMethod_String_reset() {
8223        lookupMethod_String_values = null;
8224      }
8225      /**
8226       * @attribute inh
8227       * @aspect SpecialClasses
8228       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:87
8229       */
8230      /**
8231       * @attribute inh
8232       * @aspect SpecialClasses
8233       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:87
8234       */
8235      @ASTNodeAnnotation.Attribute
8236      public TypeDecl typeInt() {
8237        TypeDecl typeInt_value = getParent().Define_typeInt(this, null);
8238    
8239        return typeInt_value;
8240      }
8241      /**
8242       * @attribute inh
8243       * @aspect SpecialClasses
8244       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:90
8245       */
8246      /**
8247       * @attribute inh
8248       * @aspect SpecialClasses
8249       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:90
8250       */
8251      @ASTNodeAnnotation.Attribute
8252      public TypeDecl typeObject() {
8253        ASTNode$State state = state();
8254        if (typeObject_computed) {
8255          return typeObject_value;
8256        }
8257        boolean intermediate = state.INTERMEDIATE_VALUE;
8258        state.INTERMEDIATE_VALUE = false;
8259        int num = state.boundariesCrossed;
8260        boolean isFinal = this.is$Final();
8261        typeObject_value = getParent().Define_typeObject(this, null);
8262        if (isFinal && num == state().boundariesCrossed) {
8263          typeObject_computed = true;
8264        } else {
8265        }
8266        state.INTERMEDIATE_VALUE |= intermediate;
8267    
8268        return typeObject_value;
8269      }
8270      /**
8271       * @apilevel internal
8272       */
8273      protected boolean typeObject_computed = false;
8274      /**
8275       * @apilevel internal
8276       */
8277      protected TypeDecl typeObject_value;
8278      /**
8279       * @apilevel internal
8280       */
8281      private void typeObject_reset() {
8282        typeObject_computed = false;
8283        typeObject_value = null;
8284      }
8285      /**
8286       * @attribute inh
8287       * @aspect LookupFullyQualifiedTypes
8288       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:132
8289       */
8290      /**
8291       * @attribute inh
8292       * @aspect LookupFullyQualifiedTypes
8293       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:132
8294       */
8295      @ASTNodeAnnotation.Attribute
8296      public TypeDecl lookupType(String packageName, String typeName) {
8297        TypeDecl lookupType_String_String_value = getParent().Define_lookupType(this, null, packageName, typeName);
8298    
8299        return lookupType_String_String_value;
8300      }
8301      /**
8302       * @attribute inh
8303       * @aspect TypeScopePropagation
8304       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:337
8305       */
8306      /**
8307       * @attribute inh
8308       * @aspect TypeScopePropagation
8309       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:337
8310       */
8311      @ASTNodeAnnotation.Attribute
8312      public SimpleSet lookupType(String name) {
8313        Object _parameters = name;
8314        if (lookupType_String_values == null) lookupType_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
8315        ASTNode$State state = state();
8316        if (lookupType_String_values.containsKey(_parameters)) {
8317          return (SimpleSet) lookupType_String_values.get(_parameters);
8318        }
8319        boolean intermediate = state.INTERMEDIATE_VALUE;
8320        state.INTERMEDIATE_VALUE = false;
8321        int num = state.boundariesCrossed;
8322        boolean isFinal = this.is$Final();
8323        SimpleSet lookupType_String_value = getParent().Define_lookupType(this, null, name);
8324        if (isFinal && num == state().boundariesCrossed) {
8325          lookupType_String_values.put(_parameters, lookupType_String_value);
8326        } else {
8327        }
8328        state.INTERMEDIATE_VALUE |= intermediate;
8329    
8330        return lookupType_String_value;
8331      }
8332      /**
8333       * @apilevel internal
8334       */
8335      protected java.util.Map lookupType_String_values;
8336      /**
8337       * @apilevel internal
8338       */
8339      private void lookupType_String_reset() {
8340        lookupType_String_values = null;
8341      }
8342      /**
8343       * @attribute inh
8344       * @aspect VariableScope
8345       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:35
8346       */
8347      /**
8348       * @attribute inh
8349       * @aspect VariableScope
8350       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:35
8351       */
8352      @ASTNodeAnnotation.Attribute
8353      public SimpleSet lookupVariable(String name) {
8354        Object _parameters = name;
8355        if (lookupVariable_String_values == null) lookupVariable_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
8356        ASTNode$State state = state();
8357        if (lookupVariable_String_values.containsKey(_parameters)) {
8358          return (SimpleSet) lookupVariable_String_values.get(_parameters);
8359        }
8360        boolean intermediate = state.INTERMEDIATE_VALUE;
8361        state.INTERMEDIATE_VALUE = false;
8362        int num = state.boundariesCrossed;
8363        boolean isFinal = this.is$Final();
8364        SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name);
8365        if (isFinal && num == state().boundariesCrossed) {
8366          lookupVariable_String_values.put(_parameters, lookupVariable_String_value);
8367        } else {
8368        }
8369        state.INTERMEDIATE_VALUE |= intermediate;
8370    
8371        return lookupVariable_String_value;
8372      }
8373      /**
8374       * @apilevel internal
8375       */
8376      protected java.util.Map lookupVariable_String_values;
8377      /**
8378       * @apilevel internal
8379       */
8380      private void lookupVariable_String_reset() {
8381        lookupVariable_String_values = null;
8382      }
8383      /**
8384       * @attribute inh
8385       * @aspect NameCheck
8386       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:307
8387       */
8388      /**
8389       * @attribute inh
8390       * @aspect NameCheck
8391       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:307
8392       */
8393      @ASTNodeAnnotation.Attribute
8394      public boolean hasPackage(String packageName) {
8395        boolean hasPackage_String_value = getParent().Define_hasPackage(this, null, packageName);
8396    
8397        return hasPackage_String_value;
8398      }
8399      /**
8400       * @attribute inh
8401       * @aspect NameCheck
8402       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:310
8403       */
8404      /**
8405       * @attribute inh
8406       * @aspect NameCheck
8407       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:310
8408       */
8409      @ASTNodeAnnotation.Attribute
8410      public ASTNode enclosingBlock() {
8411        ASTNode enclosingBlock_value = getParent().Define_enclosingBlock(this, null);
8412    
8413        return enclosingBlock_value;
8414      }
8415      /**
8416       * @attribute inh
8417       * @aspect TypeName
8418       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:103
8419       */
8420      /**
8421       * @attribute inh
8422       * @aspect TypeName
8423       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:103
8424       */
8425      @ASTNodeAnnotation.Attribute
8426      public String packageName() {
8427        ASTNode$State state = state();
8428        if (packageName_computed) {
8429          return packageName_value;
8430        }
8431        boolean intermediate = state.INTERMEDIATE_VALUE;
8432        state.INTERMEDIATE_VALUE = false;
8433        int num = state.boundariesCrossed;
8434        boolean isFinal = this.is$Final();
8435        packageName_value = getParent().Define_packageName(this, null);
8436        if (isFinal && num == state().boundariesCrossed) {
8437          packageName_computed = true;
8438        } else {
8439        }
8440        state.INTERMEDIATE_VALUE |= intermediate;
8441    
8442        return packageName_value;
8443      }
8444      /**
8445       * @apilevel internal
8446       */
8447      protected boolean packageName_computed = false;
8448      /**
8449       * @apilevel internal
8450       */
8451      protected String packageName_value;
8452      /**
8453       * @apilevel internal
8454       */
8455      private void packageName_reset() {
8456        packageName_computed = false;
8457        packageName_value = null;
8458      }
8459      /**
8460       * @attribute inh
8461       * @aspect TypeAnalysis
8462       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:240
8463       */
8464      /**
8465       * @attribute inh
8466       * @aspect TypeAnalysis
8467       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:240
8468       */
8469      @ASTNodeAnnotation.Attribute
8470      public boolean isAnonymous() {
8471        ASTNode$State state = state();
8472        if (isAnonymous_computed) {
8473          return isAnonymous_value;
8474        }
8475        boolean intermediate = state.INTERMEDIATE_VALUE;
8476        state.INTERMEDIATE_VALUE = false;
8477        int num = state.boundariesCrossed;
8478        boolean isFinal = this.is$Final();
8479        isAnonymous_value = getParent().Define_isAnonymous(this, null);
8480        if (isFinal && num == state().boundariesCrossed) {
8481          isAnonymous_computed = true;
8482        } else {
8483        }
8484        state.INTERMEDIATE_VALUE |= intermediate;
8485    
8486        return isAnonymous_value;
8487      }
8488      /**
8489       * @apilevel internal
8490       */
8491      protected boolean isAnonymous_computed = false;
8492      /**
8493       * @apilevel internal
8494       */
8495      protected boolean isAnonymous_value;
8496      /**
8497       * @apilevel internal
8498       */
8499      private void isAnonymous_reset() {
8500        isAnonymous_computed = false;
8501      }
8502      /**
8503       * @attribute inh
8504       * @aspect NestedTypes
8505       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:544
8506       */
8507      /**
8508       * @attribute inh
8509       * @aspect NestedTypes
8510       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:544
8511       */
8512      @ASTNodeAnnotation.Attribute
8513      public TypeDecl enclosingType() {
8514        TypeDecl enclosingType_value = getParent().Define_enclosingType(this, null);
8515    
8516        return enclosingType_value;
8517      }
8518      /**
8519       * @attribute inh
8520       * @aspect NestedTypes
8521       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:562
8522       */
8523      /**
8524       * @attribute inh
8525       * @aspect NestedTypes
8526       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:562
8527       */
8528      @ASTNodeAnnotation.Attribute
8529      public BodyDecl enclosingBodyDecl() {
8530        BodyDecl enclosingBodyDecl_value = getParent().Define_enclosingBodyDecl(this, null);
8531    
8532        return enclosingBodyDecl_value;
8533      }
8534      /**
8535       * @attribute inh
8536       * @aspect NestedTypes
8537       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:569
8538       */
8539      /**
8540       * @attribute inh
8541       * @aspect NestedTypes
8542       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:569
8543       */
8544      @ASTNodeAnnotation.Attribute
8545      public boolean isNestedType() {
8546        boolean isNestedType_value = getParent().Define_isNestedType(this, null);
8547    
8548        return isNestedType_value;
8549      }
8550      /**
8551       * @attribute inh
8552       * @aspect NestedTypes
8553       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:577
8554       */
8555      /**
8556       * @attribute inh
8557       * @aspect NestedTypes
8558       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:577
8559       */
8560      @ASTNodeAnnotation.Attribute
8561      public boolean isMemberType() {
8562        boolean isMemberType_value = getParent().Define_isMemberType(this, null);
8563    
8564        return isMemberType_value;
8565      }
8566      /**
8567       * @attribute inh
8568       * @aspect NestedTypes
8569       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:591
8570       */
8571      /**
8572       * @attribute inh
8573       * @aspect NestedTypes
8574       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:591
8575       */
8576      @ASTNodeAnnotation.Attribute
8577      public boolean isLocalClass() {
8578        boolean isLocalClass_value = getParent().Define_isLocalClass(this, null);
8579    
8580        return isLocalClass_value;
8581      }
8582      /**
8583       * @attribute inh
8584       * @aspect NestedTypes
8585       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:620
8586       */
8587      /**
8588       * @attribute inh
8589       * @aspect NestedTypes
8590       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:620
8591       */
8592      @ASTNodeAnnotation.Attribute
8593      public String hostPackage() {
8594        String hostPackage_value = getParent().Define_hostPackage(this, null);
8595    
8596        return hostPackage_value;
8597      }
8598      /**
8599       * @attribute inh
8600       * @aspect Circularity
8601       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:751
8602       */
8603      /**
8604       * @attribute inh
8605       * @aspect Circularity
8606       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:751
8607       */
8608      @ASTNodeAnnotation.Attribute
8609      public TypeDecl unknownType() {
8610        ASTNode$State state = state();
8611        if (unknownType_computed) {
8612          return unknownType_value;
8613        }
8614        boolean intermediate = state.INTERMEDIATE_VALUE;
8615        state.INTERMEDIATE_VALUE = false;
8616        int num = state.boundariesCrossed;
8617        boolean isFinal = this.is$Final();
8618        unknownType_value = getParent().Define_unknownType(this, null);
8619        if (isFinal && num == state().boundariesCrossed) {
8620          unknownType_computed = true;
8621        } else {
8622        }
8623        state.INTERMEDIATE_VALUE |= intermediate;
8624    
8625        return unknownType_value;
8626      }
8627      /**
8628       * @apilevel internal
8629       */
8630      protected boolean unknownType_computed = false;
8631      /**
8632       * @apilevel internal
8633       */
8634      protected TypeDecl unknownType_value;
8635      /**
8636       * @apilevel internal
8637       */
8638      private void unknownType_reset() {
8639        unknownType_computed = false;
8640        unknownType_value = null;
8641      }
8642      /**
8643       * @attribute inh
8644       * @aspect TypeCheck
8645       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:471
8646       */
8647      /**
8648       * @attribute inh
8649       * @aspect TypeCheck
8650       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:471
8651       */
8652      @ASTNodeAnnotation.Attribute
8653      public TypeDecl typeVoid() {
8654        TypeDecl typeVoid_value = getParent().Define_typeVoid(this, null);
8655    
8656        return typeVoid_value;
8657      }
8658      /**
8659       * @attribute inh
8660       * @aspect TypeCheck
8661       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:586
8662       */
8663      /**
8664       * @attribute inh
8665       * @aspect TypeCheck
8666       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:586
8667       */
8668      @ASTNodeAnnotation.Attribute
8669      public TypeDecl enclosingInstance() {
8670        TypeDecl enclosingInstance_value = getParent().Define_enclosingInstance(this, null);
8671    
8672        return enclosingInstance_value;
8673      }
8674      /**
8675       * @attribute inh
8676       * @aspect TypeHierarchyCheck
8677       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:165
8678       */
8679      /**
8680       * @attribute inh
8681       * @aspect TypeHierarchyCheck
8682       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:165
8683       */
8684      @ASTNodeAnnotation.Attribute
8685      public boolean inExplicitConstructorInvocation() {
8686        ASTNode$State state = state();
8687        if (inExplicitConstructorInvocation_computed) {
8688          return inExplicitConstructorInvocation_value;
8689        }
8690        boolean intermediate = state.INTERMEDIATE_VALUE;
8691        state.INTERMEDIATE_VALUE = false;
8692        int num = state.boundariesCrossed;
8693        boolean isFinal = this.is$Final();
8694        inExplicitConstructorInvocation_value = getParent().Define_inExplicitConstructorInvocation(this, null);
8695        if (isFinal && num == state().boundariesCrossed) {
8696          inExplicitConstructorInvocation_computed = true;
8697        } else {
8698        }
8699        state.INTERMEDIATE_VALUE |= intermediate;
8700    
8701        return inExplicitConstructorInvocation_value;
8702      }
8703      /**
8704       * @apilevel internal
8705       */
8706      protected boolean inExplicitConstructorInvocation_computed = false;
8707      /**
8708       * @apilevel internal
8709       */
8710      protected boolean inExplicitConstructorInvocation_value;
8711      /**
8712       * @apilevel internal
8713       */
8714      private void inExplicitConstructorInvocation_reset() {
8715        inExplicitConstructorInvocation_computed = false;
8716      }
8717      /**
8718       * @attribute inh
8719       * @aspect TypeHierarchyCheck
8720       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:183
8721       */
8722      /**
8723       * @attribute inh
8724       * @aspect TypeHierarchyCheck
8725       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:183
8726       */
8727      @ASTNodeAnnotation.Attribute
8728      public boolean inStaticContext() {
8729        ASTNode$State state = state();
8730        if (inStaticContext_computed) {
8731          return inStaticContext_value;
8732        }
8733        boolean intermediate = state.INTERMEDIATE_VALUE;
8734        state.INTERMEDIATE_VALUE = false;
8735        int num = state.boundariesCrossed;
8736        boolean isFinal = this.is$Final();
8737        inStaticContext_value = getParent().Define_inStaticContext(this, null);
8738        if (isFinal && num == state().boundariesCrossed) {
8739          inStaticContext_computed = true;
8740        } else {
8741        }
8742        state.INTERMEDIATE_VALUE |= intermediate;
8743    
8744        return inStaticContext_value;
8745      }
8746      /**
8747       * @apilevel internal
8748       */
8749      protected boolean inStaticContext_computed = false;
8750      /**
8751       * @apilevel internal
8752       */
8753      protected boolean inStaticContext_value;
8754      /**
8755       * @apilevel internal
8756       */
8757      private void inStaticContext_reset() {
8758        inStaticContext_computed = false;
8759      }
8760      /**
8761       * @attribute inh
8762       * @aspect Annotations
8763       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:353
8764       */
8765      /**
8766       * @attribute inh
8767       * @aspect Annotations
8768       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:353
8769       */
8770      @ASTNodeAnnotation.Attribute
8771      public boolean withinSuppressWarnings(String annot) {
8772        boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot);
8773    
8774        return withinSuppressWarnings_String_value;
8775      }
8776      /**
8777       * @attribute inh
8778       * @aspect Annotations
8779       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:456
8780       */
8781      /**
8782       * @attribute inh
8783       * @aspect Annotations
8784       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:456
8785       */
8786      @ASTNodeAnnotation.Attribute
8787      public boolean withinDeprecatedAnnotation() {
8788        boolean withinDeprecatedAnnotation_value = getParent().Define_withinDeprecatedAnnotation(this, null);
8789    
8790        return withinDeprecatedAnnotation_value;
8791      }
8792      /**
8793       * @attribute inh
8794       * @aspect LookupParTypeDecl
8795       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1488
8796       */
8797      /**
8798       * @attribute inh
8799       * @aspect LookupParTypeDecl
8800       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1488
8801       */
8802      @ASTNodeAnnotation.Attribute
8803      public TypeDecl typeWildcard() {
8804        TypeDecl typeWildcard_value = getParent().Define_typeWildcard(this, null);
8805    
8806        return typeWildcard_value;
8807      }
8808      /**
8809       * @attribute inh
8810       * @aspect LookupParTypeDecl
8811       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1502
8812       */
8813      /**
8814       * @attribute inh
8815       * @aspect LookupParTypeDecl
8816       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1502
8817       */
8818      @ASTNodeAnnotation.Attribute
8819      public TypeDecl lookupWildcardExtends(TypeDecl typeDecl) {
8820        TypeDecl lookupWildcardExtends_TypeDecl_value = getParent().Define_lookupWildcardExtends(this, null, typeDecl);
8821    
8822        return lookupWildcardExtends_TypeDecl_value;
8823      }
8824      /**
8825       * @attribute inh
8826       * @aspect LookupParTypeDecl
8827       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1516
8828       */
8829      /**
8830       * @attribute inh
8831       * @aspect LookupParTypeDecl
8832       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1516
8833       */
8834      @ASTNodeAnnotation.Attribute
8835      public TypeDecl lookupWildcardSuper(TypeDecl typeDecl) {
8836        TypeDecl lookupWildcardSuper_TypeDecl_value = getParent().Define_lookupWildcardSuper(this, null, typeDecl);
8837    
8838        return lookupWildcardSuper_TypeDecl_value;
8839      }
8840      /**
8841       * @attribute inh
8842       * @aspect LookupParTypeDecl
8843       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1539
8844       */
8845      /**
8846       * @attribute inh
8847       * @aspect LookupParTypeDecl
8848       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1539
8849       */
8850      @ASTNodeAnnotation.Attribute
8851      public LUBType lookupLUBType(Collection bounds) {
8852        LUBType lookupLUBType_Collection_value = getParent().Define_lookupLUBType(this, null, bounds);
8853    
8854        return lookupLUBType_Collection_value;
8855      }
8856      /**
8857       * @attribute inh
8858       * @aspect LookupParTypeDecl
8859       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1580
8860       */
8861      /**
8862       * @attribute inh
8863       * @aspect LookupParTypeDecl
8864       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1580
8865       */
8866      @ASTNodeAnnotation.Attribute
8867      public GLBType lookupGLBType(ArrayList bounds) {
8868        GLBType lookupGLBType_ArrayList_value = getParent().Define_lookupGLBType(this, null, bounds);
8869    
8870        return lookupGLBType_ArrayList_value;
8871      }
8872      /**
8873       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:42
8874       * @apilevel internal
8875       */
8876      public TypeDecl Define_componentType(ASTNode caller, ASTNode child) {
8877        if (caller == arrayType_value) {
8878          // @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:41
8879          return this;
8880        }
8881        else {
8882          return getParent().Define_componentType(this, caller);
8883        }
8884      }
8885      protected boolean canDefine_componentType(ASTNode caller, ASTNode child) {
8886        return true;
8887      }
8888      /**
8889       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:37
8890       * @apilevel internal
8891       */
8892      public boolean Define_isDest(ASTNode caller, ASTNode child) {
8893        int childIndex = this.getIndexOfChild(caller);
8894        return false;
8895      }
8896      protected boolean canDefine_isDest(ASTNode caller, ASTNode child) {
8897        return true;
8898      }
8899      /**
8900       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47
8901       * @apilevel internal
8902       */
8903      public boolean Define_isSource(ASTNode caller, ASTNode child) {
8904        int childIndex = this.getIndexOfChild(caller);
8905        return true;
8906      }
8907      protected boolean canDefine_isSource(ASTNode caller, ASTNode child) {
8908        return true;
8909      }
8910      /**
8911       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:272
8912       * @apilevel internal
8913       */
8914      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) {
8915        int childIndex = this.getIndexOfChild(caller);
8916        {
8917            //if (b instanceof MethodDecl || b instanceof MemberTypeDecl) {
8918            if (!v.isInstanceVariable() && !v.isClassVariable()) {
8919              if (v.hostType() != this) {
8920                return isDAbefore(v);
8921              }
8922              return false;
8923            }
8924            if (b instanceof FieldDeclaration && !((FieldDeclaration) b).isStatic() && v.isClassVariable()) {
8925              return true;
8926            }
8927        
8928            if (b instanceof MethodDecl) {
8929              return true;
8930            }
8931            if (b instanceof MemberTypeDecl && v.isBlank() && v.isFinal() && v.hostType() == this) {
8932              return true;
8933            }
8934            if (v.isClassVariable() || v.isInstanceVariable()) {
8935              if (v.isFinal() &&  v.hostType() != this && instanceOf(v.hostType())) {
8936                return true;
8937              }
8938        
8939              boolean search = true;
8940              if (b instanceof ConstructorDecl) {
8941                search = false;
8942              }
8943        
8944              for (int i = getNumBodyDecl() - 1; i >= 0; --i) {
8945                BodyDecl decl = getBodyDecl(i);
8946                if (b == decl) {
8947                  search = false;
8948                  continue;
8949                }
8950                if (search) {
8951                  continue;
8952                }
8953                if (decl instanceof FieldDeclaration) {
8954                  FieldDeclaration f = (FieldDeclaration) decl;
8955                  if ((v.isClassVariable() && f.isStatic()) || (v.isInstanceVariable() && !f.isStatic())) {
8956                    boolean c = f.isDAafter(v);
8957                    //System.err.println("DefiniteAssignment: is " + v.name() + " DA after index " + i + ", " + f + ": " + c);
8958                    return c;
8959                    //return f.isDAafter(v);
8960                  }
8961                } else if (decl instanceof StaticInitializer && v.isClassVariable()) {
8962                  StaticInitializer si = (StaticInitializer) decl;
8963                  return si.isDAafter(v);
8964                } else if (decl instanceof InstanceInitializer && v.isInstanceVariable()) {
8965                  InstanceInitializer ii = (InstanceInitializer) decl;
8966                  return ii.isDAafter(v);
8967                }
8968              }
8969            }
8970            return isDAbefore(v);
8971          }
8972      }
8973      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) {
8974        return true;
8975      }
8976      /**
8977       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:804
8978       * @apilevel internal
8979       */
8980      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) {
8981        int childIndex = this.getIndexOfChild(caller);
8982        {
8983            if (b instanceof MethodDecl || b instanceof MemberTypeDecl) {
8984              return false;
8985            }
8986            if (v.isClassVariable() || v.isInstanceVariable()) {
8987              boolean search = true;
8988              if (b instanceof ConstructorDecl) {
8989                search = false;
8990              }
8991        
8992              for (int i = getNumBodyDecl() - 1; i >= 0; --i) {
8993                BodyDecl decl = getBodyDecl(i);
8994                if (b == decl) {
8995                  search = false;
8996                  continue;
8997                }
8998                if (search) {
8999                  continue;
9000                }
9001                if (decl instanceof FieldDeclaration) {
9002                  FieldDeclaration f = (FieldDeclaration) decl;
9003                  //System.err.println("  working on field " + f.name() + " which is child " + i);
9004                  if (f == v) {
9005                    return !f.hasInit();
9006                  }
9007                  if ((v.isClassVariable() && f.isStatic()) || (v.isInstanceVariable() && !f.isStatic())) {
9008                    return f.isDUafter(v);
9009                  }
9010                  //System.err.println("  field " + f.name() + " can not affect " + v.name());
9011                } else if (decl instanceof StaticInitializer && v.isClassVariable()) {
9012                  StaticInitializer si = (StaticInitializer) decl;
9013                  //System.err.println("  working on static initializer which is child " + i);
9014                  return si.isDUafter(v);
9015                } else if (decl instanceof InstanceInitializer && v.isInstanceVariable()) {
9016                  InstanceInitializer ii = (InstanceInitializer) decl;
9017                  //System.err.println("  working on instance initializer which is child " + i);
9018                  return ii.isDUafter(v);
9019                }
9020              }
9021            }
9022            //System.err.println("Reached TypeDecl when searching for DU for variable");
9023            return isDUbefore(v);
9024          }
9025      }
9026      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) {
9027        return true;
9028      }
9029      /**
9030       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:35
9031       * @apilevel internal
9032       */
9033      public Collection Define_lookupConstructor(ASTNode caller, ASTNode child) {
9034        int childIndex = this.getIndexOfChild(caller);
9035        return constructors();
9036      }
9037      protected boolean canDefine_lookupConstructor(ASTNode caller, ASTNode child) {
9038        return true;
9039      }
9040      /**
9041       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:40
9042       * @apilevel internal
9043       */
9044      public Collection Define_lookupSuperConstructor(ASTNode caller, ASTNode child) {
9045        int childIndex = this.getIndexOfChild(caller);
9046        return lookupSuperConstructor();
9047      }
9048      protected boolean canDefine_lookupSuperConstructor(ASTNode caller, ASTNode child) {
9049        return true;
9050      }
9051      /**
9052       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46
9053       * @apilevel internal
9054       */
9055      public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) {
9056        if (caller == getBodyDeclListNoTransform()) {
9057          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:56
9058          int i = caller.getIndexOfChild(child);
9059          return unqualifiedLookupMethod(name);
9060        }
9061        else {
9062          return getParent().Define_lookupMethod(this, caller, name);
9063        }
9064      }
9065      protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) {
9066        return true;
9067      }
9068      /**
9069       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197
9070       * @apilevel internal
9071       */
9072      public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) {
9073        if (caller == getBodyDeclListNoTransform()) {
9074          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:472
9075          int index = caller.getIndexOfChild(child);
9076          return localLookupType(name);
9077        }
9078        else {
9079          return getParent().Define_lookupType(this, caller, name);
9080        }
9081      }
9082      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) {
9083        return true;
9084      }
9085      /**
9086       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
9087       * @apilevel internal
9088       */
9089      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
9090        if (caller == getBodyDeclListNoTransform()) {
9091          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:48
9092          int i = caller.getIndexOfChild(child);
9093          {
9094              SimpleSet list = memberFields(name);
9095              if (!list.isEmpty()) {
9096                return list;
9097              }
9098              list = lookupVariable(name);
9099              if (inStaticContext() || isStatic()) {
9100                list = removeInstanceVariables(list);
9101              }
9102              return list;
9103            }
9104        }
9105        else {
9106          return getParent().Define_lookupVariable(this, caller, name);
9107        }
9108      }
9109      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
9110        return true;
9111      }
9112      /**
9113       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:419
9114       * @apilevel internal
9115       */
9116      public boolean Define_mayBePublic(ASTNode caller, ASTNode child) {
9117        if (caller == getBodyDeclListNoTransform()) {
9118          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:342
9119          int childIndex = caller.getIndexOfChild(child);
9120          return false;
9121        }
9122        else if (caller == getModifiersNoTransform()) {
9123          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:292
9124          return true;
9125        }
9126        else {
9127          return getParent().Define_mayBePublic(this, caller);
9128        }
9129      }
9130      protected boolean canDefine_mayBePublic(ASTNode caller, ASTNode child) {
9131        return true;
9132      }
9133      /**
9134       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:421
9135       * @apilevel internal
9136       */
9137      public boolean Define_mayBeProtected(ASTNode caller, ASTNode child) {
9138        if (caller == getBodyDeclListNoTransform()) {
9139          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:343
9140          int childIndex = caller.getIndexOfChild(child);
9141          return false;
9142        }
9143        else if (caller == getModifiersNoTransform()) {
9144          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:293
9145          return true;
9146        }
9147        else {
9148          return getParent().Define_mayBeProtected(this, caller);
9149        }
9150      }
9151      protected boolean canDefine_mayBeProtected(ASTNode caller, ASTNode child) {
9152        return true;
9153      }
9154      /**
9155       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:420
9156       * @apilevel internal
9157       */
9158      public boolean Define_mayBePrivate(ASTNode caller, ASTNode child) {
9159        if (caller == getBodyDeclListNoTransform()) {
9160          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:344
9161          int childIndex = caller.getIndexOfChild(child);
9162          return false;
9163        }
9164        else if (caller == getModifiersNoTransform()) {
9165          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:294
9166          return true;
9167        }
9168        else {
9169          return getParent().Define_mayBePrivate(this, caller);
9170        }
9171      }
9172      protected boolean canDefine_mayBePrivate(ASTNode caller, ASTNode child) {
9173        return true;
9174      }
9175      /**
9176       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:424
9177       * @apilevel internal
9178       */
9179      public boolean Define_mayBeAbstract(ASTNode caller, ASTNode child) {
9180        if (caller == getBodyDeclListNoTransform()) {
9181          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:347
9182          int childIndex = caller.getIndexOfChild(child);
9183          return false;
9184        }
9185        else if (caller == getModifiersNoTransform()) {
9186          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:295
9187          return true;
9188        }
9189        else {
9190          return getParent().Define_mayBeAbstract(this, caller);
9191        }
9192      }
9193      protected boolean canDefine_mayBeAbstract(ASTNode caller, ASTNode child) {
9194        return true;
9195      }
9196      /**
9197       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:422
9198       * @apilevel internal
9199       */
9200      public boolean Define_mayBeStatic(ASTNode caller, ASTNode child) {
9201        if (caller == getBodyDeclListNoTransform()) {
9202          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:345
9203          int childIndex = caller.getIndexOfChild(child);
9204          return false;
9205        }
9206        else if (caller == getModifiersNoTransform()) {
9207          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:296
9208          return true;
9209        }
9210        else {
9211          return getParent().Define_mayBeStatic(this, caller);
9212        }
9213      }
9214      protected boolean canDefine_mayBeStatic(ASTNode caller, ASTNode child) {
9215        return true;
9216      }
9217      /**
9218       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:427
9219       * @apilevel internal
9220       */
9221      public boolean Define_mayBeStrictfp(ASTNode caller, ASTNode child) {
9222        if (caller == getBodyDeclListNoTransform()) {
9223          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:350
9224          int childIndex = caller.getIndexOfChild(child);
9225          return false;
9226        }
9227        else if (caller == getModifiersNoTransform()) {
9228          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:297
9229          return true;
9230        }
9231        else {
9232          return getParent().Define_mayBeStrictfp(this, caller);
9233        }
9234      }
9235      protected boolean canDefine_mayBeStrictfp(ASTNode caller, ASTNode child) {
9236        return true;
9237      }
9238      /**
9239       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423
9240       * @apilevel internal
9241       */
9242      public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) {
9243        if (caller == getBodyDeclListNoTransform()) {
9244          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:346
9245          int childIndex = caller.getIndexOfChild(child);
9246          return false;
9247        }
9248        else {
9249          return getParent().Define_mayBeFinal(this, caller);
9250        }
9251      }
9252      protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) {
9253        return true;
9254      }
9255      /**
9256       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:425
9257       * @apilevel internal
9258       */
9259      public boolean Define_mayBeVolatile(ASTNode caller, ASTNode child) {
9260        if (caller == getBodyDeclListNoTransform()) {
9261          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:348
9262          int childIndex = caller.getIndexOfChild(child);
9263          return false;
9264        }
9265        else {
9266          return getParent().Define_mayBeVolatile(this, caller);
9267        }
9268      }
9269      protected boolean canDefine_mayBeVolatile(ASTNode caller, ASTNode child) {
9270        return true;
9271      }
9272      /**
9273       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:426
9274       * @apilevel internal
9275       */
9276      public boolean Define_mayBeTransient(ASTNode caller, ASTNode child) {
9277        if (caller == getBodyDeclListNoTransform()) {
9278          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:349
9279          int childIndex = caller.getIndexOfChild(child);
9280          return false;
9281        }
9282        else {
9283          return getParent().Define_mayBeTransient(this, caller);
9284        }
9285      }
9286      protected boolean canDefine_mayBeTransient(ASTNode caller, ASTNode child) {
9287        return true;
9288      }
9289      /**
9290       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:428
9291       * @apilevel internal
9292       */
9293      public boolean Define_mayBeSynchronized(ASTNode caller, ASTNode child) {
9294        if (caller == getBodyDeclListNoTransform()) {
9295          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:351
9296          int childIndex = caller.getIndexOfChild(child);
9297          return false;
9298        }
9299        else {
9300          return getParent().Define_mayBeSynchronized(this, caller);
9301        }
9302      }
9303      protected boolean canDefine_mayBeSynchronized(ASTNode caller, ASTNode child) {
9304        return true;
9305      }
9306      /**
9307       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:429
9308       * @apilevel internal
9309       */
9310      public boolean Define_mayBeNative(ASTNode caller, ASTNode child) {
9311        if (caller == getBodyDeclListNoTransform()) {
9312          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:352
9313          int childIndex = caller.getIndexOfChild(child);
9314          return false;
9315        }
9316        else {
9317          return getParent().Define_mayBeNative(this, caller);
9318        }
9319      }
9320      protected boolean canDefine_mayBeNative(ASTNode caller, ASTNode child) {
9321        return true;
9322      }
9323      /**
9324       * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:30
9325       * @apilevel internal
9326       */
9327      public VariableScope Define_outerScope(ASTNode caller, ASTNode child) {
9328        int childIndex = this.getIndexOfChild(caller);
9329        return this;
9330      }
9331      protected boolean canDefine_outerScope(ASTNode caller, ASTNode child) {
9332        return true;
9333      }
9334      /**
9335       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441
9336       * @apilevel internal
9337       */
9338      public boolean Define_insideLoop(ASTNode caller, ASTNode child) {
9339        if (caller == getBodyDeclListNoTransform()) {
9340          // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:444
9341          int i = caller.getIndexOfChild(child);
9342          return false;
9343        }
9344        else {
9345          return getParent().Define_insideLoop(this, caller);
9346        }
9347      }
9348      protected boolean canDefine_insideLoop(ASTNode caller, ASTNode child) {
9349        return true;
9350      }
9351      /**
9352       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:449
9353       * @apilevel internal
9354       */
9355      public boolean Define_insideSwitch(ASTNode caller, ASTNode child) {
9356        if (caller == getBodyDeclListNoTransform()) {
9357          // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:451
9358          int i = caller.getIndexOfChild(child);
9359          return false;
9360        }
9361        else {
9362          return getParent().Define_insideSwitch(this, caller);
9363        }
9364      }
9365      protected boolean canDefine_insideSwitch(ASTNode caller, ASTNode child) {
9366        return true;
9367      }
9368      /**
9369       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
9370       * @apilevel internal
9371       */
9372      public NameType Define_nameType(ASTNode caller, ASTNode child) {
9373        if (caller == getBodyDeclListNoTransform()) {
9374          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:141
9375          int childIndex = caller.getIndexOfChild(child);
9376          return NameType.EXPRESSION_NAME;
9377        }
9378        else {
9379          return getParent().Define_nameType(this, caller);
9380        }
9381      }
9382      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
9383        return true;
9384      }
9385      /**
9386       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:240
9387       * @apilevel internal
9388       */
9389      public boolean Define_isAnonymous(ASTNode caller, ASTNode child) {
9390        int childIndex = this.getIndexOfChild(caller);
9391        return false;
9392      }
9393      protected boolean canDefine_isAnonymous(ASTNode caller, ASTNode child) {
9394        return true;
9395      }
9396      /**
9397       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:544
9398       * @apilevel internal
9399       */
9400      public TypeDecl Define_enclosingType(ASTNode caller, ASTNode child) {
9401        if (caller == getBodyDeclListNoTransform()) {
9402          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:540
9403          int childIndex = caller.getIndexOfChild(child);
9404          return this;
9405        }
9406        else {
9407          return getParent().Define_enclosingType(this, caller);
9408        }
9409      }
9410      protected boolean canDefine_enclosingType(ASTNode caller, ASTNode child) {
9411        return true;
9412      }
9413      /**
9414       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:569
9415       * @apilevel internal
9416       */
9417      public boolean Define_isNestedType(ASTNode caller, ASTNode child) {
9418        if (caller == getBodyDeclListNoTransform()) {
9419          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:571
9420          int childIndex = caller.getIndexOfChild(child);
9421          return true;
9422        }
9423        else {
9424          return getParent().Define_isNestedType(this, caller);
9425        }
9426      }
9427      protected boolean canDefine_isNestedType(ASTNode caller, ASTNode child) {
9428        return true;
9429      }
9430      /**
9431       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:591
9432       * @apilevel internal
9433       */
9434      public boolean Define_isLocalClass(ASTNode caller, ASTNode child) {
9435        if (caller == getBodyDeclListNoTransform()) {
9436          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:593
9437          int childIndex = caller.getIndexOfChild(child);
9438          return false;
9439        }
9440        else {
9441          return getParent().Define_isLocalClass(this, caller);
9442        }
9443      }
9444      protected boolean canDefine_isLocalClass(ASTNode caller, ASTNode child) {
9445        return true;
9446      }
9447      /**
9448       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:71
9449       * @apilevel internal
9450       */
9451      public TypeDecl Define_hostType(ASTNode caller, ASTNode child) {
9452        int childIndex = this.getIndexOfChild(caller);
9453        return this;
9454      }
9455      protected boolean canDefine_hostType(ASTNode caller, ASTNode child) {
9456        return true;
9457      }
9458      /**
9459       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:472
9460       * @apilevel internal
9461       */
9462      public TypeDecl Define_returnType(ASTNode caller, ASTNode child) {
9463        if (caller == getBodyDeclListNoTransform()) {
9464          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:473
9465          int childIndex = caller.getIndexOfChild(child);
9466          return typeVoid();
9467        }
9468        else {
9469          return getParent().Define_returnType(this, caller);
9470        }
9471      }
9472      protected boolean canDefine_returnType(ASTNode caller, ASTNode child) {
9473        return true;
9474      }
9475      /**
9476       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:586
9477       * @apilevel internal
9478       */
9479      public TypeDecl Define_enclosingInstance(ASTNode caller, ASTNode child) {
9480        if (caller == getBodyDeclListNoTransform()) {
9481          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:590
9482          int index = caller.getIndexOfChild(child);
9483          {
9484              if (getBodyDecl(index) instanceof MemberTypeDecl && !((MemberTypeDecl) getBodyDecl(index)).typeDecl().isInnerType()) {
9485                return null;
9486              }
9487              if (getBodyDecl(index) instanceof ConstructorDecl) {
9488                return enclosingInstance();
9489              }
9490              return this;
9491            }
9492        }
9493        else {
9494          return getParent().Define_enclosingInstance(this, caller);
9495        }
9496      }
9497      protected boolean canDefine_enclosingInstance(ASTNode caller, ASTNode child) {
9498        return true;
9499      }
9500      /**
9501       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:32
9502       * @apilevel internal
9503       */
9504      public String Define_methodHost(ASTNode caller, ASTNode child) {
9505        int childIndex = this.getIndexOfChild(caller);
9506        return typeName();
9507      }
9508      protected boolean canDefine_methodHost(ASTNode caller, ASTNode child) {
9509        return true;
9510      }
9511      /**
9512       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182
9513       * @apilevel internal
9514       */
9515      public boolean Define_inStaticContext(ASTNode caller, ASTNode child) {
9516        int childIndex = this.getIndexOfChild(caller);
9517        return isStatic() || inStaticContext();
9518      }
9519      protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) {
9520        return true;
9521      }
9522      /**
9523       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:283
9524       * @apilevel internal
9525       */
9526      public boolean Define_reportUnreachable(ASTNode caller, ASTNode child) {
9527        int childIndex = this.getIndexOfChild(caller);
9528        return true;
9529      }
9530      protected boolean canDefine_reportUnreachable(ASTNode caller, ASTNode child) {
9531        return true;
9532      }
9533      /**
9534       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:96
9535       * @apilevel internal
9536       */
9537      public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
9538        if (caller == getModifiersNoTransform()) {
9539          // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:101
9540          return name.equals("TYPE");
9541        }
9542        else {
9543          return getParent().Define_mayUseAnnotationTarget(this, caller, name);
9544        }
9545      }
9546      protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
9547        return true;
9548      }
9549      /**
9550       * @apilevel internal
9551       */
9552      public ASTNode rewriteTo() {
9553        return super.rewriteTo();
9554      }
9555    }