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