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:92
027     * @production MethodDecl : {@link MemberDecl} ::= <span class="component">{@link Modifiers}</span> <span class="component">TypeAccess:{@link Access}</span> <span class="component">&lt;ID:String&gt;</span> <span class="component">Parameter:{@link ParameterDeclaration}*</span> <span class="component">Exception:{@link Access}*</span> <span class="component">[{@link Block}]</span>;
028    
029     */
030    public class MethodDecl extends MemberDecl implements Cloneable, SimpleSet, Iterator, ExceptionHolder {
031      /**
032       * @aspect BoundNames
033       * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:97
034       */
035      public Access createBoundAccess(List args) {
036        if (isStatic()) {
037          return hostType().createQualifiedAccess().qualifiesAccess(
038            new BoundMethodAccess(name(), args, this)
039          );
040        }
041        return new BoundMethodAccess(name(), args, this);
042      }
043      /**
044       * @aspect DataStructures
045       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:177
046       */
047      public SimpleSet add(Object o) {
048        return new SimpleSetImpl().add(this).add(o);
049      }
050      /**
051       * @aspect DataStructures
052       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:181
053       */
054      public boolean isSingleton() { return true; }
055      /**
056       * @aspect DataStructures
057       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:182
058       */
059      public boolean isSingleton(Object o) { return contains(o); }
060      /**
061       * @aspect DataStructures
062       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:185
063       */
064      private MethodDecl iterElem;
065      /**
066       * @aspect DataStructures
067       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:186
068       */
069      public Iterator iterator() { iterElem = this; return this; }
070      /**
071       * @aspect DataStructures
072       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:187
073       */
074      public boolean hasNext() { return iterElem != null; }
075      /**
076       * @aspect DataStructures
077       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:188
078       */
079      public Object next() { Object o = iterElem; iterElem = null; return o; }
080      /**
081       * @aspect DataStructures
082       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:189
083       */
084      public void remove() { throw new UnsupportedOperationException(); }
085      /**
086       * @aspect NameCheck
087       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:131
088       */
089      public void nameCheck() {
090        // 8.4
091        // 8.4.2
092        if (hostType().methodsSignature(signature()).size() > 1) {
093          errorf("method with signature %s is multiply declared in type %s", signature(),
094              hostType().typeName());
095        }
096        // 8.4.3.4
097        if (isNative() && hasBlock()) {
098          error("native methods must have an empty semicolon body");
099        }
100        // 8.4.5
101        if (isAbstract() && hasBlock()) {
102          error("abstract methods must have an empty semicolon body");
103        }
104        // 8.4.5
105        if (!hasBlock() && !(isNative() || isAbstract())) {
106          error("only abstract and native methods may have an empty semicolon body");
107        }
108      }
109      /**
110       * @aspect Java4PrettyPrint
111       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:66
112       */
113      public void prettyPrint(PrettyPrinter out) {
114        if (hasDocComment()) {
115          out.print(docComment());
116        }
117        if (!out.isNewLine()) {
118          out.println();
119        }
120        out.print(getModifiers());
121        out.print(getTypeAccess());
122        out.print(" ");
123        out.print(getID());
124        out.print("(");
125        out.join(getParameterList(), new PrettyPrinter.Joiner() {
126          @Override
127          public void printSeparator(PrettyPrinter out) {
128            out.print(", ");
129          }
130        });
131        out.print(")");
132        if (hasExceptions()) {
133          out.print(" throws ");
134          out.join(getExceptionList(), new PrettyPrinter.Joiner() {
135            @Override
136            public void printSeparator(PrettyPrinter out) {
137              out.print(", ");
138            }
139          });
140        }
141        if (hasBlock()) {
142          out.print(" ");
143          out.print(getBlock());
144        } else {
145          out.print(";");
146        }
147      }
148      /**
149       * @aspect TypeCheck
150       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:453
151       */
152      public void typeCheck() {
153        // Thrown vs super class method see MethodDecl.nameCheck
154        // 8.4.4
155        TypeDecl exceptionType = typeThrowable();
156        for (int i = 0; i < getNumException(); i++) {
157          TypeDecl typeDecl = getException(i).type();
158          if (!typeDecl.instanceOf(exceptionType)) {
159            errorf("%s throws non throwable type %s", signature(), typeDecl.fullName());
160          }
161        }
162    
163        // check returns
164        if (!isVoid() && hasBlock() && getBlock().canCompleteNormally()) {
165          error("the body of a non void method may not complete normally");
166        }
167    
168      }
169      /**
170       * @aspect CodeGeneration
171       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:504
172       */
173      public void emitInvokeMethod(CodeGeneration gen, TypeDecl hostType) {
174        if (hostType.isInterfaceDecl()) {
175          String classname = hostType.constantPoolName();
176          String      desc = descName();
177          String      name = name();
178          int index = gen.constantPool().addInterfaceMethodref(classname, name, desc);
179          int numArg = 1; // instance
180          for (int i = 0; i < getNumParameter(); i++) {
181            numArg += getParameter(i).type().variableSize();
182          }
183          int stackChange = type().variableSize() - numArg;
184          gen.emit(Bytecode.INVOKEINTERFACE, stackChange)
185                .add2(index).add(numArg).add(0);
186        } else {
187          String classname = hostType.constantPoolName();
188          String      desc = descName();
189          String      name = name();
190          int index = gen.constantPool().addMethodref(classname, name, desc);
191          int stackChange = type().variableSize();
192          for (int i = 0; i < getNumParameter(); i++) {
193              stackChange -= getParameter(i).type().variableSize();
194          }
195          if (isStatic()) {
196            gen.emit(Bytecode.INVOKESTATIC, stackChange).add2(index);
197          } else {
198            stackChange -= 1;
199            gen.emit(Bytecode.INVOKEVIRTUAL, stackChange).add2(index);
200          }
201        }
202      }
203      /**
204       * @aspect CodeGeneration
205       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:535
206       */
207      public void emitInvokeSpecialMethod(CodeGeneration gen, TypeDecl hostType) {
208        String classname = hostType.constantPoolName();
209        String      desc = descName();
210        String      name = name();
211        int index = gen.constantPool().addMethodref(classname, name, desc);
212        int stackChange = type().variableSize() - 1;
213        for (int i = 0; i < getNumParameter(); i++) {
214          stackChange -= getParameter(i).type().variableSize();
215        }
216        gen.emit(Bytecode.INVOKESPECIAL, stackChange).add2(index);
217      }
218      /**
219       * @aspect CreateBCode
220       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:106
221       */
222      private void generateBytecodes(CodeGeneration gen) {
223        int label = gen.variableScopeLabel();
224        int paramLength = 0;
225        if (!isStatic()) {
226          paramLength += 1;
227          gen.addLocalVariableEntryAtCurrentPC("this", hostType().typeDescriptor(), 0, label);
228        }
229        for (ParameterDeclaration p: getParameterList()) {
230          paramLength += p.type().variableSize();
231          if (paramLength > 255) {
232            throw new Error("parameter list too large");
233          }
234          gen.addLocalVariableEntryAtCurrentPC(
235            p.name(), p.type().typeDescriptor(), p.localNum(), label
236          );
237        }
238        createBCode(gen);
239        if (type() instanceof VoidType) // TODO: canCompleteNormally check as well
240          gen.emitReturn();
241        gen.addVariableScopeLabel(label);
242      }
243      /**
244       * @aspect CreateBCode
245       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:160
246       */
247      public void createBCode(CodeGeneration gen) {
248        try {
249          if (hasBlock()) {
250            gen.maxLocals = Math.max(gen.maxLocals, getBlock().localNum());
251            getBlock().createBCode(gen);
252          }
253        } catch (Error e) {
254          System.err.println(hostType().typeName() + ": " + this);
255          throw e;
256        }
257      }
258      /**
259       * @aspect GenerateClassfile
260       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:283
261       */
262      public void generateMethod(DataOutputStream out, ConstantPool cp) throws IOException {
263        out.writeChar(flags());
264        out.writeChar(cp.addUtf8(name()));
265        out.writeChar(cp.addUtf8(descName()));
266        out.writeChar(attributes().size());
267        for (Iterator itera = attributes().iterator(); itera.hasNext();) {
268          ((Attribute) itera.next()).emit(out);
269        }
270      }
271      /**
272       * @aspect GenerateClassfile
273       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:305
274       */
275      public void touchMethod(ConstantPool cp) {
276        cp.addUtf8(name());
277        cp.addUtf8(descName());
278        attributes();
279      }
280      /**
281       * @aspect GenerateClassfile
282       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:420
283       */
284      public boolean clear() {
285        if (hasBlock()) {
286          getBlock().clear();
287          setBlock(new Block(new List()));
288        }
289        bytecodes_ConstantPool_values = null;
290        return false;
291      }
292      /**
293       * @aspect InnerClasses
294       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:240
295       */
296      public MethodDecl createAccessor(TypeDecl methodQualifier) {
297        MethodDecl m = (MethodDecl) methodQualifier.getAccessor(this, "method");
298        if (m != null) {
299          return m;
300        }
301    
302        int accessorIndex = methodQualifier.accessorCounter++;
303    
304        List parameterList = new List();
305        for (int i = 0; i < getNumParameter(); i++) {
306          parameterList.add(new ParameterDeclaration(
307                // We don't need to create a qualified access to the type here
308                // since there can be no ambiguity concerning unqualified
309                // type names in an inner/enclosing class
310                // Jesper 2012-05-04
311                // FALSE! We need to create a qualified access in case the
312                // method we are generating an access for is not declared
313                // in the methodQualifier type
314                getParameter(i).type().createQualifiedAccess(),
315                getParameter(i).name()));
316        }
317        List exceptionList = new List();
318        for (int i = 0; i < getNumException(); i++) {
319          exceptionList.add((Access) getException(i).treeCopyNoTransform());
320        }
321    
322        // add synthetic flag to modifiers
323        Modifiers modifiers = new Modifiers(new List());
324        if (getModifiers().isStatic()) {
325          modifiers.addModifier(new Modifier("static"));
326        }
327        modifiers.addModifier(new Modifier("synthetic"));
328        modifiers.addModifier(new Modifier("public"));
329        // build accessor declaration
330        m = new MethodDecl(
331          modifiers,
332          getTypeAccess().type().createQualifiedAccess(),
333          name() + "$access$" + accessorIndex,
334          parameterList,
335          exceptionList,
336          new Opt(
337            new Block(
338              new List().add(
339                createAccessorStmt()
340              )
341            )
342          )
343        );
344        m = methodQualifier.addMemberMethod(m);
345        methodQualifier.addAccessor(this, "method", m);
346        return m;
347      }
348      /**
349       * @aspect InnerClasses
350       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:293
351       */
352      private Stmt createAccessorStmt() {
353        List argumentList = new List();
354        for (int i = 0; i < getNumParameter(); i++) {
355          argumentList.add(new VarAccess(getParameter(i).name()));
356        }
357        Access access = new BoundMethodAccess(name(), argumentList, this);
358        if (!isStatic()) {
359          access = new ThisAccess("this").qualifiesAccess(access);
360        }
361        return isVoid() ? (Stmt) new ExprStmt(access) : new ReturnStmt(new Opt(access));
362      }
363      /**
364       * @aspect InnerClasses
365       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:305
366       */
367      public MethodDecl createSuperAccessor(TypeDecl methodQualifier) {
368        MethodDecl m = (MethodDecl) methodQualifier.getAccessor(this, "method_super");
369        if (m != null) {
370          return m;
371        }
372    
373        int accessorIndex = methodQualifier.accessorCounter++;
374        List parameters = new List();
375        List args = new List();
376        for (int i = 0; i < getNumParameter(); i++) {
377          parameters.add(new ParameterDeclaration(getParameter(i).type(), getParameter(i).name()));
378          args.add(new VarAccess(getParameter(i).name()));
379        }
380        Stmt stmt;
381        if (type().isVoid()) {
382          stmt = new ExprStmt(new SuperAccess("super").qualifiesAccess(new MethodAccess(name(), args)));
383        } else {
384          stmt = new ReturnStmt(new Opt(new SuperAccess("super").qualifiesAccess(new MethodAccess(name(), args))));
385        }
386        m = new MethodDecl(
387          new Modifiers(new List().add(new Modifier("synthetic"))),
388          type().createQualifiedAccess(),
389          name() + "$access$" + accessorIndex,
390          parameters,
391          new List(),
392          new Opt(
393            new Block(
394              new List().add(stmt)
395            )
396          )
397        );
398        m = methodQualifier.addMemberMethod(m);
399        methodQualifier.addAccessor(this, "method_super", m);
400        return m;
401      }
402      /**
403       * @aspect LookupParTypeDecl
404       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1365
405       */
406      public BodyDecl substitutedBodyDecl(Parameterization parTypeDecl) {
407        MethodDecl m = new MethodDeclSubstituted(
408          (Modifiers) getModifiers().treeCopyNoTransform(),
409          getTypeAccess().type().substituteReturnType(parTypeDecl),
410          getID(),
411          getParameterList().substitute(parTypeDecl),
412          getExceptionList().substitute(parTypeDecl),
413          substituteBody(parTypeDecl),
414          this
415        );
416        return m;
417      }
418      /**
419       * @aspect LookupParTypeDecl
420       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1378
421       */
422      public Opt substituteBody(Parameterization parTypeDecl) {
423        return new Opt();
424      }
425      /**
426       * @aspect AnnotationsCodegen
427       * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:110
428       */
429      public void addRuntimeVisibleParameterAnnotationsAttribute(Collection c) {
430        boolean foundVisibleAnnotations = false;
431        Collection annotations = new ArrayList(getNumParameter());
432        for (int i = 0; i < getNumParameter(); i++) {
433          Collection a = getParameter(i).getModifiers().runtimeVisibleAnnotations();
434          if (!a.isEmpty()) {
435            foundVisibleAnnotations = true;
436          }
437          annotations.add(a);
438        }
439        if (foundVisibleAnnotations) {
440          c.add(new ParameterAnnotationsAttribute(hostType().constantPool(), annotations, "RuntimeVisibleParameterAnnotations"));
441        }
442      }
443      /**
444       * @aspect AnnotationsCodegen
445       * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:136
446       */
447      public void addRuntimeInvisibleParameterAnnotationsAttribute(Collection c) {
448        boolean foundInvisibleAnnotations = false;
449        Collection annotations = new ArrayList(getNumParameter());
450        for (int i = 0; i < getNumParameter(); i++) {
451          Collection a = getParameter(i).getModifiers().runtimeInvisibleAnnotations();
452          if (!a.isEmpty()) {
453            foundInvisibleAnnotations = true;
454          }
455          annotations.add(a);
456        }
457        if (foundInvisibleAnnotations) {
458          c.add(new ParameterAnnotationsAttribute(hostType().constantPool(), annotations, "RuntimeInvisibleParameterAnnotations"));
459        }
460      }
461      /**
462       * @aspect GenericsCodegen
463       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:238
464       */
465      public void transformation() {
466        super.transformation();
467        HashSet processed = new HashSet();
468        for (Iterator iter = hostType().bridgeCandidates(signature()).iterator(); iter.hasNext(); ) {
469          MethodDecl m = (MethodDecl) iter.next();
470          if (this.overrides(m)) {
471            MethodDecl erased = m.erasedMethod();
472            if (!erased.signature().equals(signature()) || erased.type().erasure() != type().erasure()) {
473              StringBuilder keyBuffer = new StringBuilder();
474              for (int i = 0; i < getNumParameter(); i++) {
475                keyBuffer.append(erased.getParameter(i).type().erasure().fullName());
476              }
477              keyBuffer.append(erased.type().erasure().fullName());
478              String key = keyBuffer.toString();
479              if (!processed.contains(key)) {
480                processed.add(key);
481    
482                List args = new List();
483                List parameters = new List();
484                for (int i = 0; i < getNumParameter(); i++) {
485                  args.add(new CastExpr(getParameter(i).type().erasure().createBoundAccess(), new VarAccess("p" + i)));
486                  parameters.add(new ParameterDeclaration(erased.getParameter(i).type().erasure(), "p" + i));
487                }
488                Stmt stmt;
489                if (type().isVoid()) {
490                  stmt = new ExprStmt(
491                      createBoundAccess(
492                        args
493                        )
494                      );
495                } else {
496                  stmt = new ReturnStmt(
497                      createBoundAccess(
498                        args
499                        )
500                      );
501                }
502                List modifiersList = new List();
503                if (isPublic()) {
504                  modifiersList.add(new Modifier("public"));
505                } else if (isProtected()) {
506                  modifiersList.add(new Modifier("protected"));
507                } else if (isPrivate()) {
508                  modifiersList.add(new Modifier("private"));
509                }
510                MethodDecl bridge = new BridgeMethodDecl(
511                    new Modifiers(modifiersList),
512                    erased.type().erasure().createBoundAccess(),
513                    erased.name(),
514                    parameters,
515                    (List) getExceptionList().treeCopyNoTransform(),
516                    new Opt(
517                      new Block(
518                        new List().add(stmt)
519                        )
520                      )
521                    );
522                hostType().addBodyDecl(bridge);
523              }
524            }
525          }
526        }
527      }
528      /**
529       * Check if the method is missing a SafeVarargs annotation.
530       * @aspect SafeVarargs
531       * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:117
532       */
533      public void checkWarnings() {
534        // Check for illegal use of @SafeVarargs.
535        super.checkWarnings();
536    
537        if (!suppressWarnings("unchecked")
538            && !hasAnnotationSafeVarargs()
539            && isVariableArity()
540            && !getParameter(getNumParameter()-1).type().isReifiable()) {
541          warning("possible heap pollution for "
542              + "variable arity parameter");
543        }
544      }
545      /**
546       * Checks that the argument exception is a subtype to all exceptions
547       * in the methods throws-clause. This takes the position of the type
548       * parameters into account.
549       * @aspect FunctionDescriptor
550       * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionDescriptor.jrag:209
551       */
552      public boolean subtypeThrowsClause(Access exception) {
553        boolean foundCompatible = false;
554        for (Access throwsException : getExceptionList()) {
555          if (exception.type().strictSubtype(throwsException.type())) {
556            foundCompatible = true;
557            break;
558          }
559        }
560        return foundCompatible;
561      }
562      /**
563       * Checks that the argument exception is a subtype to all exceptions
564       * in the methods throws-clause. Performs erasure on all types before
565       * comparing them.
566       * @aspect FunctionDescriptor
567       * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionDescriptor.jrag:225
568       */
569      public boolean subtypeThrowsClauseErased(Access exception) {
570        boolean foundCompatible = false;
571        for (Access throwsException : getExceptionList()) {
572          if (exception.type().erasure().strictSubtype(throwsException.type().erasure())) {
573            foundCompatible = true;
574            break;
575          }
576        }
577        return foundCompatible;
578      }
579      /**
580       * @declaredat ASTNode:1
581       */
582      public MethodDecl() {
583        super();
584      }
585      /**
586       * Initializes the child array to the correct size.
587       * Initializes List and Opt nta children.
588       * @apilevel internal
589       * @ast method
590       * @declaredat ASTNode:10
591       */
592      public void init$Children() {
593        children = new ASTNode[5];
594        setChild(new List(), 2);
595        setChild(new List(), 3);
596        setChild(new Opt(), 4);
597      }
598      /**
599       * @declaredat ASTNode:16
600       */
601      public MethodDecl(Modifiers p0, Access p1, String p2, List<ParameterDeclaration> p3, List<Access> p4, Opt<Block> p5) {
602        setChild(p0, 0);
603        setChild(p1, 1);
604        setID(p2);
605        setChild(p3, 2);
606        setChild(p4, 3);
607        setChild(p5, 4);
608      }
609      /**
610       * @declaredat ASTNode:24
611       */
612      public MethodDecl(Modifiers p0, Access p1, beaver.Symbol p2, List<ParameterDeclaration> p3, List<Access> p4, Opt<Block> p5) {
613        setChild(p0, 0);
614        setChild(p1, 1);
615        setID(p2);
616        setChild(p3, 2);
617        setChild(p4, 3);
618        setChild(p5, 4);
619      }
620      /**
621       * @apilevel low-level
622       * @declaredat ASTNode:35
623       */
624      protected int numChildren() {
625        return 5;
626      }
627      /**
628       * @apilevel internal
629       * @declaredat ASTNode:41
630       */
631      public boolean mayHaveRewrite() {
632        return false;
633      }
634      /**
635       * @apilevel internal
636       * @declaredat ASTNode:47
637       */
638      public void flushAttrCache() {
639        super.flushAttrCache();
640        accessibleFrom_TypeDecl_reset();
641        throwsException_TypeDecl_reset();
642        signature_reset();
643        lessSpecificThan_MethodDecl_reset();
644        overrideCandidate_MethodDecl_reset();
645        overrides_MethodDecl_reset();
646        hides_MethodDecl_reset();
647        parameterDeclaration_String_reset();
648        type_reset();
649        attributes_reset();
650        descName_reset();
651        bytecodes_ConstantPool_reset();
652        flags_reset();
653        offsetBeforeParameters_reset();
654        offsetAfterParameters_reset();
655        resultOffset_reset();
656        usesTypeVariable_reset();
657        sourceMethodDecl_reset();
658        subsignatureTo_MethodDecl_reset();
659        returnTypeSubstitutableFor_MethodDecl_reset();
660        isDefault_reset();
661        handlesException_TypeDecl_reset();
662      }
663      /**
664       * @apilevel internal
665       * @declaredat ASTNode:75
666       */
667      public void flushCollectionCache() {
668        super.flushCollectionCache();
669      }
670      /**
671       * @apilevel internal
672       * @declaredat ASTNode:81
673       */
674      public void flushRewriteCache() {
675        super.flushRewriteCache();
676      }
677      /**
678       * @apilevel internal
679       * @declaredat ASTNode:87
680       */
681      public MethodDecl clone() throws CloneNotSupportedException {
682        MethodDecl node = (MethodDecl) super.clone();
683        return node;
684      }
685      /**
686       * @apilevel internal
687       * @declaredat ASTNode:94
688       */
689      public MethodDecl copy() {
690        try {
691          MethodDecl node = (MethodDecl) clone();
692          node.parent = null;
693          if (children != null) {
694            node.children = (ASTNode[]) children.clone();
695          }
696          return node;
697        } catch (CloneNotSupportedException e) {
698          throw new Error("Error: clone not supported for " + getClass().getName());
699        }
700      }
701      /**
702       * Create a deep copy of the AST subtree at this node.
703       * The copy is dangling, i.e. has no parent.
704       * @return dangling copy of the subtree at this node
705       * @apilevel low-level
706       * @deprecated Please use treeCopy or treeCopyNoTransform instead
707       * @declaredat ASTNode:113
708       */
709      @Deprecated
710      public MethodDecl fullCopy() {
711        return treeCopyNoTransform();
712      }
713      /**
714       * Create a deep copy of the AST subtree at this node.
715       * The copy is dangling, i.e. has no parent.
716       * @return dangling copy of the subtree at this node
717       * @apilevel low-level
718       * @declaredat ASTNode:123
719       */
720      public MethodDecl treeCopyNoTransform() {
721        MethodDecl tree = (MethodDecl) copy();
722        if (children != null) {
723          for (int i = 0; i < children.length; ++i) {
724            ASTNode child = (ASTNode) children[i];
725            if (child != null) {
726              child = child.treeCopyNoTransform();
727              tree.setChild(child, i);
728            }
729          }
730        }
731        return tree;
732      }
733      /**
734       * Create a deep copy of the AST subtree at this node.
735       * The subtree of this node is traversed to trigger rewrites before copy.
736       * The copy is dangling, i.e. has no parent.
737       * @return dangling copy of the subtree at this node
738       * @apilevel low-level
739       * @declaredat ASTNode:143
740       */
741      public MethodDecl treeCopy() {
742        doFullTraversal();
743        return treeCopyNoTransform();
744      }
745      /**
746       * @apilevel internal
747       * @declaredat ASTNode:150
748       */
749      protected boolean is$Equal(ASTNode node) {
750        return super.is$Equal(node) && (tokenString_ID == ((MethodDecl)node).tokenString_ID);    
751      }
752      /**
753       * Replaces the Modifiers child.
754       * @param node The new node to replace the Modifiers child.
755       * @apilevel high-level
756       */
757      public void setModifiers(Modifiers node) {
758        setChild(node, 0);
759      }
760      /**
761       * Retrieves the Modifiers child.
762       * @return The current node used as the Modifiers child.
763       * @apilevel high-level
764       */
765      @ASTNodeAnnotation.Child(name="Modifiers")
766      public Modifiers getModifiers() {
767        return (Modifiers) getChild(0);
768      }
769      /**
770       * Retrieves the Modifiers child.
771       * <p><em>This method does not invoke AST transformations.</em></p>
772       * @return The current node used as the Modifiers child.
773       * @apilevel low-level
774       */
775      public Modifiers getModifiersNoTransform() {
776        return (Modifiers) getChildNoTransform(0);
777      }
778      /**
779       * Replaces the TypeAccess child.
780       * @param node The new node to replace the TypeAccess child.
781       * @apilevel high-level
782       */
783      public void setTypeAccess(Access node) {
784        setChild(node, 1);
785      }
786      /**
787       * Retrieves the TypeAccess child.
788       * @return The current node used as the TypeAccess child.
789       * @apilevel high-level
790       */
791      @ASTNodeAnnotation.Child(name="TypeAccess")
792      public Access getTypeAccess() {
793        return (Access) getChild(1);
794      }
795      /**
796       * Retrieves the TypeAccess child.
797       * <p><em>This method does not invoke AST transformations.</em></p>
798       * @return The current node used as the TypeAccess child.
799       * @apilevel low-level
800       */
801      public Access getTypeAccessNoTransform() {
802        return (Access) getChildNoTransform(1);
803      }
804      /**
805       * Replaces the lexeme ID.
806       * @param value The new value for the lexeme ID.
807       * @apilevel high-level
808       */
809      public void setID(String value) {
810        tokenString_ID = value;
811      }
812      /**
813       * @apilevel internal
814       */
815      protected String tokenString_ID;
816      /**
817       */
818      public int IDstart;
819      /**
820       */
821      public int IDend;
822      /**
823       * JastAdd-internal setter for lexeme ID using the Beaver parser.
824       * @param symbol Symbol containing the new value for the lexeme ID
825       * @apilevel internal
826       */
827      public void setID(beaver.Symbol symbol) {
828        if (symbol.value != null && !(symbol.value instanceof String))
829        throw new UnsupportedOperationException("setID is only valid for String lexemes");
830        tokenString_ID = (String)symbol.value;
831        IDstart = symbol.getStart();
832        IDend = symbol.getEnd();
833      }
834      /**
835       * Retrieves the value for the lexeme ID.
836       * @return The value for the lexeme ID.
837       * @apilevel high-level
838       */
839      @ASTNodeAnnotation.Token(name="ID")
840      public String getID() {
841        return tokenString_ID != null ? tokenString_ID : "";
842      }
843      /**
844       * Replaces the Parameter list.
845       * @param list The new list node to be used as the Parameter list.
846       * @apilevel high-level
847       */
848      public void setParameterList(List<ParameterDeclaration> list) {
849        setChild(list, 2);
850      }
851      /**
852       * Retrieves the number of children in the Parameter list.
853       * @return Number of children in the Parameter list.
854       * @apilevel high-level
855       */
856      public int getNumParameter() {
857        return getParameterList().getNumChild();
858      }
859      /**
860       * Retrieves the number of children in the Parameter list.
861       * Calling this method will not trigger rewrites.
862       * @return Number of children in the Parameter list.
863       * @apilevel low-level
864       */
865      public int getNumParameterNoTransform() {
866        return getParameterListNoTransform().getNumChildNoTransform();
867      }
868      /**
869       * Retrieves the element at index {@code i} in the Parameter list.
870       * @param i Index of the element to return.
871       * @return The element at position {@code i} in the Parameter list.
872       * @apilevel high-level
873       */
874      public ParameterDeclaration getParameter(int i) {
875        return (ParameterDeclaration) getParameterList().getChild(i);
876      }
877      /**
878       * Check whether the Parameter list has any children.
879       * @return {@code true} if it has at least one child, {@code false} otherwise.
880       * @apilevel high-level
881       */
882      public boolean hasParameter() {
883        return getParameterList().getNumChild() != 0;
884      }
885      /**
886       * Append an element to the Parameter list.
887       * @param node The element to append to the Parameter list.
888       * @apilevel high-level
889       */
890      public void addParameter(ParameterDeclaration node) {
891        List<ParameterDeclaration> list = (parent == null) ? getParameterListNoTransform() : getParameterList();
892        list.addChild(node);
893      }
894      /**
895       * @apilevel low-level
896       */
897      public void addParameterNoTransform(ParameterDeclaration node) {
898        List<ParameterDeclaration> list = getParameterListNoTransform();
899        list.addChild(node);
900      }
901      /**
902       * Replaces the Parameter list element at index {@code i} with the new node {@code node}.
903       * @param node The new node to replace the old list element.
904       * @param i The list index of the node to be replaced.
905       * @apilevel high-level
906       */
907      public void setParameter(ParameterDeclaration node, int i) {
908        List<ParameterDeclaration> list = getParameterList();
909        list.setChild(node, i);
910      }
911      /**
912       * Retrieves the Parameter list.
913       * @return The node representing the Parameter list.
914       * @apilevel high-level
915       */
916      @ASTNodeAnnotation.ListChild(name="Parameter")
917      public List<ParameterDeclaration> getParameterList() {
918        List<ParameterDeclaration> list = (List<ParameterDeclaration>) getChild(2);
919        return list;
920      }
921      /**
922       * Retrieves the Parameter list.
923       * <p><em>This method does not invoke AST transformations.</em></p>
924       * @return The node representing the Parameter list.
925       * @apilevel low-level
926       */
927      public List<ParameterDeclaration> getParameterListNoTransform() {
928        return (List<ParameterDeclaration>) getChildNoTransform(2);
929      }
930      /**
931       * Retrieves the Parameter list.
932       * @return The node representing the Parameter list.
933       * @apilevel high-level
934       */
935      public List<ParameterDeclaration> getParameters() {
936        return getParameterList();
937      }
938      /**
939       * Retrieves the Parameter list.
940       * <p><em>This method does not invoke AST transformations.</em></p>
941       * @return The node representing the Parameter list.
942       * @apilevel low-level
943       */
944      public List<ParameterDeclaration> getParametersNoTransform() {
945        return getParameterListNoTransform();
946      }
947      /**
948       * Replaces the Exception list.
949       * @param list The new list node to be used as the Exception list.
950       * @apilevel high-level
951       */
952      public void setExceptionList(List<Access> list) {
953        setChild(list, 3);
954      }
955      /**
956       * Retrieves the number of children in the Exception list.
957       * @return Number of children in the Exception list.
958       * @apilevel high-level
959       */
960      public int getNumException() {
961        return getExceptionList().getNumChild();
962      }
963      /**
964       * Retrieves the number of children in the Exception list.
965       * Calling this method will not trigger rewrites.
966       * @return Number of children in the Exception list.
967       * @apilevel low-level
968       */
969      public int getNumExceptionNoTransform() {
970        return getExceptionListNoTransform().getNumChildNoTransform();
971      }
972      /**
973       * Retrieves the element at index {@code i} in the Exception list.
974       * @param i Index of the element to return.
975       * @return The element at position {@code i} in the Exception list.
976       * @apilevel high-level
977       */
978      public Access getException(int i) {
979        return (Access) getExceptionList().getChild(i);
980      }
981      /**
982       * Check whether the Exception list has any children.
983       * @return {@code true} if it has at least one child, {@code false} otherwise.
984       * @apilevel high-level
985       */
986      public boolean hasException() {
987        return getExceptionList().getNumChild() != 0;
988      }
989      /**
990       * Append an element to the Exception list.
991       * @param node The element to append to the Exception list.
992       * @apilevel high-level
993       */
994      public void addException(Access node) {
995        List<Access> list = (parent == null) ? getExceptionListNoTransform() : getExceptionList();
996        list.addChild(node);
997      }
998      /**
999       * @apilevel low-level
1000       */
1001      public void addExceptionNoTransform(Access node) {
1002        List<Access> list = getExceptionListNoTransform();
1003        list.addChild(node);
1004      }
1005      /**
1006       * Replaces the Exception list element at index {@code i} with the new node {@code node}.
1007       * @param node The new node to replace the old list element.
1008       * @param i The list index of the node to be replaced.
1009       * @apilevel high-level
1010       */
1011      public void setException(Access node, int i) {
1012        List<Access> list = getExceptionList();
1013        list.setChild(node, i);
1014      }
1015      /**
1016       * Retrieves the Exception list.
1017       * @return The node representing the Exception list.
1018       * @apilevel high-level
1019       */
1020      @ASTNodeAnnotation.ListChild(name="Exception")
1021      public List<Access> getExceptionList() {
1022        List<Access> list = (List<Access>) getChild(3);
1023        return list;
1024      }
1025      /**
1026       * Retrieves the Exception list.
1027       * <p><em>This method does not invoke AST transformations.</em></p>
1028       * @return The node representing the Exception list.
1029       * @apilevel low-level
1030       */
1031      public List<Access> getExceptionListNoTransform() {
1032        return (List<Access>) getChildNoTransform(3);
1033      }
1034      /**
1035       * Retrieves the Exception list.
1036       * @return The node representing the Exception list.
1037       * @apilevel high-level
1038       */
1039      public List<Access> getExceptions() {
1040        return getExceptionList();
1041      }
1042      /**
1043       * Retrieves the Exception list.
1044       * <p><em>This method does not invoke AST transformations.</em></p>
1045       * @return The node representing the Exception list.
1046       * @apilevel low-level
1047       */
1048      public List<Access> getExceptionsNoTransform() {
1049        return getExceptionListNoTransform();
1050      }
1051      /**
1052       * Replaces the optional node for the Block child. This is the <code>Opt</code>
1053       * node containing the child Block, not the actual child!
1054       * @param opt The new node to be used as the optional node for the Block child.
1055       * @apilevel low-level
1056       */
1057      public void setBlockOpt(Opt<Block> opt) {
1058        setChild(opt, 4);
1059      }
1060      /**
1061       * Replaces the (optional) Block child.
1062       * @param node The new node to be used as the Block child.
1063       * @apilevel high-level
1064       */
1065      public void setBlock(Block node) {
1066        getBlockOpt().setChild(node, 0);
1067      }
1068      /**
1069       * Check whether the optional Block child exists.
1070       * @return {@code true} if the optional Block child exists, {@code false} if it does not.
1071       * @apilevel high-level
1072       */
1073      public boolean hasBlock() {
1074        return getBlockOpt().getNumChild() != 0;
1075      }
1076      /**
1077       * Retrieves the (optional) Block child.
1078       * @return The Block child, if it exists. Returns {@code null} otherwise.
1079       * @apilevel low-level
1080       */
1081      public Block getBlock() {
1082        return (Block) getBlockOpt().getChild(0);
1083      }
1084      /**
1085       * Retrieves the optional node for the Block child. This is the <code>Opt</code> node containing the child Block, not the actual child!
1086       * @return The optional node for child the Block child.
1087       * @apilevel low-level
1088       */
1089      @ASTNodeAnnotation.OptChild(name="Block")
1090      public Opt<Block> getBlockOpt() {
1091        return (Opt<Block>) getChild(4);
1092      }
1093      /**
1094       * Retrieves the optional node for child Block. This is the <code>Opt</code> node containing the child Block, not the actual child!
1095       * <p><em>This method does not invoke AST transformations.</em></p>
1096       * @return The optional node for child Block.
1097       * @apilevel low-level
1098       */
1099      public Opt<Block> getBlockOptNoTransform() {
1100        return (Opt<Block>) getChildNoTransform(4);
1101      }
1102      /**
1103       * @aspect Enums
1104       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:768
1105       */
1106       
1107      public void refined_Enums_MethodDecl_checkModifiers() {
1108        super.checkModifiers();
1109        if (hostType().isClassDecl()) {
1110          // 8.4.3.1
1111          if (!hostType().isEnumDecl() && isAbstract() && !hostType().isAbstract()) {
1112            error("class must be abstract to include abstract methods");
1113          }
1114          // 8.4.3.1
1115          if (isAbstract() && isPrivate()) {
1116            error("method may not be abstract and private");
1117          }
1118          // 8.4.3.1
1119          // 8.4.3.2
1120          if (isAbstract() && isStatic()) {
1121            error("method may not be abstract and static");
1122          }
1123          if (isAbstract() && isSynchronized()) {
1124            error("method may not be abstract and synchronized");
1125          }
1126          // 8.4.3.4
1127          if (isAbstract() && isNative()) {
1128            error("method may not be abstract and native");
1129          }
1130          if (isAbstract() && isStrictfp()) {
1131            error("method may not be abstract and strictfp");
1132          }
1133          if (isNative() && isStrictfp()) {
1134            error("method may not be native and strictfp");
1135          }
1136        }
1137        if (hostType().isInterfaceDecl()) {
1138          // 9.4
1139          if (isStatic()) {
1140            errorf("interface method %s in %s may not be static", signature(), hostType().typeName());
1141          }
1142          if (isStrictfp()) {
1143            errorf("interface method %s in %s may not be strictfp", signature(), hostType().typeName());
1144          }
1145          if (isNative()) {
1146            errorf("interface method %s in %s may not be native", signature(), hostType().typeName());
1147          }
1148          if (isSynchronized()) {
1149            errorf("interface method %s in %s may not be synchronized", signature(),
1150                hostType().typeName());
1151          }
1152          if (isProtected()) {
1153            errorf("interface method %s in %s may not be protected", signature(),
1154                hostType().typeName());
1155          }
1156          if (isPrivate()) {
1157            errorf("interface method %s in %s may not be private", signature(), hostType().typeName());
1158          } else if (isFinal()) {
1159            errorf("interface method %s in %s may not be final", signature(), hostType().typeName());
1160          }
1161        }
1162      }
1163      /**
1164       * @aspect Modifiers
1165       * @declaredat /home/jesper/git/extendj/java8/frontend/Modifiers.jrag:40
1166       */
1167       
1168      public void checkModifiers() {
1169        super.checkModifiers();
1170        if (hostType().isClassDecl()) {
1171          // 8.4.3.1
1172          if (!hostType().isEnumDecl() && isAbstract() && !hostType().isAbstract()) {
1173            error("class must be abstract to include abstract methods");
1174          }
1175          // 8.4.3.1
1176          if (isAbstract() && isPrivate()) {
1177            error("method may not be abstract and private");
1178          }
1179          // 8.4.3.1
1180          // 8.4.3.2
1181          if (isAbstract() && isStatic()) {
1182            error("method may not be abstract and static");
1183          }
1184          if (isAbstract() && isSynchronized()) {
1185            error("method may not be abstract and synchronized");
1186          }
1187          // 8.4.3.4
1188          if (isAbstract() && isNative()) {
1189            error("method may not be abstract and native");
1190          }
1191          if (isAbstract() && isStrictfp()) {
1192            error("method may not be abstract and strictfp");
1193          }
1194          if (isNative() && isStrictfp()) {
1195            error("method may not be native and strictfp");
1196          }
1197          if (isDefault()) {
1198            error("non-interface methods may not use the default modifier");
1199          }
1200        }
1201        if (hostType().isInterfaceDecl()) {
1202          // 9.4
1203          if (isAbstract()) {
1204            if (isStatic()) {
1205              errorf("interface method %s in %s can not be both abstract and static",
1206                  signature(), hostType().typeName());
1207            }
1208            if (isDefault()) {
1209              errorf("interface method %s in %s can not be both abstract and default",
1210                  signature(), hostType().typeName());
1211            }
1212            if (isStrictfp()) {
1213              errorf("interface method %s in %s can not be both abstract and strictfp",
1214                  signature(), hostType().typeName());
1215            }
1216          }
1217          if (isStatic() && isDefault()) {
1218            errorf("interface method %s in %s can not be both static and default",
1219                signature(), hostType().typeName());
1220          }
1221          if (isNative()) {
1222            errorf("interface method %s in %s may not be native", signature(), hostType().typeName());
1223          }
1224          if (isSynchronized()) {
1225            errorf("interface method %s in %s may not be synchronized",
1226                signature(), hostType().typeName());
1227          }
1228          if (isProtected()) {
1229            errorf("interface method %s in %s may not be protected",
1230                signature(), hostType().typeName());
1231          }
1232          if (isPrivate()) {
1233            errorf("interface method %s in %s may not be private", signature(), hostType().typeName());
1234          } else if (isFinal()) {
1235            errorf("interface method %s in %s may not be final", signature(), hostType().typeName());
1236          }
1237        }
1238      }
1239      /**
1240       * @aspect MethodDecl
1241       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:217
1242       */
1243      private boolean refined_MethodDecl_MethodDecl_sameSignature_MethodDecl(MethodDecl other)
1244    { return signature().equals(other.signature()); }
1245      /**
1246       * @aspect Attributes
1247       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:221
1248       */
1249      private Collection refined_Attributes_MethodDecl_attributes()
1250    {
1251        ArrayList l = new ArrayList();
1252        CodeGeneration bytecodes = bytecodes(hostType().constantPool());
1253        l.add(new ExceptionsAttribute(bytecodes, this));
1254        if (isAbstract() || isNative()) {
1255          return l;
1256        } else {
1257          l.add(new CodeAttribute(bytecodes, this));
1258          if (getModifiers().isSynthetic()) {
1259            l.add(new SyntheticAttribute(hostType().constantPool()));
1260          }
1261          return l;
1262        }
1263      }
1264      /**
1265       * @aspect Flags
1266       * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:62
1267       */
1268      private int refined_Flags_MethodDecl_flags()
1269    {
1270        int res = 0;
1271        if (isPublic()) {
1272          res |= Modifiers.ACC_PUBLIC;
1273        }
1274        if (isPrivate()) {
1275          res |= Modifiers.ACC_PRIVATE;
1276        }
1277        if (isProtected()) {
1278          res |= Modifiers.ACC_PROTECTED;
1279        }
1280        if (isStatic()) {
1281          res |= Modifiers.ACC_STATIC;
1282        }
1283        if (isFinal()) {
1284          res |= Modifiers.ACC_FINAL;
1285        }
1286        if (isSynchronized()) {
1287          res |= Modifiers.ACC_SYNCHRONIZED;
1288        }
1289        if (isNative()) {
1290          res |= Modifiers.ACC_NATIVE;
1291        }
1292        if (isAbstract()) {
1293          res |= Modifiers.ACC_ABSTRACT;
1294        }
1295        if (isStrictfp() || (hostType().isStrictfp() && !hostType().isInterfaceDecl())) {
1296          res |= Modifiers.ACC_STRICT;
1297        }
1298        return res;
1299      }
1300      /**
1301       * @aspect AnnotationsCodegen
1302       * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:44
1303       */
1304      private Collection refined_AnnotationsCodegen_MethodDecl_attributes()
1305    {
1306        Collection c = refined_Attributes_MethodDecl_attributes();
1307        getModifiers().addRuntimeVisibleAnnotationsAttribute(c);
1308        getModifiers().addRuntimeInvisibleAnnotationsAttribute(c);
1309        addRuntimeVisibleParameterAnnotationsAttribute(c);
1310        addRuntimeInvisibleParameterAnnotationsAttribute(c);
1311        return c;
1312      }
1313      /**
1314       * @apilevel internal
1315       */
1316      protected java.util.Map accessibleFrom_TypeDecl_values;
1317      /**
1318       * @apilevel internal
1319       */
1320      private void accessibleFrom_TypeDecl_reset() {
1321        accessibleFrom_TypeDecl_values = null;
1322      }
1323      /**
1324       * @attribute syn
1325       * @aspect AccessControl
1326       * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:100
1327       */
1328      @ASTNodeAnnotation.Attribute
1329      public boolean accessibleFrom(TypeDecl type) {
1330        Object _parameters = type;
1331        if (accessibleFrom_TypeDecl_values == null) accessibleFrom_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1332        ASTNode$State state = state();
1333        if (accessibleFrom_TypeDecl_values.containsKey(_parameters)) {
1334          return (Boolean) accessibleFrom_TypeDecl_values.get(_parameters);
1335        }
1336        boolean intermediate = state.INTERMEDIATE_VALUE;
1337        state.INTERMEDIATE_VALUE = false;
1338        int num = state.boundariesCrossed;
1339        boolean isFinal = this.is$Final();
1340        boolean accessibleFrom_TypeDecl_value = accessibleFrom_compute(type);
1341        if (isFinal && num == state().boundariesCrossed) {
1342          accessibleFrom_TypeDecl_values.put(_parameters, accessibleFrom_TypeDecl_value);
1343        } else {
1344        }
1345        state.INTERMEDIATE_VALUE |= intermediate;
1346    
1347        return accessibleFrom_TypeDecl_value;
1348      }
1349      /**
1350       * @apilevel internal
1351       */
1352      private boolean accessibleFrom_compute(TypeDecl type) {
1353          if (isPublic()) {
1354            return true;
1355          } else if (isProtected()) {
1356            if (hostPackage().equals(type.hostPackage())) {
1357              return true;
1358            }
1359            if (type.withinBodyThatSubclasses(hostType()) != null) {
1360              return true;
1361            }
1362            return false;
1363          } else if (isPrivate()) {
1364            return hostType().topLevelType() == type.topLevelType();
1365          } else {
1366            return hostPackage().equals(type.hostPackage());
1367          }
1368        }
1369      /**
1370       * @attribute syn
1371       * @aspect DataStructures
1372       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:175
1373       */
1374      @ASTNodeAnnotation.Attribute
1375      public int size() {
1376        int size_value = 1;
1377    
1378        return size_value;
1379      }
1380      /**
1381       * @attribute syn
1382       * @aspect DataStructures
1383       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:176
1384       */
1385      @ASTNodeAnnotation.Attribute
1386      public boolean isEmpty() {
1387        boolean isEmpty_value = false;
1388    
1389        return isEmpty_value;
1390      }
1391      /**
1392       * @attribute syn
1393       * @aspect DataStructures
1394       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:180
1395       */
1396      @ASTNodeAnnotation.Attribute
1397      public boolean contains(Object o) {
1398        boolean contains_Object_value = this == o;
1399    
1400        return contains_Object_value;
1401      }
1402      /**
1403       * @attribute syn
1404       * @aspect ErrorCheck
1405       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:45
1406       */
1407      @ASTNodeAnnotation.Attribute
1408      public int lineNumber() {
1409        int lineNumber_value = getLine(IDstart);
1410    
1411        return lineNumber_value;
1412      }
1413      /**
1414       * @apilevel internal
1415       */
1416      protected java.util.Map throwsException_TypeDecl_values;
1417      /**
1418       * @apilevel internal
1419       */
1420      private void throwsException_TypeDecl_reset() {
1421        throwsException_TypeDecl_values = null;
1422      }
1423      /**
1424       * @attribute syn
1425       * @aspect ExceptionHandling
1426       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:182
1427       */
1428      @ASTNodeAnnotation.Attribute
1429      public boolean throwsException(TypeDecl exceptionType) {
1430        Object _parameters = exceptionType;
1431        if (throwsException_TypeDecl_values == null) throwsException_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1432        ASTNode$State state = state();
1433        if (throwsException_TypeDecl_values.containsKey(_parameters)) {
1434          return (Boolean) throwsException_TypeDecl_values.get(_parameters);
1435        }
1436        boolean intermediate = state.INTERMEDIATE_VALUE;
1437        state.INTERMEDIATE_VALUE = false;
1438        int num = state.boundariesCrossed;
1439        boolean isFinal = this.is$Final();
1440        boolean throwsException_TypeDecl_value = throwsException_compute(exceptionType);
1441        if (isFinal && num == state().boundariesCrossed) {
1442          throwsException_TypeDecl_values.put(_parameters, throwsException_TypeDecl_value);
1443        } else {
1444        }
1445        state.INTERMEDIATE_VALUE |= intermediate;
1446    
1447        return throwsException_TypeDecl_value;
1448      }
1449      /**
1450       * @apilevel internal
1451       */
1452      private boolean throwsException_compute(TypeDecl exceptionType) {
1453          for (Access exception : getExceptionList()) {
1454            if (exceptionType.instanceOf(exception.type())) {
1455              return true;
1456            }
1457          }
1458          return false;
1459        }
1460      /**
1461       * @attribute syn
1462       * @aspect MethodDecl
1463       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:178
1464       */
1465      @ASTNodeAnnotation.Attribute
1466      public String name() {
1467        String name_value = getID();
1468    
1469        return name_value;
1470      }
1471      /**
1472       * @apilevel internal
1473       */
1474      protected boolean signature_computed = false;
1475      /**
1476       * @apilevel internal
1477       */
1478      protected String signature_value;
1479      /**
1480       * @apilevel internal
1481       */
1482      private void signature_reset() {
1483        signature_computed = false;
1484        signature_value = null;
1485      }
1486      /**
1487       * @attribute syn
1488       * @aspect MethodDecl
1489       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:181
1490       */
1491      @ASTNodeAnnotation.Attribute
1492      public String signature() {
1493        ASTNode$State state = state();
1494        if (signature_computed) {
1495          return signature_value;
1496        }
1497        boolean intermediate = state.INTERMEDIATE_VALUE;
1498        state.INTERMEDIATE_VALUE = false;
1499        int num = state.boundariesCrossed;
1500        boolean isFinal = this.is$Final();
1501        signature_value = signature_compute();
1502        if (isFinal && num == state().boundariesCrossed) {
1503          signature_computed = true;
1504        } else {
1505        }
1506        state.INTERMEDIATE_VALUE |= intermediate;
1507    
1508        return signature_value;
1509      }
1510      /**
1511       * @apilevel internal
1512       */
1513      private String signature_compute() {
1514          StringBuilder sb = new StringBuilder();
1515          sb.append(name() + "(");
1516          for (int i = 0; i < getNumParameter(); i++) {
1517            if (i != 0) {
1518              sb.append(", ");
1519            }
1520            sb.append(getParameter(i).type().erasure().typeName());
1521          }
1522          sb.append(")");
1523          return sb.toString();
1524        }
1525      /**
1526       * @return Method signature, including generic parameters.
1527       * @attribute syn
1528       * @aspect MethodDecl
1529       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:197
1530       */
1531      @ASTNodeAnnotation.Attribute
1532      public String fullSignature() {
1533        {
1534            StringBuilder sb = new StringBuilder();
1535            sb.append(name() + "(");
1536            for (int i = 0; i < getNumParameter(); i++) {
1537              if (i != 0) {
1538                sb.append(", ");
1539              }
1540              if (getParameter(i).type() instanceof PrimitiveType) {
1541                sb.append(getParameter(i).type().typeName());
1542              } else {
1543                sb.append(getParameter(i).type().fullName());
1544              }
1545            }
1546            sb.append(")");
1547            return sb.toString();
1548          }
1549      }
1550      /**
1551       * 8.4.2 Method Signature
1552       * @param other
1553       * @return {@code true} if the signature of this method is same as the
1554       * the signature of the argument method
1555       * @attribute syn
1556       * @aspect MethodDecl
1557       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:217
1558       */
1559      @ASTNodeAnnotation.Attribute
1560      public boolean sameSignature(MethodDecl other) {
1561        {
1562            if (!refined_MethodDecl_MethodDecl_sameSignature_MethodDecl(other)) {
1563              return false;
1564            }
1565            for (int i = 0; i < getNumParameter(); ++i) {
1566              TypeDecl p1 = getParameter(i).type();
1567              TypeDecl p2 = other.getParameter(i).type();
1568              // JLSv7 $8.4.8.1 exception: if one parameter type is raw, then don't check type bounds
1569              if (p1 != p2 && !p1.isRawType() && !p2.isRawType()) {
1570                return false;
1571              }
1572            }
1573            return true;
1574          }
1575      }
1576      /**
1577       * @param m argument method to compare to
1578       * @return {@code true} if this the argument method is less specific than this
1579       * and this is not less specific than the argument
1580       * @attribute syn
1581       * @aspect MethodDecl
1582       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:225
1583       */
1584      @ASTNodeAnnotation.Attribute
1585      public boolean moreSpecificThan(MethodDecl m) {
1586        boolean moreSpecificThan_MethodDecl_value = m.lessSpecificThan(this) && !this.lessSpecificThan(m);
1587    
1588        return moreSpecificThan_MethodDecl_value;
1589      }
1590      /**
1591       * @apilevel internal
1592       */
1593      protected java.util.Map lessSpecificThan_MethodDecl_values;
1594      /**
1595       * @apilevel internal
1596       */
1597      private void lessSpecificThan_MethodDecl_reset() {
1598        lessSpecificThan_MethodDecl_values = null;
1599      }
1600      /**
1601       * Caution: a less specific than b does not mean b is not less specific than a!
1602       * @param m argument method to compare to
1603       * @return {@code true} if any parameter of this method decl is not a
1604       * subtype (non-proper subtype) of the corresponding parameter of the
1605       * argument method
1606       * @attribute syn
1607       * @aspect MethodDecl
1608       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:235
1609       */
1610      @ASTNodeAnnotation.Attribute
1611      public boolean lessSpecificThan(MethodDecl m) {
1612        Object _parameters = m;
1613        if (lessSpecificThan_MethodDecl_values == null) lessSpecificThan_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1614        ASTNode$State state = state();
1615        if (lessSpecificThan_MethodDecl_values.containsKey(_parameters)) {
1616          return (Boolean) lessSpecificThan_MethodDecl_values.get(_parameters);
1617        }
1618        boolean intermediate = state.INTERMEDIATE_VALUE;
1619        state.INTERMEDIATE_VALUE = false;
1620        int num = state.boundariesCrossed;
1621        boolean isFinal = this.is$Final();
1622        boolean lessSpecificThan_MethodDecl_value = lessSpecificThan_compute(m);
1623        if (isFinal && num == state().boundariesCrossed) {
1624          lessSpecificThan_MethodDecl_values.put(_parameters, lessSpecificThan_MethodDecl_value);
1625        } else {
1626        }
1627        state.INTERMEDIATE_VALUE |= intermediate;
1628    
1629        return lessSpecificThan_MethodDecl_value;
1630      }
1631      /**
1632       * @apilevel internal
1633       */
1634      private boolean lessSpecificThan_compute(MethodDecl m) {
1635          int numA = getNumParameter();
1636          int numB = m.getNumParameter();
1637          int num = Math.max(numA, numB);
1638          for (int i = 0; i < num; i++) {
1639            TypeDecl t1 = getParameter(Math.min(i, numA-1)).type();
1640            TypeDecl t2 = m.getParameter(Math.min(i, numB-1)).type();
1641            if (!t1.instanceOf(t2) && !t1.withinBounds(t2, Parameterization.RAW)) {
1642              return true;
1643            }
1644          }
1645          return false;
1646        }
1647      /**
1648       * @apilevel internal
1649       */
1650      protected java.util.Map overrideCandidate_MethodDecl_values;
1651      /**
1652       * @apilevel internal
1653       */
1654      private void overrideCandidate_MethodDecl_reset() {
1655        overrideCandidate_MethodDecl_values = null;
1656      }
1657      /**
1658       * Only check if this method would be able to override other method,
1659       * not if this method is declared in a subtype of the hostType of
1660       * other method. NB: does not check for equal signature!
1661       * @param m other method
1662       * @return {@code true} of the method could potentially override
1663       * @attribute syn
1664       * @aspect MethodDecl
1665       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:304
1666       */
1667      @ASTNodeAnnotation.Attribute
1668      public boolean overrideCandidate(MethodDecl m) {
1669        Object _parameters = m;
1670        if (overrideCandidate_MethodDecl_values == null) overrideCandidate_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1671        ASTNode$State state = state();
1672        if (overrideCandidate_MethodDecl_values.containsKey(_parameters)) {
1673          return (Boolean) overrideCandidate_MethodDecl_values.get(_parameters);
1674        }
1675        boolean intermediate = state.INTERMEDIATE_VALUE;
1676        state.INTERMEDIATE_VALUE = false;
1677        int num = state.boundariesCrossed;
1678        boolean isFinal = this.is$Final();
1679        boolean overrideCandidate_MethodDecl_value = !isStatic() && !m.isPrivate() && m.accessibleFrom(hostType());
1680        if (isFinal && num == state().boundariesCrossed) {
1681          overrideCandidate_MethodDecl_values.put(_parameters, overrideCandidate_MethodDecl_value);
1682        } else {
1683        }
1684        state.INTERMEDIATE_VALUE |= intermediate;
1685    
1686        return overrideCandidate_MethodDecl_value;
1687      }
1688      /**
1689       * @apilevel internal
1690       */
1691      protected java.util.Map overrides_MethodDecl_values;
1692      /**
1693       * @apilevel internal
1694       */
1695      private void overrides_MethodDecl_reset() {
1696        overrides_MethodDecl_values = null;
1697      }
1698      /**
1699       * @attribute syn
1700       * @aspect MethodDecl
1701       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:307
1702       */
1703      @ASTNodeAnnotation.Attribute
1704      public boolean overrides(MethodDecl m) {
1705        Object _parameters = m;
1706        if (overrides_MethodDecl_values == null) overrides_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1707        ASTNode$State state = state();
1708        if (overrides_MethodDecl_values.containsKey(_parameters)) {
1709          return (Boolean) overrides_MethodDecl_values.get(_parameters);
1710        }
1711        boolean intermediate = state.INTERMEDIATE_VALUE;
1712        state.INTERMEDIATE_VALUE = false;
1713        int num = state.boundariesCrossed;
1714        boolean isFinal = this.is$Final();
1715        boolean overrides_MethodDecl_value = !isStatic() && !m.isPrivate() && m.accessibleFrom(hostType())
1716              && hostType().instanceOf(m.hostType()) && m.signature().equals(signature());
1717        if (isFinal && num == state().boundariesCrossed) {
1718          overrides_MethodDecl_values.put(_parameters, overrides_MethodDecl_value);
1719        } else {
1720        }
1721        state.INTERMEDIATE_VALUE |= intermediate;
1722    
1723        return overrides_MethodDecl_value;
1724      }
1725      /**
1726       * @apilevel internal
1727       */
1728      protected java.util.Map hides_MethodDecl_values;
1729      /**
1730       * @apilevel internal
1731       */
1732      private void hides_MethodDecl_reset() {
1733        hides_MethodDecl_values = null;
1734      }
1735      /**
1736       * @attribute syn
1737       * @aspect MethodDecl
1738       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:311
1739       */
1740      @ASTNodeAnnotation.Attribute
1741      public boolean hides(MethodDecl m) {
1742        Object _parameters = m;
1743        if (hides_MethodDecl_values == null) hides_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1744        ASTNode$State state = state();
1745        if (hides_MethodDecl_values.containsKey(_parameters)) {
1746          return (Boolean) hides_MethodDecl_values.get(_parameters);
1747        }
1748        boolean intermediate = state.INTERMEDIATE_VALUE;
1749        state.INTERMEDIATE_VALUE = false;
1750        int num = state.boundariesCrossed;
1751        boolean isFinal = this.is$Final();
1752        boolean hides_MethodDecl_value = isStatic() && !m.isPrivate() && m.accessibleFrom(hostType())
1753              && hostType().instanceOf(m.hostType()) && m.signature().equals(signature());
1754        if (isFinal && num == state().boundariesCrossed) {
1755          hides_MethodDecl_values.put(_parameters, hides_MethodDecl_value);
1756        } else {
1757        }
1758        state.INTERMEDIATE_VALUE |= intermediate;
1759    
1760        return hides_MethodDecl_value;
1761      }
1762      /**
1763       * @apilevel internal
1764       */
1765      protected java.util.Map parameterDeclaration_String_values;
1766      /**
1767       * @apilevel internal
1768       */
1769      private void parameterDeclaration_String_reset() {
1770        parameterDeclaration_String_values = null;
1771      }
1772      /**
1773       * @attribute syn
1774       * @aspect VariableScope
1775       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:161
1776       */
1777      @ASTNodeAnnotation.Attribute
1778      public SimpleSet parameterDeclaration(String name) {
1779        Object _parameters = name;
1780        if (parameterDeclaration_String_values == null) parameterDeclaration_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1781        ASTNode$State state = state();
1782        if (parameterDeclaration_String_values.containsKey(_parameters)) {
1783          return (SimpleSet) parameterDeclaration_String_values.get(_parameters);
1784        }
1785        boolean intermediate = state.INTERMEDIATE_VALUE;
1786        state.INTERMEDIATE_VALUE = false;
1787        int num = state.boundariesCrossed;
1788        boolean isFinal = this.is$Final();
1789        SimpleSet parameterDeclaration_String_value = parameterDeclaration_compute(name);
1790        if (isFinal && num == state().boundariesCrossed) {
1791          parameterDeclaration_String_values.put(_parameters, parameterDeclaration_String_value);
1792        } else {
1793        }
1794        state.INTERMEDIATE_VALUE |= intermediate;
1795    
1796        return parameterDeclaration_String_value;
1797      }
1798      /**
1799       * @apilevel internal
1800       */
1801      private SimpleSet parameterDeclaration_compute(String name) {
1802          for (int i = 0; i < getNumParameter(); i++) {
1803            if (getParameter(i).name().equals(name)) {
1804              return (ParameterDeclaration) getParameter(i);
1805            }
1806          }
1807          return SimpleSet.emptySet;
1808        }
1809      /**
1810       * @attribute syn
1811       * @aspect Modifiers
1812       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:255
1813       */
1814      @ASTNodeAnnotation.Attribute
1815      public boolean isSynthetic() {
1816        boolean isSynthetic_value = getModifiers().isSynthetic();
1817    
1818        return isSynthetic_value;
1819      }
1820      /**
1821       * @attribute syn
1822       * @aspect Modifiers
1823       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:265
1824       */
1825      @ASTNodeAnnotation.Attribute
1826      public boolean isPublic() {
1827        boolean isPublic_value = getModifiers().isPublic() || hostType().isInterfaceDecl();
1828    
1829        return isPublic_value;
1830      }
1831      /**
1832       * @attribute syn
1833       * @aspect Modifiers
1834       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:266
1835       */
1836      @ASTNodeAnnotation.Attribute
1837      public boolean isPrivate() {
1838        boolean isPrivate_value = getModifiers().isPrivate();
1839    
1840        return isPrivate_value;
1841      }
1842      /**
1843       * @attribute syn
1844       * @aspect Modifiers
1845       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:267
1846       */
1847      @ASTNodeAnnotation.Attribute
1848      public boolean isProtected() {
1849        boolean isProtected_value = getModifiers().isProtected();
1850    
1851        return isProtected_value;
1852      }
1853      /**
1854       * @attribute syn
1855       * @aspect Modifiers
1856       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:268
1857       */
1858      @ASTNodeAnnotation.Attribute
1859      public boolean isAbstract() {
1860        {
1861            return getModifiers().isAbstract() || (hostType().isInterfaceDecl() && !isStatic() && !isDefault());
1862          }
1863      }
1864      /**
1865       * @attribute syn
1866       * @aspect Modifiers
1867       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:269
1868       */
1869      @ASTNodeAnnotation.Attribute
1870      public boolean isStatic() {
1871        boolean isStatic_value = getModifiers().isStatic();
1872    
1873        return isStatic_value;
1874      }
1875      /**
1876       * @attribute syn
1877       * @aspect Modifiers
1878       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:271
1879       */
1880      @ASTNodeAnnotation.Attribute
1881      public boolean isFinal() {
1882        boolean isFinal_value = getModifiers().isFinal() || hostType().isFinal() || isPrivate();
1883    
1884        return isFinal_value;
1885      }
1886      /**
1887       * @attribute syn
1888       * @aspect Modifiers
1889       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:272
1890       */
1891      @ASTNodeAnnotation.Attribute
1892      public boolean isSynchronized() {
1893        boolean isSynchronized_value = getModifiers().isSynchronized();
1894    
1895        return isSynchronized_value;
1896      }
1897      /**
1898       * @attribute syn
1899       * @aspect Modifiers
1900       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:273
1901       */
1902      @ASTNodeAnnotation.Attribute
1903      public boolean isNative() {
1904        boolean isNative_value = getModifiers().isNative();
1905    
1906        return isNative_value;
1907      }
1908      /**
1909       * @attribute syn
1910       * @aspect Modifiers
1911       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:274
1912       */
1913      @ASTNodeAnnotation.Attribute
1914      public boolean isStrictfp() {
1915        boolean isStrictfp_value = getModifiers().isStrictfp();
1916    
1917        return isStrictfp_value;
1918      }
1919      /**
1920       * @attribute syn
1921       * @aspect PrettyPrintUtil
1922       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:247
1923       */
1924      @ASTNodeAnnotation.Attribute
1925      public boolean hasModifiers() {
1926        boolean hasModifiers_value = getModifiers().getNumModifier() > 0;
1927    
1928        return hasModifiers_value;
1929      }
1930      /**
1931       * @attribute syn
1932       * @aspect PrettyPrintUtil
1933       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:259
1934       */
1935      @ASTNodeAnnotation.Attribute
1936      public boolean hasExceptions() {
1937        boolean hasExceptions_value = getNumException() > 0;
1938    
1939        return hasExceptions_value;
1940      }
1941      /**
1942       * @apilevel internal
1943       */
1944      protected boolean type_computed = false;
1945      /**
1946       * @apilevel internal
1947       */
1948      protected TypeDecl type_value;
1949      /**
1950       * @apilevel internal
1951       */
1952      private void type_reset() {
1953        type_computed = false;
1954        type_value = null;
1955      }
1956      /**
1957       * @attribute syn
1958       * @aspect TypeAnalysis
1959       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:295
1960       */
1961      @ASTNodeAnnotation.Attribute
1962      public TypeDecl type() {
1963        ASTNode$State state = state();
1964        if (type_computed) {
1965          return type_value;
1966        }
1967        boolean intermediate = state.INTERMEDIATE_VALUE;
1968        state.INTERMEDIATE_VALUE = false;
1969        int num = state.boundariesCrossed;
1970        boolean isFinal = this.is$Final();
1971        type_value = getTypeAccess().type();
1972        if (isFinal && num == state().boundariesCrossed) {
1973          type_computed = true;
1974        } else {
1975        }
1976        state.INTERMEDIATE_VALUE |= intermediate;
1977    
1978        return type_value;
1979      }
1980      /**
1981       * @attribute syn
1982       * @aspect TypeAnalysis
1983       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:297
1984       */
1985      @ASTNodeAnnotation.Attribute
1986      public boolean isVoid() {
1987        boolean isVoid_value = type().isVoid();
1988    
1989        return isVoid_value;
1990      }
1991      /**
1992       * @attribute syn
1993       * @aspect TypeHierarchyCheck
1994       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:360
1995       */
1996      @ASTNodeAnnotation.Attribute
1997      public boolean mayOverride(MethodDecl m) {
1998        {
1999            // 9.4.3
2000            if (isDefault() && m.hostType() == type().typeObject() && !m.isPrivate()) {
2001              return false;
2002            } else {
2003              return returnTypeSubstitutableFor(m);
2004            }
2005          }
2006      }
2007      /**
2008       * @apilevel internal
2009       */
2010      protected boolean attributes_computed = false;
2011      /**
2012       * @apilevel internal
2013       */
2014      protected Collection attributes_value;
2015      /**
2016       * @apilevel internal
2017       */
2018      private void attributes_reset() {
2019        attributes_computed = false;
2020        attributes_value = null;
2021      }
2022      /**
2023       * @attribute syn
2024       * @aspect Attributes
2025       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:212
2026       */
2027      @ASTNodeAnnotation.Attribute
2028      public Collection attributes() {
2029        ASTNode$State state = state();
2030        if (attributes_computed) {
2031          return attributes_value;
2032        }
2033        boolean intermediate = state.INTERMEDIATE_VALUE;
2034        state.INTERMEDIATE_VALUE = false;
2035        int num = state.boundariesCrossed;
2036        boolean isFinal = this.is$Final();
2037        attributes_value = attributes_compute();
2038        if (isFinal && num == state().boundariesCrossed) {
2039          attributes_computed = true;
2040        } else {
2041        }
2042        state.INTERMEDIATE_VALUE |= intermediate;
2043    
2044        return attributes_value;
2045      }
2046      /**
2047       * @apilevel internal
2048       */
2049      private Collection attributes_compute() {
2050          Collection c = refined_AnnotationsCodegen_MethodDecl_attributes();
2051          if (needsSignatureAttribute()) {
2052            c.add(new SignatureAttribute(hostType().constantPool(), methodTypeSignature()));
2053          }
2054          return c;
2055        }
2056      /**
2057       * @apilevel internal
2058       */
2059      protected boolean descName_computed = false;
2060      /**
2061       * @apilevel internal
2062       */
2063      protected String descName_value;
2064      /**
2065       * @apilevel internal
2066       */
2067      private void descName_reset() {
2068        descName_computed = false;
2069        descName_value = null;
2070      }
2071      /**
2072       * @attribute syn
2073       * @aspect ConstantPoolNames
2074       * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:103
2075       */
2076      @ASTNodeAnnotation.Attribute
2077      public String descName() {
2078        ASTNode$State state = state();
2079        if (descName_computed) {
2080          return descName_value;
2081        }
2082        boolean intermediate = state.INTERMEDIATE_VALUE;
2083        state.INTERMEDIATE_VALUE = false;
2084        int num = state.boundariesCrossed;
2085        boolean isFinal = this.is$Final();
2086        descName_value = descName_compute();
2087        if (isFinal && num == state().boundariesCrossed) {
2088          descName_computed = true;
2089        } else {
2090        }
2091        state.INTERMEDIATE_VALUE |= intermediate;
2092    
2093        return descName_value;
2094      }
2095      /**
2096       * @apilevel internal
2097       */
2098      private String descName_compute() {
2099          StringBuilder b = new StringBuilder();
2100          b.append("(");
2101          for (int i=0; i<getNumParameter(); i++) {
2102            b.append(getParameter(i).type().typeDescriptor());
2103          }
2104          b.append(")");
2105          if (type().elementType().isUnknown()) {
2106            System.err.println(getTypeAccess().dumpTree());
2107            throw new Error("Error generating descName for " + signature() + ", did not expect unknown return type");
2108          }
2109          b.append(type().typeDescriptor());
2110          return b.toString();
2111        }
2112      /**
2113       * @apilevel internal
2114       */
2115      protected java.util.Map bytecodes_ConstantPool_values;
2116      /**
2117       * @apilevel internal
2118       */
2119      private void bytecodes_ConstantPool_reset() {
2120        bytecodes_ConstantPool_values = null;
2121      }
2122      /**
2123       * @attribute syn
2124       * @aspect CreateBCode
2125       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:92
2126       */
2127      @ASTNodeAnnotation.Attribute
2128      public CodeGeneration bytecodes(ConstantPool constantPool) {
2129        Object _parameters = constantPool;
2130        if (bytecodes_ConstantPool_values == null) bytecodes_ConstantPool_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2131        ASTNode$State state = state();
2132        if (bytecodes_ConstantPool_values.containsKey(_parameters)) {
2133          return (CodeGeneration) bytecodes_ConstantPool_values.get(_parameters);
2134        }
2135        boolean intermediate = state.INTERMEDIATE_VALUE;
2136        state.INTERMEDIATE_VALUE = false;
2137        int num = state.boundariesCrossed;
2138        boolean isFinal = this.is$Final();
2139        CodeGeneration bytecodes_ConstantPool_value = bytecodes_compute(constantPool);
2140        if (isFinal && num == state().boundariesCrossed) {
2141          bytecodes_ConstantPool_values.put(_parameters, bytecodes_ConstantPool_value);
2142        } else {
2143        }
2144        state.INTERMEDIATE_VALUE |= intermediate;
2145    
2146        return bytecodes_ConstantPool_value;
2147      }
2148      /**
2149       * @apilevel internal
2150       */
2151      private CodeGeneration bytecodes_compute(ConstantPool constantPool) {
2152          CodeGeneration gen = new CodeGeneration(constantPool);
2153          generateBytecodes(gen);
2154          if (!gen.numberFormatError()) {
2155            return gen;
2156          }
2157          gen = new CodeGeneration(constantPool, true);
2158          generateBytecodes(gen);
2159          if (!gen.numberFormatError()) {
2160            return gen;
2161          }
2162          throw new Error("Could not generate code for " + signature() + " in " + hostType().typeName());
2163        }
2164      /**
2165       * @apilevel internal
2166       */
2167      protected boolean flags_computed = false;
2168      /**
2169       * @apilevel internal
2170       */
2171      protected int flags_value;
2172      /**
2173       * @apilevel internal
2174       */
2175      private void flags_reset() {
2176        flags_computed = false;
2177      }
2178      /**
2179       * @attribute syn
2180       * @aspect Flags
2181       * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:62
2182       */
2183      @ASTNodeAnnotation.Attribute
2184      public int flags() {
2185        ASTNode$State state = state();
2186        if (flags_computed) {
2187          return flags_value;
2188        }
2189        boolean intermediate = state.INTERMEDIATE_VALUE;
2190        state.INTERMEDIATE_VALUE = false;
2191        int num = state.boundariesCrossed;
2192        boolean isFinal = this.is$Final();
2193        flags_value = flags_compute();
2194        if (isFinal && num == state().boundariesCrossed) {
2195          flags_computed = true;
2196        } else {
2197        }
2198        state.INTERMEDIATE_VALUE |= intermediate;
2199    
2200        return flags_value;
2201      }
2202      /**
2203       * @apilevel internal
2204       */
2205      private int flags_compute() {
2206          int res = refined_Flags_MethodDecl_flags();
2207          if (isVariableArity()) {
2208            res |= Modifiers.ACC_VARARGS;
2209          }
2210          return res;
2211        }
2212      /**
2213       * @attribute syn
2214       * @aspect GenerateClassfile
2215       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:350
2216       */
2217      @ASTNodeAnnotation.Attribute
2218      public boolean isBytecodeMethod() {
2219        boolean isBytecodeMethod_value = true;
2220    
2221        return isBytecodeMethod_value;
2222      }
2223      /**
2224       * @attribute syn
2225       * @aspect GenerateClassfile
2226       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:379
2227       */
2228      @ASTNodeAnnotation.Attribute
2229      public boolean flush() {
2230        boolean flush_value = false;
2231    
2232        return flush_value;
2233      }
2234      /**
2235       * @apilevel internal
2236       */
2237      protected boolean offsetBeforeParameters_computed = false;
2238      /**
2239       * @apilevel internal
2240       */
2241      protected int offsetBeforeParameters_value;
2242      /**
2243       * @apilevel internal
2244       */
2245      private void offsetBeforeParameters_reset() {
2246        offsetBeforeParameters_computed = false;
2247      }
2248      /**
2249       * @attribute syn
2250       * @aspect LocalNum
2251       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:69
2252       */
2253      @ASTNodeAnnotation.Attribute
2254      public int offsetBeforeParameters() {
2255        ASTNode$State state = state();
2256        if (offsetBeforeParameters_computed) {
2257          return offsetBeforeParameters_value;
2258        }
2259        boolean intermediate = state.INTERMEDIATE_VALUE;
2260        state.INTERMEDIATE_VALUE = false;
2261        int num = state.boundariesCrossed;
2262        boolean isFinal = this.is$Final();
2263        offsetBeforeParameters_value = isStatic() ? 0 : 1;
2264        if (isFinal && num == state().boundariesCrossed) {
2265          offsetBeforeParameters_computed = true;
2266        } else {
2267        }
2268        state.INTERMEDIATE_VALUE |= intermediate;
2269    
2270        return offsetBeforeParameters_value;
2271      }
2272      /**
2273       * @apilevel internal
2274       */
2275      protected boolean offsetAfterParameters_computed = false;
2276      /**
2277       * @apilevel internal
2278       */
2279      protected int offsetAfterParameters_value;
2280      /**
2281       * @apilevel internal
2282       */
2283      private void offsetAfterParameters_reset() {
2284        offsetAfterParameters_computed = false;
2285      }
2286      /**
2287       * @attribute syn
2288       * @aspect LocalNum
2289       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:71
2290       */
2291      @ASTNodeAnnotation.Attribute
2292      public int offsetAfterParameters() {
2293        ASTNode$State state = state();
2294        if (offsetAfterParameters_computed) {
2295          return offsetAfterParameters_value;
2296        }
2297        boolean intermediate = state.INTERMEDIATE_VALUE;
2298        state.INTERMEDIATE_VALUE = false;
2299        int num = state.boundariesCrossed;
2300        boolean isFinal = this.is$Final();
2301        offsetAfterParameters_value = offsetAfterParameters_compute();
2302        if (isFinal && num == state().boundariesCrossed) {
2303          offsetAfterParameters_computed = true;
2304        } else {
2305        }
2306        state.INTERMEDIATE_VALUE |= intermediate;
2307    
2308        return offsetAfterParameters_value;
2309      }
2310      /**
2311       * @apilevel internal
2312       */
2313      private int offsetAfterParameters_compute() {
2314          if (getNumParameter() == 0) {
2315            return offsetBeforeParameters();
2316          } else {
2317            ParameterDeclaration last = getParameter(getNumParameter()-1);
2318            return last.localNum() + last.type().variableSize();
2319          }
2320        }
2321      /**
2322       * @apilevel internal
2323       */
2324      protected boolean resultOffset_computed = false;
2325      /**
2326       * @apilevel internal
2327       */
2328      protected int resultOffset_value;
2329      /**
2330       * @apilevel internal
2331       */
2332      private void resultOffset_reset() {
2333        resultOffset_computed = false;
2334      }
2335      /**
2336       * @attribute syn
2337       * @aspect LocalNum
2338       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:107
2339       */
2340      @ASTNodeAnnotation.Attribute
2341      public int resultOffset() {
2342        ASTNode$State state = state();
2343        if (resultOffset_computed) {
2344          return resultOffset_value;
2345        }
2346        boolean intermediate = state.INTERMEDIATE_VALUE;
2347        state.INTERMEDIATE_VALUE = false;
2348        int num = state.boundariesCrossed;
2349        boolean isFinal = this.is$Final();
2350        resultOffset_value = type().isVoid() ? 0 : type().variableSize();
2351        if (isFinal && num == state().boundariesCrossed) {
2352          resultOffset_computed = true;
2353        } else {
2354        }
2355        state.INTERMEDIATE_VALUE |= intermediate;
2356    
2357        return resultOffset_value;
2358      }
2359      /**
2360       * @attribute syn
2361       * @aspect Annotations
2362       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:180
2363       */
2364      @ASTNodeAnnotation.Attribute
2365      public boolean annotationMethodOverride() {
2366        boolean annotationMethodOverride_value = !hostType().ancestorMethods(signature()).isEmpty();
2367    
2368        return annotationMethodOverride_value;
2369      }
2370      /**
2371       * @attribute syn
2372       * @aspect Annotations
2373       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:356
2374       */
2375      @ASTNodeAnnotation.Attribute
2376      public boolean hasAnnotationSuppressWarnings(String annot) {
2377        boolean hasAnnotationSuppressWarnings_String_value = getModifiers().hasAnnotationSuppressWarnings(annot);
2378    
2379        return hasAnnotationSuppressWarnings_String_value;
2380      }
2381      /**
2382       * @attribute syn
2383       * @aspect Annotations
2384       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:399
2385       */
2386      @ASTNodeAnnotation.Attribute
2387      public boolean isDeprecated() {
2388        boolean isDeprecated_value = getModifiers().hasDeprecatedAnnotation();
2389    
2390        return isDeprecated_value;
2391      }
2392      /**
2393       * @apilevel internal
2394       */
2395      protected boolean usesTypeVariable_computed = false;
2396      /**
2397       * @apilevel internal
2398       */
2399      protected boolean usesTypeVariable_value;
2400      /**
2401       * @apilevel internal
2402       */
2403      private void usesTypeVariable_reset() {
2404        usesTypeVariable_computed = false;
2405      }
2406      /**
2407       * @attribute syn
2408       * @aspect LookupParTypeDecl
2409       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1249
2410       */
2411      @ASTNodeAnnotation.Attribute
2412      public boolean usesTypeVariable() {
2413        ASTNode$State state = state();
2414        if (usesTypeVariable_computed) {
2415          return usesTypeVariable_value;
2416        }
2417        boolean intermediate = state.INTERMEDIATE_VALUE;
2418        state.INTERMEDIATE_VALUE = false;
2419        int num = state.boundariesCrossed;
2420        boolean isFinal = this.is$Final();
2421        usesTypeVariable_value = getModifiers().usesTypeVariable() || getTypeAccess().usesTypeVariable()
2422              || getParameterList().usesTypeVariable() || getExceptionList().usesTypeVariable();
2423        if (isFinal && num == state().boundariesCrossed) {
2424          usesTypeVariable_computed = true;
2425        } else {
2426        }
2427        state.INTERMEDIATE_VALUE |= intermediate;
2428    
2429        return usesTypeVariable_value;
2430      }
2431      /**
2432       * @attribute syn
2433       * @aspect LookupParTypeDecl
2434       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1413
2435       */
2436      @ASTNodeAnnotation.Attribute
2437      public MethodDecl erasedMethod() {
2438        MethodDecl erasedMethod_value = this;
2439    
2440        return erasedMethod_value;
2441      }
2442      /**
2443       * @apilevel internal
2444       */
2445      protected boolean sourceMethodDecl_computed = false;
2446      /**
2447       * @apilevel internal
2448       */
2449      protected MethodDecl sourceMethodDecl_value;
2450      /**
2451       * @apilevel internal
2452       */
2453      private void sourceMethodDecl_reset() {
2454        sourceMethodDecl_computed = false;
2455        sourceMethodDecl_value = null;
2456      }
2457      /**
2458       * @attribute syn
2459       * @aspect SourceDeclarations
2460       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1625
2461       */
2462      @ASTNodeAnnotation.Attribute
2463      public MethodDecl sourceMethodDecl() {
2464        ASTNode$State state = state();
2465        if (sourceMethodDecl_computed) {
2466          return sourceMethodDecl_value;
2467        }
2468        boolean intermediate = state.INTERMEDIATE_VALUE;
2469        state.INTERMEDIATE_VALUE = false;
2470        int num = state.boundariesCrossed;
2471        boolean isFinal = this.is$Final();
2472        sourceMethodDecl_value = this;
2473        if (isFinal && num == state().boundariesCrossed) {
2474          sourceMethodDecl_computed = true;
2475        } else {
2476        }
2477        state.INTERMEDIATE_VALUE |= intermediate;
2478    
2479        return sourceMethodDecl_value;
2480      }
2481      /**
2482       * @attribute syn
2483       * @aspect GenericsParTypeDecl
2484       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:90
2485       */
2486      @ASTNodeAnnotation.Attribute
2487      public boolean visibleTypeParameters() {
2488        boolean visibleTypeParameters_value = !isStatic();
2489    
2490        return visibleTypeParameters_value;
2491      }
2492      /**
2493       * Note: isGeneric must be called first to check if this declaration is generic.
2494       * Otherwise this attribute will throw an error!
2495       * @return the original generic declaration of this method.
2496       * @attribute syn
2497       * @aspect MethodSignature15
2498       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:386
2499       */
2500      @ASTNodeAnnotation.Attribute
2501      public GenericMethodDecl genericDecl() {
2502        {
2503            throw new Error("can not evaulate generic declaration of non-generic method");
2504          }
2505      }
2506      /**
2507       * @attribute syn
2508       * @aspect MethodSignature15
2509       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:473
2510       */
2511      @ASTNodeAnnotation.Attribute
2512      public int arity() {
2513        int arity_value = getNumParameter();
2514    
2515        return arity_value;
2516      }
2517      /**
2518       * @attribute syn
2519       * @aspect VariableArityParameters
2520       * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:55
2521       */
2522      @ASTNodeAnnotation.Attribute
2523      public boolean isVariableArity() {
2524        boolean isVariableArity_value = getNumParameter() == 0 ? false : getParameter(getNumParameter()-1).isVariableArity();
2525    
2526        return isVariableArity_value;
2527      }
2528      /**
2529       * @attribute syn
2530       * @aspect VariableArityParameters
2531       * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:60
2532       */
2533      @ASTNodeAnnotation.Attribute
2534      public ParameterDeclaration lastParameter() {
2535        ParameterDeclaration lastParameter_value = getParameter(getNumParameter() - 1);
2536    
2537        return lastParameter_value;
2538      }
2539      /**
2540       * @attribute syn
2541       * @aspect GenericsCodegen
2542       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:375
2543       */
2544      @ASTNodeAnnotation.Attribute
2545      public boolean needsSignatureAttribute() {
2546        {
2547            if (type().needsSignatureAttribute()) {
2548              return true;
2549            }
2550            for (int i = 0; i < getNumParameter(); i++) {
2551              if (getParameter(i).type().needsSignatureAttribute()) {
2552                return true;
2553              }
2554            }
2555            return false;
2556          }
2557      }
2558      /**
2559       * @attribute syn
2560       * @aspect GenericsCodegen
2561       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:508
2562       */
2563      @ASTNodeAnnotation.Attribute
2564      public String methodTypeSignature() {
2565        {
2566            StringBuilder buf = new StringBuilder();
2567            buf.append("(");
2568            for (int i = 0; i < getNumParameter(); i++) {
2569              buf.append(getParameter(i).type().classTypeSignature());
2570            }
2571            buf.append(")");
2572            buf.append(type().classTypeSignature());
2573            for (int i = 0; i < getNumException(); i++) {
2574              buf.append("^" + getException(i).type().classTypeSignature());
2575            }
2576            return buf.toString();
2577          }
2578      }
2579      /**
2580       * @return true if the modifier list includes the SafeVarargs annotation
2581       * @attribute syn
2582       * @aspect SafeVarargs
2583       * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:42
2584       */
2585      @ASTNodeAnnotation.Attribute
2586      public boolean hasAnnotationSafeVarargs() {
2587        boolean hasAnnotationSafeVarargs_value = getModifiers().hasAnnotationSafeVarargs();
2588    
2589        return hasAnnotationSafeVarargs_value;
2590      }
2591      /**
2592       * It is an error if the SafeVarargs annotation is used on something
2593       * that is not a variable arity method or constructor.
2594       * @attribute syn
2595       * @aspect SafeVarargs
2596       * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:73
2597       */
2598      @ASTNodeAnnotation.Attribute
2599      public boolean hasIllegalAnnotationSafeVarargs() {
2600        boolean hasIllegalAnnotationSafeVarargs_value = hasAnnotationSafeVarargs() && (!isVariableArity() || (!isFinal() && !isStatic()));
2601    
2602        return hasIllegalAnnotationSafeVarargs_value;
2603      }
2604      /**
2605       * @attribute syn
2606       * @aspect SuppressWarnings
2607       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:46
2608       */
2609      @ASTNodeAnnotation.Attribute
2610      public boolean suppressWarnings(String type) {
2611        boolean suppressWarnings_String_value = hasAnnotationSuppressWarnings(type) || withinSuppressWarnings(type);
2612    
2613        return suppressWarnings_String_value;
2614      }
2615      /**
2616       * @attribute syn
2617       * @aspect PreciseRethrow
2618       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:40
2619       */
2620      @ASTNodeAnnotation.Attribute
2621      public boolean modifiedInScope(Variable var) {
2622        boolean modifiedInScope_Variable_value = hasBlock() && getBlock().modifiedInScope(var);
2623    
2624        return modifiedInScope_Variable_value;
2625      }
2626      /**
2627       * @apilevel internal
2628       */
2629      protected java.util.Map subsignatureTo_MethodDecl_values;
2630      /**
2631       * @apilevel internal
2632       */
2633      private void subsignatureTo_MethodDecl_reset() {
2634        subsignatureTo_MethodDecl_values = null;
2635      }
2636      /**
2637       * @attribute syn
2638       * @aspect FunctionalInterface
2639       * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionalInterface.jrag:62
2640       */
2641      @ASTNodeAnnotation.Attribute
2642      public boolean subsignatureTo(MethodDecl m) {
2643        Object _parameters = m;
2644        if (subsignatureTo_MethodDecl_values == null) subsignatureTo_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2645        ASTNode$State state = state();
2646        if (subsignatureTo_MethodDecl_values.containsKey(_parameters)) {
2647          return (Boolean) subsignatureTo_MethodDecl_values.get(_parameters);
2648        }
2649        boolean intermediate = state.INTERMEDIATE_VALUE;
2650        state.INTERMEDIATE_VALUE = false;
2651        int num = state.boundariesCrossed;
2652        boolean isFinal = this.is$Final();
2653        boolean subsignatureTo_MethodDecl_value = subsignatureTo_compute(m);
2654        if (isFinal && num == state().boundariesCrossed) {
2655          subsignatureTo_MethodDecl_values.put(_parameters, subsignatureTo_MethodDecl_value);
2656        } else {
2657        }
2658        state.INTERMEDIATE_VALUE |= intermediate;
2659    
2660        return subsignatureTo_MethodDecl_value;
2661      }
2662      /**
2663       * @apilevel internal
2664       */
2665      private boolean subsignatureTo_compute(MethodDecl m) {
2666          if (fullSignature().equals(m.fullSignature())) {
2667            return true;
2668          } else if (fullSignature().equals(m.signature())) {
2669            return true;
2670          } else {
2671            return false;
2672          }
2673        }
2674      /**
2675       * @apilevel internal
2676       */
2677      protected java.util.Map returnTypeSubstitutableFor_MethodDecl_values;
2678      /**
2679       * @apilevel internal
2680       */
2681      private void returnTypeSubstitutableFor_MethodDecl_reset() {
2682        returnTypeSubstitutableFor_MethodDecl_values = null;
2683      }
2684      /**
2685       * @attribute syn
2686       * @aspect FunctionalInterface
2687       * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionalInterface.jrag:86
2688       */
2689      @ASTNodeAnnotation.Attribute
2690      public boolean returnTypeSubstitutableFor(MethodDecl m) {
2691        Object _parameters = m;
2692        if (returnTypeSubstitutableFor_MethodDecl_values == null) returnTypeSubstitutableFor_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2693        ASTNode$State state = state();
2694        if (returnTypeSubstitutableFor_MethodDecl_values.containsKey(_parameters)) {
2695          return (Boolean) returnTypeSubstitutableFor_MethodDecl_values.get(_parameters);
2696        }
2697        boolean intermediate = state.INTERMEDIATE_VALUE;
2698        state.INTERMEDIATE_VALUE = false;
2699        int num = state.boundariesCrossed;
2700        boolean isFinal = this.is$Final();
2701        boolean returnTypeSubstitutableFor_MethodDecl_value = returnTypeSubstitutableFor_compute(m);
2702        if (isFinal && num == state().boundariesCrossed) {
2703          returnTypeSubstitutableFor_MethodDecl_values.put(_parameters, returnTypeSubstitutableFor_MethodDecl_value);
2704        } else {
2705        }
2706        state.INTERMEDIATE_VALUE |= intermediate;
2707    
2708        return returnTypeSubstitutableFor_MethodDecl_value;
2709      }
2710      /**
2711       * @apilevel internal
2712       */
2713      private boolean returnTypeSubstitutableFor_compute(MethodDecl m) {
2714          TypeDecl t1 = type();
2715          TypeDecl t2 = m.type();
2716          if (t1 instanceof VoidType && t2 instanceof VoidType) {
2717            return true;
2718          } else if (t1 instanceof PrimitiveType && t2 instanceof PrimitiveType) {
2719            PrimitiveType p1 = (PrimitiveType)t1;
2720            PrimitiveType p2 = (PrimitiveType)t2;
2721            return p1 == p2;
2722          } else if (t1.isReferenceType() && t2.isReferenceType()) {
2723            if (t1.strictSubtype(t2)) {
2724              return true;
2725            } else {
2726              return t1 == t2.erasure();
2727            }
2728          } else {
2729            return false;
2730          }
2731        }
2732      /**
2733       * @apilevel internal
2734       */
2735      protected boolean isDefault_computed = false;
2736      /**
2737       * @apilevel internal
2738       */
2739      protected boolean isDefault_value;
2740      /**
2741       * @apilevel internal
2742       */
2743      private void isDefault_reset() {
2744        isDefault_computed = false;
2745      }
2746      /**
2747       * @attribute syn
2748       * @aspect Modifiers
2749       * @declaredat /home/jesper/git/extendj/java8/frontend/Modifiers.jrag:31
2750       */
2751      @ASTNodeAnnotation.Attribute
2752      public boolean isDefault() {
2753        ASTNode$State state = state();
2754        if (isDefault_computed) {
2755          return isDefault_value;
2756        }
2757        boolean intermediate = state.INTERMEDIATE_VALUE;
2758        state.INTERMEDIATE_VALUE = false;
2759        int num = state.boundariesCrossed;
2760        boolean isFinal = this.is$Final();
2761        isDefault_value = getModifiers().isDefault();
2762        if (isFinal && num == state().boundariesCrossed) {
2763          isDefault_computed = true;
2764        } else {
2765        }
2766        state.INTERMEDIATE_VALUE |= intermediate;
2767    
2768        return isDefault_value;
2769      }
2770      /**
2771       * @attribute inh
2772       * @aspect ExceptionHandling
2773       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:84
2774       */
2775      /**
2776       * @attribute inh
2777       * @aspect ExceptionHandling
2778       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:84
2779       */
2780      @ASTNodeAnnotation.Attribute
2781      public boolean handlesException(TypeDecl exceptionType) {
2782        Object _parameters = exceptionType;
2783        if (handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
2784        ASTNode$State state = state();
2785        if (handlesException_TypeDecl_values.containsKey(_parameters)) {
2786          return (Boolean) handlesException_TypeDecl_values.get(_parameters);
2787        }
2788        boolean intermediate = state.INTERMEDIATE_VALUE;
2789        state.INTERMEDIATE_VALUE = false;
2790        int num = state.boundariesCrossed;
2791        boolean isFinal = this.is$Final();
2792        boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType);
2793        if (isFinal && num == state().boundariesCrossed) {
2794          handlesException_TypeDecl_values.put(_parameters, handlesException_TypeDecl_value);
2795        } else {
2796        }
2797        state.INTERMEDIATE_VALUE |= intermediate;
2798    
2799        return handlesException_TypeDecl_value;
2800      }
2801      /**
2802       * @apilevel internal
2803       */
2804      protected java.util.Map handlesException_TypeDecl_values;
2805      /**
2806       * @apilevel internal
2807       */
2808      private void handlesException_TypeDecl_reset() {
2809        handlesException_TypeDecl_values = null;
2810      }
2811      /**
2812       * @attribute inh
2813       * @aspect LookupMethod
2814       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:36
2815       */
2816      /**
2817       * @attribute inh
2818       * @aspect LookupMethod
2819       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:36
2820       */
2821      @ASTNodeAnnotation.Attribute
2822      public MethodDecl unknownMethod() {
2823        MethodDecl unknownMethod_value = getParent().Define_unknownMethod(this, null);
2824    
2825        return unknownMethod_value;
2826      }
2827      /**
2828       * @attribute inh
2829       * @aspect SuppressWarnings
2830       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:39
2831       */
2832      /**
2833       * @attribute inh
2834       * @aspect SuppressWarnings
2835       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:39
2836       */
2837      @ASTNodeAnnotation.Attribute
2838      public boolean withinSuppressWarnings(String annot) {
2839        boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot);
2840    
2841        return withinSuppressWarnings_String_value;
2842      }
2843      /**
2844       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
2845       * @apilevel internal
2846       */
2847      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
2848        if (caller == getBlockOptNoTransform()) {
2849          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:479
2850          return v.isFinal() && (v.isClassVariable() || v.isInstanceVariable()) ? true : isDAbefore(v);
2851        }
2852        else {
2853          return super.Define_isDAbefore(caller, child, v);
2854        }
2855      }
2856      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
2857        return true;
2858      }
2859      /**
2860       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
2861       * @apilevel internal
2862       */
2863      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
2864        if (caller == getBlockOptNoTransform()) {
2865          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:983
2866          return v.isFinal() && (v.isClassVariable() || v.isInstanceVariable()) ? false : true;
2867        }
2868        else {
2869          return super.Define_isDUbefore(caller, child, v);
2870        }
2871      }
2872      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
2873        return true;
2874      }
2875      /**
2876       * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:113
2877       * @apilevel internal
2878       */
2879      public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
2880        if (caller == getBlockOptNoTransform()) {
2881          // @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:179
2882          return throwsException(exceptionType);
2883        }
2884        else {
2885          return getParent().Define_handlesException(this, caller, exceptionType);
2886        }
2887      }
2888      protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
2889        return true;
2890      }
2891      /**
2892       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
2893       * @apilevel internal
2894       */
2895      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
2896        if (caller == getParameterListNoTransform()) {
2897          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:72
2898          int childIndex = caller.getIndexOfChild(child);
2899          return parameterDeclaration(name);
2900        }
2901        else if (caller == getBlockOptNoTransform()) {
2902          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:61
2903          {
2904              SimpleSet set = parameterDeclaration(name);
2905              // A declaration of a method parameter name shadows any other variable declarations
2906              if (!set.isEmpty()) {
2907                return set;
2908              }
2909              // Delegate to other declarations in scope
2910              return lookupVariable(name);
2911            }
2912        }
2913        else {
2914          return getParent().Define_lookupVariable(this, caller, name);
2915        }
2916      }
2917      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
2918        return true;
2919      }
2920      /**
2921       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:419
2922       * @apilevel internal
2923       */
2924      public boolean Define_mayBePublic(ASTNode caller, ASTNode child) {
2925        if (caller == getModifiersNoTransform()) {
2926          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:312
2927          return true;
2928        }
2929        else {
2930          return getParent().Define_mayBePublic(this, caller);
2931        }
2932      }
2933      protected boolean canDefine_mayBePublic(ASTNode caller, ASTNode child) {
2934        return true;
2935      }
2936      /**
2937       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:421
2938       * @apilevel internal
2939       */
2940      public boolean Define_mayBeProtected(ASTNode caller, ASTNode child) {
2941        if (caller == getModifiersNoTransform()) {
2942          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:313
2943          return true;
2944        }
2945        else {
2946          return getParent().Define_mayBeProtected(this, caller);
2947        }
2948      }
2949      protected boolean canDefine_mayBeProtected(ASTNode caller, ASTNode child) {
2950        return true;
2951      }
2952      /**
2953       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:420
2954       * @apilevel internal
2955       */
2956      public boolean Define_mayBePrivate(ASTNode caller, ASTNode child) {
2957        if (caller == getModifiersNoTransform()) {
2958          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:314
2959          return true;
2960        }
2961        else {
2962          return getParent().Define_mayBePrivate(this, caller);
2963        }
2964      }
2965      protected boolean canDefine_mayBePrivate(ASTNode caller, ASTNode child) {
2966        return true;
2967      }
2968      /**
2969       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:424
2970       * @apilevel internal
2971       */
2972      public boolean Define_mayBeAbstract(ASTNode caller, ASTNode child) {
2973        if (caller == getModifiersNoTransform()) {
2974          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:315
2975          return true;
2976        }
2977        else {
2978          return getParent().Define_mayBeAbstract(this, caller);
2979        }
2980      }
2981      protected boolean canDefine_mayBeAbstract(ASTNode caller, ASTNode child) {
2982        return true;
2983      }
2984      /**
2985       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:422
2986       * @apilevel internal
2987       */
2988      public boolean Define_mayBeStatic(ASTNode caller, ASTNode child) {
2989        if (caller == getModifiersNoTransform()) {
2990          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:316
2991          return true;
2992        }
2993        else {
2994          return getParent().Define_mayBeStatic(this, caller);
2995        }
2996      }
2997      protected boolean canDefine_mayBeStatic(ASTNode caller, ASTNode child) {
2998        return true;
2999      }
3000      /**
3001       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423
3002       * @apilevel internal
3003       */
3004      public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) {
3005        if (caller == getModifiersNoTransform()) {
3006          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:317
3007          return true;
3008        }
3009        else {
3010          return getParent().Define_mayBeFinal(this, caller);
3011        }
3012      }
3013      protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) {
3014        return true;
3015      }
3016      /**
3017       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:428
3018       * @apilevel internal
3019       */
3020      public boolean Define_mayBeSynchronized(ASTNode caller, ASTNode child) {
3021        if (caller == getModifiersNoTransform()) {
3022          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:318
3023          return true;
3024        }
3025        else {
3026          return getParent().Define_mayBeSynchronized(this, caller);
3027        }
3028      }
3029      protected boolean canDefine_mayBeSynchronized(ASTNode caller, ASTNode child) {
3030        return true;
3031      }
3032      /**
3033       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:429
3034       * @apilevel internal
3035       */
3036      public boolean Define_mayBeNative(ASTNode caller, ASTNode child) {
3037        if (caller == getModifiersNoTransform()) {
3038          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:319
3039          return true;
3040        }
3041        else {
3042          return getParent().Define_mayBeNative(this, caller);
3043        }
3044      }
3045      protected boolean canDefine_mayBeNative(ASTNode caller, ASTNode child) {
3046        return true;
3047      }
3048      /**
3049       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:427
3050       * @apilevel internal
3051       */
3052      public boolean Define_mayBeStrictfp(ASTNode caller, ASTNode child) {
3053        if (caller == getModifiersNoTransform()) {
3054          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:320
3055          return true;
3056        }
3057        else {
3058          return getParent().Define_mayBeStrictfp(this, caller);
3059        }
3060      }
3061      protected boolean canDefine_mayBeStrictfp(ASTNode caller, ASTNode child) {
3062        return true;
3063      }
3064      /**
3065       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:310
3066       * @apilevel internal
3067       */
3068      public ASTNode Define_enclosingBlock(ASTNode caller, ASTNode child) {
3069        if (caller == getBlockOptNoTransform()) {
3070          // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:311
3071          return this;
3072        }
3073        else {
3074          return getParent().Define_enclosingBlock(this, caller);
3075        }
3076      }
3077      protected boolean canDefine_enclosingBlock(ASTNode caller, ASTNode child) {
3078        return true;
3079      }
3080      /**
3081       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
3082       * @apilevel internal
3083       */
3084      public NameType Define_nameType(ASTNode caller, ASTNode child) {
3085        if (caller == getExceptionListNoTransform()) {
3086          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:108
3087          int childIndex = caller.getIndexOfChild(child);
3088          return NameType.TYPE_NAME;
3089        }
3090        else if (caller == getParameterListNoTransform()) {
3091          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:107
3092          int childIndex = caller.getIndexOfChild(child);
3093          return NameType.TYPE_NAME;
3094        }
3095        else if (caller == getTypeAccessNoTransform()) {
3096          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:106
3097          return NameType.TYPE_NAME;
3098        }
3099        else {
3100          return getParent().Define_nameType(this, caller);
3101        }
3102      }
3103      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
3104        return true;
3105      }
3106      /**
3107       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:472
3108       * @apilevel internal
3109       */
3110      public TypeDecl Define_returnType(ASTNode caller, ASTNode child) {
3111        if (caller == getBlockOptNoTransform()) {
3112          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:474
3113          return type();
3114        }
3115        else {
3116          return getParent().Define_returnType(this, caller);
3117        }
3118      }
3119      protected boolean canDefine_returnType(ASTNode caller, ASTNode child) {
3120        return true;
3121      }
3122      /**
3123       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182
3124       * @apilevel internal
3125       */
3126      public boolean Define_inStaticContext(ASTNode caller, ASTNode child) {
3127        if (caller == getBlockOptNoTransform()) {
3128          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:190
3129          return isStatic();
3130        }
3131        else {
3132          return getParent().Define_inStaticContext(this, caller);
3133        }
3134      }
3135      protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) {
3136        return true;
3137      }
3138      /**
3139       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52
3140       * @apilevel internal
3141       */
3142      public boolean Define_reachable(ASTNode caller, ASTNode child) {
3143        if (caller == getBlockOptNoTransform()) {
3144          // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:64
3145          return true;
3146        }
3147        else {
3148          return getParent().Define_reachable(this, caller);
3149        }
3150      }
3151      protected boolean canDefine_reachable(ASTNode caller, ASTNode child) {
3152        return true;
3153      }
3154      /**
3155       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:44
3156       * @apilevel internal
3157       */
3158      public boolean Define_isMethodParameter(ASTNode caller, ASTNode child) {
3159        if (caller == getParameterListNoTransform()) {
3160          // @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:82
3161          int childIndex = caller.getIndexOfChild(child);
3162          return true;
3163        }
3164        else {
3165          return getParent().Define_isMethodParameter(this, caller);
3166        }
3167      }
3168      protected boolean canDefine_isMethodParameter(ASTNode caller, ASTNode child) {
3169        return true;
3170      }
3171      /**
3172       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:45
3173       * @apilevel internal
3174       */
3175      public boolean Define_isConstructorParameter(ASTNode caller, ASTNode child) {
3176        if (caller == getParameterListNoTransform()) {
3177          // @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:83
3178          int childIndex = caller.getIndexOfChild(child);
3179          return false;
3180        }
3181        else {
3182          return getParent().Define_isConstructorParameter(this, caller);
3183        }
3184      }
3185      protected boolean canDefine_isConstructorParameter(ASTNode caller, ASTNode child) {
3186        return true;
3187      }
3188      /**
3189       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:46
3190       * @apilevel internal
3191       */
3192      public boolean Define_isExceptionHandlerParameter(ASTNode caller, ASTNode child) {
3193        if (caller == getParameterListNoTransform()) {
3194          // @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:84
3195          int childIndex = caller.getIndexOfChild(child);
3196          return false;
3197        }
3198        else {
3199          return getParent().Define_isExceptionHandlerParameter(this, caller);
3200        }
3201      }
3202      protected boolean canDefine_isExceptionHandlerParameter(ASTNode caller, ASTNode child) {
3203        return true;
3204      }
3205      /**
3206       * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64
3207       * @apilevel internal
3208       */
3209      public int Define_localNum(ASTNode caller, ASTNode child) {
3210        if (caller == getBlockOptNoTransform()) {
3211          // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:109
3212          return offsetAfterParameters() + resultOffset();
3213        }
3214        else if (caller == getParameterListNoTransform()) {
3215          // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:80
3216          int index = caller.getIndexOfChild(child);
3217          {
3218              if (index == 0) {
3219                return offsetBeforeParameters();
3220              } else {
3221                ParameterDeclaration last = getParameter(index-1);
3222                return last.localNum() + last.type().variableSize();
3223              }
3224            }
3225        }
3226        else {
3227          return getParent().Define_localNum(this, caller);
3228        }
3229      }
3230      protected boolean canDefine_localNum(ASTNode caller, ASTNode child) {
3231        return true;
3232      }
3233      /**
3234       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:101
3235       * @apilevel internal
3236       */
3237      public int Define_resultSaveLocalNum(ASTNode caller, ASTNode child) {
3238        if (caller == getBlockOptNoTransform()) {
3239          // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:102
3240          return offsetAfterParameters();
3241        }
3242        else {
3243          return getParent().Define_resultSaveLocalNum(this, caller);
3244        }
3245      }
3246      protected boolean canDefine_resultSaveLocalNum(ASTNode caller, ASTNode child) {
3247        return true;
3248      }
3249      /**
3250       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:96
3251       * @apilevel internal
3252       */
3253      public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
3254        if (caller == getModifiersNoTransform()) {
3255          // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:113
3256          return name.equals("METHOD");
3257        }
3258        else {
3259          return getParent().Define_mayUseAnnotationTarget(this, caller, name);
3260        }
3261      }
3262      protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
3263        return true;
3264      }
3265      /**
3266       * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:48
3267       * @apilevel internal
3268       */
3269      public boolean Define_variableArityValid(ASTNode caller, ASTNode child) {
3270        if (caller == getParameterListNoTransform()) {
3271          // @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:44
3272          int i = caller.getIndexOfChild(child);
3273          return i == getNumParameter() - 1;
3274        }
3275        else {
3276          return getParent().Define_variableArityValid(this, caller);
3277        }
3278      }
3279      protected boolean canDefine_variableArityValid(ASTNode caller, ASTNode child) {
3280        return true;
3281      }
3282      /**
3283       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30
3284       * @apilevel internal
3285       */
3286      public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
3287        if (caller == getParameterListNoTransform()) {
3288          // @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:79
3289          int childIndex = caller.getIndexOfChild(child);
3290          return hasBlock() && getBlock().modifiedInScope(var);
3291        }
3292        else {
3293          return getParent().Define_inhModifiedInScope(this, caller, var);
3294        }
3295      }
3296      protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
3297        return true;
3298      }
3299      /**
3300       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:206
3301       * @apilevel internal
3302       */
3303      public boolean Define_isCatchParam(ASTNode caller, ASTNode child) {
3304        if (caller == getParameterListNoTransform()) {
3305          // @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:209
3306          int childIndex = caller.getIndexOfChild(child);
3307          return false;
3308        }
3309        else {
3310          return getParent().Define_isCatchParam(this, caller);
3311        }
3312      }
3313      protected boolean canDefine_isCatchParam(ASTNode caller, ASTNode child) {
3314        return true;
3315      }
3316      /**
3317       * @apilevel internal
3318       */
3319      public ASTNode rewriteTo() {
3320        return super.rewriteTo();
3321      }
3322    }