001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:77
027     * @production FieldDeclaration : {@link MemberDecl} ::= <span class="component">{@link Modifiers}</span> <span class="component">TypeAccess:{@link Access}</span> <span class="component">&lt;ID:String&gt;</span> <span class="component">[Init:{@link Expr}]</span>;
028    
029     */
030    public class FieldDeclaration extends MemberDecl implements Cloneable, SimpleSet, Iterator, Variable {
031      /**
032       * @aspect BoundNames
033       * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:32
034       */
035      public Access createQualifiedBoundAccess() {
036        if (isStatic()) {
037          return hostType().createQualifiedAccess().qualifiesAccess(new BoundFieldAccess(this));
038        } else
039          return new ThisAccess("this").qualifiesAccess(
040            new BoundFieldAccess(this));
041      }
042      /**
043       * @aspect BoundNames
044       * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:106
045       */
046      public Access createBoundFieldAccess() {
047        return createQualifiedBoundAccess();
048      }
049      /**
050       * @aspect DataStructures
051       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:105
052       */
053      public SimpleSet add(Object o) {
054        return new SimpleSetImpl().add(this).add(o);
055      }
056      /**
057       * @aspect DataStructures
058       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:109
059       */
060      public boolean isSingleton() { return true; }
061      /**
062       * @aspect DataStructures
063       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:110
064       */
065      public boolean isSingleton(Object o) { return contains(o); }
066      /**
067       * @aspect DataStructures
068       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:113
069       */
070      private FieldDeclaration iterElem;
071      /**
072       * @aspect DataStructures
073       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:114
074       */
075      public Iterator iterator() { iterElem = this; return this; }
076      /**
077       * @aspect DataStructures
078       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:115
079       */
080      public boolean hasNext() { return iterElem != null; }
081      /**
082       * @aspect DataStructures
083       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:116
084       */
085      public Object next() { Object o = iterElem; iterElem = null; return o; }
086      /**
087       * @aspect DataStructures
088       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:117
089       */
090      public void remove() { throw new UnsupportedOperationException(); }
091      /**
092       * @aspect DefiniteAssignment
093       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:194
094       */
095      public void definiteAssignment() {
096        super.definiteAssignment();
097        if (isBlank() && isFinal() && isClassVariable()) {
098          boolean found = false;
099          TypeDecl typeDecl = hostType();
100          for (int i = 0; i < typeDecl.getNumBodyDecl(); i++) {
101            if (typeDecl.getBodyDecl(i) instanceof StaticInitializer) {
102              StaticInitializer s = (StaticInitializer) typeDecl.getBodyDecl(i);
103              if (s.isDAafter(this)) {
104                found = true;
105              }
106            }
107    
108            else if (typeDecl.getBodyDecl(i) instanceof FieldDeclaration) {
109              FieldDeclaration f = (FieldDeclaration) typeDecl.getBodyDecl(i);
110              if (f.isStatic() && f.isDAafter(this)) {
111                found = true;
112              }
113            }
114    
115          }
116          if (!found) {
117            errorf("blank final class variable %s in %s is not definitely assigned in static initializer",
118                name(), hostType().typeName());
119          }
120    
121        }
122        if (isBlank() && isFinal() && isInstanceVariable()) {
123          TypeDecl typeDecl = hostType();
124          boolean found = false;
125          for (int i = 0; !found && i < typeDecl.getNumBodyDecl(); i++) {
126            if (typeDecl.getBodyDecl(i) instanceof FieldDeclaration) {
127              FieldDeclaration f = (FieldDeclaration) typeDecl.getBodyDecl(i);
128              if (!f.isStatic() && f.isDAafter(this)) {
129                found = true;
130              }
131            } else if (typeDecl.getBodyDecl(i) instanceof InstanceInitializer) {
132              InstanceInitializer ii = (InstanceInitializer) typeDecl.getBodyDecl(i);
133              if (ii.getBlock().isDAafter(this)) {
134                found = true;
135              }
136            }
137          }
138          for (Iterator iter = typeDecl.constructors().iterator(); !found && iter.hasNext(); ) {
139            ConstructorDecl c = (ConstructorDecl) iter.next();
140            if (!c.isDAafter(this)) {
141              errorf("blank final instance variable %s in %s is not definitely assigned after %s",
142                  name(), hostType().typeName(), c.signature());
143            }
144          }
145        }
146        if (isBlank() && hostType().isInterfaceDecl()) {
147          errorf("variable  %s in %s which is an interface must have an initializer",
148              name(), hostType().typeName());
149        }
150      }
151      /**
152       * @aspect Modifiers
153       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:140
154       */
155      public void checkModifiers() {
156        super.checkModifiers();
157        if (hostType().isInterfaceDecl()) {
158          if (isProtected()) {
159            error("an interface field may not be protected");
160          }
161          if (isPrivate()) {
162            error("an interface field may not be private");
163          }
164          if (isTransient()) {
165            error("an interface field may not be transient");
166          }
167          if (isVolatile()) {
168            error("an interface field may not be volatile");
169          }
170        }
171      }
172      /**
173       * @aspect NameCheck
174       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:352
175       */
176      public void nameCheck() {
177        super.nameCheck();
178        // 8.3
179        for (Iterator iter = hostType().memberFields(name()).iterator(); iter.hasNext(); ) {
180          Variable v = (Variable) iter.next();
181          if (v != this && v.hostType() == hostType()) {
182            errorf("field named %s is multiply declared in type %s", name(), hostType().typeName());
183          }
184        }
185    
186      }
187      /**
188       * @aspect NodeConstructors
189       * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:97
190       */
191      public FieldDeclaration(Modifiers m, Access type, String name) {
192        this(m, type, name, new Opt());
193      }
194      /**
195       * @aspect NodeConstructors
196       * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:101
197       */
198      public FieldDeclaration(Modifiers m, Access type, String name, Expr init) {
199        this(m, type, name, new Opt(init));
200      }
201      /**
202       * @aspect Java4PrettyPrint
203       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:41
204       */
205      public void prettyPrint(PrettyPrinter out) {
206        if (hasDocComment()) {
207          out.print(docComment());
208        }
209        if (!out.isNewLine()) {
210          out.println();
211        }
212        out.print(getModifiers());
213        out.print(getTypeAccess());
214        out.print(" ");
215        out.print(getID());
216        if (hasInit()) {
217          out.print(" = ");
218          out.print(getInit());
219        }
220        out.print(";");
221      }
222      /**
223       * @aspect TypeCheck
224       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:55
225       */
226      public void typeCheck() {
227        if (hasInit()) {
228          TypeDecl source = getInit().type();
229          TypeDecl dest = type();
230          if (!source.assignConversionTo(dest, getInit())) {
231            errorf("can not assign field %s of type %s a value of type %s",
232                name(), dest.typeName(), source.typeName());
233          }
234        }
235      }
236      /**
237       * @aspect VariableDeclarationTransformation
238       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:112
239       */
240      private FieldDecl fieldDecl = null;
241      /**
242       * @aspect VariableDeclarationTransformation
243       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:113
244       */
245      public FieldDecl getFieldDecl() {
246        return fieldDecl;
247      }
248      /**
249       * @aspect VariableDeclarationTransformation
250       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:116
251       */
252      public void setFieldDecl(FieldDecl fieldDecl) {
253        this.fieldDecl = fieldDecl;
254      }
255      /**
256       * @aspect CodeGeneration
257       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:334
258       */
259      public void emitLoadField(CodeGeneration gen, TypeDecl typeDecl) {
260        if (hostType().isArrayDecl() && name().equals("length")) {
261          gen.emit(Bytecode.ARRAYLENGTH);
262          return;
263        }
264        String classname = typeDecl.constantPoolName();
265        String      desc = type().typeDescriptor();
266        String      name = name();
267        int index = gen.constantPool().addFieldref(classname, name, desc);
268        if (isStatic()) {
269          gen.emit(Bytecode.GETSTATIC, type().variableSize()).add2(index);
270        } else {
271          gen.emit(Bytecode.GETFIELD, type().variableSize() - 1).add2(index);
272        }
273      }
274      /**
275       * @aspect CodeGeneration
276       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:393
277       */
278      public void emitStoreField(CodeGeneration gen, TypeDecl typeDecl) {
279        String classname = typeDecl.constantPoolName();
280        String      desc = type().typeDescriptor();
281        String      name = name();
282        int index = gen.constantPool().addFieldref(classname, name, desc);
283        if (isStatic()) {
284          gen.emit(Bytecode.PUTSTATIC, -type().variableSize()).add2(index);
285        } else {
286          gen.emit(Bytecode.PUTFIELD, -type().variableSize() - 1).add2(index);
287        }
288      }
289      /**
290       * Generate static initialization code for the field.
291       * @aspect CreateBCode
292       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:295
293       */
294      public void emitStaticInitializer(CodeGeneration gen, TypeDecl hostType) {
295        if (isStatic() && hasInit()) {
296          emitInitializerBCode(gen);
297          emitStoreField(gen, hostType);
298        }
299      }
300      /**
301       * Generate instance initialization code for the field.
302       * @aspect CreateBCode
303       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:305
304       */
305      public void emitInstanceInitializer(CodeGeneration gen, TypeDecl hostType) {
306        if (!isStatic() && hasInit()) {
307          gen.emit(Bytecode.ALOAD_0);
308          emitInitializerBCode(gen);
309          emitStoreField(gen, hostType);
310        }
311      }
312      /**
313       * Generate field initialization bytecode.
314       * @aspect CreateBCode
315       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:316
316       */
317      protected void emitInitializerBCode(CodeGeneration gen) {
318        getInit().createBCode(gen);
319        getInit().type().emitAssignConvTo(gen, type());
320      }
321      /**
322       * @aspect GenerateClassfile
323       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:429
324       */
325      public boolean clear() {
326        return false;
327      }
328      /**
329       * @aspect InnerClasses
330       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:341
331       */
332      public MethodDecl createAccessor(TypeDecl fieldQualifier) {
333        MethodDecl m = (MethodDecl) fieldQualifier.getAccessor(this, "field_read");
334        if (m != null) {
335          return m;
336        }
337    
338        int accessorIndex = fieldQualifier.accessorCounter++;
339        Modifiers modifiers = new Modifiers(new List());
340        modifiers.addModifier(new Modifier("static"));
341        modifiers.addModifier(new Modifier("synthetic"));
342        modifiers.addModifier(new Modifier("public"));
343    
344        List parameters = new List();
345        if (!isStatic()) {
346          parameters.add(new ParameterDeclaration(fieldQualifier.createQualifiedAccess(), "that"));
347        }
348    
349        m = new MethodDecl(
350          modifiers,
351          type().createQualifiedAccess(),
352          "get$" + name() + "$access$" + accessorIndex,
353          parameters,
354          new List(),
355          new Opt(
356            new Block(
357              new List().add(
358                new ReturnStmt(createAccess())
359              )
360            )
361          )
362        );
363        m = fieldQualifier.addMemberMethod(m);
364        fieldQualifier.addAccessor(this, "field_read", m);
365        return m;
366      }
367      /**
368       * @aspect InnerClasses
369       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:377
370       */
371      public MethodDecl createAccessorWrite(TypeDecl fieldQualifier) {
372        MethodDecl m = (MethodDecl) fieldQualifier.getAccessor(this, "field_write");
373        if (m != null) {
374          return m;
375        }
376    
377        int accessorIndex = fieldQualifier.accessorCounter++;
378        Modifiers modifiers = new Modifiers(new List());
379        modifiers.addModifier(new Modifier("static"));
380        modifiers.addModifier(new Modifier("synthetic"));
381        modifiers.addModifier(new Modifier("public"));
382    
383        List parameters = new List();
384        if (!isStatic()) {
385          parameters.add(new ParameterDeclaration(fieldQualifier.createQualifiedAccess(), "that"));
386        }
387        parameters.add(new ParameterDeclaration(type().createQualifiedAccess(), "value"));
388    
389        m = new MethodDecl(
390          modifiers,
391          type().createQualifiedAccess(),
392          "set$" + name() + "$access$" + accessorIndex,
393          parameters,
394          new List(),
395          new Opt(
396            new Block(
397              new List().add(
398                new ExprStmt(
399                  new AssignSimpleExpr(
400                    createAccess(),
401                    new VarAccess("value")
402                  )
403                )
404              ).add(
405                new ReturnStmt(
406                  new Opt(
407                    new VarAccess("value")
408                  )
409                )
410              )
411            )
412          )
413        );
414        m = fieldQualifier.addMemberMethod(m);
415        fieldQualifier.addAccessor(this, "field_write", m);
416        return m;
417      }
418      /**
419       * @aspect InnerClasses
420       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:425
421       */
422      private Access createAccess() {
423        Access fieldAccess = new BoundFieldAccess(this);
424        return isStatic() ? fieldAccess : new VarAccess("that").qualifiesAccess(fieldAccess);
425      }
426      /**
427       * @aspect LookupParTypeDecl
428       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1400
429       */
430      public BodyDecl substitutedBodyDecl(Parameterization parTypeDecl) {
431        return new FieldDeclarationSubstituted(
432          (Modifiers) getModifiers().treeCopyNoTransform(),
433          getTypeAccess().type().substituteReturnType(parTypeDecl),
434          getID(),
435          new Opt(),
436          this
437        );
438      }
439      /**
440       * @aspect UncheckedConversion
441       * @declaredat /home/jesper/git/extendj/java7/frontend/UncheckedConversion.jrag:47
442       */
443      public void checkWarnings() {
444        if (hasInit() && !suppressWarnings("unchecked")) {
445          checkUncheckedConversion(getInit().type(), type());
446        }
447      }
448      /**
449       * @declaredat ASTNode:1
450       */
451      public FieldDeclaration() {
452        super();
453      }
454      /**
455       * Initializes the child array to the correct size.
456       * Initializes List and Opt nta children.
457       * @apilevel internal
458       * @ast method
459       * @declaredat ASTNode:10
460       */
461      public void init$Children() {
462        children = new ASTNode[3];
463        setChild(new Opt(), 2);
464      }
465      /**
466       * @declaredat ASTNode:14
467       */
468      public FieldDeclaration(Modifiers p0, Access p1, String p2, Opt<Expr> p3) {
469        setChild(p0, 0);
470        setChild(p1, 1);
471        setID(p2);
472        setChild(p3, 2);
473      }
474      /**
475       * @declaredat ASTNode:20
476       */
477      public FieldDeclaration(Modifiers p0, Access p1, beaver.Symbol p2, Opt<Expr> p3) {
478        setChild(p0, 0);
479        setChild(p1, 1);
480        setID(p2);
481        setChild(p3, 2);
482      }
483      /**
484       * @apilevel low-level
485       * @declaredat ASTNode:29
486       */
487      protected int numChildren() {
488        return 3;
489      }
490      /**
491       * @apilevel internal
492       * @declaredat ASTNode:35
493       */
494      public boolean mayHaveRewrite() {
495        return false;
496      }
497      /**
498       * @apilevel internal
499       * @declaredat ASTNode:41
500       */
501      public void flushAttrCache() {
502        super.flushAttrCache();
503        accessibleFrom_TypeDecl_reset();
504        exceptions_reset();
505        isDAafter_Variable_reset();
506        isDUafter_Variable_reset();
507        constant_reset();
508        attributes_reset();
509        flags_reset();
510        usesTypeVariable_reset();
511        sourceVariableDecl_reset();
512        throwTypes_reset();
513        isEffectivelyFinal_reset();
514      }
515      /**
516       * @apilevel internal
517       * @declaredat ASTNode:58
518       */
519      public void flushCollectionCache() {
520        super.flushCollectionCache();
521      }
522      /**
523       * @apilevel internal
524       * @declaredat ASTNode:64
525       */
526      public void flushRewriteCache() {
527        super.flushRewriteCache();
528      }
529      /**
530       * @apilevel internal
531       * @declaredat ASTNode:70
532       */
533      public FieldDeclaration clone() throws CloneNotSupportedException {
534        FieldDeclaration node = (FieldDeclaration) super.clone();
535        return node;
536      }
537      /**
538       * @apilevel internal
539       * @declaredat ASTNode:77
540       */
541      public FieldDeclaration copy() {
542        try {
543          FieldDeclaration node = (FieldDeclaration) clone();
544          node.parent = null;
545          if (children != null) {
546            node.children = (ASTNode[]) children.clone();
547          }
548          return node;
549        } catch (CloneNotSupportedException e) {
550          throw new Error("Error: clone not supported for " + getClass().getName());
551        }
552      }
553      /**
554       * Create a deep copy of the AST subtree at this node.
555       * The copy is dangling, i.e. has no parent.
556       * @return dangling copy of the subtree at this node
557       * @apilevel low-level
558       * @deprecated Please use treeCopy or treeCopyNoTransform instead
559       * @declaredat ASTNode:96
560       */
561      @Deprecated
562      public FieldDeclaration fullCopy() {
563        return treeCopyNoTransform();
564      }
565      /**
566       * Create a deep copy of the AST subtree at this node.
567       * The copy is dangling, i.e. has no parent.
568       * @return dangling copy of the subtree at this node
569       * @apilevel low-level
570       * @declaredat ASTNode:106
571       */
572      public FieldDeclaration treeCopyNoTransform() {
573        FieldDeclaration tree = (FieldDeclaration) copy();
574        if (children != null) {
575          for (int i = 0; i < children.length; ++i) {
576            ASTNode child = (ASTNode) children[i];
577            if (child != null) {
578              child = child.treeCopyNoTransform();
579              tree.setChild(child, i);
580            }
581          }
582        }
583        return tree;
584      }
585      /**
586       * Create a deep copy of the AST subtree at this node.
587       * The subtree of this node is traversed to trigger rewrites before copy.
588       * The copy is dangling, i.e. has no parent.
589       * @return dangling copy of the subtree at this node
590       * @apilevel low-level
591       * @declaredat ASTNode:126
592       */
593      public FieldDeclaration treeCopy() {
594        doFullTraversal();
595        return treeCopyNoTransform();
596      }
597      /**
598       * @apilevel internal
599       * @declaredat ASTNode:133
600       */
601      protected boolean is$Equal(ASTNode node) {
602        return super.is$Equal(node) && (tokenString_ID == ((FieldDeclaration)node).tokenString_ID);    
603      }
604      /**
605       * Replaces the Modifiers child.
606       * @param node The new node to replace the Modifiers child.
607       * @apilevel high-level
608       */
609      public void setModifiers(Modifiers node) {
610        setChild(node, 0);
611      }
612      /**
613       * Retrieves the Modifiers child.
614       * @return The current node used as the Modifiers child.
615       * @apilevel high-level
616       */
617      @ASTNodeAnnotation.Child(name="Modifiers")
618      public Modifiers getModifiers() {
619        return (Modifiers) getChild(0);
620      }
621      /**
622       * Retrieves the Modifiers child.
623       * <p><em>This method does not invoke AST transformations.</em></p>
624       * @return The current node used as the Modifiers child.
625       * @apilevel low-level
626       */
627      public Modifiers getModifiersNoTransform() {
628        return (Modifiers) getChildNoTransform(0);
629      }
630      /**
631       * Replaces the TypeAccess child.
632       * @param node The new node to replace the TypeAccess child.
633       * @apilevel high-level
634       */
635      public void setTypeAccess(Access node) {
636        setChild(node, 1);
637      }
638      /**
639       * Retrieves the TypeAccess child.
640       * @return The current node used as the TypeAccess child.
641       * @apilevel high-level
642       */
643      @ASTNodeAnnotation.Child(name="TypeAccess")
644      public Access getTypeAccess() {
645        return (Access) getChild(1);
646      }
647      /**
648       * Retrieves the TypeAccess child.
649       * <p><em>This method does not invoke AST transformations.</em></p>
650       * @return The current node used as the TypeAccess child.
651       * @apilevel low-level
652       */
653      public Access getTypeAccessNoTransform() {
654        return (Access) getChildNoTransform(1);
655      }
656      /**
657       * Replaces the lexeme ID.
658       * @param value The new value for the lexeme ID.
659       * @apilevel high-level
660       */
661      public void setID(String value) {
662        tokenString_ID = value;
663      }
664      /**
665       * @apilevel internal
666       */
667      protected String tokenString_ID;
668      /**
669       */
670      public int IDstart;
671      /**
672       */
673      public int IDend;
674      /**
675       * JastAdd-internal setter for lexeme ID using the Beaver parser.
676       * @param symbol Symbol containing the new value for the lexeme ID
677       * @apilevel internal
678       */
679      public void setID(beaver.Symbol symbol) {
680        if (symbol.value != null && !(symbol.value instanceof String))
681        throw new UnsupportedOperationException("setID is only valid for String lexemes");
682        tokenString_ID = (String)symbol.value;
683        IDstart = symbol.getStart();
684        IDend = symbol.getEnd();
685      }
686      /**
687       * Retrieves the value for the lexeme ID.
688       * @return The value for the lexeme ID.
689       * @apilevel high-level
690       */
691      @ASTNodeAnnotation.Token(name="ID")
692      public String getID() {
693        return tokenString_ID != null ? tokenString_ID : "";
694      }
695      /**
696       * Replaces the optional node for the Init child. This is the <code>Opt</code>
697       * node containing the child Init, not the actual child!
698       * @param opt The new node to be used as the optional node for the Init child.
699       * @apilevel low-level
700       */
701      public void setInitOpt(Opt<Expr> opt) {
702        setChild(opt, 2);
703      }
704      /**
705       * Replaces the (optional) Init child.
706       * @param node The new node to be used as the Init child.
707       * @apilevel high-level
708       */
709      public void setInit(Expr node) {
710        getInitOpt().setChild(node, 0);
711      }
712      /**
713       * Check whether the optional Init child exists.
714       * @return {@code true} if the optional Init child exists, {@code false} if it does not.
715       * @apilevel high-level
716       */
717      public boolean hasInit() {
718        return getInitOpt().getNumChild() != 0;
719      }
720      /**
721       * Retrieves the (optional) Init child.
722       * @return The Init child, if it exists. Returns {@code null} otherwise.
723       * @apilevel low-level
724       */
725      public Expr getInit() {
726        return (Expr) getInitOpt().getChild(0);
727      }
728      /**
729       * Retrieves the optional node for the Init child. This is the <code>Opt</code> node containing the child Init, not the actual child!
730       * @return The optional node for child the Init child.
731       * @apilevel low-level
732       */
733      @ASTNodeAnnotation.OptChild(name="Init")
734      public Opt<Expr> getInitOpt() {
735        return (Opt<Expr>) getChild(2);
736      }
737      /**
738       * Retrieves the optional node for child Init. This is the <code>Opt</code> node containing the child Init, not the actual child!
739       * <p><em>This method does not invoke AST transformations.</em></p>
740       * @return The optional node for child Init.
741       * @apilevel low-level
742       */
743      public Opt<Expr> getInitOptNoTransform() {
744        return (Opt<Expr>) getChildNoTransform(2);
745      }
746      /**
747       * @aspect Attributes
748       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:213
749       */
750      private Collection refined_Attributes_FieldDeclaration_attributes()
751    {
752        ArrayList l = new ArrayList();
753        if (isFinal() && isConstant() && (type().isPrimitive() || type().isString())) {
754          l.add(new ConstantValueAttribute(hostType().constantPool(), this));
755        }
756        return l;
757      }
758      /**
759       * @aspect AnnotationsCodegen
760       * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:38
761       */
762      private Collection refined_AnnotationsCodegen_FieldDeclaration_attributes()
763    {
764        Collection c = refined_Attributes_FieldDeclaration_attributes();
765        getModifiers().addRuntimeVisibleAnnotationsAttribute(c);
766        getModifiers().addRuntimeInvisibleAnnotationsAttribute(c);
767        return c;
768      }
769      /**
770       * @apilevel internal
771       */
772      protected java.util.Map accessibleFrom_TypeDecl_values;
773      /**
774       * @apilevel internal
775       */
776      private void accessibleFrom_TypeDecl_reset() {
777        accessibleFrom_TypeDecl_values = null;
778      }
779      /**
780       * @attribute syn
781       * @aspect AccessControl
782       * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:132
783       */
784      @ASTNodeAnnotation.Attribute
785      public boolean accessibleFrom(TypeDecl type) {
786        Object _parameters = type;
787        if (accessibleFrom_TypeDecl_values == null) accessibleFrom_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
788        ASTNode$State state = state();
789        if (accessibleFrom_TypeDecl_values.containsKey(_parameters)) {
790          return (Boolean) accessibleFrom_TypeDecl_values.get(_parameters);
791        }
792        boolean intermediate = state.INTERMEDIATE_VALUE;
793        state.INTERMEDIATE_VALUE = false;
794        int num = state.boundariesCrossed;
795        boolean isFinal = this.is$Final();
796        boolean accessibleFrom_TypeDecl_value = accessibleFrom_compute(type);
797        if (isFinal && num == state().boundariesCrossed) {
798          accessibleFrom_TypeDecl_values.put(_parameters, accessibleFrom_TypeDecl_value);
799        } else {
800        }
801        state.INTERMEDIATE_VALUE |= intermediate;
802    
803        return accessibleFrom_TypeDecl_value;
804      }
805      /**
806       * @apilevel internal
807       */
808      private boolean accessibleFrom_compute(TypeDecl type) {
809          if (isPublic()) {
810            return true;
811          } else if (isProtected()) {
812            if (hostPackage().equals(type.hostPackage())) {
813              return true;
814            }
815            if (type.withinBodyThatSubclasses(hostType()) != null) {
816              return true;
817            }
818            return false;
819          } else if (isPrivate()) {
820            return hostType().topLevelType() == type.topLevelType();
821          } else {
822            return hostPackage().equals(type.hostPackage());
823          }
824        }
825      /**
826       * @apilevel internal
827       */
828      protected boolean exceptions_computed = false;
829      /**
830       * @apilevel internal
831       */
832      protected Collection exceptions_value;
833      /**
834       * @apilevel internal
835       */
836      private void exceptions_reset() {
837        exceptions_computed = false;
838        exceptions_value = null;
839      }
840      /**
841       * @attribute syn
842       * @aspect AnonymousClasses
843       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:97
844       */
845      @ASTNodeAnnotation.Attribute
846      public Collection exceptions() {
847        ASTNode$State state = state();
848        if (exceptions_computed) {
849          return exceptions_value;
850        }
851        boolean intermediate = state.INTERMEDIATE_VALUE;
852        state.INTERMEDIATE_VALUE = false;
853        int num = state.boundariesCrossed;
854        boolean isFinal = this.is$Final();
855        exceptions_value = exceptions_compute();
856        if (isFinal && num == state().boundariesCrossed) {
857          exceptions_computed = true;
858        } else {
859        }
860        state.INTERMEDIATE_VALUE |= intermediate;
861    
862        return exceptions_value;
863      }
864      /**
865       * @apilevel internal
866       */
867      private Collection exceptions_compute() {
868          HashSet set = new HashSet();
869          if (isInstanceVariable() && hasInit()) {
870            collectExceptions(set, this);
871            for (Iterator iter = set.iterator(); iter.hasNext(); ) {
872              TypeDecl typeDecl = (TypeDecl) iter.next();
873              if (!getInit().reachedException(typeDecl)) {
874                iter.remove();
875              }
876            }
877          }
878          return set;
879        }
880      /**
881       * @attribute syn
882       * @aspect ConstantExpression
883       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:250
884       */
885      @ASTNodeAnnotation.Attribute
886      public boolean isConstant() {
887        boolean isConstant_value = isFinal() && hasInit() && getInit().isConstant() && (type() instanceof PrimitiveType || type().isString());
888    
889        return isConstant_value;
890      }
891      /**
892       * @attribute syn
893       * @aspect DataStructures
894       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:103
895       */
896      @ASTNodeAnnotation.Attribute
897      public int size() {
898        int size_value = 1;
899    
900        return size_value;
901      }
902      /**
903       * @attribute syn
904       * @aspect DataStructures
905       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:104
906       */
907      @ASTNodeAnnotation.Attribute
908      public boolean isEmpty() {
909        boolean isEmpty_value = false;
910    
911        return isEmpty_value;
912      }
913      /**
914       * @attribute syn
915       * @aspect DataStructures
916       * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:108
917       */
918      @ASTNodeAnnotation.Attribute
919      public boolean contains(Object o) {
920        boolean contains_Object_value = this == o;
921    
922        return contains_Object_value;
923      }
924      /**
925       * @apilevel internal
926       */
927      protected java.util.Map isDAafter_Variable_values;
928      /**
929       * @apilevel internal
930       */
931      private void isDAafter_Variable_reset() {
932        isDAafter_Variable_values = null;
933      }
934      /**
935       * @attribute syn
936       * @aspect DA
937       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:266
938       */
939      @ASTNodeAnnotation.Attribute
940      public boolean isDAafter(Variable v) {
941        Object _parameters = v;
942        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
943        ASTNode$State state = state();
944        if (isDAafter_Variable_values.containsKey(_parameters)) {
945          return (Boolean) isDAafter_Variable_values.get(_parameters);
946        }
947        boolean intermediate = state.INTERMEDIATE_VALUE;
948        state.INTERMEDIATE_VALUE = false;
949        int num = state.boundariesCrossed;
950        boolean isFinal = this.is$Final();
951        boolean isDAafter_Variable_value = isDAafter_compute(v);
952        if (isFinal && num == state().boundariesCrossed) {
953          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
954        } else {
955        }
956        state.INTERMEDIATE_VALUE |= intermediate;
957    
958        return isDAafter_Variable_value;
959      }
960      /**
961       * @apilevel internal
962       */
963      private boolean isDAafter_compute(Variable v) {
964          if (v == this) {
965            return hasInit();
966          }
967          return hasInit() ? getInit().isDAafter(v) : isDAbefore(v);
968        }
969      /**
970       * @apilevel internal
971       */
972      protected java.util.Map isDUafter_Variable_values;
973      /**
974       * @apilevel internal
975       */
976      private void isDUafter_Variable_reset() {
977        isDUafter_Variable_values = null;
978      }
979      /**
980       * @attribute syn
981       * @aspect DU
982       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:796
983       */
984      @ASTNodeAnnotation.Attribute
985      public boolean isDUafter(Variable v) {
986        Object _parameters = v;
987        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
988        ASTNode$State state = state();
989        if (isDUafter_Variable_values.containsKey(_parameters)) {
990          return (Boolean) isDUafter_Variable_values.get(_parameters);
991        }
992        boolean intermediate = state.INTERMEDIATE_VALUE;
993        state.INTERMEDIATE_VALUE = false;
994        int num = state.boundariesCrossed;
995        boolean isFinal = this.is$Final();
996        boolean isDUafter_Variable_value = isDUafter_compute(v);
997        if (isFinal && num == state().boundariesCrossed) {
998          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
999        } else {
1000        }
1001        state.INTERMEDIATE_VALUE |= intermediate;
1002    
1003        return isDUafter_Variable_value;
1004      }
1005      /**
1006       * @apilevel internal
1007       */
1008      private boolean isDUafter_compute(Variable v) {
1009          if (v == this) {
1010            return !hasInit();
1011          }
1012          return hasInit() ? getInit().isDUafter(v) : isDUbefore(v);
1013        }
1014      /**
1015       * @attribute syn
1016       * @aspect Modifiers
1017       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:255
1018       */
1019      @ASTNodeAnnotation.Attribute
1020      public boolean isSynthetic() {
1021        boolean isSynthetic_value = getModifiers().isSynthetic();
1022    
1023        return isSynthetic_value;
1024      }
1025      /**
1026       * @attribute syn
1027       * @aspect Modifiers
1028       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:280
1029       */
1030      @ASTNodeAnnotation.Attribute
1031      public boolean isPublic() {
1032        boolean isPublic_value = getModifiers().isPublic() || hostType().isInterfaceDecl();
1033    
1034        return isPublic_value;
1035      }
1036      /**
1037       * @attribute syn
1038       * @aspect Modifiers
1039       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:281
1040       */
1041      @ASTNodeAnnotation.Attribute
1042      public boolean isPrivate() {
1043        boolean isPrivate_value = getModifiers().isPrivate();
1044    
1045        return isPrivate_value;
1046      }
1047      /**
1048       * @attribute syn
1049       * @aspect Modifiers
1050       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:282
1051       */
1052      @ASTNodeAnnotation.Attribute
1053      public boolean isProtected() {
1054        boolean isProtected_value = getModifiers().isProtected();
1055    
1056        return isProtected_value;
1057      }
1058      /**
1059       * @attribute syn
1060       * @aspect Modifiers
1061       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:283
1062       */
1063      @ASTNodeAnnotation.Attribute
1064      public boolean isStatic() {
1065        boolean isStatic_value = getModifiers().isStatic() || hostType().isInterfaceDecl();
1066    
1067        return isStatic_value;
1068      }
1069      /**
1070       * @attribute syn
1071       * @aspect Modifiers
1072       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:285
1073       */
1074      @ASTNodeAnnotation.Attribute
1075      public boolean isFinal() {
1076        boolean isFinal_value = getModifiers().isFinal() || hostType().isInterfaceDecl();
1077    
1078        return isFinal_value;
1079      }
1080      /**
1081       * @attribute syn
1082       * @aspect Modifiers
1083       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:286
1084       */
1085      @ASTNodeAnnotation.Attribute
1086      public boolean isTransient() {
1087        boolean isTransient_value = getModifiers().isTransient();
1088    
1089        return isTransient_value;
1090      }
1091      /**
1092       * @attribute syn
1093       * @aspect Modifiers
1094       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:287
1095       */
1096      @ASTNodeAnnotation.Attribute
1097      public boolean isVolatile() {
1098        boolean isVolatile_value = getModifiers().isVolatile();
1099    
1100        return isVolatile_value;
1101      }
1102      /**
1103       * @attribute syn
1104       * @aspect PrettyPrintUtil
1105       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:249
1106       */
1107      @ASTNodeAnnotation.Attribute
1108      public boolean hasModifiers() {
1109        boolean hasModifiers_value = getModifiers().getNumModifier() > 0;
1110    
1111        return hasModifiers_value;
1112      }
1113      /**
1114       * @attribute syn
1115       * @aspect TypeAnalysis
1116       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:275
1117       */
1118      @ASTNodeAnnotation.Attribute
1119      public TypeDecl type() {
1120        TypeDecl type_value = getTypeAccess().type();
1121    
1122        return type_value;
1123      }
1124      /**
1125       * @attribute syn
1126       * @aspect TypeAnalysis
1127       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:297
1128       */
1129      @ASTNodeAnnotation.Attribute
1130      public boolean isVoid() {
1131        boolean isVoid_value = type().isVoid();
1132    
1133        return isVoid_value;
1134      }
1135      /**
1136       * @attribute syn
1137       * @aspect Variables
1138       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:53
1139       */
1140      @ASTNodeAnnotation.Attribute
1141      public boolean isParameter() {
1142        boolean isParameter_value = false;
1143    
1144        return isParameter_value;
1145      }
1146      /**
1147       * @attribute syn
1148       * @aspect Variables
1149       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:55
1150       */
1151      @ASTNodeAnnotation.Attribute
1152      public boolean isClassVariable() {
1153        boolean isClassVariable_value = isStatic() || hostType().isInterfaceDecl();
1154    
1155        return isClassVariable_value;
1156      }
1157      /**
1158       * @attribute syn
1159       * @aspect Variables
1160       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:56
1161       */
1162      @ASTNodeAnnotation.Attribute
1163      public boolean isInstanceVariable() {
1164        boolean isInstanceVariable_value = (hostType().isClassDecl() || hostType().isAnonymous() )&& !isStatic();
1165    
1166        return isInstanceVariable_value;
1167      }
1168      /**
1169       * @attribute syn
1170       * @aspect Variables
1171       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:57
1172       */
1173      @ASTNodeAnnotation.Attribute
1174      public boolean isMethodParameter() {
1175        boolean isMethodParameter_value = false;
1176    
1177        return isMethodParameter_value;
1178      }
1179      /**
1180       * @attribute syn
1181       * @aspect Variables
1182       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:58
1183       */
1184      @ASTNodeAnnotation.Attribute
1185      public boolean isConstructorParameter() {
1186        boolean isConstructorParameter_value = false;
1187    
1188        return isConstructorParameter_value;
1189      }
1190      /**
1191       * @attribute syn
1192       * @aspect Variables
1193       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:59
1194       */
1195      @ASTNodeAnnotation.Attribute
1196      public boolean isExceptionHandlerParameter() {
1197        boolean isExceptionHandlerParameter_value = false;
1198    
1199        return isExceptionHandlerParameter_value;
1200      }
1201      /**
1202       * @attribute syn
1203       * @aspect Variables
1204       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:60
1205       */
1206      @ASTNodeAnnotation.Attribute
1207      public boolean isLocalVariable() {
1208        boolean isLocalVariable_value = false;
1209    
1210        return isLocalVariable_value;
1211      }
1212      /**
1213       * @attribute syn
1214       * @aspect Variables
1215       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:62
1216       */
1217      @ASTNodeAnnotation.Attribute
1218      public boolean isBlank() {
1219        boolean isBlank_value = !hasInit();
1220    
1221        return isBlank_value;
1222      }
1223      /**
1224       * @attribute syn
1225       * @aspect Variables
1226       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:64
1227       */
1228      @ASTNodeAnnotation.Attribute
1229      public String name() {
1230        String name_value = getID();
1231    
1232        return name_value;
1233      }
1234      /**
1235       * @apilevel internal
1236       */
1237      protected boolean constant_computed = false;
1238      /**
1239       * @apilevel internal
1240       */
1241      protected Constant constant_value;
1242      /**
1243       * @apilevel internal
1244       */
1245      private void constant_reset() {
1246        constant_computed = false;
1247        constant_value = null;
1248      }
1249      /**
1250       * @attribute syn
1251       * @aspect Variables
1252       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:65
1253       */
1254      @ASTNodeAnnotation.Attribute
1255      public Constant constant() {
1256        ASTNode$State state = state();
1257        if (constant_computed) {
1258          return constant_value;
1259        }
1260        boolean intermediate = state.INTERMEDIATE_VALUE;
1261        state.INTERMEDIATE_VALUE = false;
1262        int num = state.boundariesCrossed;
1263        boolean isFinal = this.is$Final();
1264        constant_value = type().cast(getInit().constant());
1265        if (isFinal && num == state().boundariesCrossed) {
1266          constant_computed = true;
1267        } else {
1268        }
1269        state.INTERMEDIATE_VALUE |= intermediate;
1270    
1271        return constant_value;
1272      }
1273      /**
1274       * @apilevel internal
1275       */
1276      protected boolean attributes_computed = false;
1277      /**
1278       * @apilevel internal
1279       */
1280      protected Collection attributes_value;
1281      /**
1282       * @apilevel internal
1283       */
1284      private void attributes_reset() {
1285        attributes_computed = false;
1286        attributes_value = null;
1287      }
1288      /**
1289       * @attribute syn
1290       * @aspect Attributes
1291       * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:212
1292       */
1293      @ASTNodeAnnotation.Attribute
1294      public Collection attributes() {
1295        ASTNode$State state = state();
1296        if (attributes_computed) {
1297          return attributes_value;
1298        }
1299        boolean intermediate = state.INTERMEDIATE_VALUE;
1300        state.INTERMEDIATE_VALUE = false;
1301        int num = state.boundariesCrossed;
1302        boolean isFinal = this.is$Final();
1303        attributes_value = attributes_compute();
1304        if (isFinal && num == state().boundariesCrossed) {
1305          attributes_computed = true;
1306        } else {
1307        }
1308        state.INTERMEDIATE_VALUE |= intermediate;
1309    
1310        return attributes_value;
1311      }
1312      /**
1313       * @apilevel internal
1314       */
1315      private Collection attributes_compute() {
1316          Collection c = refined_AnnotationsCodegen_FieldDeclaration_attributes();
1317          if (needsSignatureAttribute()) {
1318            c.add(new SignatureAttribute(hostType().constantPool(), type().fieldTypeSignature()));
1319          }
1320          return c;
1321        }
1322      /**
1323       * @apilevel internal
1324       */
1325      protected boolean flags_computed = false;
1326      /**
1327       * @apilevel internal
1328       */
1329      protected int flags_value;
1330      /**
1331       * @apilevel internal
1332       */
1333      private void flags_reset() {
1334        flags_computed = false;
1335      }
1336      /**
1337       * @attribute syn
1338       * @aspect Flags
1339       * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:134
1340       */
1341      @ASTNodeAnnotation.Attribute
1342      public int flags() {
1343        ASTNode$State state = state();
1344        if (flags_computed) {
1345          return flags_value;
1346        }
1347        boolean intermediate = state.INTERMEDIATE_VALUE;
1348        state.INTERMEDIATE_VALUE = false;
1349        int num = state.boundariesCrossed;
1350        boolean isFinal = this.is$Final();
1351        flags_value = flags_compute();
1352        if (isFinal && num == state().boundariesCrossed) {
1353          flags_computed = true;
1354        } else {
1355        }
1356        state.INTERMEDIATE_VALUE |= intermediate;
1357    
1358        return flags_value;
1359      }
1360      /**
1361       * @apilevel internal
1362       */
1363      private int flags_compute() {
1364          int res = 0;
1365          if (isPublic()) {
1366            res |= Modifiers.ACC_PUBLIC;
1367          }
1368          if (isPrivate()) {
1369            res |= Modifiers.ACC_PRIVATE;
1370          }
1371          if (isProtected()) {
1372            res |= Modifiers.ACC_PROTECTED;
1373          }
1374          if (isStatic()) {
1375            res |= Modifiers.ACC_STATIC;
1376          }
1377          if (isFinal()) {
1378            res |= Modifiers.ACC_FINAL;
1379          }
1380          if (isVolatile()) {
1381            res |= Modifiers.ACC_VOLATILE;
1382          }
1383          if (isTransient()) {
1384            res |= Modifiers.ACC_TRANSIENT;
1385          }
1386          return res;
1387        }
1388      /**
1389       * @attribute syn
1390       * @aspect GenerateClassfile
1391       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:347
1392       */
1393      @ASTNodeAnnotation.Attribute
1394      public boolean isBytecodeField() {
1395        boolean isBytecodeField_value = true;
1396    
1397        return isBytecodeField_value;
1398      }
1399      /**
1400       * @attribute syn
1401       * @aspect GenerateClassfile
1402       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:379
1403       */
1404      @ASTNodeAnnotation.Attribute
1405      public boolean flush() {
1406        boolean flush_value = false;
1407    
1408        return flush_value;
1409      }
1410      /**
1411       * @attribute syn
1412       * @aspect Annotations
1413       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:356
1414       */
1415      @ASTNodeAnnotation.Attribute
1416      public boolean hasAnnotationSuppressWarnings(String annot) {
1417        boolean hasAnnotationSuppressWarnings_String_value = getModifiers().hasAnnotationSuppressWarnings(annot);
1418    
1419        return hasAnnotationSuppressWarnings_String_value;
1420      }
1421      /**
1422       * @attribute syn
1423       * @aspect Annotations
1424       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:401
1425       */
1426      @ASTNodeAnnotation.Attribute
1427      public boolean isDeprecated() {
1428        boolean isDeprecated_value = getModifiers().hasDeprecatedAnnotation();
1429    
1430        return isDeprecated_value;
1431      }
1432      /**
1433       * @apilevel internal
1434       */
1435      protected boolean usesTypeVariable_computed = false;
1436      /**
1437       * @apilevel internal
1438       */
1439      protected boolean usesTypeVariable_value;
1440      /**
1441       * @apilevel internal
1442       */
1443      private void usesTypeVariable_reset() {
1444        usesTypeVariable_computed = false;
1445      }
1446      /**
1447       * @attribute syn
1448       * @aspect LookupParTypeDecl
1449       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1253
1450       */
1451      @ASTNodeAnnotation.Attribute
1452      public boolean usesTypeVariable() {
1453        ASTNode$State state = state();
1454        if (usesTypeVariable_computed) {
1455          return usesTypeVariable_value;
1456        }
1457        boolean intermediate = state.INTERMEDIATE_VALUE;
1458        state.INTERMEDIATE_VALUE = false;
1459        int num = state.boundariesCrossed;
1460        boolean isFinal = this.is$Final();
1461        usesTypeVariable_value = getTypeAccess().usesTypeVariable();
1462        if (isFinal && num == state().boundariesCrossed) {
1463          usesTypeVariable_computed = true;
1464        } else {
1465        }
1466        state.INTERMEDIATE_VALUE |= intermediate;
1467    
1468        return usesTypeVariable_value;
1469      }
1470      /**
1471       * @attribute syn
1472       * @aspect LookupParTypeDecl
1473       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1410
1474       */
1475      @ASTNodeAnnotation.Attribute
1476      public FieldDeclaration erasedField() {
1477        FieldDeclaration erasedField_value = this;
1478    
1479        return erasedField_value;
1480      }
1481      /**
1482       * @apilevel internal
1483       */
1484      protected boolean sourceVariableDecl_computed = false;
1485      /**
1486       * @apilevel internal
1487       */
1488      protected Variable sourceVariableDecl_value;
1489      /**
1490       * @apilevel internal
1491       */
1492      private void sourceVariableDecl_reset() {
1493        sourceVariableDecl_computed = false;
1494        sourceVariableDecl_value = null;
1495      }
1496      /**
1497       * @attribute syn
1498       * @aspect SourceDeclarations
1499       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1637
1500       */
1501      @ASTNodeAnnotation.Attribute
1502      public Variable sourceVariableDecl() {
1503        ASTNode$State state = state();
1504        if (sourceVariableDecl_computed) {
1505          return sourceVariableDecl_value;
1506        }
1507        boolean intermediate = state.INTERMEDIATE_VALUE;
1508        state.INTERMEDIATE_VALUE = false;
1509        int num = state.boundariesCrossed;
1510        boolean isFinal = this.is$Final();
1511        sourceVariableDecl_value = this;
1512        if (isFinal && num == state().boundariesCrossed) {
1513          sourceVariableDecl_computed = true;
1514        } else {
1515        }
1516        state.INTERMEDIATE_VALUE |= intermediate;
1517    
1518        return sourceVariableDecl_value;
1519      }
1520      /**
1521       * @attribute syn
1522       * @aspect GenericsParTypeDecl
1523       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:90
1524       */
1525      @ASTNodeAnnotation.Attribute
1526      public boolean visibleTypeParameters() {
1527        boolean visibleTypeParameters_value = !isStatic();
1528    
1529        return visibleTypeParameters_value;
1530      }
1531      /**
1532       * @attribute syn
1533       * @aspect GenericsCodegen
1534       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:374
1535       */
1536      @ASTNodeAnnotation.Attribute
1537      public boolean needsSignatureAttribute() {
1538        boolean needsSignatureAttribute_value = type().needsSignatureAttribute();
1539    
1540        return needsSignatureAttribute_value;
1541      }
1542      /**
1543       * @apilevel internal
1544       */
1545      protected boolean throwTypes_computed = false;
1546      /**
1547       * @apilevel internal
1548       */
1549      protected Collection<TypeDecl> throwTypes_value;
1550      /**
1551       * @apilevel internal
1552       */
1553      private void throwTypes_reset() {
1554        throwTypes_computed = false;
1555        throwTypes_value = null;
1556      }
1557      /**
1558       * @attribute syn
1559       * @aspect PreciseRethrow
1560       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:47
1561       */
1562      @ASTNodeAnnotation.Attribute
1563      public Collection<TypeDecl> throwTypes() {
1564        ASTNode$State state = state();
1565        if (throwTypes_computed) {
1566          return throwTypes_value;
1567        }
1568        boolean intermediate = state.INTERMEDIATE_VALUE;
1569        state.INTERMEDIATE_VALUE = false;
1570        int num = state.boundariesCrossed;
1571        boolean isFinal = this.is$Final();
1572        throwTypes_value = throwTypes_compute();
1573        if (isFinal && num == state().boundariesCrossed) {
1574          throwTypes_computed = true;
1575        } else {
1576        }
1577        state.INTERMEDIATE_VALUE |= intermediate;
1578    
1579        return throwTypes_value;
1580      }
1581      /**
1582       * @apilevel internal
1583       */
1584      private Collection<TypeDecl> throwTypes_compute() {
1585          Collection<TypeDecl> tts = new LinkedList<TypeDecl>();
1586          tts.add(type());
1587          return tts;
1588        }
1589      /**
1590       * @return true if the modifier list includes the SafeVarargs annotation
1591       * @attribute syn
1592       * @aspect SafeVarargs
1593       * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:42
1594       */
1595      @ASTNodeAnnotation.Attribute
1596      public boolean hasAnnotationSafeVarargs() {
1597        boolean hasAnnotationSafeVarargs_value = getModifiers().hasAnnotationSafeVarargs();
1598    
1599        return hasAnnotationSafeVarargs_value;
1600      }
1601      /**
1602       * @attribute syn
1603       * @aspect SuppressWarnings
1604       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:44
1605       */
1606      @ASTNodeAnnotation.Attribute
1607      public boolean suppressWarnings(String type) {
1608        boolean suppressWarnings_String_value = hasAnnotationSuppressWarnings(type) || withinSuppressWarnings(type);
1609    
1610        return suppressWarnings_String_value;
1611      }
1612      /**
1613       * @apilevel internal
1614       */
1615      protected boolean isEffectivelyFinal_computed = false;
1616      /**
1617       * @apilevel internal
1618       */
1619      protected boolean isEffectivelyFinal_value;
1620      /**
1621       * @apilevel internal
1622       */
1623      private void isEffectivelyFinal_reset() {
1624        isEffectivelyFinal_computed = false;
1625      }
1626      /**
1627       * @attribute syn
1628       * @aspect EffectivelyFinal
1629       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:138
1630       */
1631      @ASTNodeAnnotation.Attribute
1632      public boolean isEffectivelyFinal() {
1633        ASTNode$State state = state();
1634        if (isEffectivelyFinal_computed) {
1635          return isEffectivelyFinal_value;
1636        }
1637        boolean intermediate = state.INTERMEDIATE_VALUE;
1638        state.INTERMEDIATE_VALUE = false;
1639        int num = state.boundariesCrossed;
1640        boolean isFinal = this.is$Final();
1641        isEffectivelyFinal_value = isFinal();
1642        if (isFinal && num == state().boundariesCrossed) {
1643          isEffectivelyFinal_computed = true;
1644        } else {
1645        }
1646        state.INTERMEDIATE_VALUE |= intermediate;
1647    
1648        return isEffectivelyFinal_value;
1649      }
1650      /**
1651       * @attribute inh
1652       * @aspect ExceptionHandling
1653       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:81
1654       */
1655      /**
1656       * @attribute inh
1657       * @aspect ExceptionHandling
1658       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:81
1659       */
1660      @ASTNodeAnnotation.Attribute
1661      public boolean handlesException(TypeDecl exceptionType) {
1662        boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType);
1663    
1664        return handlesException_TypeDecl_value;
1665      }
1666      /**
1667       * @attribute inh
1668       * @aspect SuppressWarnings
1669       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:36
1670       */
1671      /**
1672       * @attribute inh
1673       * @aspect SuppressWarnings
1674       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:36
1675       */
1676      @ASTNodeAnnotation.Attribute
1677      public boolean withinSuppressWarnings(String annot) {
1678        boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot);
1679    
1680        return withinSuppressWarnings_String_value;
1681      }
1682      /**
1683       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47
1684       * @apilevel internal
1685       */
1686      public boolean Define_isSource(ASTNode caller, ASTNode child) {
1687        if (caller == getInitOptNoTransform()) {
1688          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:61
1689          return true;
1690        }
1691        else {
1692          return getParent().Define_isSource(this, caller);
1693        }
1694      }
1695      protected boolean canDefine_isSource(ASTNode caller, ASTNode child) {
1696        return true;
1697      }
1698      /**
1699       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
1700       * @apilevel internal
1701       */
1702      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1703        if (caller == getInitOptNoTransform()) {
1704          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:361
1705          {
1706              return isDAbefore(v);
1707            }
1708        }
1709        else {
1710          return super.Define_isDAbefore(caller, child, v);
1711        }
1712      }
1713      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1714        return true;
1715      }
1716      /**
1717       * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:113
1718       * @apilevel internal
1719       */
1720      public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
1721        if (caller == getInitOptNoTransform()) {
1722          // @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:209
1723          {
1724              if (hostType().isAnonymous()) {
1725                return true;
1726              }
1727              for (Iterator iter = hostType().constructors().iterator(); iter.hasNext(); ) {
1728                ConstructorDecl decl = (ConstructorDecl) iter.next();
1729                if (!decl.throwsException(exceptionType)) {
1730                  return false;
1731                }
1732              }
1733              return true;
1734            }
1735        }
1736        else {
1737          return getParent().Define_handlesException(this, caller, exceptionType);
1738        }
1739      }
1740      protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
1741        return true;
1742      }
1743      /**
1744       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:419
1745       * @apilevel internal
1746       */
1747      public boolean Define_mayBePublic(ASTNode caller, ASTNode child) {
1748        if (caller == getModifiersNoTransform()) {
1749          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:303
1750          return true;
1751        }
1752        else {
1753          return getParent().Define_mayBePublic(this, caller);
1754        }
1755      }
1756      protected boolean canDefine_mayBePublic(ASTNode caller, ASTNode child) {
1757        return true;
1758      }
1759      /**
1760       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:421
1761       * @apilevel internal
1762       */
1763      public boolean Define_mayBeProtected(ASTNode caller, ASTNode child) {
1764        if (caller == getModifiersNoTransform()) {
1765          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:304
1766          return true;
1767        }
1768        else {
1769          return getParent().Define_mayBeProtected(this, caller);
1770        }
1771      }
1772      protected boolean canDefine_mayBeProtected(ASTNode caller, ASTNode child) {
1773        return true;
1774      }
1775      /**
1776       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:420
1777       * @apilevel internal
1778       */
1779      public boolean Define_mayBePrivate(ASTNode caller, ASTNode child) {
1780        if (caller == getModifiersNoTransform()) {
1781          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:305
1782          return true;
1783        }
1784        else {
1785          return getParent().Define_mayBePrivate(this, caller);
1786        }
1787      }
1788      protected boolean canDefine_mayBePrivate(ASTNode caller, ASTNode child) {
1789        return true;
1790      }
1791      /**
1792       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:422
1793       * @apilevel internal
1794       */
1795      public boolean Define_mayBeStatic(ASTNode caller, ASTNode child) {
1796        if (caller == getModifiersNoTransform()) {
1797          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:306
1798          return true;
1799        }
1800        else {
1801          return getParent().Define_mayBeStatic(this, caller);
1802        }
1803      }
1804      protected boolean canDefine_mayBeStatic(ASTNode caller, ASTNode child) {
1805        return true;
1806      }
1807      /**
1808       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423
1809       * @apilevel internal
1810       */
1811      public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) {
1812        if (caller == getModifiersNoTransform()) {
1813          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:307
1814          return true;
1815        }
1816        else {
1817          return getParent().Define_mayBeFinal(this, caller);
1818        }
1819      }
1820      protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) {
1821        return true;
1822      }
1823      /**
1824       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:426
1825       * @apilevel internal
1826       */
1827      public boolean Define_mayBeTransient(ASTNode caller, ASTNode child) {
1828        if (caller == getModifiersNoTransform()) {
1829          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:308
1830          return true;
1831        }
1832        else {
1833          return getParent().Define_mayBeTransient(this, caller);
1834        }
1835      }
1836      protected boolean canDefine_mayBeTransient(ASTNode caller, ASTNode child) {
1837        return true;
1838      }
1839      /**
1840       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:425
1841       * @apilevel internal
1842       */
1843      public boolean Define_mayBeVolatile(ASTNode caller, ASTNode child) {
1844        if (caller == getModifiersNoTransform()) {
1845          // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:309
1846          return true;
1847        }
1848        else {
1849          return getParent().Define_mayBeVolatile(this, caller);
1850        }
1851      }
1852      protected boolean canDefine_mayBeVolatile(ASTNode caller, ASTNode child) {
1853        return true;
1854      }
1855      /**
1856       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
1857       * @apilevel internal
1858       */
1859      public NameType Define_nameType(ASTNode caller, ASTNode child) {
1860        if (caller == getTypeAccessNoTransform()) {
1861          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:105
1862          return NameType.TYPE_NAME;
1863        }
1864        else {
1865          return getParent().Define_nameType(this, caller);
1866        }
1867      }
1868      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
1869        return true;
1870      }
1871      /**
1872       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:601
1873       * @apilevel internal
1874       */
1875      public TypeDecl Define_declType(ASTNode caller, ASTNode child) {
1876        if (caller == getInitOptNoTransform()) {
1877          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:286
1878          return type();
1879        }
1880        else {
1881          return getParent().Define_declType(this, caller);
1882        }
1883      }
1884      protected boolean canDefine_declType(ASTNode caller, ASTNode child) {
1885        return true;
1886      }
1887      /**
1888       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182
1889       * @apilevel internal
1890       */
1891      public boolean Define_inStaticContext(ASTNode caller, ASTNode child) {
1892        if (caller == getInitOptNoTransform()) {
1893          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:189
1894          return isStatic();
1895        }
1896        else {
1897          return getParent().Define_inStaticContext(this, caller);
1898        }
1899      }
1900      protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) {
1901        return true;
1902      }
1903      /**
1904       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:93
1905       * @apilevel internal
1906       */
1907      public TypeDecl Define_expectedType(ASTNode caller, ASTNode child) {
1908        if (caller == getInitOptNoTransform()) {
1909          // @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:98
1910          return type().componentType();
1911        }
1912        else {
1913          return getParent().Define_expectedType(this, caller);
1914        }
1915      }
1916      protected boolean canDefine_expectedType(ASTNode caller, ASTNode child) {
1917        return true;
1918      }
1919      /**
1920       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:96
1921       * @apilevel internal
1922       */
1923      public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
1924        if (caller == getModifiersNoTransform()) {
1925          // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:107
1926          return name.equals("FIELD");
1927        }
1928        else {
1929          return getParent().Define_mayUseAnnotationTarget(this, caller, name);
1930        }
1931      }
1932      protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
1933        return true;
1934      }
1935      /**
1936       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:58
1937       * @apilevel internal
1938       */
1939      public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) {
1940        if (caller == getInitOptNoTransform()) {
1941          // @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:60
1942          return type();
1943        }
1944        else {
1945          return getParent().Define_assignConvertedType(this, caller);
1946        }
1947      }
1948      protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) {
1949        return true;
1950      }
1951      /**
1952       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30
1953       * @apilevel internal
1954       */
1955      public TypeDecl Define_targetType(ASTNode caller, ASTNode child) {
1956        if (caller == getInitOptNoTransform()) {
1957          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:40
1958          return getTypeAccess().type();
1959        }
1960        else {
1961          return getParent().Define_targetType(this, caller);
1962        }
1963      }
1964      protected boolean canDefine_targetType(ASTNode caller, ASTNode child) {
1965        return true;
1966      }
1967      /**
1968       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196
1969       * @apilevel internal
1970       */
1971      public boolean Define_assignmentContext(ASTNode caller, ASTNode child) {
1972        if (caller == getInitOptNoTransform()) {
1973          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:373
1974          return true;
1975        }
1976        else {
1977          return getParent().Define_assignmentContext(this, caller);
1978        }
1979      }
1980      protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) {
1981        return true;
1982      }
1983      /**
1984       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197
1985       * @apilevel internal
1986       */
1987      public boolean Define_invocationContext(ASTNode caller, ASTNode child) {
1988        if (caller == getInitOptNoTransform()) {
1989          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:374
1990          return false;
1991        }
1992        else {
1993          return getParent().Define_invocationContext(this, caller);
1994        }
1995      }
1996      protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) {
1997        return true;
1998      }
1999      /**
2000       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198
2001       * @apilevel internal
2002       */
2003      public boolean Define_castContext(ASTNode caller, ASTNode child) {
2004        if (caller == getInitOptNoTransform()) {
2005          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:375
2006          return false;
2007        }
2008        else {
2009          return getParent().Define_castContext(this, caller);
2010        }
2011      }
2012      protected boolean canDefine_castContext(ASTNode caller, ASTNode child) {
2013        return true;
2014      }
2015      /**
2016       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199
2017       * @apilevel internal
2018       */
2019      public boolean Define_stringContext(ASTNode caller, ASTNode child) {
2020        if (caller == getInitOptNoTransform()) {
2021          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:376
2022          return false;
2023        }
2024        else {
2025          return getParent().Define_stringContext(this, caller);
2026        }
2027      }
2028      protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) {
2029        return true;
2030      }
2031      /**
2032       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200
2033       * @apilevel internal
2034       */
2035      public boolean Define_numericContext(ASTNode caller, ASTNode child) {
2036        if (caller == getInitOptNoTransform()) {
2037          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:377
2038          return false;
2039        }
2040        else {
2041          return getParent().Define_numericContext(this, caller);
2042        }
2043      }
2044      protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) {
2045        return true;
2046      }
2047      /**
2048       * @apilevel internal
2049       */
2050      public ASTNode rewriteTo() {
2051        return super.rewriteTo();
2052      }
2053    }