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:63
027     * @production ClassDecl : {@link ReferenceType} ::= <span class="component">{@link Modifiers}</span> <span class="component">&lt;ID:String&gt;</span> <span class="component">[SuperClass:{@link Access}]</span> <span class="component">Implements:{@link Access}*</span> <span class="component">{@link BodyDecl}*</span> <span class="component">[ImplicitConstructor:{@link ConstructorDecl}]</span>;
028    
029     */
030    public class ClassDecl extends ReferenceType implements Cloneable {
031      /**
032       * @aspect AccessControl
033       * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:175
034       */
035      public void accessControl() {
036        super.accessControl();
037    
038        // 8.1.1.2 final Classes
039        TypeDecl typeDecl = superclass();
040        if (!typeDecl.isUnknown() && !typeDecl.accessibleFromExtend(this)) {
041          errorf("class %s may not extend non accessible type %s", fullName(), typeDecl.fullName());
042        }
043    
044        if (hasSuperclass() && !superclass().accessibleFrom(this)) {
045          errorf("a superclass must be accessible which %s is not", superclass().name());
046        }
047    
048        // 8.1.4
049        for (int i = 0; i < getNumImplements(); i++) {
050          TypeDecl decl = getImplements(i).type();
051          if (!decl.isCircular() && !decl.accessibleFrom(this)) {
052            errorf("class %s can not implement non accessible type %s", fullName(), decl.fullName());
053          }
054        }
055      }
056      /**
057       * @aspect ErrorCheck
058       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:243
059       */
060      public void collectErrors() {
061        super.collectErrors();
062        if (hasImplicitConstructor()) {
063          getImplicitConstructor().collectErrors();
064        }
065      }
066      /**
067       * @aspect Modifiers
068       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:122
069       */
070      public void checkModifiers() {
071        super.checkModifiers();
072        // 8.1.1.2 final Classes
073        TypeDecl typeDecl = superclass();
074        if (!typeDecl.isUnknown() && typeDecl.isFinal()) {
075          errorf("class %s may not extend final class %s", fullName(), typeDecl.fullName());
076        }
077    
078      }
079      /**
080       * @aspect Java4PrettyPrint
081       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:362
082       */
083      public void prettyPrint(PrettyPrinter out) {
084        if (hasDocComment()) {
085          out.print(docComment());
086        }
087        if (!out.isNewLine()) {
088          out.println();
089        }
090        out.print(getModifiers());
091        out.print("class ");
092        out.print(getID());
093        if (hasSuperClass()) {
094          out.print(" extends ");
095          out.print(getSuperClass());
096        }
097        if (hasImplements()) {
098          out.print(" implements ");
099          out.join(getImplementss(), new PrettyPrinter.Joiner() {
100            @Override
101            public void printSeparator(PrettyPrinter out) {
102              out.print(", ");
103            }
104          });
105        }
106        out.print(" {");
107        out.println();
108        out.indent(1);
109        out.join(getBodyDecls(), new PrettyPrinter.Joiner() {
110          @Override
111          public void printSeparator(PrettyPrinter out) {
112            out.println();
113            out.println();
114          }
115        });
116        if (!out.isNewLine()) {
117          out.println();
118        }
119        out.print("}");
120      }
121      /**
122       * @aspect SuperClasses
123       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:647
124       */
125      public boolean hasSuperclass() {
126        return !isObject();
127      }
128      /**
129       * @aspect SuperClasses
130       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:651
131       */
132      public TypeDecl superclass() {
133        if (isObject()) {
134          return unknownType();
135        } else if (hasSuperClass() && !isCircular() && getSuperClass().type().isClassDecl()) {
136          return getSuperClass().type();
137        } else {
138          return typeObject();
139        }
140      }
141      /**
142       * @aspect SuperClasses
143       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:688
144       */
145      public Iterator<TypeDecl> interfacesIterator() {
146        return new Iterator<TypeDecl>() {
147          public boolean hasNext() {
148            computeNextCurrent();
149            return current != null;
150          }
151          public TypeDecl next() {
152            return current;
153          }
154          public void remove() {
155            throw new UnsupportedOperationException();
156          }
157          private int index = 0;
158          private TypeDecl current = null;
159          private void computeNextCurrent() {
160            current = null;
161            if (isObject() || isCircular()) {
162              return;
163            }
164            while (index < getNumImplements()) {
165              TypeDecl typeDecl = getImplements(index++).type();
166              if (!typeDecl.isCircular() && typeDecl.isInterfaceDecl()) {
167                current = typeDecl;
168                return;
169              }
170            }
171          }
172        };
173      }
174      /**
175       * @aspect TypeHierarchyCheck
176       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:321
177       */
178      public void refined_TypeHierarchyCheck_ClassDecl_typeCheck() {
179        super.typeCheck();
180    
181        // check if methods from superclass are incompatible with interface methods
182        for (Iterator<MethodDecl> iter = interfacesMethodsIterator(); iter.hasNext(); ) {
183          MethodDecl decl = iter.next();
184          SimpleSet set = localMethodsSignature(decl.signature());
185          Iterator i2 = set.iterator();
186          boolean overridden = false;
187          while (i2.hasNext()) {
188            MethodDecl m = (MethodDecl) i2.next();
189            // regardless of overriding
190            // 8.4.6.3
191            if (m.overrideCandidate(decl)) {
192              overridden = true;
193              if (!m.mayOverride(decl)) {
194                errorf("the return type of method %s in %s does not match the return type of"
195                    + " method %s in %s and may thus not be overridden",
196                    m.fullSignature(), m.hostType().typeName(), decl.fullSignature(),
197                    decl.hostType().typeName());
198              }
199            }
200          }
201          if (!overridden) {
202            set = ancestorMethods(decl.signature());
203            for (i2 = set.iterator(); i2.hasNext(); ) {
204              MethodDecl m = (MethodDecl) i2.next();
205              if (!m.isAbstract() && m.overrideCandidate(decl) &&
206                  !m.mayOverride(decl)) {
207                errorf("the return type of method %s in %s does not match the return type of"
208                    + " method %s in %s and may thus not be overridden",
209                    m.fullSignature(), m.hostType().typeName(), decl.fullSignature(),
210                    decl.hostType().typeName());
211              }
212            }
213          }
214        }
215      }
216      /**
217       * @aspect TypeHierarchyCheck
218       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:362
219       */
220      public void refined_TypeHierarchyCheck_ClassDecl_nameCheck() {
221        super.nameCheck();
222        if (hasSuperClass() && !getSuperClass().type().isClassDecl()) {
223          errorf("a class may only inherit another class, which %s is not",
224              getSuperClass().type().typeName());
225        }
226        if (isObject() && hasSuperClass()) {
227          error("class Object may not have a superclass");
228        }
229        if (isObject() && getNumImplements() != 0) {
230          error("class Object may not implement an interface");
231        }
232    
233        // 8.1.3
234        if (isCircular()) {
235          errorf("circular inheritance dependency in %s", typeName());
236        }
237    
238        // 8.1.4
239        HashSet set = new HashSet();
240        for (int i = 0; i < getNumImplements(); i++) {
241          TypeDecl decl = getImplements(i).type();
242          if (!decl.isInterfaceDecl() && !decl.isUnknown()) {
243            errorf("type %s can not implement the non-interface type %s", fullName(), decl.fullName());
244          }
245          if (set.contains(decl)) {
246            errorf("type %s is mentionened multiple times in implements clause", decl.fullName());
247          }
248          set.add(decl);
249        }
250    
251        for (Iterator iter = interfacesMethodsIterator(); iter.hasNext(); ) {
252          MethodDecl m = (MethodDecl) iter.next();
253          if (localMethodsSignature(m.signature()).isEmpty()) {
254            SimpleSet s = superclass().methodsSignature(m.signature());
255            for (Iterator i2 = s.iterator(); i2.hasNext(); ) {
256              MethodDecl n = (MethodDecl) i2.next();
257              if (n.accessibleFrom(this)) {
258                interfaceMethodCompatibleWithInherited(m, n);
259              }
260            }
261            if (s.isEmpty()) {
262              for (Iterator i2 = interfacesMethodsSignature(m.signature()).iterator(); i2.hasNext(); ) {
263                MethodDecl n = (MethodDecl) i2.next();
264                // TODO don't report error twice
265                checkAbstractMethodDecls(m, n);
266              }
267            }
268          }
269        }
270      }
271      /**
272       * Check compatibility of interface method and superclass method.
273       * @param m interface method
274       * @param n superclass method
275       * @aspect TypeHierarchyCheck
276       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:419
277       */
278      private void interfaceMethodCompatibleWithInherited(MethodDecl m, MethodDecl n) {
279        if (n.isAbstract()) {
280          checkAbstractMethodDecls(m, n);
281        }
282        if (n.isStatic()) {
283          error("Xa static method may not hide an instance method");
284        }
285        if (!n.isAbstract() && !n.isPublic()) {
286          errorf("Xoverriding access modifier error for %s in %s and %s",
287              m.fullSignature(), m.hostType().typeName(), n.hostType().typeName());
288        }
289        if (!n.mayOverride(m) && !m.mayOverride(m)) {
290          errorf("Xthe return type of method %s in %s does not match"
291              + " the return type of method %s in %s and may thus not be overridden",
292              m.fullSignature(), m.hostType().typeName(), n.fullSignature(), n.hostType().typeName());
293        }
294    
295        if (!n.isAbstract()) {
296          // n implements and overrides method m in the interface
297          // may not throw more checked exceptions
298          for (Access e: n.getExceptionList()) {
299            if (e.type().isCheckedException()) {
300              boolean found = false;
301              for (Access declException: m.getExceptionList()) {
302                if (e.type().instanceOf(declException.type())) {
303                  found = true;
304                  break;
305                }
306              }
307              if (!found) {
308                errorf("%s in %s may not throw more checked exceptions than overridden method %s in %s",
309                    n.fullSignature(), n.hostType().typeName(), m.fullSignature(),
310                    m.hostType().typeName());
311              }
312            }
313          }
314        }
315      }
316      /**
317       * @aspect GenerateClassfile
318       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:59
319       */
320      public void generateClassfile() {
321        super.generateClassfile();
322        String fileName = destinationPath();
323        if (program().options().verbose()) {
324          System.out.println("Writing class file to " + fileName);
325        }
326        try {
327          ConstantPool cp = constantPool();
328    
329          // force building of constant pool
330          cp.addClass(constantPoolName());
331          if (hasSuperclass()) {
332            cp.addClass(superclass().constantPoolName());
333          }
334          int numInterfaces = 0;
335          for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); numInterfaces++) {
336            cp.addClass(iter.next().constantPoolName());
337          }
338          for (Iterator iter = bcFields().iterator(); iter.hasNext(); ) {
339            FieldDeclaration field = (FieldDeclaration) iter.next();
340            cp.addUtf8(field.name());
341            cp.addUtf8(field.type().typeDescriptor());
342            field.attributes();
343          }
344          if (needsEnclosing()) {
345            cp.addUtf8("this$0");
346            cp.addUtf8(enclosing().typeDescriptor());
347            cp.addUtf8("Synthetic");
348          }
349    
350          for (Iterator iter = bcMethods().iterator(); iter.hasNext(); ) {
351            BodyDecl decl = (BodyDecl) iter.next();
352            decl.touchMethod(cp);
353          }
354          if (hasClinit()) {
355            cp.addUtf8("<clinit>");
356            cp.addUtf8("()V");
357            clinit_attributes();
358          }
359          attributes();
360    
361          // Actual ClassFile generation
362          File dest = new File(fileName);
363          File parentFile = dest.getParentFile();
364          if (parentFile != null) {
365            parentFile.mkdirs();
366          }
367          FileOutputStream f = new FileOutputStream(fileName);
368          DataOutputStream out = new DataOutputStream(new BufferedOutputStream(f));
369          out.writeInt(magicHeader());
370          out.writeChar(minorVersion());
371          out.writeChar(majorVersion());
372          cp.emit(out);
373          int flags = flags();
374          if (isNestedType()) {
375            flags = mangledFlags(flags);
376          }
377          flags |= Modifiers.ACC_SUPER;
378          out.writeChar(flags);
379          out.writeChar(cp.addClass(constantPoolName()));
380          out.writeChar(hasSuperclass() ? cp.addClass(superclass().constantPoolName()) : 0);
381          out.writeChar(numInterfaces);
382          for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) {
383            out.writeChar(cp.addClass(iter.next().constantPoolName()));
384          }
385          Collection fields = bcFields();
386          out.writeChar(fields.size() + (needsEnclosing() ? 1 : 0));
387          for (Iterator iter = fields.iterator(); iter.hasNext(); ) {
388            FieldDeclaration field = (FieldDeclaration) iter.next();
389            out.writeChar(field.flags());
390            out.writeChar(cp.addUtf8(field.name()));
391            out.writeChar(cp.addUtf8(field.type().typeDescriptor()));
392            out.writeChar(field.attributes().size());
393            for (Iterator itera = field.attributes().iterator(); itera.hasNext();) {
394              ((Attribute) itera.next()).emit(out);
395            }
396          }
397          if (needsEnclosing()) {
398            out.writeChar(0 /*Modifiers.ACC_PRIVATE*/);
399            out.writeChar(cp.addUtf8("this$0"));
400            out.writeChar(cp.addUtf8(enclosing().typeDescriptor()));
401            out.writeChar(1);
402            new SyntheticAttribute(cp).emit(out);
403    
404          }
405    
406          Collection methods = bcMethods();
407          out.writeChar(methods.size() + (hasClinit() ? 1 : 0));
408          for (Iterator iter = methods.iterator(); iter.hasNext(); ) {
409            BodyDecl b = (BodyDecl) iter.next();
410            b.generateMethod(out, cp);
411          }
412          if (hasClinit()) {
413            out.writeChar(Modifiers.ACC_STATIC);
414            out.writeChar(cp.addUtf8("<clinit>"));
415            out.writeChar(cp.addUtf8("()V"));
416            out.writeChar(clinit_attributes().size());
417            for (Iterator itera = clinit_attributes().iterator(); itera.hasNext();) {
418              ((Attribute) itera.next()).emit(out);
419            }
420          }
421          out.writeChar(attributes().size());
422          for (Iterator itera = attributes().iterator(); itera.hasNext();) {
423            ((Attribute) itera.next()).emit(out);
424          }
425    
426          out.close();
427        } catch (IOException e) {
428          e.printStackTrace();
429        }
430      }
431      /**
432       * @aspect Transformations
433       * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:56
434       */
435      public void transformation() {
436        super.transformation();
437        if (hasImplicitConstructor()) {
438          getImplicitConstructor().transformation();
439        }
440      }
441      /**
442       * @aspect Generics
443       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:231
444       */
445      public TypeDecl makeGeneric(Signatures.ClassSignature s) {
446        // NOTE: we are overwriting List- and Opt- children here using setSuperClassOpt
447        // and setImplementsList. This is dangerous since those children are in some
448        // cases NTAs, and we should not use set methods to try to overwrite NTA values.
449        // However, we have to do this here in order to not trigger rewrites that in
450        // turn need to access certain (inherited) lookup attributes, and we are reasonably
451        // sure that we are in fact not overwriting NTA children. We exclude EnumDecl here
452        // because its [SuperClass] and Implements* are in fact NTAs.
453        // /Jesper 2015-01-22
454        if (this instanceof EnumDecl) {
455          return this; // Enum superclass and superinterfaces are NTAs.
456        }
457        if (s.hasFormalTypeParameters()) {
458          ASTNode node = getParent();
459          int index = node.getIndexOfChild(this);
460          node.setChild(
461              new GenericClassDecl(
462                getModifiersNoTransform(),
463                getID(),
464                s.hasSuperclassSignature()
465                    ? new Opt(s.superclassSignature())
466                    : getSuperClassOptNoTransform(),
467                s.hasSuperinterfaceSignature()
468                    ? s.superinterfaceSignature()
469                    : getImplementsListNoTransform(),
470                getBodyDeclListNoTransform(),
471                s.typeParameters()
472              ),
473              index
474          );
475          return (TypeDecl) node.getChildNoTransform(index);
476        } else {
477          if (s.hasSuperclassSignature()) {
478            setSuperClassOpt(new Opt(s.superclassSignature()));
479          }
480          if (s.hasSuperinterfaceSignature()) {
481            setImplementsList(s.superinterfaceSignature());
482          }
483          return this;
484        }
485      }
486      /**
487       * @aspect LookupParTypeDecl
488       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1424
489       */
490      public ClassDecl substitutedClassDecl(Parameterization parTypeDecl) {
491        return new ClassDeclSubstituted(
492          (Modifiers) getModifiers().treeCopyNoTransform(),
493          getID(),
494          hasSuperClass() ? new Opt(getSuperClass().type().substitute(parTypeDecl)) : new Opt(),
495          getImplementsList().substitute(parTypeDecl),
496          this
497        );
498      }
499      /**
500       * @declaredat ASTNode:1
501       */
502      public ClassDecl() {
503        super();
504      }
505      /**
506       * Initializes the child array to the correct size.
507       * Initializes List and Opt nta children.
508       * @apilevel internal
509       * @ast method
510       * @declaredat ASTNode:10
511       */
512      public void init$Children() {
513        children = new ASTNode[5];
514        setChild(new Opt(), 1);
515        setChild(new List(), 2);
516        setChild(new List(), 3);
517        setChild(new Opt(), 4);
518      }
519      /**
520       * @declaredat ASTNode:17
521       */
522      public ClassDecl(Modifiers p0, String p1, Opt<Access> p2, List<Access> p3, List<BodyDecl> p4) {
523        setChild(p0, 0);
524        setID(p1);
525        setChild(p2, 1);
526        setChild(p3, 2);
527        setChild(p4, 3);
528      }
529      /**
530       * @declaredat ASTNode:24
531       */
532      public ClassDecl(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<Access> p3, List<BodyDecl> p4) {
533        setChild(p0, 0);
534        setID(p1);
535        setChild(p2, 1);
536        setChild(p3, 2);
537        setChild(p4, 3);
538      }
539      /**
540       * @apilevel low-level
541       * @declaredat ASTNode:34
542       */
543      protected int numChildren() {
544        return 4;
545      }
546      /**
547       * @apilevel internal
548       * @declaredat ASTNode:40
549       */
550      public boolean mayHaveRewrite() {
551        return false;
552      }
553      /**
554       * @apilevel internal
555       * @declaredat ASTNode:46
556       */
557      public void flushAttrCache() {
558        super.flushAttrCache();
559        constructors_reset();
560        getImplicitConstructorOpt_reset();
561        methodsSignatureMap_reset();
562        ancestorMethods_String_reset();
563        memberTypes_String_reset();
564        memberFieldsMap_reset();
565        memberFields_String_reset();
566        unimplementedMethods_reset();
567        hasAbstract_reset();
568        castingConversionTo_TypeDecl_reset();
569        isString_reset();
570        isObject_reset();
571        instanceOf_TypeDecl_reset();
572        isCircular_reset();
573        typeDescriptor_reset();
574        erasedAncestorMethodsMap_reset();
575        implementedInterfaces_reset();
576        subtype_TypeDecl_reset();
577        needsSignatureAttribute_reset();
578        classSignature_reset();
579        strictSubtype_TypeDecl_reset();
580        hasOverridingMethodInSuper_MethodDecl_reset();
581      }
582      /**
583       * @apilevel internal
584       * @declaredat ASTNode:74
585       */
586      public void flushCollectionCache() {
587        super.flushCollectionCache();
588      }
589      /**
590       * @apilevel internal
591       * @declaredat ASTNode:80
592       */
593      public void flushRewriteCache() {
594        super.flushRewriteCache();
595      }
596      /**
597       * @apilevel internal
598       * @declaredat ASTNode:86
599       */
600      public ClassDecl clone() throws CloneNotSupportedException {
601        ClassDecl node = (ClassDecl) super.clone();
602        return node;
603      }
604      /**
605       * @apilevel internal
606       * @declaredat ASTNode:93
607       */
608      public ClassDecl copy() {
609        try {
610          ClassDecl node = (ClassDecl) clone();
611          node.parent = null;
612          if (children != null) {
613            node.children = (ASTNode[]) children.clone();
614          }
615          return node;
616        } catch (CloneNotSupportedException e) {
617          throw new Error("Error: clone not supported for " + getClass().getName());
618        }
619      }
620      /**
621       * Create a deep copy of the AST subtree at this node.
622       * The copy is dangling, i.e. has no parent.
623       * @return dangling copy of the subtree at this node
624       * @apilevel low-level
625       * @deprecated Please use treeCopy or treeCopyNoTransform instead
626       * @declaredat ASTNode:112
627       */
628      @Deprecated
629      public ClassDecl fullCopy() {
630        return treeCopyNoTransform();
631      }
632      /**
633       * Create a deep copy of the AST subtree at this node.
634       * The copy is dangling, i.e. has no parent.
635       * @return dangling copy of the subtree at this node
636       * @apilevel low-level
637       * @declaredat ASTNode:122
638       */
639      public ClassDecl treeCopyNoTransform() {
640        ClassDecl tree = (ClassDecl) copy();
641        if (children != null) {
642          for (int i = 0; i < children.length; ++i) {
643            switch (i) {
644            case 4:
645              tree.children[i] = new Opt();
646              continue;
647            }
648            ASTNode child = (ASTNode) children[i];
649            if (child != null) {
650              child = child.treeCopyNoTransform();
651              tree.setChild(child, i);
652            }
653          }
654        }
655        return tree;
656      }
657      /**
658       * Create a deep copy of the AST subtree at this node.
659       * The subtree of this node is traversed to trigger rewrites before copy.
660       * The copy is dangling, i.e. has no parent.
661       * @return dangling copy of the subtree at this node
662       * @apilevel low-level
663       * @declaredat ASTNode:147
664       */
665      public ClassDecl treeCopy() {
666        doFullTraversal();
667        return treeCopyNoTransform();
668      }
669      /**
670       * @apilevel internal
671       * @declaredat ASTNode:154
672       */
673      protected boolean is$Equal(ASTNode node) {
674        return super.is$Equal(node) && (tokenString_ID == ((ClassDecl)node).tokenString_ID);    
675      }
676      /**
677       * Replaces the Modifiers child.
678       * @param node The new node to replace the Modifiers child.
679       * @apilevel high-level
680       */
681      public void setModifiers(Modifiers node) {
682        setChild(node, 0);
683      }
684      /**
685       * Retrieves the Modifiers child.
686       * @return The current node used as the Modifiers child.
687       * @apilevel high-level
688       */
689      @ASTNodeAnnotation.Child(name="Modifiers")
690      public Modifiers getModifiers() {
691        return (Modifiers) getChild(0);
692      }
693      /**
694       * Retrieves the Modifiers child.
695       * <p><em>This method does not invoke AST transformations.</em></p>
696       * @return The current node used as the Modifiers child.
697       * @apilevel low-level
698       */
699      public Modifiers getModifiersNoTransform() {
700        return (Modifiers) getChildNoTransform(0);
701      }
702      /**
703       * Replaces the lexeme ID.
704       * @param value The new value for the lexeme ID.
705       * @apilevel high-level
706       */
707      public void setID(String value) {
708        tokenString_ID = value;
709      }
710      /**
711       * JastAdd-internal setter for lexeme ID using the Beaver parser.
712       * @param symbol Symbol containing the new value for the lexeme ID
713       * @apilevel internal
714       */
715      public void setID(beaver.Symbol symbol) {
716        if (symbol.value != null && !(symbol.value instanceof String))
717        throw new UnsupportedOperationException("setID is only valid for String lexemes");
718        tokenString_ID = (String)symbol.value;
719        IDstart = symbol.getStart();
720        IDend = symbol.getEnd();
721      }
722      /**
723       * Retrieves the value for the lexeme ID.
724       * @return The value for the lexeme ID.
725       * @apilevel high-level
726       */
727      @ASTNodeAnnotation.Token(name="ID")
728      public String getID() {
729        return tokenString_ID != null ? tokenString_ID : "";
730      }
731      /**
732       * Replaces the optional node for the SuperClass child. This is the <code>Opt</code>
733       * node containing the child SuperClass, not the actual child!
734       * @param opt The new node to be used as the optional node for the SuperClass child.
735       * @apilevel low-level
736       */
737      public void setSuperClassOpt(Opt<Access> opt) {
738        setChild(opt, 1);
739      }
740      /**
741       * Replaces the (optional) SuperClass child.
742       * @param node The new node to be used as the SuperClass child.
743       * @apilevel high-level
744       */
745      public void setSuperClass(Access node) {
746        getSuperClassOpt().setChild(node, 0);
747      }
748      /**
749       * Check whether the optional SuperClass child exists.
750       * @return {@code true} if the optional SuperClass child exists, {@code false} if it does not.
751       * @apilevel high-level
752       */
753      public boolean hasSuperClass() {
754        return getSuperClassOpt().getNumChild() != 0;
755      }
756      /**
757       * Retrieves the (optional) SuperClass child.
758       * @return The SuperClass child, if it exists. Returns {@code null} otherwise.
759       * @apilevel low-level
760       */
761      public Access getSuperClass() {
762        return (Access) getSuperClassOpt().getChild(0);
763      }
764      /**
765       * Retrieves the optional node for the SuperClass child. This is the <code>Opt</code> node containing the child SuperClass, not the actual child!
766       * @return The optional node for child the SuperClass child.
767       * @apilevel low-level
768       */
769      @ASTNodeAnnotation.OptChild(name="SuperClass")
770      public Opt<Access> getSuperClassOpt() {
771        return (Opt<Access>) getChild(1);
772      }
773      /**
774       * Retrieves the optional node for child SuperClass. This is the <code>Opt</code> node containing the child SuperClass, not the actual child!
775       * <p><em>This method does not invoke AST transformations.</em></p>
776       * @return The optional node for child SuperClass.
777       * @apilevel low-level
778       */
779      public Opt<Access> getSuperClassOptNoTransform() {
780        return (Opt<Access>) getChildNoTransform(1);
781      }
782      /**
783       * Replaces the Implements list.
784       * @param list The new list node to be used as the Implements list.
785       * @apilevel high-level
786       */
787      public void setImplementsList(List<Access> list) {
788        setChild(list, 2);
789      }
790      /**
791       * Retrieves the number of children in the Implements list.
792       * @return Number of children in the Implements list.
793       * @apilevel high-level
794       */
795      public int getNumImplements() {
796        return getImplementsList().getNumChild();
797      }
798      /**
799       * Retrieves the number of children in the Implements list.
800       * Calling this method will not trigger rewrites.
801       * @return Number of children in the Implements list.
802       * @apilevel low-level
803       */
804      public int getNumImplementsNoTransform() {
805        return getImplementsListNoTransform().getNumChildNoTransform();
806      }
807      /**
808       * Retrieves the element at index {@code i} in the Implements list.
809       * @param i Index of the element to return.
810       * @return The element at position {@code i} in the Implements list.
811       * @apilevel high-level
812       */
813      public Access getImplements(int i) {
814        return (Access) getImplementsList().getChild(i);
815      }
816      /**
817       * Check whether the Implements list has any children.
818       * @return {@code true} if it has at least one child, {@code false} otherwise.
819       * @apilevel high-level
820       */
821      public boolean hasImplements() {
822        return getImplementsList().getNumChild() != 0;
823      }
824      /**
825       * Append an element to the Implements list.
826       * @param node The element to append to the Implements list.
827       * @apilevel high-level
828       */
829      public void addImplements(Access node) {
830        List<Access> list = (parent == null) ? getImplementsListNoTransform() : getImplementsList();
831        list.addChild(node);
832      }
833      /**
834       * @apilevel low-level
835       */
836      public void addImplementsNoTransform(Access node) {
837        List<Access> list = getImplementsListNoTransform();
838        list.addChild(node);
839      }
840      /**
841       * Replaces the Implements list element at index {@code i} with the new node {@code node}.
842       * @param node The new node to replace the old list element.
843       * @param i The list index of the node to be replaced.
844       * @apilevel high-level
845       */
846      public void setImplements(Access node, int i) {
847        List<Access> list = getImplementsList();
848        list.setChild(node, i);
849      }
850      /**
851       * Retrieves the Implements list.
852       * @return The node representing the Implements list.
853       * @apilevel high-level
854       */
855      @ASTNodeAnnotation.ListChild(name="Implements")
856      public List<Access> getImplementsList() {
857        List<Access> list = (List<Access>) getChild(2);
858        return list;
859      }
860      /**
861       * Retrieves the Implements list.
862       * <p><em>This method does not invoke AST transformations.</em></p>
863       * @return The node representing the Implements list.
864       * @apilevel low-level
865       */
866      public List<Access> getImplementsListNoTransform() {
867        return (List<Access>) getChildNoTransform(2);
868      }
869      /**
870       * Retrieves the Implements list.
871       * @return The node representing the Implements list.
872       * @apilevel high-level
873       */
874      public List<Access> getImplementss() {
875        return getImplementsList();
876      }
877      /**
878       * Retrieves the Implements list.
879       * <p><em>This method does not invoke AST transformations.</em></p>
880       * @return The node representing the Implements list.
881       * @apilevel low-level
882       */
883      public List<Access> getImplementssNoTransform() {
884        return getImplementsListNoTransform();
885      }
886      /**
887       * Replaces the BodyDecl list.
888       * @param list The new list node to be used as the BodyDecl list.
889       * @apilevel high-level
890       */
891      public void setBodyDeclList(List<BodyDecl> list) {
892        setChild(list, 3);
893      }
894      /**
895       * Retrieves the number of children in the BodyDecl list.
896       * @return Number of children in the BodyDecl list.
897       * @apilevel high-level
898       */
899      public int getNumBodyDecl() {
900        return getBodyDeclList().getNumChild();
901      }
902      /**
903       * Retrieves the number of children in the BodyDecl list.
904       * Calling this method will not trigger rewrites.
905       * @return Number of children in the BodyDecl list.
906       * @apilevel low-level
907       */
908      public int getNumBodyDeclNoTransform() {
909        return getBodyDeclListNoTransform().getNumChildNoTransform();
910      }
911      /**
912       * Retrieves the element at index {@code i} in the BodyDecl list.
913       * @param i Index of the element to return.
914       * @return The element at position {@code i} in the BodyDecl list.
915       * @apilevel high-level
916       */
917      public BodyDecl getBodyDecl(int i) {
918        return (BodyDecl) getBodyDeclList().getChild(i);
919      }
920      /**
921       * Check whether the BodyDecl list has any children.
922       * @return {@code true} if it has at least one child, {@code false} otherwise.
923       * @apilevel high-level
924       */
925      public boolean hasBodyDecl() {
926        return getBodyDeclList().getNumChild() != 0;
927      }
928      /**
929       * Append an element to the BodyDecl list.
930       * @param node The element to append to the BodyDecl list.
931       * @apilevel high-level
932       */
933      public void addBodyDecl(BodyDecl node) {
934        List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
935        list.addChild(node);
936      }
937      /**
938       * @apilevel low-level
939       */
940      public void addBodyDeclNoTransform(BodyDecl node) {
941        List<BodyDecl> list = getBodyDeclListNoTransform();
942        list.addChild(node);
943      }
944      /**
945       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
946       * @param node The new node to replace the old list element.
947       * @param i The list index of the node to be replaced.
948       * @apilevel high-level
949       */
950      public void setBodyDecl(BodyDecl node, int i) {
951        List<BodyDecl> list = getBodyDeclList();
952        list.setChild(node, i);
953      }
954      /**
955       * Retrieves the BodyDecl list.
956       * @return The node representing the BodyDecl list.
957       * @apilevel high-level
958       */
959      @ASTNodeAnnotation.ListChild(name="BodyDecl")
960      public List<BodyDecl> getBodyDeclList() {
961        List<BodyDecl> list = (List<BodyDecl>) getChild(3);
962        return list;
963      }
964      /**
965       * Retrieves the BodyDecl list.
966       * <p><em>This method does not invoke AST transformations.</em></p>
967       * @return The node representing the BodyDecl list.
968       * @apilevel low-level
969       */
970      public List<BodyDecl> getBodyDeclListNoTransform() {
971        return (List<BodyDecl>) getChildNoTransform(3);
972      }
973      /**
974       * Retrieves the BodyDecl list.
975       * @return The node representing the BodyDecl list.
976       * @apilevel high-level
977       */
978      public List<BodyDecl> getBodyDecls() {
979        return getBodyDeclList();
980      }
981      /**
982       * Retrieves the BodyDecl list.
983       * <p><em>This method does not invoke AST transformations.</em></p>
984       * @return The node representing the BodyDecl list.
985       * @apilevel low-level
986       */
987      public List<BodyDecl> getBodyDeclsNoTransform() {
988        return getBodyDeclListNoTransform();
989      }
990      /**
991       * Replaces the (optional) ImplicitConstructor child.
992       * @param node The new node to be used as the ImplicitConstructor child.
993       * @apilevel high-level
994       */
995      public void setImplicitConstructor(ConstructorDecl node) {
996        getImplicitConstructorOpt().setChild(node, 0);
997      }
998      /**
999       * Check whether the optional ImplicitConstructor child exists.
1000       * @return {@code true} if the optional ImplicitConstructor child exists, {@code false} if it does not.
1001       * @apilevel high-level
1002       */
1003      public boolean hasImplicitConstructor() {
1004        return getImplicitConstructorOpt().getNumChild() != 0;
1005      }
1006      /**
1007       * Retrieves the (optional) ImplicitConstructor child.
1008       * @return The ImplicitConstructor child, if it exists. Returns {@code null} otherwise.
1009       * @apilevel low-level
1010       */
1011      public ConstructorDecl getImplicitConstructor() {
1012        return (ConstructorDecl) getImplicitConstructorOpt().getChild(0);
1013      }
1014      /**
1015       * Retrieves the optional node for child ImplicitConstructor. This is the <code>Opt</code> node containing the child ImplicitConstructor, not the actual child!
1016       * <p><em>This method does not invoke AST transformations.</em></p>
1017       * @return The optional node for child ImplicitConstructor.
1018       * @apilevel low-level
1019       */
1020      public Opt<ConstructorDecl> getImplicitConstructorOptNoTransform() {
1021        return (Opt<ConstructorDecl>) getChildNoTransform(4);
1022      }
1023      /**
1024       * Retrieves the child position of the optional child ImplicitConstructor.
1025       * @return The the child position of the optional child ImplicitConstructor.
1026       * @apilevel low-level
1027       */
1028      protected int getImplicitConstructorOptChildPosition() {
1029        return 4;
1030      }
1031      /**
1032       * @aspect GenericsTypeCheck
1033       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:563
1034       */
1035       
1036      public void typeCheck() {
1037        refined_TypeHierarchyCheck_ClassDecl_typeCheck();
1038    
1039        if (hasSuperclass()) {
1040          // JLS SE7 8.4.8.4
1041          // check for duplicate methods inherited from parameterized supertype
1042          if (superclass().isParameterizedType()) {
1043            Map<String,SimpleSet> localMap = localMethodsSignatureMap();
1044            Map<String,SimpleSet> methodMap = superclass().localMethodsSignatureMap();
1045            for (Map.Entry<String,SimpleSet> entry: methodMap.entrySet()) {
1046              String signature = entry.getKey();
1047              if (!localMap.containsKey(signature)) {
1048                // not locally overridden
1049                SimpleSet set = entry.getValue();
1050                Iterator iter = set.iterator();
1051                iter.next();
1052                while (iter.hasNext()) {
1053                  MethodDecl m = (MethodDecl) iter.next();
1054                  errorf("method with signature %s is multiply declared when inherited from %s",
1055                      signature, superclass().typeName());
1056                }
1057              }
1058            }
1059          }
1060        }
1061      }
1062      /**
1063       * @aspect Java8NameCheck
1064       * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:311
1065       */
1066       
1067      public void nameCheck() {
1068        refined_TypeHierarchyCheck_ClassDecl_nameCheck();
1069        for (Iterator<SimpleSet> iter = methodsSignatureMap().values().iterator(); iter.hasNext(); ) {
1070          SimpleSet set = iter.next();
1071          if (set.size() > 1) {
1072            Iterator i2 = set.iterator();
1073            boolean foundClassAbstract = false;
1074            MethodDecl foundNonAbstract = null;
1075            while (i2.hasNext()) {
1076              MethodDecl m = (MethodDecl) i2.next();
1077              if (!m.isAbstract()) {
1078                foundNonAbstract = m;
1079              } else {
1080                if (m.hostType().isClassDecl() && m.hostType() != this) {
1081                  foundClassAbstract = true;
1082                }
1083              }
1084            }
1085            // 8.4.8.1
1086            if (foundNonAbstract != null && !foundClassAbstract) {
1087              errorf("Method %s is multiply declared in %s",
1088                  foundNonAbstract.fullSignature(), typeName());
1089            }
1090          }
1091        }
1092      }
1093      /**
1094       * @aspect TypeConversion
1095       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:112
1096       */
1097      private boolean refined_TypeConversion_ClassDecl_castingConversionTo_TypeDecl(TypeDecl type)
1098    {
1099        if (type.isArrayDecl()) {
1100          return isObject();
1101        } else if (type.isClassDecl()) {
1102          return this == type || instanceOf(type) || type.instanceOf(this);
1103        } else if (type.isInterfaceDecl()) {
1104          return !isFinal() || instanceOf(type);
1105        } else return super.castingConversionTo(type);
1106      }
1107      /**
1108       * @aspect Generics
1109       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:81
1110       */
1111      private boolean refined_Generics_ClassDecl_castingConversionTo_TypeDecl(TypeDecl type)
1112    {
1113        TypeDecl S = this;
1114        TypeDecl T = type;
1115        if (T instanceof TypeVariable) {
1116          TypeVariable t = (TypeVariable) T;
1117          if (t.getNumTypeBound() == 0) {
1118            return true;
1119          }
1120          for (int i = 0; i < t.getNumTypeBound(); i++) {
1121            if (castingConversionTo(t.getTypeBound(i).type())) {
1122              return true;
1123            }
1124          }
1125          return false;
1126        }
1127        if (T.isClassDecl() && (S.erasure() != S || T.erasure() != T)) {
1128            return S.erasure().castingConversionTo(T.erasure());
1129        }
1130        return refined_TypeConversion_ClassDecl_castingConversionTo_TypeDecl(type);
1131      }
1132      /**
1133       * @attribute syn
1134       * @aspect ConstantExpression
1135       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:72
1136       */
1137      @ASTNodeAnnotation.Attribute
1138      public Constant cast(Constant c) {
1139        Constant cast_Constant_value = Constant.create(c.stringValue());
1140    
1141        return cast_Constant_value;
1142      }
1143      /**
1144       * @attribute syn
1145       * @aspect ConstantExpression
1146       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:138
1147       */
1148      @ASTNodeAnnotation.Attribute
1149      public Constant add(Constant c1, Constant c2) {
1150        Constant add_Constant_Constant_value = Constant.create(c1.stringValue() + c2.stringValue());
1151    
1152        return add_Constant_Constant_value;
1153      }
1154      /**
1155       * @attribute syn
1156       * @aspect ConstantExpression
1157       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:202
1158       */
1159      @ASTNodeAnnotation.Attribute
1160      public Constant questionColon(Constant cond, Constant c1, Constant c2) {
1161        Constant questionColon_Constant_Constant_Constant_value = Constant.create(cond.booleanValue() ? c1.stringValue() : c2.stringValue());
1162    
1163        return questionColon_Constant_Constant_Constant_value;
1164      }
1165      /**
1166       * @attribute syn
1167       * @aspect ConstantExpression
1168       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:326
1169       */
1170      @ASTNodeAnnotation.Attribute
1171      public boolean eqIsTrue(Expr left, Expr right) {
1172        boolean eqIsTrue_Expr_Expr_value = isString() && left.constant().stringValue().equals(right.constant().stringValue());
1173    
1174        return eqIsTrue_Expr_Expr_value;
1175      }
1176      /**
1177       * @attribute syn
1178       * @aspect ErrorCheck
1179       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:45
1180       */
1181      @ASTNodeAnnotation.Attribute
1182      public int lineNumber() {
1183        int lineNumber_value = getLine(IDstart);
1184    
1185        return lineNumber_value;
1186      }
1187      /**
1188       * @attribute syn
1189       * @aspect ConstructScope
1190       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:42
1191       */
1192      @ASTNodeAnnotation.Attribute
1193      public Collection lookupSuperConstructor() {
1194        Collection lookupSuperConstructor_value = hasSuperclass() ? superclass().constructors() : Collections.EMPTY_LIST;
1195    
1196        return lookupSuperConstructor_value;
1197      }
1198      /**
1199       * @apilevel internal
1200       */
1201      protected boolean constructors_computed = false;
1202      /**
1203       * @apilevel internal
1204       */
1205      protected Collection<ConstructorDecl> constructors_value;
1206      /**
1207       * @apilevel internal
1208       */
1209      private void constructors_reset() {
1210        constructors_computed = false;
1211        constructors_value = null;
1212      }
1213      /**
1214       * @attribute syn
1215       * @aspect ConstructorLookup
1216       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:127
1217       */
1218      @ASTNodeAnnotation.Attribute
1219      public Collection<ConstructorDecl> constructors() {
1220        ASTNode$State state = state();
1221        if (constructors_computed) {
1222          return constructors_value;
1223        }
1224        boolean intermediate = state.INTERMEDIATE_VALUE;
1225        state.INTERMEDIATE_VALUE = false;
1226        int num = state.boundariesCrossed;
1227        boolean isFinal = this.is$Final();
1228        constructors_value = constructors_compute();
1229        if (isFinal && num == state().boundariesCrossed) {
1230          constructors_computed = true;
1231        } else {
1232        }
1233        state.INTERMEDIATE_VALUE |= intermediate;
1234    
1235        return constructors_value;
1236      }
1237      /**
1238       * @apilevel internal
1239       */
1240      private Collection<ConstructorDecl> constructors_compute() {
1241          Collection<ConstructorDecl> c = super.constructors();
1242          if (hasImplicitConstructor()) {
1243            c.add(getImplicitConstructor());
1244          }
1245          return c;
1246        }
1247      /**
1248       * A class declaration requires an implicit constructor if it has no
1249       * explicit constructor.
1250       * @return <code>true</code> if this class requires an implicit default
1251       * contstructor.
1252       * @attribute syn
1253       * @aspect ImplicitConstructor
1254       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:213
1255       */
1256      @ASTNodeAnnotation.Attribute
1257      public boolean needsImplicitConstructor() {
1258        boolean needsImplicitConstructor_value = compilationUnit().fromSource() && !hasExplicitConstructor();
1259    
1260        return needsImplicitConstructor_value;
1261      }
1262      /**
1263       * @apilevel internal
1264       */
1265      protected boolean getImplicitConstructorOpt_computed = false;
1266      /**
1267       * @apilevel internal
1268       */
1269      protected Opt<ConstructorDecl> getImplicitConstructorOpt_value;
1270      /**
1271       * @apilevel internal
1272       */
1273      private void getImplicitConstructorOpt_reset() {
1274        getImplicitConstructorOpt_computed = false;
1275        getImplicitConstructorOpt_value = null;
1276      }
1277      /**
1278       * @attribute syn nta
1279       * @aspect ImplicitConstructor
1280       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:236
1281       */
1282      @ASTNodeAnnotation.Attribute
1283      public Opt<ConstructorDecl> getImplicitConstructorOpt() {
1284        ASTNode$State state = state();
1285        if (getImplicitConstructorOpt_computed) {
1286          return (Opt<ConstructorDecl>) getChild(getImplicitConstructorOptChildPosition());
1287        }
1288        boolean intermediate = state.INTERMEDIATE_VALUE;
1289        state.INTERMEDIATE_VALUE = false;
1290        int num = state.boundariesCrossed;
1291        boolean isFinal = this.is$Final();
1292        getImplicitConstructorOpt_value = getImplicitConstructorOpt_compute();
1293        setChild(getImplicitConstructorOpt_value, getImplicitConstructorOptChildPosition());
1294        if (isFinal && num == state().boundariesCrossed) {
1295          getImplicitConstructorOpt_computed = true;
1296        } else {
1297        }
1298        state.INTERMEDIATE_VALUE |= intermediate;
1299    
1300        Opt<ConstructorDecl> node = (Opt<ConstructorDecl>) this.getChild(getImplicitConstructorOptChildPosition());
1301        return node;
1302      }
1303      /**
1304       * @apilevel internal
1305       */
1306      private Opt<ConstructorDecl> getImplicitConstructorOpt_compute() {
1307          if (needsImplicitConstructor()) {
1308            Modifiers m = new Modifiers();
1309            if (isPublic()) {
1310              m.addModifier(new Modifier("public"));
1311            } else if (isProtected()) {
1312              m.addModifier(new Modifier("protected"));
1313            } else if (isPrivate()) {
1314              m.addModifier(new Modifier("private"));
1315            }
1316            ConstructorDecl constructor = new ConstructorDecl(
1317                m,
1318                name(),
1319                new List(),
1320                new List(),
1321                new Opt(),
1322                new Block()
1323            );
1324            constructor.setParsedConstructorInvocation(
1325              new ExprStmt(
1326                new SuperConstructorAccess("super", new List())
1327              )
1328            );
1329            constructor.setImplicitConstructor();
1330            return new Opt<ConstructorDecl>(constructor);
1331          } else {
1332            return new Opt<ConstructorDecl>();
1333          }
1334        }
1335      /**
1336       * @attribute syn
1337       * @aspect ImplicitConstructor
1338       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:323
1339       */
1340      @ASTNodeAnnotation.Attribute
1341      public boolean hasExplicitConstructor() {
1342        {
1343            for (int i = 0; i < getNumBodyDecl(); i++) {
1344              if (getBodyDecl(i) instanceof ConstructorDecl) {
1345                return true;
1346              }
1347            }
1348            return false;
1349          }
1350      }
1351      /**
1352       * @attribute syn
1353       * @aspect MemberMethods
1354       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:406
1355       */
1356      @ASTNodeAnnotation.Attribute
1357      public SimpleSet interfacesMethodsSignature(String signature) {
1358        {
1359            SimpleSet set = interfacesMethodsSignatureMap().get(signature);
1360            if (set != null) {
1361              return set;
1362            } else {
1363              return SimpleSet.emptySet;
1364            }
1365          }
1366      }
1367      /**
1368       * @apilevel internal
1369       */
1370      protected boolean methodsSignatureMap_computed = false;
1371      /**
1372       * @apilevel internal
1373       */
1374      protected Map<String,SimpleSet> methodsSignatureMap_value;
1375      /**
1376       * @apilevel internal
1377       */
1378      private void methodsSignatureMap_reset() {
1379        methodsSignatureMap_computed = false;
1380        methodsSignatureMap_value = null;
1381      }
1382      /**
1383       * @attribute syn
1384       * @aspect MemberMethods
1385       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:466
1386       */
1387      @ASTNodeAnnotation.Attribute
1388      public Map<String,SimpleSet> methodsSignatureMap() {
1389        ASTNode$State state = state();
1390        if (methodsSignatureMap_computed) {
1391          return methodsSignatureMap_value;
1392        }
1393        boolean intermediate = state.INTERMEDIATE_VALUE;
1394        state.INTERMEDIATE_VALUE = false;
1395        int num = state.boundariesCrossed;
1396        boolean isFinal = this.is$Final();
1397        methodsSignatureMap_value = methodsSignatureMap_compute();
1398        if (isFinal && num == state().boundariesCrossed) {
1399          methodsSignatureMap_computed = true;
1400        } else {
1401        }
1402        state.INTERMEDIATE_VALUE |= intermediate;
1403    
1404        return methodsSignatureMap_value;
1405      }
1406      /**
1407       * @apilevel internal
1408       */
1409      private Map<String,SimpleSet> methodsSignatureMap_compute() {
1410          Map<String,SimpleSet> localMap = localMethodsSignatureMap();
1411          Map<String,SimpleSet> map = new HashMap<String,SimpleSet>(localMap);
1412          HashMap fromSuperClass = new HashMap();
1413          if (hasSuperclass()) {
1414            for (Iterator<MethodDecl> iter = superclass().methodsIterator(); iter.hasNext(); ) {
1415              MethodDecl m = iter.next();
1416              if (!m.isPrivate() && m.accessibleFrom(this) && !localMap.containsKey(m.signature())) {
1417                putSimpleSetElement(map, m.signature(), m);
1418                if (!m.isAbstract()) {
1419                  putSimpleSetElement(fromSuperClass, m.signature(), m);
1420                }
1421              }
1422            }
1423          }
1424          for (Iterator<MethodDecl> iter = interfacesMethodsIterator(); iter.hasNext(); ) {
1425            MethodDecl m = iter.next();
1426            if (!m.isStatic()
1427                && m.accessibleFrom(this) && !localMap.containsKey(m.signature())
1428                && !hasOverridingMethodInSuper(m)) {
1429              if (!fromSuperClass.containsKey(m.signature())) {
1430                putSimpleSetElement(map, m.signature(), m);
1431              }
1432            }
1433          }
1434          return map;
1435        }
1436      /**
1437       * @apilevel internal
1438       */
1439      protected java.util.Map ancestorMethods_String_values;
1440      /**
1441       * @apilevel internal
1442       */
1443      private void ancestorMethods_String_reset() {
1444        ancestorMethods_String_values = null;
1445      }
1446      /**
1447       * @attribute syn
1448       * @aspect AncestorMethods
1449       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:536
1450       */
1451      @ASTNodeAnnotation.Attribute
1452      public SimpleSet ancestorMethods(String signature) {
1453        Object _parameters = signature;
1454        if (ancestorMethods_String_values == null) ancestorMethods_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1455        ASTNode$State state = state();
1456        if (ancestorMethods_String_values.containsKey(_parameters)) {
1457          return (SimpleSet) ancestorMethods_String_values.get(_parameters);
1458        }
1459        boolean intermediate = state.INTERMEDIATE_VALUE;
1460        state.INTERMEDIATE_VALUE = false;
1461        int num = state.boundariesCrossed;
1462        boolean isFinal = this.is$Final();
1463        SimpleSet ancestorMethods_String_value = ancestorMethods_compute(signature);
1464        if (isFinal && num == state().boundariesCrossed) {
1465          ancestorMethods_String_values.put(_parameters, ancestorMethods_String_value);
1466        } else {
1467        }
1468        state.INTERMEDIATE_VALUE |= intermediate;
1469    
1470        return ancestorMethods_String_value;
1471      }
1472      /**
1473       * @apilevel internal
1474       */
1475      private SimpleSet ancestorMethods_compute(String signature) {
1476          SimpleSet set = SimpleSet.emptySet;
1477          if (hasSuperclass()) {
1478            for (Iterator iter = superclass().localMethodsSignature(signature).iterator(); iter.hasNext(); ) {
1479              MethodDecl m = (MethodDecl) iter.next();
1480              if (!m.isPrivate()) {
1481                set = set.add(m);
1482              }
1483            }
1484          }
1485          // always add interface methods to the ancestorMethods set so that their
1486          // access modifiers are checked against local overriding methods
1487          for (Iterator iter = interfacesMethodsSignature(signature).iterator(); iter.hasNext(); ) {
1488            MethodDecl m = (MethodDecl) iter.next();
1489            set = set.add(m);
1490          }
1491          if (!hasSuperclass()) {
1492            return set;
1493          }
1494          if (set.size() == 1) {
1495            MethodDecl m = (MethodDecl) set.iterator().next();
1496            if (!m.isAbstract()) {
1497              boolean done = true;
1498              for (Iterator iter = superclass().ancestorMethods(signature).iterator(); iter.hasNext(); ) {
1499                MethodDecl n = (MethodDecl) iter.next();
1500                if (n.isPrivate() || !n.accessibleFrom(m.hostType())) {
1501                  done = false;
1502                }
1503              }
1504              if (done) {
1505                return set;
1506              }
1507            }
1508          }
1509          for (Iterator iter = superclass().ancestorMethods(signature).iterator(); iter.hasNext(); ) {
1510            MethodDecl m = (MethodDecl) iter.next();
1511            set = set.add(m);
1512          }
1513          return set;
1514        }
1515      /**
1516       * @apilevel internal
1517       */
1518      protected java.util.Map memberTypes_String_values;
1519      /**
1520       * @apilevel internal
1521       */
1522      private void memberTypes_String_reset() {
1523        memberTypes_String_values = null;
1524      }
1525      /**
1526       * @attribute syn
1527       * @aspect TypeScopePropagation
1528       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:619
1529       */
1530      @ASTNodeAnnotation.Attribute
1531      public SimpleSet memberTypes(String name) {
1532        Object _parameters = name;
1533        if (memberTypes_String_values == null) memberTypes_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1534        ASTNode$State state = state();
1535        if (memberTypes_String_values.containsKey(_parameters)) {
1536          return (SimpleSet) memberTypes_String_values.get(_parameters);
1537        }
1538        boolean intermediate = state.INTERMEDIATE_VALUE;
1539        state.INTERMEDIATE_VALUE = false;
1540        int num = state.boundariesCrossed;
1541        boolean isFinal = this.is$Final();
1542        SimpleSet memberTypes_String_value = memberTypes_compute(name);
1543        if (isFinal && num == state().boundariesCrossed) {
1544          memberTypes_String_values.put(_parameters, memberTypes_String_value);
1545        } else {
1546        }
1547        state.INTERMEDIATE_VALUE |= intermediate;
1548    
1549        return memberTypes_String_value;
1550      }
1551      /**
1552       * @apilevel internal
1553       */
1554      private SimpleSet memberTypes_compute(String name) {
1555          SimpleSet set = localTypeDecls(name);
1556          if (!set.isEmpty()) {
1557            return set;
1558          }
1559          for (Iterator<TypeDecl> outerIter = interfacesIterator(); outerIter.hasNext(); ) {
1560            TypeDecl type = outerIter.next();
1561            for (Iterator iter = type.memberTypes(name).iterator(); iter.hasNext(); ) {
1562              TypeDecl decl = (TypeDecl) iter.next();
1563              if (!decl.isPrivate() && decl.accessibleFrom(this)) {
1564                set = set.add(decl);
1565              }
1566            }
1567          }
1568          if (hasSuperclass()) {
1569            for (Iterator iter = superclass().memberTypes(name).iterator(); iter.hasNext(); ) {
1570              TypeDecl decl = (TypeDecl) iter.next();
1571              if (!decl.isPrivate() && decl.accessibleFrom(this)) {
1572                set = set.add(decl);
1573              }
1574            }
1575          }
1576          return set;
1577        }
1578      /**
1579       * @apilevel internal
1580       */
1581      protected boolean memberFieldsMap_computed = false;
1582      /**
1583       * @apilevel internal
1584       */
1585      protected HashMap memberFieldsMap_value;
1586      /**
1587       * @apilevel internal
1588       */
1589      private void memberFieldsMap_reset() {
1590        memberFieldsMap_computed = false;
1591        memberFieldsMap_value = null;
1592      }
1593      /**
1594       * @attribute syn
1595       * @aspect Fields
1596       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:383
1597       */
1598      @ASTNodeAnnotation.Attribute
1599      public HashMap memberFieldsMap() {
1600        ASTNode$State state = state();
1601        if (memberFieldsMap_computed) {
1602          return memberFieldsMap_value;
1603        }
1604        boolean intermediate = state.INTERMEDIATE_VALUE;
1605        state.INTERMEDIATE_VALUE = false;
1606        int num = state.boundariesCrossed;
1607        boolean isFinal = this.is$Final();
1608        memberFieldsMap_value = memberFieldsMap_compute();
1609        if (isFinal && num == state().boundariesCrossed) {
1610          memberFieldsMap_computed = true;
1611        } else {
1612        }
1613        state.INTERMEDIATE_VALUE |= intermediate;
1614    
1615        return memberFieldsMap_value;
1616      }
1617      /**
1618       * @apilevel internal
1619       */
1620      private HashMap memberFieldsMap_compute() {
1621          HashMap map = new HashMap(localFieldsMap());
1622          if (hasSuperclass()) {
1623            for (Iterator iter = superclass().fieldsIterator(); iter.hasNext(); ) {
1624              FieldDeclaration decl = (FieldDeclaration) iter.next();
1625              if (!decl.isPrivate() && decl.accessibleFrom(this) && !localFieldsMap().containsKey(decl.name())) {
1626                putSimpleSetElement(map, decl.name(), decl);
1627              }
1628            }
1629          }
1630          for (Iterator<TypeDecl> outerIter = interfacesIterator(); outerIter.hasNext(); ) {
1631            TypeDecl type = outerIter.next();
1632            for (Iterator iter = type.fieldsIterator(); iter.hasNext(); ) {
1633              FieldDeclaration decl = (FieldDeclaration) iter.next();
1634              if (!decl.isPrivate() && decl.accessibleFrom(this) && !localFieldsMap().containsKey(decl.name())) {
1635                putSimpleSetElement(map, decl.name(), decl);
1636              }
1637            }
1638          }
1639          return map;
1640        }
1641      /**
1642       * @apilevel internal
1643       */
1644      protected java.util.Map memberFields_String_values;
1645      /**
1646       * @apilevel internal
1647       */
1648      private void memberFields_String_reset() {
1649        memberFields_String_values = null;
1650      }
1651      /**
1652       * @attribute syn
1653       * @aspect Fields
1654       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:435
1655       */
1656      @ASTNodeAnnotation.Attribute
1657      public SimpleSet memberFields(String name) {
1658        Object _parameters = name;
1659        if (memberFields_String_values == null) memberFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1660        ASTNode$State state = state();
1661        if (memberFields_String_values.containsKey(_parameters)) {
1662          return (SimpleSet) memberFields_String_values.get(_parameters);
1663        }
1664        boolean intermediate = state.INTERMEDIATE_VALUE;
1665        state.INTERMEDIATE_VALUE = false;
1666        int num = state.boundariesCrossed;
1667        boolean isFinal = this.is$Final();
1668        SimpleSet memberFields_String_value = memberFields_compute(name);
1669        if (isFinal && num == state().boundariesCrossed) {
1670          memberFields_String_values.put(_parameters, memberFields_String_value);
1671        } else {
1672        }
1673        state.INTERMEDIATE_VALUE |= intermediate;
1674    
1675        return memberFields_String_value;
1676      }
1677      /**
1678       * @apilevel internal
1679       */
1680      private SimpleSet memberFields_compute(String name) {
1681          SimpleSet fields = localFields(name);
1682          if (!fields.isEmpty()) {
1683            return fields; // this causes hiding of fields in superclass and interfaces
1684          }
1685          if (hasSuperclass()) {
1686            for (Iterator iter = superclass().memberFields(name).iterator(); iter.hasNext(); ) {
1687              FieldDeclaration decl = (FieldDeclaration) iter.next();
1688              if (!decl.isPrivate() && decl.accessibleFrom(this)) {
1689                fields = fields.add(decl);
1690              }
1691            }
1692          }
1693          for (Iterator<TypeDecl> outerIter = interfacesIterator(); outerIter.hasNext(); ) {
1694            TypeDecl type = outerIter.next();
1695            for (Iterator iter = type.memberFields(name).iterator(); iter.hasNext(); ) {
1696              FieldDeclaration decl = (FieldDeclaration) iter.next();
1697              if (!decl.isPrivate() && decl.accessibleFrom(this)) {
1698                fields = fields.add(decl);
1699              }
1700            }
1701          }
1702          return fields;
1703        }
1704      /**
1705       * @apilevel internal
1706       */
1707      protected boolean unimplementedMethods_computed = false;
1708      /**
1709       * @apilevel internal
1710       */
1711      protected Collection unimplementedMethods_value;
1712      /**
1713       * @apilevel internal
1714       */
1715      private void unimplementedMethods_reset() {
1716        unimplementedMethods_computed = false;
1717        unimplementedMethods_value = null;
1718      }
1719      /**
1720       * @attribute syn
1721       * @aspect Modifiers
1722       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:37
1723       */
1724      @ASTNodeAnnotation.Attribute
1725      public Collection unimplementedMethods() {
1726        ASTNode$State state = state();
1727        if (unimplementedMethods_computed) {
1728          return unimplementedMethods_value;
1729        }
1730        boolean intermediate = state.INTERMEDIATE_VALUE;
1731        state.INTERMEDIATE_VALUE = false;
1732        int num = state.boundariesCrossed;
1733        boolean isFinal = this.is$Final();
1734        unimplementedMethods_value = unimplementedMethods_compute();
1735        if (isFinal && num == state().boundariesCrossed) {
1736          unimplementedMethods_computed = true;
1737        } else {
1738        }
1739        state.INTERMEDIATE_VALUE |= intermediate;
1740    
1741        return unimplementedMethods_value;
1742      }
1743      /**
1744       * @apilevel internal
1745       */
1746      private Collection unimplementedMethods_compute() {
1747          Collection c = new ArrayList();
1748          for (Iterator iter = interfacesMethodsIterator(); iter.hasNext(); ) {
1749            MethodDecl m = (MethodDecl) iter.next();
1750            boolean implemented = false;
1751            SimpleSet set = (SimpleSet) localMethodsSignature(m.signature());
1752            if (set.size() == 1) {
1753              MethodDecl n = (MethodDecl) set.iterator().next();
1754              if (!n.isAbstract()) {
1755                implemented = true;
1756              }
1757            }
1758            if (!implemented) {
1759              set = ancestorMethods(m.signature());
1760              for (Iterator i2 = set.iterator(); i2.hasNext(); ) {
1761                MethodDecl n = (MethodDecl) i2.next();
1762                if (!n.isAbstract() && n.isPublic()) {
1763                  implemented = true;
1764                  break;
1765                }
1766              }
1767            }
1768            if (!implemented) {
1769              c.add(m);
1770            }
1771          }
1772      
1773          if (hasSuperclass()) {
1774            for (Iterator iter = superclass().unimplementedMethods().iterator(); iter.hasNext(); ) {
1775              MethodDecl m = (MethodDecl) iter.next();
1776              SimpleSet set = (SimpleSet) localMethodsSignature(m.signature());
1777              if (set.size() == 1) {
1778                MethodDecl n = (MethodDecl) set.iterator().next();
1779                if (n.isAbstract() || !n.overrides(m)) {
1780                  c.add(m);
1781                }
1782              } else {
1783                c.add(m);
1784              }
1785            }
1786          }
1787      
1788          for (Iterator iter = localMethodsIterator(); iter.hasNext(); ) {
1789            MethodDecl m = (MethodDecl) iter.next();
1790            if (m.isAbstract()) {
1791              c.add(m);
1792            }
1793          }
1794          return c;
1795        }
1796      /**
1797       * @apilevel internal
1798       */
1799      protected boolean hasAbstract_computed = false;
1800      /**
1801       * @apilevel internal
1802       */
1803      protected boolean hasAbstract_value;
1804      /**
1805       * @apilevel internal
1806       */
1807      private void hasAbstract_reset() {
1808        hasAbstract_computed = false;
1809      }
1810      /**
1811       * @attribute syn
1812       * @aspect Modifiers
1813       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:35
1814       */
1815      @ASTNodeAnnotation.Attribute
1816      public boolean hasAbstract() {
1817        ASTNode$State state = state();
1818        if (hasAbstract_computed) {
1819          return hasAbstract_value;
1820        }
1821        boolean intermediate = state.INTERMEDIATE_VALUE;
1822        state.INTERMEDIATE_VALUE = false;
1823        int num = state.boundariesCrossed;
1824        boolean isFinal = this.is$Final();
1825        hasAbstract_value = !unimplementedMethods().isEmpty();
1826        if (isFinal && num == state().boundariesCrossed) {
1827          hasAbstract_computed = true;
1828        } else {
1829        }
1830        state.INTERMEDIATE_VALUE |= intermediate;
1831    
1832        return hasAbstract_value;
1833      }
1834      /**
1835       * @attribute syn
1836       * @aspect PrettyPrintUtil
1837       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:241
1838       */
1839      @ASTNodeAnnotation.Attribute
1840      public boolean hasModifiers() {
1841        boolean hasModifiers_value = getModifiers().getNumModifier() > 0;
1842    
1843        return hasModifiers_value;
1844      }
1845      /**
1846       * @apilevel internal
1847       */
1848      protected java.util.Map castingConversionTo_TypeDecl_values;
1849      /**
1850       * @apilevel internal
1851       */
1852      private void castingConversionTo_TypeDecl_reset() {
1853        castingConversionTo_TypeDecl_values = null;
1854      }
1855      /**
1856       * @attribute syn
1857       * @aspect TypeConversion
1858       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:109
1859       */
1860      @ASTNodeAnnotation.Attribute
1861      public boolean castingConversionTo(TypeDecl type) {
1862        Object _parameters = type;
1863        if (castingConversionTo_TypeDecl_values == null) castingConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1864        ASTNode$State state = state();
1865        if (castingConversionTo_TypeDecl_values.containsKey(_parameters)) {
1866          return (Boolean) castingConversionTo_TypeDecl_values.get(_parameters);
1867        }
1868        boolean intermediate = state.INTERMEDIATE_VALUE;
1869        state.INTERMEDIATE_VALUE = false;
1870        int num = state.boundariesCrossed;
1871        boolean isFinal = this.is$Final();
1872        boolean castingConversionTo_TypeDecl_value = castingConversionTo_compute(type);
1873        if (isFinal && num == state().boundariesCrossed) {
1874          castingConversionTo_TypeDecl_values.put(_parameters, castingConversionTo_TypeDecl_value);
1875        } else {
1876        }
1877        state.INTERMEDIATE_VALUE |= intermediate;
1878    
1879        return castingConversionTo_TypeDecl_value;
1880      }
1881      /**
1882       * @apilevel internal
1883       */
1884      private boolean castingConversionTo_compute(TypeDecl type) {
1885          if (refined_Generics_ClassDecl_castingConversionTo_TypeDecl(type)) {
1886            return true;
1887          }
1888          boolean canUnboxThis = !unboxed().isUnknown();
1889          boolean canUnboxType = !type.unboxed().isUnknown();
1890          if (canUnboxThis && !canUnboxType) {
1891            return unboxed().wideningConversionTo(type);
1892          }
1893          return false;
1894          /*
1895          else if (unboxingConversionTo(type)) {
1896            return true;
1897          }
1898          return false;
1899          */
1900        }
1901      /**
1902       * @attribute syn
1903       * @aspect TypeAnalysis
1904       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:231
1905       */
1906      @ASTNodeAnnotation.Attribute
1907      public boolean isClassDecl() {
1908        boolean isClassDecl_value = true;
1909    
1910        return isClassDecl_value;
1911      }
1912      /**
1913       * @apilevel internal
1914       */
1915      protected boolean isString_computed = false;
1916      /**
1917       * @apilevel internal
1918       */
1919      protected boolean isString_value;
1920      /**
1921       * @apilevel internal
1922       */
1923      private void isString_reset() {
1924        isString_computed = false;
1925      }
1926      /**
1927       * @attribute syn
1928       * @aspect TypeAnalysis
1929       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:248
1930       */
1931      @ASTNodeAnnotation.Attribute
1932      public boolean isString() {
1933        ASTNode$State state = state();
1934        if (isString_computed) {
1935          return isString_value;
1936        }
1937        boolean intermediate = state.INTERMEDIATE_VALUE;
1938        state.INTERMEDIATE_VALUE = false;
1939        int num = state.boundariesCrossed;
1940        boolean isFinal = this.is$Final();
1941        isString_value = fullName().equals("java.lang.String");
1942        if (isFinal && num == state().boundariesCrossed) {
1943          isString_computed = true;
1944        } else {
1945        }
1946        state.INTERMEDIATE_VALUE |= intermediate;
1947    
1948        return isString_value;
1949      }
1950      /**
1951       * @apilevel internal
1952       */
1953      protected boolean isObject_computed = false;
1954      /**
1955       * @apilevel internal
1956       */
1957      protected boolean isObject_value;
1958      /**
1959       * @apilevel internal
1960       */
1961      private void isObject_reset() {
1962        isObject_computed = false;
1963      }
1964      /**
1965       * @attribute syn
1966       * @aspect TypeAnalysis
1967       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:251
1968       */
1969      @ASTNodeAnnotation.Attribute
1970      public boolean isObject() {
1971        ASTNode$State state = state();
1972        if (isObject_computed) {
1973          return isObject_value;
1974        }
1975        boolean intermediate = state.INTERMEDIATE_VALUE;
1976        state.INTERMEDIATE_VALUE = false;
1977        int num = state.boundariesCrossed;
1978        boolean isFinal = this.is$Final();
1979        isObject_value = name().equals("Object") && packageName().equals("java.lang");
1980        if (isFinal && num == state().boundariesCrossed) {
1981          isObject_computed = true;
1982        } else {
1983        }
1984        state.INTERMEDIATE_VALUE |= intermediate;
1985    
1986        return isObject_value;
1987      }
1988      /**
1989       * @apilevel internal
1990       */
1991      protected java.util.Map instanceOf_TypeDecl_values;
1992      /**
1993       * @apilevel internal
1994       */
1995      private void instanceOf_TypeDecl_reset() {
1996        instanceOf_TypeDecl_values = null;
1997      }
1998      /**
1999       * @attribute syn
2000       * @aspect TypeWideningAndIdentity
2001       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442
2002       */
2003      @ASTNodeAnnotation.Attribute
2004      public boolean instanceOf(TypeDecl type) {
2005        Object _parameters = type;
2006        if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2007        ASTNode$State state = state();
2008        if (instanceOf_TypeDecl_values.containsKey(_parameters)) {
2009          return (Boolean) instanceOf_TypeDecl_values.get(_parameters);
2010        }
2011        boolean intermediate = state.INTERMEDIATE_VALUE;
2012        state.INTERMEDIATE_VALUE = false;
2013        int num = state.boundariesCrossed;
2014        boolean isFinal = this.is$Final();
2015        boolean instanceOf_TypeDecl_value = instanceOf_compute(type);
2016        if (isFinal && num == state().boundariesCrossed) {
2017          instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value);
2018        } else {
2019        }
2020        state.INTERMEDIATE_VALUE |= intermediate;
2021    
2022        return instanceOf_TypeDecl_value;
2023      }
2024      /**
2025       * @apilevel internal
2026       */
2027      private boolean instanceOf_compute(TypeDecl type) { return subtype(type); }
2028      /**
2029       * @attribute syn
2030       * @aspect TypeWideningAndIdentity
2031       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:458
2032       */
2033      @ASTNodeAnnotation.Attribute
2034      public boolean isSupertypeOfClassDecl(ClassDecl type) {
2035        {
2036            if (super.isSupertypeOfClassDecl(type)) {
2037              return true;
2038            }
2039            return type.hasSuperclass() && type.superclass().instanceOf(this);
2040          }
2041      }
2042      /**
2043       * @attribute syn
2044       * @aspect TypeWideningAndIdentity
2045       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:478
2046       */
2047      @ASTNodeAnnotation.Attribute
2048      public boolean isSupertypeOfInterfaceDecl(InterfaceDecl type) {
2049        boolean isSupertypeOfInterfaceDecl_InterfaceDecl_value = isObject();
2050    
2051        return isSupertypeOfInterfaceDecl_InterfaceDecl_value;
2052      }
2053      /**
2054       * @attribute syn
2055       * @aspect TypeWideningAndIdentity
2056       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:493
2057       */
2058      @ASTNodeAnnotation.Attribute
2059      public boolean isSupertypeOfArrayDecl(ArrayDecl type) {
2060        {
2061            if (super.isSupertypeOfArrayDecl(type)) {
2062              return true;
2063            }
2064            return type.hasSuperclass() && type.superclass().instanceOf(this);
2065          }
2066      }
2067      /**
2068       * @attribute syn
2069       * @aspect NestedTypes
2070       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:585
2071       */
2072      @ASTNodeAnnotation.Attribute
2073      public boolean isInnerClass() {
2074        boolean isInnerClass_value = isNestedType() && !isStatic() && enclosingType().isClassDecl();
2075    
2076        return isInnerClass_value;
2077      }
2078      /**
2079       * @apilevel internal
2080       */
2081      protected int isCircular_visited = -1;
2082      /**
2083       * @apilevel internal
2084       */
2085      private void isCircular_reset() {
2086        isCircular_computed = false;
2087        isCircular_initialized = false;
2088        isCircular_visited = -1;
2089      }
2090      /**
2091       * @apilevel internal
2092       */
2093      protected boolean isCircular_computed = false;
2094      /**
2095       * @apilevel internal
2096       */
2097      protected boolean isCircular_initialized = false;
2098      /**
2099       * @apilevel internal
2100       */
2101      protected boolean isCircular_value;
2102      @ASTNodeAnnotation.Attribute
2103      public boolean isCircular() {
2104        if (isCircular_computed) {
2105          return isCircular_value;
2106        }
2107        ASTNode$State state = state();
2108        boolean new_isCircular_value;
2109        if (!isCircular_initialized) {
2110          isCircular_initialized = true;
2111          isCircular_value = true;
2112        }
2113        if (!state.IN_CIRCLE) {
2114          state.IN_CIRCLE = true;
2115          int num = state.boundariesCrossed;
2116          boolean isFinal = this.is$Final();
2117          do {
2118            isCircular_visited = state.CIRCLE_INDEX;
2119            state.CHANGE = false;
2120            new_isCircular_value = isCircular_compute();
2121            if (new_isCircular_value != isCircular_value) {
2122              state.CHANGE = true;
2123            }
2124            isCircular_value = new_isCircular_value;
2125            state.CIRCLE_INDEX++;
2126          } while (state.CHANGE);
2127          if (isFinal && num == state().boundariesCrossed) {
2128            isCircular_computed = true;
2129          } else {
2130            state.RESET_CYCLE = true;
2131            boolean $tmp = isCircular_compute();
2132            state.RESET_CYCLE = false;
2133            isCircular_computed = false;
2134            isCircular_initialized = false;
2135          }
2136          state.IN_CIRCLE = false;
2137          state.INTERMEDIATE_VALUE = false;
2138          return isCircular_value;
2139        }
2140        if (isCircular_visited != state.CIRCLE_INDEX) {
2141          isCircular_visited = state.CIRCLE_INDEX;
2142          if (state.RESET_CYCLE) {
2143            isCircular_computed = false;
2144            isCircular_initialized = false;
2145            isCircular_visited = -1;
2146            return isCircular_value;
2147          }
2148          new_isCircular_value = isCircular_compute();
2149          if (new_isCircular_value != isCircular_value) {
2150            state.CHANGE = true;
2151          }
2152          isCircular_value = new_isCircular_value;
2153          state.INTERMEDIATE_VALUE = true;
2154          return isCircular_value;
2155        }
2156        state.INTERMEDIATE_VALUE = true;
2157        return isCircular_value;
2158      }
2159      /**
2160       * @apilevel internal
2161       */
2162      private boolean isCircular_compute() {
2163          if (hasSuperClass()) {
2164            Access a = getSuperClass().lastAccess();
2165            while (a != null) {
2166              if (a.type().isCircular()) {
2167                return true;
2168              }
2169              a = (a.isQualified() && a.qualifier().isTypeAccess()) ? (Access) a.qualifier() : null;
2170            }
2171          }
2172          for (int i = 0; i < getNumImplements(); i++) {
2173            Access a = getImplements(i).lastAccess();
2174            while (a != null) {
2175              if (a.type().isCircular()) {
2176                return true;
2177              }
2178              a = (a.isQualified() && a.qualifier().isTypeAccess()) ? (Access) a.qualifier() : null;
2179            }
2180          }
2181          return false;
2182        }
2183      /**
2184       * @apilevel internal
2185       */
2186      protected boolean typeDescriptor_computed = false;
2187      /**
2188       * @apilevel internal
2189       */
2190      protected String typeDescriptor_value;
2191      /**
2192       * @apilevel internal
2193       */
2194      private void typeDescriptor_reset() {
2195        typeDescriptor_computed = false;
2196        typeDescriptor_value = null;
2197      }
2198      /**
2199       * @attribute syn
2200       * @aspect ConstantPoolNames
2201       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77
2202       */
2203      @ASTNodeAnnotation.Attribute
2204      public String typeDescriptor() {
2205        ASTNode$State state = state();
2206        if (typeDescriptor_computed) {
2207          return typeDescriptor_value;
2208        }
2209        boolean intermediate = state.INTERMEDIATE_VALUE;
2210        state.INTERMEDIATE_VALUE = false;
2211        int num = state.boundariesCrossed;
2212        boolean isFinal = this.is$Final();
2213        typeDescriptor_value = "L" + constantPoolName() + ";";
2214        if (isFinal && num == state().boundariesCrossed) {
2215          typeDescriptor_computed = true;
2216        } else {
2217        }
2218        state.INTERMEDIATE_VALUE |= intermediate;
2219    
2220        return typeDescriptor_value;
2221      }
2222      /**
2223       * @attribute syn
2224       * @aspect CreateBCode
2225       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:900
2226       */
2227      @ASTNodeAnnotation.Attribute
2228      public String arrayTypeDescriptor() {
2229        String arrayTypeDescriptor_value = constantPoolName();
2230    
2231        return arrayTypeDescriptor_value;
2232      }
2233      /**
2234       * @attribute syn
2235       * @aspect GenerateClassfile
2236       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:328
2237       */
2238      @ASTNodeAnnotation.Attribute
2239      public Collection bcMethods() {
2240        {
2241            Collection c = new ArrayList();
2242            if (hasImplicitConstructor()) {
2243              c.add(getImplicitConstructor());
2244            }
2245            c.addAll(super.bcMethods());
2246            return c;
2247          }
2248      }
2249      /**
2250       * @attribute syn
2251       * @aspect InnerClasses
2252       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:499
2253       */
2254      @ASTNodeAnnotation.Attribute
2255      public TypeDecl superEnclosing() {
2256        {
2257             return superclass().erasure().enclosing();
2258           }
2259      }
2260      /**
2261       * @attribute syn
2262       * @aspect Annotations
2263       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:292
2264       */
2265      @ASTNodeAnnotation.Attribute
2266      public Annotation annotation(TypeDecl typeDecl) {
2267        {
2268            Annotation a = super.annotation(typeDecl);
2269            if (a != null) {
2270              return a;
2271            }
2272            if (hasSuperclass()) {
2273              // If the queried annotation is itself annotation with @Inherited then
2274              // delegate the query to the superclass
2275              if (typeDecl.annotation(lookupType("java.lang.annotation", "Inherited")) != null) {
2276                return superclass().annotation(typeDecl);
2277              }
2278            }
2279            return null;
2280          }
2281      }
2282      /**
2283       * @apilevel internal
2284       */
2285      protected boolean erasedAncestorMethodsMap_computed = false;
2286      /**
2287       * @apilevel internal
2288       */
2289      protected Map<String,SimpleSet> erasedAncestorMethodsMap_value;
2290      /**
2291       * @apilevel internal
2292       */
2293      private void erasedAncestorMethodsMap_reset() {
2294        erasedAncestorMethodsMap_computed = false;
2295        erasedAncestorMethodsMap_value = null;
2296      }
2297      /**
2298       * @attribute syn
2299       * @aspect GenericsTypeCheck
2300       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:496
2301       */
2302      @ASTNodeAnnotation.Attribute
2303      public Map<String,SimpleSet> erasedAncestorMethodsMap() {
2304        ASTNode$State state = state();
2305        if (erasedAncestorMethodsMap_computed) {
2306          return erasedAncestorMethodsMap_value;
2307        }
2308        boolean intermediate = state.INTERMEDIATE_VALUE;
2309        state.INTERMEDIATE_VALUE = false;
2310        int num = state.boundariesCrossed;
2311        boolean isFinal = this.is$Final();
2312        erasedAncestorMethodsMap_value = erasedAncestorMethodsMap_compute();
2313        if (isFinal && num == state().boundariesCrossed) {
2314          erasedAncestorMethodsMap_computed = true;
2315        } else {
2316        }
2317        state.INTERMEDIATE_VALUE |= intermediate;
2318    
2319        return erasedAncestorMethodsMap_value;
2320      }
2321      /**
2322       * @apilevel internal
2323       */
2324      private Map<String,SimpleSet> erasedAncestorMethodsMap_compute() {
2325          Map<String,SimpleSet> localMap = localMethodsSignatureMap();
2326          Map<String,SimpleSet> map = new HashMap<String,SimpleSet>();
2327          if (hasSuperclass()) {
2328            for (Iterator<MethodDecl> iter = superclass().localMethodsIterator(); iter.hasNext(); ) {
2329              MethodDecl m = iter.next();
2330              if (!m.isPrivate() && m.accessibleFrom(this) && m.erasedMethod() != m) {
2331                // map erased signature to substituted method
2332                putSimpleSetElement(map, m.erasedMethod().signature(), m);
2333              }
2334            }
2335            mergeMap(map, superclass().erasedAncestorMethodsMap());
2336          }
2337          for (Iterator<MethodDecl> iter = interfacesMethodsIterator(); iter.hasNext(); ) {
2338            MethodDecl m = iter.next();
2339            if (m.accessibleFrom(this) && m.erasedMethod() != m) {
2340              String erasedSignature = m.erasedMethod().signature();
2341              // map erased signature to substituted method
2342              putSimpleSetElement(map, erasedSignature, m);
2343            }
2344          }
2345          return map;
2346        }
2347      /**
2348       * @apilevel internal
2349       */
2350      protected boolean implementedInterfaces_computed = false;
2351      /**
2352       * @apilevel internal
2353       */
2354      protected HashSet<InterfaceDecl> implementedInterfaces_value;
2355      /**
2356       * @apilevel internal
2357       */
2358      private void implementedInterfaces_reset() {
2359        implementedInterfaces_computed = false;
2360        implementedInterfaces_value = null;
2361      }
2362      /**
2363       * @attribute syn
2364       * @aspect GenericsTypeCheck
2365       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:614
2366       */
2367      @ASTNodeAnnotation.Attribute
2368      public HashSet<InterfaceDecl> implementedInterfaces() {
2369        ASTNode$State state = state();
2370        if (implementedInterfaces_computed) {
2371          return implementedInterfaces_value;
2372        }
2373        boolean intermediate = state.INTERMEDIATE_VALUE;
2374        state.INTERMEDIATE_VALUE = false;
2375        int num = state.boundariesCrossed;
2376        boolean isFinal = this.is$Final();
2377        implementedInterfaces_value = implementedInterfaces_compute();
2378        if (isFinal && num == state().boundariesCrossed) {
2379          implementedInterfaces_computed = true;
2380        } else {
2381        }
2382        state.INTERMEDIATE_VALUE |= intermediate;
2383    
2384        return implementedInterfaces_value;
2385      }
2386      /**
2387       * @apilevel internal
2388       */
2389      private HashSet<InterfaceDecl> implementedInterfaces_compute() {
2390          HashSet set = new HashSet();
2391          if (hasSuperclass()) {
2392            set.addAll(superclass().implementedInterfaces());
2393          }
2394          for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) {
2395            InterfaceDecl decl = (InterfaceDecl) iter.next();
2396            set.add(decl);
2397            set.addAll(decl.implementedInterfaces());
2398          }
2399          return set;
2400        }
2401      /**
2402       * @apilevel internal
2403       */
2404      private void subtype_TypeDecl_reset() {
2405        subtype_TypeDecl_values = null;
2406      }
2407      protected java.util.Map subtype_TypeDecl_values;
2408      @ASTNodeAnnotation.Attribute
2409      public boolean subtype(TypeDecl type) {
2410        Object _parameters = type;
2411        if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2412        ASTNode$State.CircularValue _value;
2413        if (subtype_TypeDecl_values.containsKey(_parameters)) {
2414          Object _o = subtype_TypeDecl_values.get(_parameters);
2415          if (!(_o instanceof ASTNode$State.CircularValue)) {
2416            return (Boolean) _o;
2417          } else {
2418            _value = (ASTNode$State.CircularValue) _o;
2419          }
2420        } else {
2421          _value = new ASTNode$State.CircularValue();
2422          subtype_TypeDecl_values.put(_parameters, _value);
2423          _value.value = true;
2424        }
2425        ASTNode$State state = state();
2426        boolean new_subtype_TypeDecl_value;
2427        if (!state.IN_CIRCLE) {
2428          state.IN_CIRCLE = true;
2429          int num = state.boundariesCrossed;
2430          boolean isFinal = this.is$Final();
2431          // TODO: fixme
2432          // state().CIRCLE_INDEX = 1;
2433          do {
2434            _value.visited = state.CIRCLE_INDEX;
2435            state.CHANGE = false;
2436            new_subtype_TypeDecl_value = type.supertypeClassDecl(this);
2437            if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
2438              state.CHANGE = true;
2439              _value.value = new_subtype_TypeDecl_value;
2440            }
2441            state.CIRCLE_INDEX++;
2442          } while (state.CHANGE);
2443          if (isFinal && num == state().boundariesCrossed) {
2444            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
2445          } else {
2446            subtype_TypeDecl_values.remove(_parameters);
2447            state.RESET_CYCLE = true;
2448            boolean $tmp = type.supertypeClassDecl(this);
2449            state.RESET_CYCLE = false;
2450          }
2451          state.IN_CIRCLE = false;
2452          state.INTERMEDIATE_VALUE = false;
2453          return new_subtype_TypeDecl_value;
2454        }
2455        if (state.CIRCLE_INDEX != _value.visited) {
2456          _value.visited = state.CIRCLE_INDEX;
2457          new_subtype_TypeDecl_value = type.supertypeClassDecl(this);
2458          if (state.RESET_CYCLE) {
2459            subtype_TypeDecl_values.remove(_parameters);
2460          }
2461          else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) {
2462            state.CHANGE = true;
2463            _value.value = new_subtype_TypeDecl_value;
2464          }
2465          state.INTERMEDIATE_VALUE = true;
2466          return new_subtype_TypeDecl_value;
2467        }
2468        state.INTERMEDIATE_VALUE = true;
2469        return (Boolean) _value.value;
2470      }
2471      /**
2472       * @attribute syn
2473       * @aspect GenericsSubtype
2474       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:448
2475       */
2476      @ASTNodeAnnotation.Attribute
2477      public boolean supertypeClassDecl(ClassDecl type) {
2478        boolean supertypeClassDecl_ClassDecl_value = super.supertypeClassDecl(type) || type.hasSuperclass() && type.superclass().subtype(this);
2479    
2480        return supertypeClassDecl_ClassDecl_value;
2481      }
2482      /**
2483       * @attribute syn
2484       * @aspect GenericsSubtype
2485       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:465
2486       */
2487      @ASTNodeAnnotation.Attribute
2488      public boolean supertypeInterfaceDecl(InterfaceDecl type) {
2489        boolean supertypeInterfaceDecl_InterfaceDecl_value = isObject();
2490    
2491        return supertypeInterfaceDecl_InterfaceDecl_value;
2492      }
2493      /**
2494       * @attribute syn
2495       * @aspect GenericsSubtype
2496       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:480
2497       */
2498      @ASTNodeAnnotation.Attribute
2499      public boolean supertypeArrayDecl(ArrayDecl type) {
2500        {
2501            if (super.supertypeArrayDecl(type)) {
2502              return true;
2503            }
2504            return type.hasSuperclass() && type.superclass().subtype(this);
2505          }
2506      }
2507      /**
2508       * A type is reifiable if it either refers to a non-parameterized type,
2509       * is a raw type, is a parameterized type with only unbound wildcard
2510       * parameters or is an array type with a reifiable type parameter.
2511       * 
2512       * @see "JLS SE7 &sect;4.7"
2513       * @attribute syn
2514       * @aspect ReifiableTypes
2515       * @declaredat /home/jesper/git/extendj/java5/frontend/ReifiableTypes.jrag:39
2516       */
2517      @ASTNodeAnnotation.Attribute
2518      public boolean isReifiable() {
2519        boolean isReifiable_value = !isInnerClass() || enclosingType().isReifiable();
2520    
2521        return isReifiable_value;
2522      }
2523      /**
2524       * @attribute syn
2525       * @aspect GenericsCodegen
2526       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:228
2527       */
2528      @ASTNodeAnnotation.Attribute
2529      public SimpleSet bridgeCandidates(String signature) {
2530        {
2531            SimpleSet set = ancestorMethods(signature);
2532            for (Iterator iter = interfacesMethodsSignature(signature).iterator(); iter.hasNext(); ) {
2533              set = set.add(iter.next());
2534            }
2535            return set;
2536          }
2537      }
2538      /**
2539       * @apilevel internal
2540       */
2541      protected boolean needsSignatureAttribute_computed = false;
2542      /**
2543       * @apilevel internal
2544       */
2545      protected boolean needsSignatureAttribute_value;
2546      /**
2547       * @apilevel internal
2548       */
2549      private void needsSignatureAttribute_reset() {
2550        needsSignatureAttribute_computed = false;
2551      }
2552      /**
2553       * @attribute syn
2554       * @aspect GenericsCodegen
2555       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:345
2556       */
2557      @ASTNodeAnnotation.Attribute
2558      public boolean needsSignatureAttribute() {
2559        ASTNode$State state = state();
2560        if (needsSignatureAttribute_computed) {
2561          return needsSignatureAttribute_value;
2562        }
2563        boolean intermediate = state.INTERMEDIATE_VALUE;
2564        state.INTERMEDIATE_VALUE = false;
2565        int num = state.boundariesCrossed;
2566        boolean isFinal = this.is$Final();
2567        needsSignatureAttribute_value = needsSignatureAttribute_compute();
2568        if (isFinal && num == state().boundariesCrossed) {
2569          needsSignatureAttribute_computed = true;
2570        } else {
2571        }
2572        state.INTERMEDIATE_VALUE |= intermediate;
2573    
2574        return needsSignatureAttribute_value;
2575      }
2576      /**
2577       * @apilevel internal
2578       */
2579      private boolean needsSignatureAttribute_compute() {
2580          if (hasSuperclass() && superclass().needsSignatureAttribute()) {
2581            return true;
2582          }
2583          for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) {
2584            if (iter.next().needsSignatureAttribute()) {
2585              return true;
2586            }
2587          }
2588          return false;
2589        }
2590      /**
2591       * @apilevel internal
2592       */
2593      protected boolean classSignature_computed = false;
2594      /**
2595       * @apilevel internal
2596       */
2597      protected String classSignature_value;
2598      /**
2599       * @apilevel internal
2600       */
2601      private void classSignature_reset() {
2602        classSignature_computed = false;
2603        classSignature_value = null;
2604      }
2605      /**
2606       * @attribute syn
2607       * @aspect GenericsCodegen
2608       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:401
2609       */
2610      @ASTNodeAnnotation.Attribute
2611      public String classSignature() {
2612        ASTNode$State state = state();
2613        if (classSignature_computed) {
2614          return classSignature_value;
2615        }
2616        boolean intermediate = state.INTERMEDIATE_VALUE;
2617        state.INTERMEDIATE_VALUE = false;
2618        int num = state.boundariesCrossed;
2619        boolean isFinal = this.is$Final();
2620        classSignature_value = classSignature_compute();
2621        if (isFinal && num == state().boundariesCrossed) {
2622          classSignature_computed = true;
2623        } else {
2624        }
2625        state.INTERMEDIATE_VALUE |= intermediate;
2626    
2627        return classSignature_value;
2628      }
2629      /**
2630       * @apilevel internal
2631       */
2632      private String classSignature_compute() {
2633          StringBuilder buf = new StringBuilder();
2634          // SuperclassSignature
2635          if (hasSuperclass()) {
2636            buf.append(superclass().classTypeSignature());
2637          }
2638          // SuperinterfaceSignature*
2639          for (Iterator<TypeDecl> iter = interfacesIterator(); iter.hasNext(); ) {
2640            buf.append(iter.next().classTypeSignature());
2641          }
2642          return buf.toString();
2643        }
2644      /**
2645       * @apilevel internal
2646       */
2647      private void strictSubtype_TypeDecl_reset() {
2648        strictSubtype_TypeDecl_values = null;
2649      }
2650      protected java.util.Map strictSubtype_TypeDecl_values;
2651      @ASTNodeAnnotation.Attribute
2652      public boolean strictSubtype(TypeDecl type) {
2653        Object _parameters = type;
2654        if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2655        ASTNode$State.CircularValue _value;
2656        if (strictSubtype_TypeDecl_values.containsKey(_parameters)) {
2657          Object _o = strictSubtype_TypeDecl_values.get(_parameters);
2658          if (!(_o instanceof ASTNode$State.CircularValue)) {
2659            return (Boolean) _o;
2660          } else {
2661            _value = (ASTNode$State.CircularValue) _o;
2662          }
2663        } else {
2664          _value = new ASTNode$State.CircularValue();
2665          strictSubtype_TypeDecl_values.put(_parameters, _value);
2666          _value.value = true;
2667        }
2668        ASTNode$State state = state();
2669        boolean new_strictSubtype_TypeDecl_value;
2670        if (!state.IN_CIRCLE) {
2671          state.IN_CIRCLE = true;
2672          int num = state.boundariesCrossed;
2673          boolean isFinal = this.is$Final();
2674          // TODO: fixme
2675          // state().CIRCLE_INDEX = 1;
2676          do {
2677            _value.visited = state.CIRCLE_INDEX;
2678            state.CHANGE = false;
2679            new_strictSubtype_TypeDecl_value = type.strictSupertypeClassDecl(this);
2680            if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
2681              state.CHANGE = true;
2682              _value.value = new_strictSubtype_TypeDecl_value;
2683            }
2684            state.CIRCLE_INDEX++;
2685          } while (state.CHANGE);
2686          if (isFinal && num == state().boundariesCrossed) {
2687            strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value);
2688          } else {
2689            strictSubtype_TypeDecl_values.remove(_parameters);
2690            state.RESET_CYCLE = true;
2691            boolean $tmp = type.strictSupertypeClassDecl(this);
2692            state.RESET_CYCLE = false;
2693          }
2694          state.IN_CIRCLE = false;
2695          state.INTERMEDIATE_VALUE = false;
2696          return new_strictSubtype_TypeDecl_value;
2697        }
2698        if (state.CIRCLE_INDEX != _value.visited) {
2699          _value.visited = state.CIRCLE_INDEX;
2700          new_strictSubtype_TypeDecl_value = type.strictSupertypeClassDecl(this);
2701          if (state.RESET_CYCLE) {
2702            strictSubtype_TypeDecl_values.remove(_parameters);
2703          }
2704          else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) {
2705            state.CHANGE = true;
2706            _value.value = new_strictSubtype_TypeDecl_value;
2707          }
2708          state.INTERMEDIATE_VALUE = true;
2709          return new_strictSubtype_TypeDecl_value;
2710        }
2711        state.INTERMEDIATE_VALUE = true;
2712        return (Boolean) _value.value;
2713      }
2714      /**
2715       * @attribute syn
2716       * @aspect StrictSubtype
2717       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:370
2718       */
2719      @ASTNodeAnnotation.Attribute
2720      public boolean strictSupertypeClassDecl(ClassDecl type) {
2721        boolean strictSupertypeClassDecl_ClassDecl_value = super.strictSupertypeClassDecl(type) || type.hasSuperclass()
2722              && type.superclass() != null && type.superclass().strictSubtype(this);
2723    
2724        return strictSupertypeClassDecl_ClassDecl_value;
2725      }
2726      /**
2727       * @attribute syn
2728       * @aspect StrictSubtype
2729       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:390
2730       */
2731      @ASTNodeAnnotation.Attribute
2732      public boolean strictSupertypeInterfaceDecl(InterfaceDecl type) {
2733        boolean strictSupertypeInterfaceDecl_InterfaceDecl_value = isObject();
2734    
2735        return strictSupertypeInterfaceDecl_InterfaceDecl_value;
2736      }
2737      /**
2738       * @attribute syn
2739       * @aspect StrictSubtype
2740       * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:407
2741       */
2742      @ASTNodeAnnotation.Attribute
2743      public boolean strictSupertypeArrayDecl(ArrayDecl type) {
2744        {
2745            if (super.strictSupertypeArrayDecl(type)) {
2746              return true;
2747            }
2748            return type.hasSuperclass() && type.superclass() != null
2749                && type.superclass().strictSubtype(this);
2750          }
2751      }
2752      /**
2753       * @apilevel internal
2754       */
2755      protected java.util.Map hasOverridingMethodInSuper_MethodDecl_values;
2756      /**
2757       * @apilevel internal
2758       */
2759      private void hasOverridingMethodInSuper_MethodDecl_reset() {
2760        hasOverridingMethodInSuper_MethodDecl_values = null;
2761      }
2762      /**
2763       * @attribute syn
2764       * @aspect MethodSignature18
2765       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:1066
2766       */
2767      @ASTNodeAnnotation.Attribute
2768      public boolean hasOverridingMethodInSuper(MethodDecl m) {
2769        Object _parameters = m;
2770        if (hasOverridingMethodInSuper_MethodDecl_values == null) hasOverridingMethodInSuper_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2771        ASTNode$State state = state();
2772        if (hasOverridingMethodInSuper_MethodDecl_values.containsKey(_parameters)) {
2773          return (Boolean) hasOverridingMethodInSuper_MethodDecl_values.get(_parameters);
2774        }
2775        boolean intermediate = state.INTERMEDIATE_VALUE;
2776        state.INTERMEDIATE_VALUE = false;
2777        int num = state.boundariesCrossed;
2778        boolean isFinal = this.is$Final();
2779        boolean hasOverridingMethodInSuper_MethodDecl_value = hasOverridingMethodInSuper_compute(m);
2780        if (isFinal && num == state().boundariesCrossed) {
2781          hasOverridingMethodInSuper_MethodDecl_values.put(_parameters, hasOverridingMethodInSuper_MethodDecl_value);
2782        } else {
2783        }
2784        state.INTERMEDIATE_VALUE |= intermediate;
2785    
2786        return hasOverridingMethodInSuper_MethodDecl_value;
2787      }
2788      /**
2789       * @apilevel internal
2790       */
2791      private boolean hasOverridingMethodInSuper_compute(MethodDecl m) {
2792          for (Iterator<MethodDecl> outerIter = interfacesMethodsIterator(); outerIter.hasNext(); ) {
2793            MethodDecl superMethod = outerIter.next();
2794            if (m != superMethod && superMethod.overrides(m)) {
2795              return true;
2796            }
2797      
2798          }
2799          if (hasSuperclass()) {
2800            for (Iterator iter = superclass().methodsIterator(); iter.hasNext(); ) {
2801              MethodDecl superMethod = (MethodDecl) iter.next();
2802              if (m != superMethod && superMethod.overrides(m)) {
2803                return true;
2804              }
2805            }
2806          }
2807      
2808          return false;
2809        }
2810      /**
2811       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197
2812       * @apilevel internal
2813       */
2814      public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) {
2815        if (caller == getImplicitConstructorOptNoTransform()) {
2816          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:474
2817          return localLookupType(name);
2818        }
2819        else {
2820          return super.Define_lookupType(caller, child, name);
2821        }
2822      }
2823      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) {
2824        return true;
2825      }
2826      /**
2827       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423
2828       * @apilevel internal
2829       */
2830      public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) {
2831        if (caller == getModifiersNoTransform()) {
2832          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:300
2833          return true;
2834        }
2835        else {
2836          return super.Define_mayBeFinal(caller, child);
2837        }
2838      }
2839      protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) {
2840        return true;
2841      }
2842      /**
2843       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
2844       * @apilevel internal
2845       */
2846      public NameType Define_nameType(ASTNode caller, ASTNode child) {
2847        if (caller == getImplementsListNoTransform()) {
2848          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:101
2849          int childIndex = caller.getIndexOfChild(child);
2850          return NameType.TYPE_NAME;
2851        }
2852        else if (caller == getSuperClassOptNoTransform()) {
2853          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:100
2854          return NameType.TYPE_NAME;
2855        }
2856        else {
2857          return super.Define_nameType(caller, child);
2858        }
2859      }
2860      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
2861        return true;
2862      }
2863      /**
2864       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:544
2865       * @apilevel internal
2866       */
2867      public TypeDecl Define_enclosingType(ASTNode caller, ASTNode child) {
2868        if (caller == getImplicitConstructorOptNoTransform()) {
2869          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:542
2870          return this;
2871        }
2872        else {
2873          return super.Define_enclosingType(caller, child);
2874        }
2875      }
2876      protected boolean canDefine_enclosingType(ASTNode caller, ASTNode child) {
2877        return true;
2878      }
2879      /**
2880       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:71
2881       * @apilevel internal
2882       */
2883      public TypeDecl Define_hostType(ASTNode caller, ASTNode child) {
2884        if (caller == getImplementsListNoTransform()) {
2885          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:631
2886          int childIndex = caller.getIndexOfChild(child);
2887          return hostType();
2888        }
2889        else if (caller == getSuperClassOptNoTransform()) {
2890          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:630
2891          return hostType();
2892        }
2893        else {
2894          return super.Define_hostType(caller, child);
2895        }
2896      }
2897      protected boolean canDefine_hostType(ASTNode caller, ASTNode child) {
2898        return true;
2899      }
2900      /**
2901       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:38
2902       * @apilevel internal
2903       */
2904      public boolean Define_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) {
2905        if (caller == getImplementsListNoTransform()) {
2906          // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:349
2907          int childIndex = caller.getIndexOfChild(child);
2908          return hasAnnotationSuppressWarnings(annot) || withinSuppressWarnings(annot);
2909        }
2910        else if (caller == getSuperClassOptNoTransform()) {
2911          // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:347
2912          return hasAnnotationSuppressWarnings(annot) || withinSuppressWarnings(annot);
2913        }
2914        else {
2915          return getParent().Define_withinSuppressWarnings(this, caller, annot);
2916        }
2917      }
2918      protected boolean canDefine_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) {
2919        return true;
2920      }
2921      /**
2922       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:449
2923       * @apilevel internal
2924       */
2925      public boolean Define_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) {
2926        if (caller == getImplementsListNoTransform()) {
2927          // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:454
2928          int childIndex = caller.getIndexOfChild(child);
2929          return isDeprecated() || withinDeprecatedAnnotation();
2930        }
2931        else if (caller == getSuperClassOptNoTransform()) {
2932          // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:453
2933          return isDeprecated() || withinDeprecatedAnnotation();
2934        }
2935        else {
2936          return getParent().Define_withinDeprecatedAnnotation(this, caller);
2937        }
2938      }
2939      protected boolean canDefine_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) {
2940        return true;
2941      }
2942      /**
2943       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:338
2944       * @apilevel internal
2945       */
2946      public boolean Define_inExtendsOrImplements(ASTNode caller, ASTNode child) {
2947        if (caller == getImplementsListNoTransform()) {
2948          // @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:336
2949          int i = caller.getIndexOfChild(child);
2950          return true;
2951        }
2952        else if (caller == getSuperClassOptNoTransform()) {
2953          // @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:335
2954          return true;
2955        }
2956        else {
2957          return getParent().Define_inExtendsOrImplements(this, caller);
2958        }
2959      }
2960      protected boolean canDefine_inExtendsOrImplements(ASTNode caller, ASTNode child) {
2961        return true;
2962      }
2963      /**
2964       * @apilevel internal
2965       */
2966      public ASTNode rewriteTo() {
2967        return super.rewriteTo();
2968      }
2969    }