001    /* This file was generated with JastAdd2 (http://jastadd.org) version R20130213 */
002    package AST;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.*;
007    import beaver.*;
008    import java.util.ArrayList;
009    import java.util.zip.*;
010    import java.io.*;
011    import java.io.FileNotFoundException;
012    import java.util.Collection;
013    /**
014     * @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">[ConstructorInvocation:{@link Stmt}]</span> <span class="component">{@link Block}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:75
017     */
018    public class ConstructorDecl extends BodyDecl implements Cloneable, ExceptionHolder {
019      /**
020       * @apilevel low-level
021       */
022      public void flushCache() {
023      }
024      /**
025       * @apilevel internal
026       */
027      public void flushCollectionCache() {
028      }
029      /**
030       * @apilevel internal
031       */
032      @SuppressWarnings({"unchecked", "cast"})
033      public ConstructorDecl clone() throws CloneNotSupportedException {
034        ConstructorDecl node = (ConstructorDecl)super.clone();
035        node.accessibleFrom_TypeDecl_values = null;
036        node.isDAafter_Variable_values = null;
037        node.isDUafter_Variable_values = null;
038        node.throwsException_TypeDecl_values = null;
039        node.name_computed = false;
040        node.name_value = null;
041        node.signature_computed = false;
042        node.signature_value = null;
043        node.sameSignature_ConstructorDecl_values = null;
044        node.moreSpecificThan_ConstructorDecl_values = null;
045        node.parameterDeclaration_String_values = null;
046        node.circularThisInvocation_ConstructorDecl_values = null;
047        node.attributes_computed = false;
048        node.attributes_value = null;
049        node.descName_computed = false;
050        node.descName_value = null;
051        node.bytecodes_ConstantPool_values = null;
052        node.flags_computed = false;
053        node.localNumOfFirstParameter_computed = false;
054        node.offsetFirstEnclosingVariable_computed = false;
055        node.sourceConstructorDecl_computed = false;
056        node.sourceConstructorDecl_value = null;
057        node.handlesException_TypeDecl_values = null;
058        node.in$Circle(false);
059        node.is$Final(false);
060        return node;
061      }
062    /**
063     * @apilevel internal
064     */
065      @SuppressWarnings({"unchecked", "cast"})
066    public ConstructorDecl copy() {
067      
068      try {
069        ConstructorDecl node = (ConstructorDecl) clone();
070        node.parent = null;
071        if(children != null)
072          node.children = (ASTNode[]) children.clone();
073        
074        return node;
075      } catch (CloneNotSupportedException e) {
076        throw new Error("Error: clone not supported for " + getClass().getName());
077      }
078      
079    }/**
080     * Create a deep copy of the AST subtree at this node.
081     * The copy is dangling, i.e. has no parent.
082     * @return dangling copy of the subtree at this node
083     * @apilevel low-level
084     */
085      @SuppressWarnings({"unchecked", "cast"})
086    public ConstructorDecl fullCopy() {
087      
088      ConstructorDecl tree = (ConstructorDecl) copy();
089      if (children != null) {
090        for (int i = 0; i < children.length; ++i) {
091          
092          ASTNode child = (ASTNode) children[i];
093          if(child != null) {
094            child = child.fullCopy();
095            tree.setChild(child, i);
096          }
097        }
098      }
099      return tree;
100      
101    }  /**
102       * @ast method 
103       * @aspect ConstructorDecl
104       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:144
105       */
106      public boolean applicable(List argList) {
107        if(getNumParameter() != argList.getNumChild())
108          return false;
109        for(int i = 0; i < getNumParameter(); i++) {
110          TypeDecl arg = ((Expr)argList.getChild(i)).type();
111          TypeDecl parameter = getParameter(i).type();
112          if(!arg.instanceOf(parameter)) {
113            return false;
114          }  
115        }
116        return true;
117      }
118      /**
119       * Flag to indicate if this constructor is an auto-generated
120       * default constructor. Default constructors are not pretty
121       * printed.
122       * @ast method 
123       * @aspect ImplicitConstructor
124       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:171
125       */
126      
127    
128      /**
129       * Flag to indicate if this constructor is an auto-generated
130       * default constructor. Default constructors are not pretty
131       * printed.
132       */
133      private boolean isDefaultConstructor = false;
134      /**
135       * Set the default constructor flag. Causes this constructor
136       * to not be pretty printed.
137       * @ast method 
138       * @aspect ImplicitConstructor
139       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:176
140       */
141      public void setDefaultConstructor() {
142        isDefaultConstructor = true;
143      }
144      /**
145       * @ast method 
146       * @aspect Modifiers
147       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Modifiers.jrag:110
148       */
149      public void checkModifiers() {
150        super.checkModifiers();
151      }
152      /**
153       * @ast method 
154       * @aspect NameCheck
155       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:73
156       */
157      public void nameCheck() {
158        super.nameCheck();
159        // 8.8
160        if(!hostType().name().equals(name()))
161          error("constructor " + name() +" does not have the same name as the simple name of the host class " + hostType().name());
162        
163        // 8.8.2
164        if(hostType().lookupConstructor(this) != this)
165          error("constructor with signature " + signature() + " is multiply declared in type " + hostType().typeName());
166    
167        if(circularThisInvocation(this))
168          error("The constructor " + signature() + " may not directly or indirectly invoke itself");
169      }
170      /**
171       * @ast method 
172       * @aspect PrettyPrint
173       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:119
174       */
175      public void toString(StringBuffer s) {
176        if(isDefaultConstructor()) return;
177        s.append(indent());
178        getModifiers().toString(s);
179        s.append(name() + "(");
180        if(getNumParameter() > 0) {
181          getParameter(0).toString(s);
182          for(int i = 1; i < getNumParameter(); i++) {
183            s.append(", ");
184            getParameter(i).toString(s);
185          }
186        }
187        s.append(")");
188        if(getNumException() > 0) {
189          s.append(" throws ");
190          getException(0).toString(s);
191          for(int i = 1; i < getNumException(); i++) {
192            s.append(", ");
193            getException(i).toString(s);
194          }
195        }
196        
197        s.append(" {");
198        if(hasConstructorInvocation()) {
199          getConstructorInvocation().toString(s);
200        }
201        for(int i = 0; i < getBlock().getNumStmt(); i++) {
202          getBlock().getStmt(i).toString(s);
203        }
204        s.append(indent());
205        s.append("}");
206      }
207      /**
208       * @ast method 
209       * @aspect TypeCheck
210       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:424
211       */
212      public void typeCheck() {
213        // 8.8.4 (8.4.4)
214        TypeDecl exceptionType = typeThrowable();
215        for(int i = 0; i < getNumException(); i++) {
216          TypeDecl typeDecl = getException(i).type();
217          if(!typeDecl.instanceOf(exceptionType))
218            error(signature() + " throws non throwable type " + typeDecl.fullName());
219        }
220      }
221      /**
222       * @ast method 
223       * @aspect CodeGeneration
224       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:912
225       */
226      public void emitInvokeConstructor(CodeGeneration gen) {
227        int size = -1;
228        for(int i = 0; i < getNumParameter(); i++)
229          size -= getParameter(i).type().variableSize();
230        if(hostType().needsEnclosing())
231          size--;
232        if(hostType().needsSuperEnclosing()) {
233          size--;
234        }
235        String classname = hostType().constantPoolName();
236        String      desc = descName();
237        String      name = "<init>";
238        int index = gen.constantPool().addMethodref(classname, name, desc);
239        gen.emit(Bytecode.INVOKESPECIAL, size).add2(index);
240      }
241      /**
242       * @ast method 
243       * @aspect CreateBCode
244       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:111
245       */
246      private void generateBytecodes(CodeGeneration gen) {
247        int label = gen.variableScopeLabel();
248        gen.addLocalVariableEntryAtCurrentPC("this", hostType().typeDescriptor(), 0, label);
249        for(int i = 0; i < getNumParameter(); i++) {
250          ParameterDeclaration p = (ParameterDeclaration)getParameter(i);
251          gen.addLocalVariableEntryAtCurrentPC(
252            p.name(), p.type().typeDescriptor(), p.localNum(), label
253          );
254        }
255        createBCode(gen);
256        gen.emitReturn();
257        gen.addVariableScopeLabel(label);
258      }
259      /**
260       * @ast method 
261       * @aspect CreateBCode
262       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:137
263       */
264      public void createBCode(CodeGeneration gen) {
265        try {
266        boolean needsInit = true;
267    
268        if(hasConstructorInvocation()) {
269          getConstructorInvocation().createBCode(gen);
270          Stmt stmt = getConstructorInvocation();
271          if(stmt instanceof ExprStmt) {
272            ExprStmt exprStmt = (ExprStmt)stmt;
273            Expr expr = exprStmt.getExpr();
274            if(!expr.isSuperConstructorAccess())
275              needsInit = false;
276    
277          }
278        }
279    
280        if(needsEnclosing()) {
281          gen.emitLoadReference(0);
282          gen.emitLoadReference(1);
283          String classname = hostType().constantPoolName();
284          String desc = enclosing().typeDescriptor();
285          String name = "this$0";
286          int index = gen.constantPool().addFieldref(classname, name, desc);
287          gen.emit(Bytecode.PUTFIELD, -2).add2(index);
288        }
289    
290        int localIndex = offsetFirstEnclosingVariable();
291        for(Iterator iter = hostType().enclosingVariables().iterator(); iter.hasNext(); ) {
292            Variable v = (Variable)iter.next();
293            gen.emitLoadReference(0);
294            v.type().emitLoadLocal(gen, localIndex);
295            String classname = hostType().constantPoolName();
296            String desc = v.type().typeDescriptor();
297            String name = "val$" + v.name();
298            int index = gen.constantPool().addFieldref(classname, name, desc);
299            gen.emit(Bytecode.PUTFIELD, -1 - v.type().variableSize()).add2(index);
300            localIndex += v.type().variableSize();
301        }
302    
303        if(needsInit) {
304          TypeDecl typeDecl = hostType();
305          for(int i = 0; i < typeDecl.getNumBodyDecl(); i++) {
306            BodyDecl b = typeDecl.getBodyDecl(i);
307            if(b instanceof FieldDeclaration && b.isBytecodeField() && b.generate()) {
308              FieldDeclaration f = (FieldDeclaration)b;
309              if(!f.isStatic() && f.hasInit()) {
310                gen.emit(Bytecode.ALOAD_0);
311                f.getInit().createBCode(gen);
312                f.getInit().type().emitAssignConvTo(gen, f.type()); // AssignConversion
313                f.emitStoreField(gen, hostType());
314              }
315            }
316            else if(b instanceof InstanceInitializer) {
317              b.createBCode(gen);
318            }
319          }
320        }
321        gen.maxLocals = Math.max(gen.maxLocals, getBlock().localNum());
322        getBlock().createBCode(gen);
323        } catch (Error e) {
324          System.err.println(hostType().typeName() + ": " + this);
325          throw e;
326        }
327      }
328      /**
329       * @ast method 
330       * @aspect GenerateClassfile
331       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/GenerateClassfile.jrag:252
332       */
333      public void generateMethod(DataOutputStream out, ConstantPool cp) throws IOException {
334        out.writeChar(flags());
335        out.writeChar(cp.addUtf8("<init>"));
336        out.writeChar(cp.addUtf8(descName()));
337        out.writeChar(attributes().size());
338        for(Iterator itera = attributes().iterator(); itera.hasNext();)
339          ((Attribute)itera.next()).emit(out);
340      }
341      /**
342       * @ast method 
343       * @aspect GenerateClassfile
344       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/GenerateClassfile.jrag:268
345       */
346      public void touchMethod(ConstantPool cp) {
347        cp.addUtf8("<init>");
348        cp.addUtf8(descName());
349        attributes();
350      }
351      /**
352       * @ast method 
353       * @aspect GenerateClassfile
354       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/GenerateClassfile.jrag:376
355       */
356      public boolean clear() {
357        getBlock().clear();
358        setBlock(new Block(new List()));
359        bytecodes_ConstantPool_values = null;
360        return false;
361      }
362      /**
363       * @ast method 
364       * @aspect InnerClasses
365       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:457
366       */
367      
368    
369      // add val$name as parameters to the constructor
370      protected boolean addEnclosingVariables = true;
371      /**
372       * @ast method 
373       * @aspect InnerClasses
374       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:458
375       */
376      public void addEnclosingVariables() {
377        if(!addEnclosingVariables) return;
378        addEnclosingVariables = false;
379        hostType().addEnclosingVariables();
380        for(Iterator iter = hostType().enclosingVariables().iterator(); iter.hasNext(); ) {
381          Variable v = (Variable)iter.next();
382          getParameterList().add(new ParameterDeclaration(v.type(), "val$" + v.name()));
383        }
384      }
385      /**
386       * @ast method 
387       * @aspect InnerClasses
388       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:492
389       */
390      public ConstructorDecl createAccessor() {
391        ConstructorDecl c = (ConstructorDecl)hostType().getAccessor(this, "constructor");
392        if(c != null) return c;
393    
394        // make sure enclosing varibles are added as parameters prior to building accessor
395        addEnclosingVariables();
396    
397        Modifiers modifiers = new Modifiers(new List());
398        modifiers.addModifier(new Modifier("synthetic"));
399        modifiers.addModifier(new Modifier("public"));
400    
401        List parameters = createAccessorParameters();
402    
403        List exceptionList = new List(); 
404        for(int i = 0; i < getNumException(); i++)
405          exceptionList.add(getException(i).type().createQualifiedAccess());
406        
407        // add all parameters as arguments except for the dummy parameter
408        List args = new List();
409        for(int i = 0; i < parameters.getNumChildNoTransform() - 1; i++)
410          args.add(new VarAccess(((ParameterDeclaration)parameters.getChildNoTransform(i)).name()));
411        ConstructorAccess access = new ConstructorAccess("this", args);
412        access.addEnclosingVariables = false;
413    
414        c = new ConstructorDecl(
415          modifiers,
416          name(),
417          parameters,
418          exceptionList,
419          new Opt(
420            new ExprStmt(
421              access
422            )
423          ),
424          new Block(
425            new List().add(new ReturnStmt(new Opt()))
426          )
427        );
428        c = hostType().addConstructor(c);
429        c.addEnclosingVariables = false;
430        hostType().addAccessor(this, "constructor", c);
431        return c;
432      }
433      /**
434       * @ast method 
435       * @aspect InnerClasses
436       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:536
437       */
438      protected List createAccessorParameters() {
439        List parameters = new List();
440        for (int i=0; i<getNumParameter(); i++)
441          parameters.add(new ParameterDeclaration(getParameter(i).type(), getParameter(i).name()));
442        parameters.add(new ParameterDeclaration(createAnonymousJavaTypeDecl().createBoundAccess(), ("p" + getNumParameter())));
443        return parameters;
444      }
445      /**
446       * @ast method 
447       * @aspect InnerClasses
448       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:544
449       */
450      protected TypeDecl createAnonymousJavaTypeDecl() {
451        ClassDecl classDecl =
452          new ClassDecl(
453              new Modifiers(new List().add(new Modifier("synthetic"))),
454              "" + hostType().nextAnonymousIndex(),
455              new Opt(),
456              new List(),
457              new List()
458          );
459        classDecl = hostType().addMemberClass(classDecl);
460        hostType().addNestedType(classDecl);
461        return classDecl;
462      }
463      /**
464       * @ast method 
465       * @aspect Transformations
466       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Transformations.jrag:119
467       */
468      public void transformation() {
469        // this$val as fields and constructor parameters
470        addEnclosingVariables();
471        super.transformation();
472      }
473      /**
474       * @ast method 
475       * @aspect Enums
476       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Enums.jrag:138
477       */
478      protected void transformEnumConstructors() {
479        // make sure constructor is private
480        Modifiers newModifiers = new Modifiers(new List());
481        for (int i = 0; i < getModifiers().getNumModifier(); ++i) {
482          String modifier = getModifiers().getModifier(i).getID();
483          if (modifier.equals("public") || modifier.equals("private") ||
484            modifier.equals("protected"))
485              continue;
486          newModifiers.addModifier(new Modifier(modifier));
487        }
488        newModifiers.addModifier(new Modifier("private"));
489        setModifiers(newModifiers);
490    
491        // add implicit super constructor access since we are traversing
492        // without doing rewrites
493        if(!hasConstructorInvocation()) {
494          setConstructorInvocation(
495            new ExprStmt(
496              new SuperConstructorAccess("super", new List())
497            )
498          );
499        }
500        super.transformEnumConstructors();
501        getParameterList().insertChild(
502          new ParameterDeclaration(new TypeAccess("java.lang", "String"), "@p0"),
503          0
504        );
505        getParameterList().insertChild(
506          new ParameterDeclaration(new TypeAccess("int"), "@p1"),
507          1
508        );
509      }
510      /**
511       * @ast method 
512       * @aspect LookupParTypeDecl
513       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:1283
514       */
515      public BodyDecl substitutedBodyDecl(Parameterization parTypeDecl) {
516        ConstructorDecl c = new ConstructorDeclSubstituted(
517          (Modifiers)getModifiers().fullCopy(),
518          getID(),
519          getParameterList().substitute(parTypeDecl),
520          getExceptionList().substitute(parTypeDecl),
521          new Opt(),
522          new Block(),
523          this
524        );
525        return c;
526      }
527      /**
528       * @ast method 
529       * 
530       */
531      public ConstructorDecl() {
532        super();
533    
534    
535      }
536      /**
537       * Initializes the child array to the correct size.
538       * Initializes List and Opt nta children.
539       * @apilevel internal
540       * @ast method
541       * @ast method 
542       * 
543       */
544      public void init$Children() {
545        children = new ASTNode[5];
546        setChild(new List(), 1);
547        setChild(new List(), 2);
548        setChild(new Opt(), 3);
549      }
550      /**
551       * @ast method 
552       * 
553       */
554      public ConstructorDecl(Modifiers p0, String p1, List<ParameterDeclaration> p2, List<Access> p3, Opt<Stmt> p4, Block p5) {
555        setChild(p0, 0);
556        setID(p1);
557        setChild(p2, 1);
558        setChild(p3, 2);
559        setChild(p4, 3);
560        setChild(p5, 4);
561      }
562      /**
563       * @ast method 
564       * 
565       */
566      public ConstructorDecl(Modifiers p0, beaver.Symbol p1, List<ParameterDeclaration> p2, List<Access> p3, Opt<Stmt> p4, Block p5) {
567        setChild(p0, 0);
568        setID(p1);
569        setChild(p2, 1);
570        setChild(p3, 2);
571        setChild(p4, 3);
572        setChild(p5, 4);
573      }
574      /**
575       * @apilevel low-level
576       * @ast method 
577       * 
578       */
579      protected int numChildren() {
580        return 5;
581      }
582      /**
583       * @apilevel internal
584       * @ast method 
585       * 
586       */
587      public boolean mayHaveRewrite() {
588        return true;
589      }
590      /**
591       * Replaces the Modifiers child.
592       * @param node The new node to replace the Modifiers child.
593       * @apilevel high-level
594       * @ast method 
595       * 
596       */
597      public void setModifiers(Modifiers node) {
598        setChild(node, 0);
599      }
600      /**
601       * Retrieves the Modifiers child.
602       * @return The current node used as the Modifiers child.
603       * @apilevel high-level
604       * @ast method 
605       * 
606       */
607      public Modifiers getModifiers() {
608        return (Modifiers)getChild(0);
609      }
610      /**
611       * Retrieves the Modifiers child.
612       * <p><em>This method does not invoke AST transformations.</em></p>
613       * @return The current node used as the Modifiers child.
614       * @apilevel low-level
615       * @ast method 
616       * 
617       */
618      public Modifiers getModifiersNoTransform() {
619        return (Modifiers)getChildNoTransform(0);
620      }
621      /**
622       * Replaces the lexeme ID.
623       * @param value The new value for the lexeme ID.
624       * @apilevel high-level
625       * @ast method 
626       * 
627       */
628      public void setID(String value) {
629        tokenString_ID = value;
630      }
631      /**
632       * @apilevel internal
633       * @ast method 
634       * 
635       */
636      
637      /**
638       * @apilevel internal
639       */
640      protected String tokenString_ID;
641      /**
642       * @ast method 
643       * 
644       */
645      
646      public int IDstart;
647      /**
648       * @ast method 
649       * 
650       */
651      
652      public int IDend;
653      /**
654       * JastAdd-internal setter for lexeme ID using the Beaver parser.
655       * @apilevel internal
656       * @ast method 
657       * 
658       */
659      public void setID(beaver.Symbol symbol) {
660        if(symbol.value != null && !(symbol.value instanceof String))
661          throw new UnsupportedOperationException("setID is only valid for String lexemes");
662        tokenString_ID = (String)symbol.value;
663        IDstart = symbol.getStart();
664        IDend = symbol.getEnd();
665      }
666      /**
667       * Retrieves the value for the lexeme ID.
668       * @return The value for the lexeme ID.
669       * @apilevel high-level
670       * @ast method 
671       * 
672       */
673      public String getID() {
674        return tokenString_ID != null ? tokenString_ID : "";
675      }
676      /**
677       * Replaces the Parameter list.
678       * @param list The new list node to be used as the Parameter list.
679       * @apilevel high-level
680       * @ast method 
681       * 
682       */
683      public void setParameterList(List<ParameterDeclaration> list) {
684        setChild(list, 1);
685      }
686      /**
687       * Retrieves the number of children in the Parameter list.
688       * @return Number of children in the Parameter list.
689       * @apilevel high-level
690       * @ast method 
691       * 
692       */
693      public int getNumParameter() {
694        return getParameterList().getNumChild();
695      }
696      /**
697       * Retrieves the number of children in the Parameter list.
698       * Calling this method will not trigger rewrites..
699       * @return Number of children in the Parameter list.
700       * @apilevel low-level
701       * @ast method 
702       * 
703       */
704      public int getNumParameterNoTransform() {
705        return getParameterListNoTransform().getNumChildNoTransform();
706      }
707      /**
708       * Retrieves the element at index {@code i} in the Parameter list..
709       * @param i Index of the element to return.
710       * @return The element at position {@code i} in the Parameter list.
711       * @apilevel high-level
712       * @ast method 
713       * 
714       */
715      @SuppressWarnings({"unchecked", "cast"})
716      public ParameterDeclaration getParameter(int i) {
717        return (ParameterDeclaration)getParameterList().getChild(i);
718      }
719      /**
720       * Append an element to the Parameter list.
721       * @param node The element to append to the Parameter list.
722       * @apilevel high-level
723       * @ast method 
724       * 
725       */
726      public void addParameter(ParameterDeclaration node) {
727        List<ParameterDeclaration> list = (parent == null || state == null) ? getParameterListNoTransform() : getParameterList();
728        list.addChild(node);
729      }
730      /**
731       * @apilevel low-level
732       * @ast method 
733       * 
734       */
735      public void addParameterNoTransform(ParameterDeclaration node) {
736        List<ParameterDeclaration> list = getParameterListNoTransform();
737        list.addChild(node);
738      }
739      /**
740       * Replaces the Parameter list element at index {@code i} with the new node {@code node}.
741       * @param node The new node to replace the old list element.
742       * @param i The list index of the node to be replaced.
743       * @apilevel high-level
744       * @ast method 
745       * 
746       */
747      public void setParameter(ParameterDeclaration node, int i) {
748        List<ParameterDeclaration> list = getParameterList();
749        list.setChild(node, i);
750      }
751      /**
752       * Retrieves the Parameter list.
753       * @return The node representing the Parameter list.
754       * @apilevel high-level
755       * @ast method 
756       * 
757       */
758      public List<ParameterDeclaration> getParameters() {
759        return getParameterList();
760      }
761      /**
762       * Retrieves the Parameter list.
763       * <p><em>This method does not invoke AST transformations.</em></p>
764       * @return The node representing the Parameter list.
765       * @apilevel low-level
766       * @ast method 
767       * 
768       */
769      public List<ParameterDeclaration> getParametersNoTransform() {
770        return getParameterListNoTransform();
771      }
772      /**
773       * Retrieves the Parameter list.
774       * @return The node representing the Parameter list.
775       * @apilevel high-level
776       * @ast method 
777       * 
778       */
779      @SuppressWarnings({"unchecked", "cast"})
780      public List<ParameterDeclaration> getParameterList() {
781        List<ParameterDeclaration> list = (List<ParameterDeclaration>)getChild(1);
782        list.getNumChild();
783        return list;
784      }
785      /**
786       * Retrieves the Parameter list.
787       * <p><em>This method does not invoke AST transformations.</em></p>
788       * @return The node representing the Parameter list.
789       * @apilevel low-level
790       * @ast method 
791       * 
792       */
793      @SuppressWarnings({"unchecked", "cast"})
794      public List<ParameterDeclaration> getParameterListNoTransform() {
795        return (List<ParameterDeclaration>)getChildNoTransform(1);
796      }
797      /**
798       * Replaces the Exception list.
799       * @param list The new list node to be used as the Exception list.
800       * @apilevel high-level
801       * @ast method 
802       * 
803       */
804      public void setExceptionList(List<Access> list) {
805        setChild(list, 2);
806      }
807      /**
808       * Retrieves the number of children in the Exception list.
809       * @return Number of children in the Exception list.
810       * @apilevel high-level
811       * @ast method 
812       * 
813       */
814      public int getNumException() {
815        return getExceptionList().getNumChild();
816      }
817      /**
818       * Retrieves the number of children in the Exception list.
819       * Calling this method will not trigger rewrites..
820       * @return Number of children in the Exception list.
821       * @apilevel low-level
822       * @ast method 
823       * 
824       */
825      public int getNumExceptionNoTransform() {
826        return getExceptionListNoTransform().getNumChildNoTransform();
827      }
828      /**
829       * Retrieves the element at index {@code i} in the Exception list..
830       * @param i Index of the element to return.
831       * @return The element at position {@code i} in the Exception list.
832       * @apilevel high-level
833       * @ast method 
834       * 
835       */
836      @SuppressWarnings({"unchecked", "cast"})
837      public Access getException(int i) {
838        return (Access)getExceptionList().getChild(i);
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       * @ast method 
845       * 
846       */
847      public void addException(Access node) {
848        List<Access> list = (parent == null || state == null) ? getExceptionListNoTransform() : getExceptionList();
849        list.addChild(node);
850      }
851      /**
852       * @apilevel low-level
853       * @ast method 
854       * 
855       */
856      public void addExceptionNoTransform(Access node) {
857        List<Access> list = getExceptionListNoTransform();
858        list.addChild(node);
859      }
860      /**
861       * Replaces the Exception list element at index {@code i} with the new node {@code node}.
862       * @param node The new node to replace the old list element.
863       * @param i The list index of the node to be replaced.
864       * @apilevel high-level
865       * @ast method 
866       * 
867       */
868      public void setException(Access node, int i) {
869        List<Access> list = getExceptionList();
870        list.setChild(node, i);
871      }
872      /**
873       * Retrieves the Exception list.
874       * @return The node representing the Exception list.
875       * @apilevel high-level
876       * @ast method 
877       * 
878       */
879      public List<Access> getExceptions() {
880        return getExceptionList();
881      }
882      /**
883       * Retrieves the Exception list.
884       * <p><em>This method does not invoke AST transformations.</em></p>
885       * @return The node representing the Exception list.
886       * @apilevel low-level
887       * @ast method 
888       * 
889       */
890      public List<Access> getExceptionsNoTransform() {
891        return getExceptionListNoTransform();
892      }
893      /**
894       * Retrieves the Exception list.
895       * @return The node representing the Exception list.
896       * @apilevel high-level
897       * @ast method 
898       * 
899       */
900      @SuppressWarnings({"unchecked", "cast"})
901      public List<Access> getExceptionList() {
902        List<Access> list = (List<Access>)getChild(2);
903        list.getNumChild();
904        return list;
905      }
906      /**
907       * Retrieves the Exception list.
908       * <p><em>This method does not invoke AST transformations.</em></p>
909       * @return The node representing the Exception list.
910       * @apilevel low-level
911       * @ast method 
912       * 
913       */
914      @SuppressWarnings({"unchecked", "cast"})
915      public List<Access> getExceptionListNoTransform() {
916        return (List<Access>)getChildNoTransform(2);
917      }
918      /**
919       * Replaces the optional node for the ConstructorInvocation child. This is the {@code Opt} node containing the child ConstructorInvocation, not the actual child!
920       * @param opt The new node to be used as the optional node for the ConstructorInvocation child.
921       * @apilevel low-level
922       * @ast method 
923       * 
924       */
925      public void setConstructorInvocationOpt(Opt<Stmt> opt) {
926        setChild(opt, 3);
927      }
928      /**
929       * Check whether the optional ConstructorInvocation child exists.
930       * @return {@code true} if the optional ConstructorInvocation child exists, {@code false} if it does not.
931       * @apilevel high-level
932       * @ast method 
933       * 
934       */
935      public boolean hasConstructorInvocation() {
936        return getConstructorInvocationOpt().getNumChild() != 0;
937      }
938      /**
939       * Retrieves the (optional) ConstructorInvocation child.
940       * @return The ConstructorInvocation child, if it exists. Returns {@code null} otherwise.
941       * @apilevel low-level
942       * @ast method 
943       * 
944       */
945      @SuppressWarnings({"unchecked", "cast"})
946      public Stmt getConstructorInvocation() {
947        return (Stmt)getConstructorInvocationOpt().getChild(0);
948      }
949      /**
950       * Replaces the (optional) ConstructorInvocation child.
951       * @param node The new node to be used as the ConstructorInvocation child.
952       * @apilevel high-level
953       * @ast method 
954       * 
955       */
956      public void setConstructorInvocation(Stmt node) {
957        getConstructorInvocationOpt().setChild(node, 0);
958      }
959      /**
960       * @apilevel low-level
961       * @ast method 
962       * 
963       */
964      @SuppressWarnings({"unchecked", "cast"})
965      public Opt<Stmt> getConstructorInvocationOpt() {
966        return (Opt<Stmt>)getChild(3);
967      }
968      /**
969       * Retrieves the optional node for child ConstructorInvocation. This is the {@code Opt} node containing the child ConstructorInvocation, not the actual child!
970       * <p><em>This method does not invoke AST transformations.</em></p>
971       * @return The optional node for child ConstructorInvocation.
972       * @apilevel low-level
973       * @ast method 
974       * 
975       */
976      @SuppressWarnings({"unchecked", "cast"})
977      public Opt<Stmt> getConstructorInvocationOptNoTransform() {
978        return (Opt<Stmt>)getChildNoTransform(3);
979      }
980      /**
981       * Replaces the Block child.
982       * @param node The new node to replace the Block child.
983       * @apilevel high-level
984       * @ast method 
985       * 
986       */
987      public void setBlock(Block node) {
988        setChild(node, 4);
989      }
990      /**
991       * Retrieves the Block child.
992       * @return The current node used as the Block child.
993       * @apilevel high-level
994       * @ast method 
995       * 
996       */
997      public Block getBlock() {
998        return (Block)getChild(4);
999      }
1000      /**
1001       * Retrieves the Block child.
1002       * <p><em>This method does not invoke AST transformations.</em></p>
1003       * @return The current node used as the Block child.
1004       * @apilevel low-level
1005       * @ast method 
1006       * 
1007       */
1008      public Block getBlockNoTransform() {
1009        return (Block)getChildNoTransform(4);
1010      }
1011      /**
1012       * @ast method 
1013       * @aspect ConstructorDecl
1014       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:136
1015       */
1016      private boolean refined_ConstructorDecl_ConstructorDecl_moreSpecificThan_ConstructorDecl(ConstructorDecl m)
1017    {
1018        for(int i = 0; i < getNumParameter(); i++) {
1019          if(!getParameter(i).type().instanceOf(m.getParameter(i).type()))
1020            return false;
1021        }
1022        return true;
1023      }
1024      /**
1025       * @ast method 
1026       * @aspect Attributes
1027       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Attributes.jrag:198
1028       */
1029      private Collection refined_Attributes_ConstructorDecl_attributes()
1030    {
1031        ArrayList l = new ArrayList();
1032        l.add(new CodeAttribute(bytecodes(hostType().constantPool()), null));
1033        l.add(new ExceptionsAttribute(bytecodes(hostType().constantPool()), this));
1034        if(getModifiers().isSynthetic())
1035          l.add(new SyntheticAttribute(hostType().constantPool()));
1036        return l;
1037      }
1038      /**
1039       * @ast method 
1040       * @aspect Flags
1041       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Flags.jrag:54
1042       */
1043      private int refined_Flags_ConstructorDecl_flags()
1044    {
1045        int res = 0;
1046        if(isPublic()) res |= Modifiers.ACC_PUBLIC;
1047        if(isPrivate()) res |= Modifiers.ACC_PRIVATE;
1048        if(isProtected()) res |= Modifiers.ACC_PROTECTED;
1049        //if(isSynchronized()) res |= Modifiers.ACC_SYNCHRONIZED;
1050        //if(isStrictfp()) res |= Modifiers.ACC_STRICT;
1051        return res;
1052      }
1053      protected java.util.Map accessibleFrom_TypeDecl_values;
1054      /**
1055       * @attribute syn
1056       * @aspect AccessControl
1057       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/AccessControl.jrag:94
1058       */
1059      @SuppressWarnings({"unchecked", "cast"})
1060      public boolean accessibleFrom(TypeDecl type) {
1061        Object _parameters = type;
1062        if(accessibleFrom_TypeDecl_values == null) accessibleFrom_TypeDecl_values = new java.util.HashMap(4);
1063        if(accessibleFrom_TypeDecl_values.containsKey(_parameters)) {
1064          return ((Boolean)accessibleFrom_TypeDecl_values.get(_parameters)).booleanValue();
1065        }
1066          ASTNode$State state = state();
1067      int num = state.boundariesCrossed;
1068      boolean isFinal = this.is$Final();
1069        boolean accessibleFrom_TypeDecl_value = accessibleFrom_compute(type);
1070      if(isFinal && num == state().boundariesCrossed){ accessibleFrom_TypeDecl_values.put(_parameters, Boolean.valueOf(accessibleFrom_TypeDecl_value)); }
1071            return accessibleFrom_TypeDecl_value;
1072      }
1073      /**
1074       * @apilevel internal
1075       */
1076      private boolean accessibleFrom_compute(TypeDecl type) {
1077        if(!hostType().accessibleFrom(type))
1078          return false;
1079        else if(isPublic())
1080          return true;
1081        else if(isProtected()) {
1082          return true;
1083        }
1084        else if(isPrivate()) {
1085          return hostType().topLevelType() == type.topLevelType();
1086        }
1087        else
1088          return hostPackage().equals(type.hostPackage());
1089      }
1090      protected java.util.Map isDAafter_Variable_values;
1091      /**
1092       * @attribute syn
1093       * @aspect DA
1094       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:295
1095       */
1096      @SuppressWarnings({"unchecked", "cast"})
1097      public boolean isDAafter(Variable v) {
1098        Object _parameters = v;
1099        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
1100        if(isDAafter_Variable_values.containsKey(_parameters)) {
1101          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
1102        }
1103          ASTNode$State state = state();
1104      int num = state.boundariesCrossed;
1105      boolean isFinal = this.is$Final();
1106        boolean isDAafter_Variable_value = isDAafter_compute(v);
1107      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
1108            return isDAafter_Variable_value;
1109      }
1110      /**
1111       * @apilevel internal
1112       */
1113      private boolean isDAafter_compute(Variable v) {  return getBlock().isDAafter(v) && getBlock().checkReturnDA(v);  }
1114      protected java.util.Map isDUafter_Variable_values;
1115      /**
1116       * @attribute syn
1117       * @aspect DU
1118       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:752
1119       */
1120      @SuppressWarnings({"unchecked", "cast"})
1121      public boolean isDUafter(Variable v) {
1122        Object _parameters = v;
1123        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
1124        if(isDUafter_Variable_values.containsKey(_parameters)) {
1125          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
1126        }
1127          ASTNode$State state = state();
1128      int num = state.boundariesCrossed;
1129      boolean isFinal = this.is$Final();
1130        boolean isDUafter_Variable_value = isDUafter_compute(v);
1131      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
1132            return isDUafter_Variable_value;
1133      }
1134      /**
1135       * @apilevel internal
1136       */
1137      private boolean isDUafter_compute(Variable v) {  return getBlock().isDUafter(v) && getBlock().checkReturnDU(v);  }
1138      protected java.util.Map throwsException_TypeDecl_values;
1139      /**
1140       * @attribute syn
1141       * @aspect ExceptionHandling
1142       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ExceptionHandling.jrag:159
1143       */
1144      @SuppressWarnings({"unchecked", "cast"})
1145      public boolean throwsException(TypeDecl exceptionType) {
1146        Object _parameters = exceptionType;
1147        if(throwsException_TypeDecl_values == null) throwsException_TypeDecl_values = new java.util.HashMap(4);
1148        if(throwsException_TypeDecl_values.containsKey(_parameters)) {
1149          return ((Boolean)throwsException_TypeDecl_values.get(_parameters)).booleanValue();
1150        }
1151          ASTNode$State state = state();
1152      int num = state.boundariesCrossed;
1153      boolean isFinal = this.is$Final();
1154        boolean throwsException_TypeDecl_value = throwsException_compute(exceptionType);
1155      if(isFinal && num == state().boundariesCrossed){ throwsException_TypeDecl_values.put(_parameters, Boolean.valueOf(throwsException_TypeDecl_value)); }
1156            return throwsException_TypeDecl_value;
1157      }
1158      /**
1159       * @apilevel internal
1160       */
1161      private boolean throwsException_compute(TypeDecl exceptionType) {
1162        for(int i = 0; i < getNumException(); i++)
1163          if(exceptionType.instanceOf(getException(i).type()))
1164            return true;
1165        return false;
1166      }
1167      /**
1168       * @apilevel internal
1169       */
1170      protected boolean name_computed = false;
1171      /**
1172       * @apilevel internal
1173       */
1174      protected String name_value;
1175      /**
1176       * @attribute syn
1177       * @aspect ConstructorDecl
1178       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:110
1179       */
1180      @SuppressWarnings({"unchecked", "cast"})
1181      public String name() {
1182        if(name_computed) {
1183          return name_value;
1184        }
1185          ASTNode$State state = state();
1186      int num = state.boundariesCrossed;
1187      boolean isFinal = this.is$Final();
1188        name_value = name_compute();
1189      if(isFinal && num == state().boundariesCrossed){ name_computed = true; }
1190            return name_value;
1191      }
1192      /**
1193       * @apilevel internal
1194       */
1195      private String name_compute() {  return getID();  }
1196      /**
1197       * @apilevel internal
1198       */
1199      protected boolean signature_computed = false;
1200      /**
1201       * @apilevel internal
1202       */
1203      protected String signature_value;
1204      /**
1205       * @attribute syn
1206       * @aspect ConstructorDecl
1207       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:112
1208       */
1209      @SuppressWarnings({"unchecked", "cast"})
1210      public String signature() {
1211        if(signature_computed) {
1212          return signature_value;
1213        }
1214          ASTNode$State state = state();
1215      int num = state.boundariesCrossed;
1216      boolean isFinal = this.is$Final();
1217        signature_value = signature_compute();
1218      if(isFinal && num == state().boundariesCrossed){ signature_computed = true; }
1219            return signature_value;
1220      }
1221      /**
1222       * @apilevel internal
1223       */
1224      private String signature_compute() {
1225        StringBuffer s = new StringBuffer();
1226        s.append(name() + "(");
1227        for(int i = 0; i < getNumParameter(); i++) {
1228          s.append(getParameter(i));
1229          if(i != getNumParameter() - 1)
1230            s.append(", ");
1231        }
1232        s.append(")");
1233        return s.toString();
1234      }
1235      protected java.util.Map sameSignature_ConstructorDecl_values;
1236      /**
1237       * @attribute syn
1238       * @aspect ConstructorDecl
1239       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:125
1240       */
1241      @SuppressWarnings({"unchecked", "cast"})
1242      public boolean sameSignature(ConstructorDecl c) {
1243        Object _parameters = c;
1244        if(sameSignature_ConstructorDecl_values == null) sameSignature_ConstructorDecl_values = new java.util.HashMap(4);
1245        if(sameSignature_ConstructorDecl_values.containsKey(_parameters)) {
1246          return ((Boolean)sameSignature_ConstructorDecl_values.get(_parameters)).booleanValue();
1247        }
1248          ASTNode$State state = state();
1249      int num = state.boundariesCrossed;
1250      boolean isFinal = this.is$Final();
1251        boolean sameSignature_ConstructorDecl_value = sameSignature_compute(c);
1252      if(isFinal && num == state().boundariesCrossed){ sameSignature_ConstructorDecl_values.put(_parameters, Boolean.valueOf(sameSignature_ConstructorDecl_value)); }
1253            return sameSignature_ConstructorDecl_value;
1254      }
1255      /**
1256       * @apilevel internal
1257       */
1258      private boolean sameSignature_compute(ConstructorDecl c) {
1259        if(!name().equals(c.name()))
1260          return false;
1261        if(c.getNumParameter() != getNumParameter())
1262          return false;
1263        for(int i = 0; i < getNumParameter(); i++)
1264          if(!c.getParameter(i).type().equals(getParameter(i).type()))
1265            return false;
1266        return true;
1267      }
1268      protected java.util.Map moreSpecificThan_ConstructorDecl_values;
1269      /**
1270       * @attribute syn
1271       * @aspect MethodSignature15
1272       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/MethodSignature.jrag:168
1273       */
1274      @SuppressWarnings({"unchecked", "cast"})
1275      public boolean moreSpecificThan(ConstructorDecl m) {
1276        Object _parameters = m;
1277        if(moreSpecificThan_ConstructorDecl_values == null) moreSpecificThan_ConstructorDecl_values = new java.util.HashMap(4);
1278        if(moreSpecificThan_ConstructorDecl_values.containsKey(_parameters)) {
1279          return ((Boolean)moreSpecificThan_ConstructorDecl_values.get(_parameters)).booleanValue();
1280        }
1281          ASTNode$State state = state();
1282      int num = state.boundariesCrossed;
1283      boolean isFinal = this.is$Final();
1284        boolean moreSpecificThan_ConstructorDecl_value = moreSpecificThan_compute(m);
1285      if(isFinal && num == state().boundariesCrossed){ moreSpecificThan_ConstructorDecl_values.put(_parameters, Boolean.valueOf(moreSpecificThan_ConstructorDecl_value)); }
1286            return moreSpecificThan_ConstructorDecl_value;
1287      }
1288      /**
1289       * @apilevel internal
1290       */
1291      private boolean moreSpecificThan_compute(ConstructorDecl m) {
1292        if(!isVariableArity() && !m.isVariableArity())
1293          return refined_ConstructorDecl_ConstructorDecl_moreSpecificThan_ConstructorDecl(m);
1294        int num = Math.max(getNumParameter(), m.getNumParameter());
1295        for(int i = 0; i < num; i++) {
1296          TypeDecl t1 = i < getNumParameter() - 1 ? getParameter(i).type() : getParameter(getNumParameter()-1).type().componentType();
1297          TypeDecl t2 = i < m.getNumParameter() - 1 ? m.getParameter(i).type() : m.getParameter(m.getNumParameter()-1).type().componentType();
1298          if(!t1.instanceOf(t2))
1299            return false;
1300        }
1301        return true;
1302      }
1303      /**
1304       * @return true if this is an auto-generated default constructor
1305       * @attribute syn
1306       * @aspect ImplicitConstructor
1307       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:182
1308       */
1309      public boolean isDefaultConstructor() {
1310        ASTNode$State state = state();
1311        try {  return isDefaultConstructor;  }
1312        finally {
1313        }
1314      }
1315      protected java.util.Map parameterDeclaration_String_values;
1316      /**
1317       * @attribute syn
1318       * @aspect VariableScope
1319       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupVariable.jrag:105
1320       */
1321      @SuppressWarnings({"unchecked", "cast"})
1322      public SimpleSet parameterDeclaration(String name) {
1323        Object _parameters = name;
1324        if(parameterDeclaration_String_values == null) parameterDeclaration_String_values = new java.util.HashMap(4);
1325        if(parameterDeclaration_String_values.containsKey(_parameters)) {
1326          return (SimpleSet)parameterDeclaration_String_values.get(_parameters);
1327        }
1328          ASTNode$State state = state();
1329      int num = state.boundariesCrossed;
1330      boolean isFinal = this.is$Final();
1331        SimpleSet parameterDeclaration_String_value = parameterDeclaration_compute(name);
1332      if(isFinal && num == state().boundariesCrossed){ parameterDeclaration_String_values.put(_parameters, parameterDeclaration_String_value); }
1333            return parameterDeclaration_String_value;
1334      }
1335      /**
1336       * @apilevel internal
1337       */
1338      private SimpleSet parameterDeclaration_compute(String name) {
1339        for(int i = 0; i < getNumParameter(); i++)
1340          if(getParameter(i).name().equals(name))
1341            return (ParameterDeclaration)getParameter(i);
1342        return SimpleSet.emptySet;
1343      }
1344      /**
1345       * @attribute syn
1346       * @aspect Modifiers
1347       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Modifiers.jrag:217
1348       */
1349      public boolean isSynthetic() {
1350        ASTNode$State state = state();
1351        try {  return getModifiers().isSynthetic();  }
1352        finally {
1353        }
1354      }
1355      /**
1356       * @attribute syn
1357       * @aspect Modifiers
1358       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Modifiers.jrag:235
1359       */
1360      public boolean isPublic() {
1361        ASTNode$State state = state();
1362        try {  return getModifiers().isPublic();  }
1363        finally {
1364        }
1365      }
1366      /**
1367       * @attribute syn
1368       * @aspect Modifiers
1369       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Modifiers.jrag:236
1370       */
1371      public boolean isPrivate() {
1372        ASTNode$State state = state();
1373        try {  return getModifiers().isPrivate();  }
1374        finally {
1375        }
1376      }
1377      /**
1378       * @attribute syn
1379       * @aspect Modifiers
1380       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Modifiers.jrag:237
1381       */
1382      public boolean isProtected() {
1383        ASTNode$State state = state();
1384        try {  return getModifiers().isProtected();  }
1385        finally {
1386        }
1387      }
1388      protected java.util.Map circularThisInvocation_ConstructorDecl_values;
1389      /**
1390       * @attribute syn
1391       * @aspect NameCheck
1392       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:88
1393       */
1394      @SuppressWarnings({"unchecked", "cast"})
1395      public boolean circularThisInvocation(ConstructorDecl decl) {
1396        Object _parameters = decl;
1397        if(circularThisInvocation_ConstructorDecl_values == null) circularThisInvocation_ConstructorDecl_values = new java.util.HashMap(4);
1398        ASTNode$State.CircularValue _value;
1399        if(circularThisInvocation_ConstructorDecl_values.containsKey(_parameters)) {
1400          Object _o = circularThisInvocation_ConstructorDecl_values.get(_parameters);
1401          if(!(_o instanceof ASTNode$State.CircularValue)) {
1402            return ((Boolean)_o).booleanValue();
1403          }
1404          else
1405            _value = (ASTNode$State.CircularValue)_o;
1406        }
1407        else {
1408          _value = new ASTNode$State.CircularValue();
1409          circularThisInvocation_ConstructorDecl_values.put(_parameters, _value);
1410          _value.value = Boolean.valueOf(true);
1411        }
1412        ASTNode$State state = state();
1413        if (!state.IN_CIRCLE) {
1414          state.IN_CIRCLE = true;
1415          int num = state.boundariesCrossed;
1416          boolean isFinal = this.is$Final();
1417          boolean new_circularThisInvocation_ConstructorDecl_value;
1418          do {
1419            _value.visited = new Integer(state.CIRCLE_INDEX);
1420            state.CHANGE = false;
1421            new_circularThisInvocation_ConstructorDecl_value = circularThisInvocation_compute(decl);
1422            if (new_circularThisInvocation_ConstructorDecl_value!=((Boolean)_value.value).booleanValue()) {
1423              state.CHANGE = true;
1424              _value.value = Boolean.valueOf(new_circularThisInvocation_ConstructorDecl_value);
1425            }
1426            state.CIRCLE_INDEX++;
1427          } while (state.CHANGE);
1428            if(isFinal && num == state().boundariesCrossed) {
1429            circularThisInvocation_ConstructorDecl_values.put(_parameters, new_circularThisInvocation_ConstructorDecl_value);
1430          }
1431          else {
1432            circularThisInvocation_ConstructorDecl_values.remove(_parameters);
1433          state.RESET_CYCLE = true;
1434          circularThisInvocation_compute(decl);
1435          state.RESET_CYCLE = false;
1436          }
1437          state.IN_CIRCLE = false; 
1438          return new_circularThisInvocation_ConstructorDecl_value;
1439        }
1440        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
1441          _value.visited = new Integer(state.CIRCLE_INDEX);
1442          boolean new_circularThisInvocation_ConstructorDecl_value = circularThisInvocation_compute(decl);
1443          if (state.RESET_CYCLE) {
1444            circularThisInvocation_ConstructorDecl_values.remove(_parameters);
1445          }
1446          else if (new_circularThisInvocation_ConstructorDecl_value!=((Boolean)_value.value).booleanValue()) {
1447            state.CHANGE = true;
1448            _value.value = new_circularThisInvocation_ConstructorDecl_value;
1449          }
1450          return new_circularThisInvocation_ConstructorDecl_value;
1451        }
1452        return ((Boolean)_value.value).booleanValue();
1453      }
1454      /**
1455       * @apilevel internal
1456       */
1457      private boolean circularThisInvocation_compute(ConstructorDecl decl) {
1458        if(hasConstructorInvocation()) {
1459          Expr e = ((ExprStmt)getConstructorInvocation()).getExpr();
1460          if(e instanceof ConstructorAccess) {
1461            ConstructorDecl constructorDecl = ((ConstructorAccess)e).decl();
1462            if(constructorDecl == decl)
1463              return true;
1464            return constructorDecl.circularThisInvocation(decl);
1465          }
1466        }
1467        return false;
1468      }
1469      /**
1470       * @attribute syn
1471       * @aspect TypeAnalysis
1472       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:268
1473       */
1474      public TypeDecl type() {
1475        ASTNode$State state = state();
1476        try {  return unknownType();  }
1477        finally {
1478        }
1479      }
1480      /**
1481       * @attribute syn
1482       * @aspect TypeAnalysis
1483       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:271
1484       */
1485      public boolean isVoid() {
1486        ASTNode$State state = state();
1487        try {  return true;  }
1488        finally {
1489        }
1490      }
1491      /**
1492       * @apilevel internal
1493       */
1494      protected boolean attributes_computed = false;
1495      /**
1496       * @apilevel internal
1497       */
1498      protected Collection attributes_value;
1499      /**
1500       * @attribute syn
1501       * @aspect AnnotationsCodegen
1502       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/AnnotationsCodegen.jrag:31
1503       */
1504      @SuppressWarnings({"unchecked", "cast"})
1505      public Collection attributes() {
1506        if(attributes_computed) {
1507          return attributes_value;
1508        }
1509          ASTNode$State state = state();
1510      int num = state.boundariesCrossed;
1511      boolean isFinal = this.is$Final();
1512        attributes_value = attributes_compute();
1513      if(isFinal && num == state().boundariesCrossed){ attributes_computed = true; }
1514            return attributes_value;
1515      }
1516      /**
1517       * @apilevel internal
1518       */
1519      private Collection attributes_compute() {
1520        Collection c = refined_Attributes_ConstructorDecl_attributes();
1521        getModifiers().addRuntimeVisibleAnnotationsAttribute(c);
1522        getModifiers().addRuntimeInvisibleAnnotationsAttribute(c);
1523        return c;
1524      }
1525      /**
1526       * @apilevel internal
1527       */
1528      protected boolean descName_computed = false;
1529      /**
1530       * @apilevel internal
1531       */
1532      protected String descName_value;
1533      /**
1534       * @attribute syn
1535       * @aspect ConstantPoolNames
1536       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/ConstantPoolNames.jrag:48
1537       */
1538      @SuppressWarnings({"unchecked", "cast"})
1539      public String descName() {
1540        if(descName_computed) {
1541          return descName_value;
1542        }
1543          ASTNode$State state = state();
1544      int num = state.boundariesCrossed;
1545      boolean isFinal = this.is$Final();
1546        descName_value = descName_compute();
1547      if(isFinal && num == state().boundariesCrossed){ descName_computed = true; }
1548            return descName_value;
1549      }
1550      /**
1551       * @apilevel internal
1552       */
1553      private String descName_compute() {
1554        StringBuffer b = new StringBuffer();
1555        b.append("(");
1556        // this$0
1557        if(needsEnclosing())
1558          b.append(enclosing().typeDescriptor());
1559        if(needsSuperEnclosing())
1560          b.append(superEnclosing().typeDescriptor());
1561        // args
1562        for (int i=0; i<getNumParameter(); i++)
1563          b.append(getParameter(i).type().typeDescriptor());
1564        b.append(")V");
1565        return b.toString();
1566      }
1567      protected java.util.Map bytecodes_ConstantPool_values;
1568      /**
1569       * @attribute syn
1570       * @aspect CreateBCode
1571       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:100
1572       */
1573      @SuppressWarnings({"unchecked", "cast"})
1574      public CodeGeneration bytecodes(ConstantPool constantPool) {
1575        Object _parameters = constantPool;
1576        if(bytecodes_ConstantPool_values == null) bytecodes_ConstantPool_values = new java.util.HashMap(4);
1577        if(bytecodes_ConstantPool_values.containsKey(_parameters)) {
1578          return (CodeGeneration)bytecodes_ConstantPool_values.get(_parameters);
1579        }
1580          ASTNode$State state = state();
1581      int num = state.boundariesCrossed;
1582      boolean isFinal = this.is$Final();
1583        CodeGeneration bytecodes_ConstantPool_value = bytecodes_compute(constantPool);
1584      if(isFinal && num == state().boundariesCrossed){ bytecodes_ConstantPool_values.put(_parameters, bytecodes_ConstantPool_value); }
1585            return bytecodes_ConstantPool_value;
1586      }
1587      /**
1588       * @apilevel internal
1589       */
1590      private CodeGeneration bytecodes_compute(ConstantPool constantPool) {
1591        CodeGeneration gen = new CodeGeneration(constantPool);
1592        generateBytecodes(gen);
1593        if(!gen.numberFormatError())
1594          return gen;
1595        gen = new CodeGeneration(constantPool, true);
1596        generateBytecodes(gen);
1597        if(!gen.numberFormatError())
1598          return gen;
1599        throw new Error("Could not generate code for " + signature() + " in " + hostType().typeName());
1600      }
1601      /**
1602       * @apilevel internal
1603       */
1604      protected boolean flags_computed = false;
1605      /**
1606       * @apilevel internal
1607       */
1608      protected int flags_value;
1609      /**
1610       * @attribute syn
1611       * @aspect VariableArityParametersCodegen
1612       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/VariableArityParametersCodegen.jrag:94
1613       */
1614      @SuppressWarnings({"unchecked", "cast"})
1615      public int flags() {
1616        if(flags_computed) {
1617          return flags_value;
1618        }
1619          ASTNode$State state = state();
1620      int num = state.boundariesCrossed;
1621      boolean isFinal = this.is$Final();
1622        flags_value = flags_compute();
1623      if(isFinal && num == state().boundariesCrossed){ flags_computed = true; }
1624            return flags_value;
1625      }
1626      /**
1627       * @apilevel internal
1628       */
1629      private int flags_compute() {
1630        int res = refined_Flags_ConstructorDecl_flags();
1631        if(isVariableArity())
1632          res |= Modifiers.ACC_VARARGS;
1633        return res;
1634      }
1635      /**
1636       * @attribute syn
1637       * @aspect GenerateClassfile
1638       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/GenerateClassfile.jrag:296
1639       */
1640      public boolean isBytecodeMethod() {
1641        ASTNode$State state = state();
1642        try {  return true;  }
1643        finally {
1644        }
1645      }
1646      /**
1647       * @attribute syn
1648       * @aspect GenerateClassfile
1649       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/GenerateClassfile.jrag:325
1650       */
1651      public boolean flush() {
1652        ASTNode$State state = state();
1653        try {  return false;  }
1654        finally {
1655        }
1656      }
1657      /**
1658       * @attribute syn
1659       * @aspect InnerClasses
1660       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:433
1661       */
1662      public boolean needsEnclosing() {
1663        ASTNode$State state = state();
1664        try {  return hostType().needsEnclosing();  }
1665        finally {
1666        }
1667      }
1668      /**
1669       * @attribute syn
1670       * @aspect InnerClasses
1671       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:434
1672       */
1673      public boolean needsSuperEnclosing() {
1674        ASTNode$State state = state();
1675        try {  return hostType().needsSuperEnclosing();  }
1676        finally {
1677        }
1678      }
1679      /**
1680       * @attribute syn
1681       * @aspect InnerClasses
1682       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:436
1683       */
1684      public TypeDecl enclosing() {
1685        ASTNode$State state = state();
1686        try {  return hostType().enclosing();  }
1687        finally {
1688        }
1689      }
1690      /**
1691       * @attribute syn
1692       * @aspect InnerClasses
1693       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/InnerClasses.jrag:437
1694       */
1695      public TypeDecl superEnclosing() {
1696        ASTNode$State state = state();
1697        try {  return hostType().superEnclosing();  }
1698        finally {
1699        }
1700      }
1701      /**
1702       * @apilevel internal
1703       */
1704      protected boolean localNumOfFirstParameter_computed = false;
1705      /**
1706       * @apilevel internal
1707       */
1708      protected int localNumOfFirstParameter_value;
1709      /**
1710       * @attribute syn
1711       * @aspect LocalNum
1712       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/LocalNum.jrag:55
1713       */
1714      @SuppressWarnings({"unchecked", "cast"})
1715      public int localNumOfFirstParameter() {
1716        if(localNumOfFirstParameter_computed) {
1717          return localNumOfFirstParameter_value;
1718        }
1719          ASTNode$State state = state();
1720      int num = state.boundariesCrossed;
1721      boolean isFinal = this.is$Final();
1722        localNumOfFirstParameter_value = localNumOfFirstParameter_compute();
1723      if(isFinal && num == state().boundariesCrossed){ localNumOfFirstParameter_computed = true; }
1724            return localNumOfFirstParameter_value;
1725      }
1726      /**
1727       * @apilevel internal
1728       */
1729      private int localNumOfFirstParameter_compute() {
1730        int i = 1;
1731        if(hostType().needsEnclosing())
1732          i++;
1733        if(hostType().needsSuperEnclosing())
1734          i++;
1735        return i;
1736      }
1737      /**
1738       * @apilevel internal
1739       */
1740      protected boolean offsetFirstEnclosingVariable_computed = false;
1741      /**
1742       * @apilevel internal
1743       */
1744      protected int offsetFirstEnclosingVariable_value;
1745      /**
1746       * @attribute syn
1747       * @aspect LocalNum
1748       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/LocalNum.jrag:64
1749       */
1750      @SuppressWarnings({"unchecked", "cast"})
1751      public int offsetFirstEnclosingVariable() {
1752        if(offsetFirstEnclosingVariable_computed) {
1753          return offsetFirstEnclosingVariable_value;
1754        }
1755          ASTNode$State state = state();
1756      int num = state.boundariesCrossed;
1757      boolean isFinal = this.is$Final();
1758        offsetFirstEnclosingVariable_value = offsetFirstEnclosingVariable_compute();
1759      if(isFinal && num == state().boundariesCrossed){ offsetFirstEnclosingVariable_computed = true; }
1760            return offsetFirstEnclosingVariable_value;
1761      }
1762      /**
1763       * @apilevel internal
1764       */
1765      private int offsetFirstEnclosingVariable_compute() {
1766        int localIndex = localNumOfFirstParameter();
1767        Collection vars = hostType().enclosingVariables();
1768        if(vars.isEmpty())
1769          return localIndex;
1770        String name = "val$" + ((Variable)vars.iterator().next()).name();
1771        for(int i = 0; !getParameter(i).name().equals(name); i++)
1772          localIndex += getParameter(i).type().variableSize();
1773        return localIndex;
1774      }
1775      /**
1776       * @attribute syn
1777       * @aspect LocalNum
1778       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/LocalNum.jrag:75
1779       */
1780      public int localIndexOfEnclosingVariable(Variable v) {
1781        ASTNode$State state = state();
1782        try {
1783        int localIndex  = offsetFirstEnclosingVariable();
1784        Iterator iter = hostType().enclosingVariables().iterator();
1785        Variable varDecl = (Variable)iter.next();
1786        while(varDecl != v && iter.hasNext()) {
1787          localIndex += varDecl.type().variableSize();
1788          varDecl = (Variable)iter.next();
1789        }
1790        return localIndex;
1791      }
1792        finally {
1793        }
1794      }
1795      /**
1796       * @attribute syn
1797       * @aspect Annotations
1798       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Annotations.jrag:283
1799       */
1800      public boolean hasAnnotationSuppressWarnings(String s) {
1801        ASTNode$State state = state();
1802        try {  return getModifiers().hasAnnotationSuppressWarnings(s);  }
1803        finally {
1804        }
1805      }
1806      /**
1807       * @attribute syn
1808       * @aspect Annotations
1809       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Annotations.jrag:324
1810       */
1811      public boolean isDeprecated() {
1812        ASTNode$State state = state();
1813        try {  return getModifiers().hasDeprecatedAnnotation();  }
1814        finally {
1815        }
1816      }
1817      /**
1818       * @apilevel internal
1819       */
1820      protected boolean sourceConstructorDecl_computed = false;
1821      /**
1822       * @apilevel internal
1823       */
1824      protected ConstructorDecl sourceConstructorDecl_value;
1825      /**
1826       * @attribute syn
1827       * @aspect SourceDeclarations
1828       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:1515
1829       */
1830      @SuppressWarnings({"unchecked", "cast"})
1831      public ConstructorDecl sourceConstructorDecl() {
1832        if(sourceConstructorDecl_computed) {
1833          return sourceConstructorDecl_value;
1834        }
1835          ASTNode$State state = state();
1836      int num = state.boundariesCrossed;
1837      boolean isFinal = this.is$Final();
1838        sourceConstructorDecl_value = sourceConstructorDecl_compute();
1839      if(isFinal && num == state().boundariesCrossed){ sourceConstructorDecl_computed = true; }
1840            return sourceConstructorDecl_value;
1841      }
1842      /**
1843       * @apilevel internal
1844       */
1845      private ConstructorDecl sourceConstructorDecl_compute() {  return this;  }
1846      /**
1847       * @attribute syn
1848       * @aspect MethodSignature15
1849       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/MethodSignature.jrag:190
1850       */
1851      public boolean applicableBySubtyping(List argList) {
1852        ASTNode$State state = state();
1853        try {
1854        if(getNumParameter() != argList.getNumChild())
1855          return false;
1856        for(int i = 0; i < getNumParameter(); i++) {
1857          TypeDecl arg = ((Expr)argList.getChild(i)).type();
1858          if(!arg.instanceOf(getParameter(i).type()))
1859            return false;
1860        }
1861        return true;
1862      }
1863        finally {
1864        }
1865      }
1866      /**
1867       * @attribute syn
1868       * @aspect MethodSignature15
1869       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/MethodSignature.jrag:210
1870       */
1871      public boolean applicableByMethodInvocationConversion(List argList) {
1872        ASTNode$State state = state();
1873        try {
1874        if(getNumParameter() != argList.getNumChild())
1875          return false;
1876        for(int i = 0; i < getNumParameter(); i++) {
1877          TypeDecl arg = ((Expr)argList.getChild(i)).type();
1878          if(!arg.methodInvocationConversionTo(getParameter(i).type()))
1879            return false;
1880        }
1881        return true;
1882      }
1883        finally {
1884        }
1885      }
1886      /**
1887       * @attribute syn
1888       * @aspect MethodSignature15
1889       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/MethodSignature.jrag:231
1890       */
1891      public boolean applicableVariableArity(List argList) {
1892        ASTNode$State state = state();
1893        try {
1894        for(int i = 0; i < getNumParameter() - 1; i++) {
1895          TypeDecl arg = ((Expr)argList.getChild(i)).type();
1896          if(!arg.methodInvocationConversionTo(getParameter(i).type()))
1897            return false;
1898        }
1899        for(int i = getNumParameter() - 1; i < argList.getNumChild(); i++) {
1900          TypeDecl arg = ((Expr)argList.getChild(i)).type();
1901          if(!arg.methodInvocationConversionTo(lastParameter().type().componentType()))
1902            return false;
1903        }
1904        return true;
1905      }
1906        finally {
1907        }
1908      }
1909      /**
1910       * @attribute syn
1911       * @aspect MethodSignature15
1912       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/MethodSignature.jrag:318
1913       */
1914      public boolean potentiallyApplicable(List argList) {
1915        ASTNode$State state = state();
1916        try {
1917        if(isVariableArity() && !(argList.getNumChild() >= arity()-1))
1918          return false;
1919        if(!isVariableArity() && !(arity() == argList.getNumChild()))
1920          return false;
1921        return true;
1922      }
1923        finally {
1924        }
1925      }
1926      /**
1927       * @attribute syn
1928       * @aspect MethodSignature15
1929       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/MethodSignature.jrag:325
1930       */
1931      public int arity() {
1932        ASTNode$State state = state();
1933        try {  return getNumParameter();  }
1934        finally {
1935        }
1936      }
1937      /**
1938       * @attribute syn
1939       * @aspect VariableArityParameters
1940       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/VariableArityParameters.jrag:34
1941       */
1942      public boolean isVariableArity() {
1943        ASTNode$State state = state();
1944        try {  return getNumParameter() == 0 ? false : getParameter(getNumParameter()-1).isVariableArity();  }
1945        finally {
1946        }
1947      }
1948      /**
1949       * @attribute syn
1950       * @aspect VariableArityParameters
1951       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/VariableArityParameters.jrag:63
1952       */
1953      public ParameterDeclaration lastParameter() {
1954        ASTNode$State state = state();
1955        try {  return getParameter(getNumParameter() - 1);  }
1956        finally {
1957        }
1958      }
1959      /**
1960       * @attribute syn
1961       * @aspect GenericsCodegen
1962       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:168
1963       */
1964      public ConstructorDecl erasedConstructor() {
1965        ASTNode$State state = state();
1966        try {  return this;  }
1967        finally {
1968        }
1969      }
1970      /**
1971       * @attribute syn
1972       * @aspect GenericsCodegen
1973       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:373
1974       */
1975      public boolean needsSignatureAttribute() {
1976        ASTNode$State state = state();
1977        try {
1978        for(int i = 0; i < getNumParameter(); i++)
1979          if(getParameter(i).type().needsSignatureAttribute())
1980            return true;
1981        return false;
1982      }
1983        finally {
1984        }
1985      }
1986      /**
1987      * @return true if the modifier list includes the SafeVarargs annotation
1988      * @attribute syn
1989       * @aspect SafeVarargs
1990       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/SafeVarargs.jrag:20
1991       */
1992      public boolean hasAnnotationSafeVarargs() {
1993        ASTNode$State state = state();
1994        try {  return getModifiers().hasAnnotationSafeVarargs();  }
1995        finally {
1996        }
1997      }
1998      /**
1999      * It is an error if the SafeVarargs annotation is used on something
2000      * that is not a variable arity method or constructor.
2001      * @attribute syn
2002       * @aspect SafeVarargs
2003       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/SafeVarargs.jrag:56
2004       */
2005      public boolean hasIllegalAnnotationSafeVarargs() {
2006        ASTNode$State state = state();
2007        try {  return hasAnnotationSafeVarargs() && !isVariableArity();  }
2008        finally {
2009        }
2010      }
2011      protected java.util.Map handlesException_TypeDecl_values;
2012      /**
2013       * @attribute inh
2014       * @aspect ExceptionHandling
2015       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ExceptionHandling.jrag:50
2016       */
2017      @SuppressWarnings({"unchecked", "cast"})
2018      public boolean handlesException(TypeDecl exceptionType) {
2019        Object _parameters = exceptionType;
2020        if(handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new java.util.HashMap(4);
2021        if(handlesException_TypeDecl_values.containsKey(_parameters)) {
2022          return ((Boolean)handlesException_TypeDecl_values.get(_parameters)).booleanValue();
2023        }
2024          ASTNode$State state = state();
2025      int num = state.boundariesCrossed;
2026      boolean isFinal = this.is$Final();
2027        boolean handlesException_TypeDecl_value = getParent().Define_boolean_handlesException(this, null, exceptionType);
2028      if(isFinal && num == state().boundariesCrossed){ handlesException_TypeDecl_values.put(_parameters, Boolean.valueOf(handlesException_TypeDecl_value)); }
2029            return handlesException_TypeDecl_value;
2030      }
2031      /**
2032       * @attribute inh
2033       * @aspect TypeAnalysis
2034       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:267
2035       */
2036      @SuppressWarnings({"unchecked", "cast"})
2037      public TypeDecl unknownType() {
2038          ASTNode$State state = state();
2039        TypeDecl unknownType_value = getParent().Define_TypeDecl_unknownType(this, null);
2040            return unknownType_value;
2041      }
2042      /**
2043       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:298
2044       * @apilevel internal
2045       */
2046      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
2047        if(caller == getBlockNoTransform()) {
2048          return hasConstructorInvocation() ? getConstructorInvocation().isDAafter(v) : isDAbefore(v);
2049        }
2050        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
2051        }
2052      }
2053      /**
2054       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:755
2055       * @apilevel internal
2056       */
2057      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
2058        if(caller == getBlockNoTransform()) {
2059          return hasConstructorInvocation() ? getConstructorInvocation().isDUafter(v) : isDUbefore(v);
2060        }
2061        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
2062        }
2063      }
2064      /**
2065       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ExceptionHandling.jrag:156
2066       * @apilevel internal
2067       */
2068      public boolean Define_boolean_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
2069        if(caller == getConstructorInvocationOptNoTransform()) {
2070          return throwsException(exceptionType) || handlesException(exceptionType);
2071        }
2072        else if(caller == getBlockNoTransform()) {
2073          return throwsException(exceptionType) || handlesException(exceptionType);
2074        }
2075        else {      return getParent().Define_boolean_handlesException(this, caller, exceptionType);
2076        }
2077      }
2078      /**
2079       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupMethod.jrag:45
2080       * @apilevel internal
2081       */
2082      public Collection Define_Collection_lookupMethod(ASTNode caller, ASTNode child, String name) {
2083        if(caller == getConstructorInvocationOptNoTransform()){
2084        Collection c = new ArrayList();
2085        for(Iterator iter = lookupMethod(name).iterator(); iter.hasNext(); ) {
2086          MethodDecl m = (MethodDecl)iter.next();
2087          if(!hostType().memberMethods(name).contains(m) || m.isStatic())
2088            c.add(m);
2089        }
2090        return c;
2091      }
2092        else {      return getParent().Define_Collection_lookupMethod(this, caller, name);
2093        }
2094      }
2095      /**
2096       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupVariable.jrag:64
2097       * @apilevel internal
2098       */
2099      public SimpleSet Define_SimpleSet_lookupVariable(ASTNode caller, ASTNode child, String name) {
2100        if(caller == getParameterListNoTransform())  {
2101        int childIndex = caller.getIndexOfChild(child);
2102        return parameterDeclaration(name);
2103      }
2104        else if(caller == getConstructorInvocationOptNoTransform()){
2105        SimpleSet set = parameterDeclaration(name);
2106        if(!set.isEmpty()) return set;
2107        for(Iterator iter = lookupVariable(name).iterator(); iter.hasNext(); ) {
2108          Variable v = (Variable)iter.next();
2109          if(!hostType().memberFields(name).contains(v) || v.isStatic())
2110            set = set.add(v);
2111        }
2112        return set;
2113      }
2114        else if(caller == getBlockNoTransform()){
2115        SimpleSet set = parameterDeclaration(name);
2116        if(!set.isEmpty()) return set;
2117        return lookupVariable(name);
2118      }
2119        else {      return getParent().Define_SimpleSet_lookupVariable(this, caller, name);
2120        }
2121      }
2122      /**
2123       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Modifiers.jrag:282
2124       * @apilevel internal
2125       */
2126      public boolean Define_boolean_mayBePublic(ASTNode caller, ASTNode child) {
2127        if(caller == getModifiersNoTransform()) {
2128          return true;
2129        }
2130        else {      return getParent().Define_boolean_mayBePublic(this, caller);
2131        }
2132      }
2133      /**
2134       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Modifiers.jrag:283
2135       * @apilevel internal
2136       */
2137      public boolean Define_boolean_mayBeProtected(ASTNode caller, ASTNode child) {
2138        if(caller == getModifiersNoTransform()) {
2139          return true;
2140        }
2141        else {      return getParent().Define_boolean_mayBeProtected(this, caller);
2142        }
2143      }
2144      /**
2145       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Modifiers.jrag:284
2146       * @apilevel internal
2147       */
2148      public boolean Define_boolean_mayBePrivate(ASTNode caller, ASTNode child) {
2149        if(caller == getModifiersNoTransform()) {
2150          return true;
2151        }
2152        else {      return getParent().Define_boolean_mayBePrivate(this, caller);
2153        }
2154      }
2155      /**
2156       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:247
2157       * @apilevel internal
2158       */
2159      public ASTNode Define_ASTNode_enclosingBlock(ASTNode caller, ASTNode child) {
2160        if(caller == getBlockNoTransform()) {
2161          return this;
2162        }
2163        else {      return getParent().Define_ASTNode_enclosingBlock(this, caller);
2164        }
2165      }
2166      /**
2167       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/SyntacticClassification.jrag:117
2168       * @apilevel internal
2169       */
2170      public NameType Define_NameType_nameType(ASTNode caller, ASTNode child) {
2171        if(caller == getConstructorInvocationOptNoTransform()) {
2172          return NameType.EXPRESSION_NAME;
2173        }
2174        else if(caller == getExceptionListNoTransform())  {
2175        int childIndex = caller.getIndexOfChild(child);
2176        return NameType.TYPE_NAME;
2177      }
2178        else if(caller == getParameterListNoTransform())  {
2179        int childIndex = caller.getIndexOfChild(child);
2180        return NameType.TYPE_NAME;
2181      }
2182        else {      return getParent().Define_NameType_nameType(this, caller);
2183        }
2184      }
2185      /**
2186       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:517
2187       * @apilevel internal
2188       */
2189      public TypeDecl Define_TypeDecl_enclosingInstance(ASTNode caller, ASTNode child) {
2190        if(caller == getConstructorInvocationOptNoTransform()) {
2191          return unknownType();
2192        }
2193        else {      return getParent().Define_TypeDecl_enclosingInstance(this, caller);
2194        }
2195      }
2196      /**
2197       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeHierarchyCheck.jrag:132
2198       * @apilevel internal
2199       */
2200      public boolean Define_boolean_inExplicitConstructorInvocation(ASTNode caller, ASTNode child) {
2201        if(caller == getConstructorInvocationOptNoTransform()) {
2202          return true;
2203        }
2204        else {      return getParent().Define_boolean_inExplicitConstructorInvocation(this, caller);
2205        }
2206      }
2207      /**
2208       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeHierarchyCheck.jrag:144
2209       * @apilevel internal
2210       */
2211      public boolean Define_boolean_inStaticContext(ASTNode caller, ASTNode child) {
2212        if(caller == getConstructorInvocationOptNoTransform()) {
2213          return false;
2214        }
2215        else if(caller == getBlockNoTransform()) {
2216          return false;
2217        }
2218        else {      return getParent().Define_boolean_inStaticContext(this, caller);
2219        }
2220      }
2221      /**
2222       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:32
2223       * @apilevel internal
2224       */
2225      public boolean Define_boolean_reachable(ASTNode caller, ASTNode child) {
2226        if(caller == getBlockNoTransform()) {
2227          return !hasConstructorInvocation() ? true : getConstructorInvocation().canCompleteNormally();
2228        }
2229        else if(caller == getConstructorInvocationOptNoTransform()) {
2230          return true;
2231        }
2232        else {      return getParent().Define_boolean_reachable(this, caller);
2233        }
2234      }
2235      /**
2236       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/VariableDeclaration.jrag:58
2237       * @apilevel internal
2238       */
2239      public boolean Define_boolean_isMethodParameter(ASTNode caller, ASTNode child) {
2240        if(caller == getParameterListNoTransform())  {
2241        int childIndex = caller.getIndexOfChild(child);
2242        return false;
2243      }
2244        else {      return getParent().Define_boolean_isMethodParameter(this, caller);
2245        }
2246      }
2247      /**
2248       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/VariableDeclaration.jrag:59
2249       * @apilevel internal
2250       */
2251      public boolean Define_boolean_isConstructorParameter(ASTNode caller, ASTNode child) {
2252        if(caller == getParameterListNoTransform())  {
2253        int childIndex = caller.getIndexOfChild(child);
2254        return true;
2255      }
2256        else {      return getParent().Define_boolean_isConstructorParameter(this, caller);
2257        }
2258      }
2259      /**
2260       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/VariableDeclaration.jrag:60
2261       * @apilevel internal
2262       */
2263      public boolean Define_boolean_isExceptionHandlerParameter(ASTNode caller, ASTNode child) {
2264        if(caller == getParameterListNoTransform())  {
2265        int childIndex = caller.getIndexOfChild(child);
2266        return false;
2267      }
2268        else {      return getParent().Define_boolean_isExceptionHandlerParameter(this, caller);
2269        }
2270      }
2271      /**
2272       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/LocalNum.jrag:90
2273       * @apilevel internal
2274       */
2275      public int Define_int_localNum(ASTNode caller, ASTNode child) {
2276        if(caller == getBlockNoTransform()) {
2277          return getNumParameter() == 0 ? 
2278        localNumOfFirstParameter() :
2279        getParameter(getNumParameter()-1).localNum() + getParameter(getNumParameter()-1).type().variableSize();
2280        }
2281        else if(caller == getParameterListNoTransform())  {
2282        int index = caller.getIndexOfChild(child);
2283        return index == 0 ?
2284        localNumOfFirstParameter() :
2285        getParameter(index-1).localNum() + getParameter(index-1).type().variableSize();
2286      }
2287        else {      return getParent().Define_int_localNum(this, caller);
2288        }
2289      }
2290      /**
2291       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Annotations.jrag:89
2292       * @apilevel internal
2293       */
2294      public boolean Define_boolean_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
2295        if(caller == getModifiersNoTransform()) {
2296          return name.equals("CONSTRUCTOR");
2297        }
2298        else {      return getParent().Define_boolean_mayUseAnnotationTarget(this, caller, name);
2299        }
2300      }
2301      /**
2302       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/VariableArityParameters.jrag:21
2303       * @apilevel internal
2304       */
2305      public boolean Define_boolean_variableArityValid(ASTNode caller, ASTNode child) {
2306        if(caller == getParameterListNoTransform())  {
2307        int i = caller.getIndexOfChild(child);
2308        return i == getNumParameter() - 1;
2309      }
2310        else {      return getParent().Define_boolean_variableArityValid(this, caller);
2311        }
2312      }
2313      /**
2314       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:48
2315       * @apilevel internal
2316       */
2317      public boolean Define_boolean_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
2318        if(caller == getParameterListNoTransform())  {
2319        int childIndex = caller.getIndexOfChild(child);
2320        return getBlock().modifiedInScope(var);
2321      }
2322        else {      return getParent().Define_boolean_inhModifiedInScope(this, caller, var);
2323        }
2324      }
2325      /**
2326       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:123
2327       * @apilevel internal
2328       */
2329      public boolean Define_boolean_isCatchParam(ASTNode caller, ASTNode child) {
2330        if(caller == getParameterListNoTransform())  {
2331        int childIndex = caller.getIndexOfChild(child);
2332        return false;
2333      }
2334        else {      return getParent().Define_boolean_isCatchParam(this, caller);
2335        }
2336      }
2337      /**
2338       * @apilevel internal
2339       */
2340      public ASTNode rewriteTo() {
2341        // Declared in /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag at line 218
2342        if(!hasConstructorInvocation() && !hostType().isObject()) {
2343          state().duringImplicitConstructor++;
2344          ASTNode result = rewriteRule0();
2345          state().duringImplicitConstructor--;
2346          return result;
2347        }
2348    
2349        return super.rewriteTo();
2350      }
2351      /**
2352       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:218
2353       * @apilevel internal
2354       */  private ConstructorDecl rewriteRule0() {
2355    {
2356          setConstructorInvocation(
2357            new ExprStmt(
2358              new SuperConstructorAccess("super", new List())
2359              )
2360            );
2361          return this;
2362        }  }
2363    }