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:34
027     * @production ClassInstanceExpr : {@link Access} ::= <span class="component">{@link Access}</span> <span class="component">Arg:{@link Expr}*</span> <span class="component">[{@link TypeDecl}]</span>;
028    
029     */
030    public class ClassInstanceExpr extends Access implements Cloneable {
031      /**
032       * @aspect AccessControl
033       * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:165
034       */
035      public void accessControl() {
036        super.accessControl();
037        if (type().isAbstract()) {
038          errorf("Can not instantiate abstract class %s", type().fullName());
039        }
040        if (!decl().accessibleFrom(hostType())) {
041          errorf("constructor %s is not accessible", decl().signature());
042        }
043      }
044      /**
045       * @aspect ExceptionHandling
046       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:152
047       */
048      public void exceptionHandling() {
049        for (Access exception : decl().getExceptionList()) {
050          TypeDecl exceptionType = exception.type();
051          if (exceptionType.isCheckedException() && !handlesException(exceptionType)) {
052            errorf("%s may throw uncaught exception %s; it must be caught or declared as being thrown",
053                this.prettyPrint(), exceptionType.fullName());
054          }
055        }
056      }
057      /**
058       * @aspect ExceptionHandling
059       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:340
060       */
061      protected boolean reachedException(TypeDecl catchType) {
062        ConstructorDecl decl = decl();
063        for (Access exception : decl().getExceptionList()) {
064          TypeDecl exceptionType = exception.type();
065          if (catchType.mayCatch(exceptionType)) {
066            return true;
067          }
068        }
069        for (int i = 0; i < getNumArg(); i++) {
070          if (getArg(i).reachedException(catchType)) {
071            return true;
072          }
073        }
074        return false;
075      }
076      /**
077       * @aspect TypeScopePropagation
078       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:538
079       */
080      public SimpleSet keepInnerClasses(SimpleSet c) {
081        SimpleSet newSet = SimpleSet.emptySet;
082        for (Iterator iter = c.iterator(); iter.hasNext(); ) {
083          TypeDecl t = (TypeDecl) iter.next();
084          if (t.isInnerType() && t.isClassDecl()) {
085            newSet = newSet.add(c);
086          }
087        }
088        return newSet;
089      }
090      /**
091       * @aspect NameCheck
092       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:186
093       */
094      public void refined_NameCheck_ClassInstanceExpr_nameCheck() {
095        super.nameCheck();
096        if (decls().isEmpty()) {
097          errorf("can not instantiate %s no matching constructor found in %s", type().typeName(),
098              type().typeName());
099        } else if (decls().size() > 1 && validArgs()) {
100          error("several most specific constructors found");
101          for (Iterator iter = decls().iterator(); iter.hasNext(); ) {
102            errorf("         %s", ((ConstructorDecl) iter.next()).signature());
103          }
104        } else if (!hasTypeDecl()) {
105          // check if the constructor is accessible (stricter when not in a class instance expression)
106          // if constructor is private it can not be accessed outside the host class or a subtype of it
107          ConstructorDecl decl = decl();
108          if (decl.isProtected() && !hostPackage().equals(decl.hostPackage()) &&
109              !hostType().instanceOf(decl.hostType())) {
110            errorf("can not access the constructor %s", this.prettyPrint());
111          }
112        }
113      }
114      /**
115       * @aspect NodeConstructors
116       * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:93
117       */
118      public ClassInstanceExpr(Access type, List args) {
119        this(type, args, new Opt());
120      }
121      /**
122       * @aspect Java4PrettyPrint
123       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:561
124       */
125      public void prettyPrint(PrettyPrinter out) {
126        out.print("new ");
127        out.print(getAccess());
128        out.print("(");
129        out.join(getArgList(), new PrettyPrinter.Joiner() {
130          @Override
131          public void printSeparator(PrettyPrinter out) {
132            out.print(", ");
133          }
134        });
135        out.print(")");
136        if (hasTypeDecl()) {
137          if (hasPrintableBodyDecl()) {
138            out.print(" {");
139            out.println();
140            out.indent(1);
141            out.join(bodyDecls(), new PrettyPrinter.Joiner() {
142              @Override
143              public void printSeparator(PrettyPrinter out) {
144                out.println();
145              }
146            });
147            out.print("}");
148          } else {
149            out.print(" { }");
150          }
151        }
152      }
153      /**
154       * @aspect TypeCheck
155       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:509
156       */
157      public void typeCheck() {
158        if (isQualified() && qualifier().isTypeAccess() && !qualifier().type().isUnknown()) {
159          error("*** The expression in a qualified class instance expr must not be a type name");
160        }
161        // 15.9
162        if (isQualified() && !type().isInnerClass() && !((ClassDecl) type()).superclass().isInnerClass() && !type().isUnknown()) {
163          error("*** Qualified class instance creation can only instantiate inner classes and their anonymous subclasses");
164        }
165        if (!type().isClassDecl()) {
166          errorf("*** Can only instantiate classes, which %s is not", type().typeName());
167        }
168        typeCheckEnclosingInstance();
169        typeCheckAnonymousSuperclassEnclosingInstance();
170      }
171      /**
172       * @aspect TypeCheck
173       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:524
174       */
175      public void typeCheckEnclosingInstance() {
176        TypeDecl C = type();
177        if (!C.isInnerClass()) {
178          return;
179        }
180    
181        TypeDecl enclosing = null;
182        if (C.isAnonymous()) {
183          if (noEnclosingInstance()) {
184            enclosing = null;
185          } else {
186            enclosing = hostType();
187          }
188        } else if (C.isLocalClass()) {
189          if (C.inStaticContext()) {
190            enclosing = null;
191          } else if (noEnclosingInstance()) {
192            enclosing = unknownType();
193          } else {
194            TypeDecl nest = hostType();
195            while (nest != null && !nest.instanceOf(C.enclosingType())) {
196              nest = nest.enclosingType();
197            }
198            enclosing = nest;
199          }
200        } else if (C.isMemberType()) {
201          if (!isQualified()) {
202            if (noEnclosingInstance()) {
203              errorf("No enclosing instance to initialize %s with", C.typeName());
204              //System.err.println("ClassInstanceExpr: Non qualified MemberType " + C.typeName() + " is in a static context when instantiated in " + this);
205              enclosing = unknownType();
206            } else {
207              TypeDecl nest = hostType();
208              while (nest != null && !nest.instanceOf(C.enclosingType())) {
209                if (nest.isStatic()) {
210                  errorf("No enclosing instance to initialize %s with", C.typeName());
211                  nest = unknownType();
212                  break;
213                }
214                nest = nest.enclosingType();
215              }
216              enclosing = nest == null ? unknownType() : nest;
217            }
218          } else {
219            enclosing = enclosingInstance();
220          }
221        }
222        if (enclosing != null) {
223          if (enclosing.isUnknown()) {
224            errorf("No enclosing instance to initialize %s with", C.typeName());
225          } else if (!enclosing.instanceOf(C.enclosingType())) {
226            errorf("*** Can not instantiate %s with the enclosing instance %s due to incorrect enclosing instance",
227                C.typeName(), enclosing.typeName());
228          } else if (!isQualified() && C.isMemberType() && inExplicitConstructorInvocation() && enclosing == hostType()) {
229            errorf("*** The innermost enclosing instance of type %s is this which is not yet initialized here.",
230                enclosing.typeName());
231          }
232        }
233      }
234      /**
235       * @aspect TypeCheck
236       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:606
237       */
238      public void typeCheckAnonymousSuperclassEnclosingInstance() {
239        if (type().isAnonymous() && ((ClassDecl) type()).superclass().isInnerType()) {
240          TypeDecl S = ((ClassDecl) type()).superclass();
241          if (S.isLocalClass()) {
242            if (S.inStaticContext()) {
243            } else if (noEnclosingInstance()) {
244              errorf("*** No enclosing instance to class %s due to static context", type().typeName());
245            } else if (inExplicitConstructorInvocation()) {
246              errorf("*** No enclosing instance to superclass %s of %s since this is not initialized yet",
247                  S.typeName(), type().typeName());
248            }
249          } else if (S.isMemberType()) {
250            if (!isQualified()) {
251              // 15.9.2 2nd paragraph
252              if (noEnclosingInstance()) {
253                errorf("*** No enclosing instance to class %s due to static context", type().typeName());
254              } else {
255                TypeDecl nest = hostType();
256                while (nest != null && !nest.instanceOf(S.enclosingType())) {
257                  nest = nest.enclosingType();
258                }
259                if (nest == null) {
260                  errorf("*** No enclosing instance to superclass %s of %s",
261                      S.typeName(), type().typeName());
262                } else if (inExplicitConstructorInvocation()) {
263                  errorf("*** No enclosing instance to superclass %s of %s since this is not initialized yet",
264                      S.typeName(), type().typeName());
265                }
266              }
267            }
268          }
269        }
270      }
271      /**
272       * @aspect CreateBCode
273       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:755
274       */
275      private void emitLocalEnclosing(CodeGeneration gen, TypeDecl localClass) {
276        if (!localClass.inStaticContext()) {
277          emitThis(gen, localClass.enclosingType());
278        }
279      }
280      /**
281       * @aspect CreateBCode
282       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:760
283       */
284      private void emitInnerMemberEnclosing(CodeGeneration gen, TypeDecl innerClass) {
285        if (hasPrevExpr()) {
286          prevExpr().createBCode(gen);
287          gen.emitDup();
288          int index = gen.constantPool().addMethodref("java/lang/Object", "getClass", "()Ljava/lang/Class;");
289          gen.emit(Bytecode.INVOKEVIRTUAL, 0).add2(index);
290          gen.emitPop();
291        } else {
292          TypeDecl enclosing = hostType();
293          while (enclosing != null && !enclosing.hasType(innerClass.name())) {
294            enclosing = enclosing.enclosingType();
295          }
296          if (enclosing == null) {
297            throw new Error(errorPrefix() + "Could not find enclosing for " + this);
298          } else {
299            emitThis(gen, enclosing);
300          }
301        }
302      }
303      /**
304       * @aspect CreateBCode
305       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:779
306       */
307      public void createBCode(CodeGeneration gen) {
308        type().emitNew(gen);
309        type().emitDup(gen);
310    
311        // 15.9.2 first part
312        if (type().isAnonymous()) {
313          if (type().isAnonymousInNonStaticContext()) {
314            if (type().inExplicitConstructorInvocation()) {
315              gen.emit(Bytecode.ALOAD_1);
316            } else {
317              gen.emit(Bytecode.ALOAD_0);
318            }
319          }
320          // 15.9.2 second part
321          ClassDecl C = (ClassDecl) type();
322          TypeDecl S = C.superclass();
323          if (S.isLocalClass()) {
324            if (!type().inStaticContext()) {
325              emitLocalEnclosing(gen, S);
326            }
327          } else if (S.isInnerType()) {
328            emitInnerMemberEnclosing(gen, S);
329          }
330        } else if (type().isLocalClass()) {
331          if (!type().inStaticContext()) {
332            emitLocalEnclosing(gen, type());
333          }
334        } else if (type().isInnerType()) {
335          emitInnerMemberEnclosing(gen, type());
336        }
337        /*
338        // 15.9.2 first part
339        if (type().isAnonymous()) {
340          if (type().isAnonymousInNonStaticContext()) {
341            if (type().inExplicitConstructorInvocation()) {
342              gen.emit(Bytecode.ALOAD_1);
343            } else {
344              gen.emit(Bytecode.ALOAD_0);
345            }
346          }
347          if (type().needsSuperEnclosing()) {
348            // 15.9.2 second part
349            ClassDecl C = (ClassDecl) type();
350            TypeDecl S = C.superclass();
351            if (S.isLocalClass()) {
352              emitLocalEnclosing(gen, S);
353            } else if (S.isInnerType()) {
354              emitInnerMemberEnclosing(gen, S);
355            }
356          }
357        } else if (type().isLocalClass()) {
358          emitLocalEnclosing(gen, type());
359        } else if (type().isInnerType()) {
360          emitInnerMemberEnclosing(gen, type());
361        }
362        */
363    
364        for (int i = 0; i < getNumArg(); ++i) {
365          getArg(i).createBCode(gen);
366          getArg(i).type().emitCastTo(gen, decl().getParameter(i).type()); // MethodInvocationConversion
367        }
368    
369        if (decl().isPrivate() && type() != hostType()) {
370          gen.emit(Bytecode.ACONST_NULL);
371          decl().createAccessor().emitInvokeConstructor(gen);
372        } else {
373          decl().emitInvokeConstructor(gen);
374        }
375      }
376      /**
377       * @aspect InnerClasses
378       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:554
379       */
380      protected boolean addEnclosingVariables = true;
381      /**
382       * @aspect InnerClasses
383       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:555
384       */
385      public void addEnclosingVariables() {
386        if (!addEnclosingVariables) {
387          return;
388        }
389        addEnclosingVariables = false;
390        decl().addEnclosingVariables();
391        for (Iterator iter = decl().hostType().enclosingVariables().iterator(); iter.hasNext(); ) {
392          Variable v = (Variable) iter.next();
393          getArgList().add(new VarAccess(v.name()));
394        }
395      }
396      /**
397       * @aspect Transformations
398       * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:121
399       */
400      public void refined_Transformations_ClassInstanceExpr_transformation() {
401        // this$val
402        addEnclosingVariables();
403        // touch accessorIndex go force creation of private constructorAccessor
404        if (decl().isPrivate() && type() != hostType()) {
405          decl().createAccessor();
406        }
407        super.transformation();
408      }
409      /**
410       * @aspect Annotations
411       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:439
412       */
413      public void checkModifiers() {
414        if (decl().isDeprecated() &&
415          !withinDeprecatedAnnotation() &&
416          hostType().topLevelType() != decl().hostType().topLevelType() &&
417          !withinSuppressWarnings("deprecation"))
418            warning(decl().signature() + " in " + decl().hostType().typeName() + " has been deprecated");
419      }
420      /**
421       * @declaredat ASTNode:1
422       */
423      public ClassInstanceExpr() {
424        super();
425      }
426      /**
427       * Initializes the child array to the correct size.
428       * Initializes List and Opt nta children.
429       * @apilevel internal
430       * @ast method
431       * @declaredat ASTNode:10
432       */
433      public void init$Children() {
434        children = new ASTNode[3];
435        setChild(new List(), 1);
436        setChild(new Opt(), 2);
437      }
438      /**
439       * @declaredat ASTNode:15
440       */
441      public ClassInstanceExpr(Access p0, List<Expr> p1, Opt<TypeDecl> p2) {
442        setChild(p0, 0);
443        setChild(p1, 1);
444        setChild(p2, 2);
445      }
446      /**
447       * @apilevel low-level
448       * @declaredat ASTNode:23
449       */
450      protected int numChildren() {
451        return 3;
452      }
453      /**
454       * @apilevel internal
455       * @declaredat ASTNode:29
456       */
457      public boolean mayHaveRewrite() {
458        return false;
459      }
460      /**
461       * @apilevel internal
462       * @declaredat ASTNode:35
463       */
464      public void flushAttrCache() {
465        super.flushAttrCache();
466        isDAafterInstance_Variable_reset();
467        computeDAbefore_int_Variable_reset();
468        computeDUbefore_int_Variable_reset();
469        decls_reset();
470        decl_reset();
471        localLookupType_String_reset();
472        type_reset();
473        stmtCompatible_reset();
474        compatibleStrictContext_TypeDecl_reset();
475        compatibleLooseContext_TypeDecl_reset();
476        isBooleanExpression_reset();
477        isPolyExpression_reset();
478        assignConversionTo_TypeDecl_reset();
479      }
480      /**
481       * @apilevel internal
482       * @declaredat ASTNode:54
483       */
484      public void flushCollectionCache() {
485        super.flushCollectionCache();
486      }
487      /**
488       * @apilevel internal
489       * @declaredat ASTNode:60
490       */
491      public void flushRewriteCache() {
492        super.flushRewriteCache();
493      }
494      /**
495       * @apilevel internal
496       * @declaredat ASTNode:66
497       */
498      public ClassInstanceExpr clone() throws CloneNotSupportedException {
499        ClassInstanceExpr node = (ClassInstanceExpr) super.clone();
500        return node;
501      }
502      /**
503       * @apilevel internal
504       * @declaredat ASTNode:73
505       */
506      public ClassInstanceExpr copy() {
507        try {
508          ClassInstanceExpr node = (ClassInstanceExpr) clone();
509          node.parent = null;
510          if (children != null) {
511            node.children = (ASTNode[]) children.clone();
512          }
513          return node;
514        } catch (CloneNotSupportedException e) {
515          throw new Error("Error: clone not supported for " + getClass().getName());
516        }
517      }
518      /**
519       * Create a deep copy of the AST subtree at this node.
520       * The copy is dangling, i.e. has no parent.
521       * @return dangling copy of the subtree at this node
522       * @apilevel low-level
523       * @deprecated Please use treeCopy or treeCopyNoTransform instead
524       * @declaredat ASTNode:92
525       */
526      @Deprecated
527      public ClassInstanceExpr fullCopy() {
528        return treeCopyNoTransform();
529      }
530      /**
531       * Create a deep copy of the AST subtree at this node.
532       * The copy is dangling, i.e. has no parent.
533       * @return dangling copy of the subtree at this node
534       * @apilevel low-level
535       * @declaredat ASTNode:102
536       */
537      public ClassInstanceExpr treeCopyNoTransform() {
538        ClassInstanceExpr tree = (ClassInstanceExpr) copy();
539        if (children != null) {
540          for (int i = 0; i < children.length; ++i) {
541            ASTNode child = (ASTNode) children[i];
542            if (child != null) {
543              child = child.treeCopyNoTransform();
544              tree.setChild(child, i);
545            }
546          }
547        }
548        return tree;
549      }
550      /**
551       * Create a deep copy of the AST subtree at this node.
552       * The subtree of this node is traversed to trigger rewrites before copy.
553       * The copy is dangling, i.e. has no parent.
554       * @return dangling copy of the subtree at this node
555       * @apilevel low-level
556       * @declaredat ASTNode:122
557       */
558      public ClassInstanceExpr treeCopy() {
559        doFullTraversal();
560        return treeCopyNoTransform();
561      }
562      /**
563       * @apilevel internal
564       * @declaredat ASTNode:129
565       */
566      protected boolean is$Equal(ASTNode node) {
567        return super.is$Equal(node);    
568      }
569      /**
570       * Replaces the Access child.
571       * @param node The new node to replace the Access child.
572       * @apilevel high-level
573       */
574      public void setAccess(Access node) {
575        setChild(node, 0);
576      }
577      /**
578       * Retrieves the Access child.
579       * @return The current node used as the Access child.
580       * @apilevel high-level
581       */
582      @ASTNodeAnnotation.Child(name="Access")
583      public Access getAccess() {
584        return (Access) getChild(0);
585      }
586      /**
587       * Retrieves the Access child.
588       * <p><em>This method does not invoke AST transformations.</em></p>
589       * @return The current node used as the Access child.
590       * @apilevel low-level
591       */
592      public Access getAccessNoTransform() {
593        return (Access) getChildNoTransform(0);
594      }
595      /**
596       * Replaces the Arg list.
597       * @param list The new list node to be used as the Arg list.
598       * @apilevel high-level
599       */
600      public void setArgList(List<Expr> list) {
601        setChild(list, 1);
602      }
603      /**
604       * Retrieves the number of children in the Arg list.
605       * @return Number of children in the Arg list.
606       * @apilevel high-level
607       */
608      public int getNumArg() {
609        return getArgList().getNumChild();
610      }
611      /**
612       * Retrieves the number of children in the Arg list.
613       * Calling this method will not trigger rewrites.
614       * @return Number of children in the Arg list.
615       * @apilevel low-level
616       */
617      public int getNumArgNoTransform() {
618        return getArgListNoTransform().getNumChildNoTransform();
619      }
620      /**
621       * Retrieves the element at index {@code i} in the Arg list.
622       * @param i Index of the element to return.
623       * @return The element at position {@code i} in the Arg list.
624       * @apilevel high-level
625       */
626      public Expr getArg(int i) {
627        return (Expr) getArgList().getChild(i);
628      }
629      /**
630       * Check whether the Arg list has any children.
631       * @return {@code true} if it has at least one child, {@code false} otherwise.
632       * @apilevel high-level
633       */
634      public boolean hasArg() {
635        return getArgList().getNumChild() != 0;
636      }
637      /**
638       * Append an element to the Arg list.
639       * @param node The element to append to the Arg list.
640       * @apilevel high-level
641       */
642      public void addArg(Expr node) {
643        List<Expr> list = (parent == null) ? getArgListNoTransform() : getArgList();
644        list.addChild(node);
645      }
646      /**
647       * @apilevel low-level
648       */
649      public void addArgNoTransform(Expr node) {
650        List<Expr> list = getArgListNoTransform();
651        list.addChild(node);
652      }
653      /**
654       * Replaces the Arg list element at index {@code i} with the new node {@code node}.
655       * @param node The new node to replace the old list element.
656       * @param i The list index of the node to be replaced.
657       * @apilevel high-level
658       */
659      public void setArg(Expr node, int i) {
660        List<Expr> list = getArgList();
661        list.setChild(node, i);
662      }
663      /**
664       * Retrieves the Arg list.
665       * @return The node representing the Arg list.
666       * @apilevel high-level
667       */
668      @ASTNodeAnnotation.ListChild(name="Arg")
669      public List<Expr> getArgList() {
670        List<Expr> list = (List<Expr>) getChild(1);
671        return list;
672      }
673      /**
674       * Retrieves the Arg list.
675       * <p><em>This method does not invoke AST transformations.</em></p>
676       * @return The node representing the Arg list.
677       * @apilevel low-level
678       */
679      public List<Expr> getArgListNoTransform() {
680        return (List<Expr>) getChildNoTransform(1);
681      }
682      /**
683       * Retrieves the Arg list.
684       * @return The node representing the Arg list.
685       * @apilevel high-level
686       */
687      public List<Expr> getArgs() {
688        return getArgList();
689      }
690      /**
691       * Retrieves the Arg list.
692       * <p><em>This method does not invoke AST transformations.</em></p>
693       * @return The node representing the Arg list.
694       * @apilevel low-level
695       */
696      public List<Expr> getArgsNoTransform() {
697        return getArgListNoTransform();
698      }
699      /**
700       * Replaces the optional node for the TypeDecl child. This is the <code>Opt</code>
701       * node containing the child TypeDecl, not the actual child!
702       * @param opt The new node to be used as the optional node for the TypeDecl child.
703       * @apilevel low-level
704       */
705      public void setTypeDeclOpt(Opt<TypeDecl> opt) {
706        setChild(opt, 2);
707      }
708      /**
709       * Replaces the (optional) TypeDecl child.
710       * @param node The new node to be used as the TypeDecl child.
711       * @apilevel high-level
712       */
713      public void setTypeDecl(TypeDecl node) {
714        getTypeDeclOpt().setChild(node, 0);
715      }
716      /**
717       * Check whether the optional TypeDecl child exists.
718       * @return {@code true} if the optional TypeDecl child exists, {@code false} if it does not.
719       * @apilevel high-level
720       */
721      public boolean hasTypeDecl() {
722        return getTypeDeclOpt().getNumChild() != 0;
723      }
724      /**
725       * Retrieves the (optional) TypeDecl child.
726       * @return The TypeDecl child, if it exists. Returns {@code null} otherwise.
727       * @apilevel low-level
728       */
729      public TypeDecl getTypeDecl() {
730        return (TypeDecl) getTypeDeclOpt().getChild(0);
731      }
732      /**
733       * Retrieves the optional node for the TypeDecl child. This is the <code>Opt</code> node containing the child TypeDecl, not the actual child!
734       * @return The optional node for child the TypeDecl child.
735       * @apilevel low-level
736       */
737      @ASTNodeAnnotation.OptChild(name="TypeDecl")
738      public Opt<TypeDecl> getTypeDeclOpt() {
739        return (Opt<TypeDecl>) getChild(2);
740      }
741      /**
742       * Retrieves the optional node for child TypeDecl. This is the <code>Opt</code> node containing the child TypeDecl, not the actual child!
743       * <p><em>This method does not invoke AST transformations.</em></p>
744       * @return The optional node for child TypeDecl.
745       * @apilevel low-level
746       */
747      public Opt<TypeDecl> getTypeDeclOptNoTransform() {
748        return (Opt<TypeDecl>) getChildNoTransform(2);
749      }
750      /**
751       * @aspect Enums
752       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:40
753       */
754        public void nameCheck() {
755        if (getAccess().type().isEnumDecl() && !enclosingBodyDecl().isEnumConstant()) {
756          error("enum types may not be instantiated explicitly");
757        } else {
758          refined_NameCheck_ClassInstanceExpr_nameCheck();
759        }
760      }
761      /**
762       * @aspect VariableArityParametersCodegen
763       * @declaredat /home/jesper/git/extendj/java5/backend/VariableArityParametersCodegen.jrag:61
764       */
765        public void transformation() {
766        if (decl().isVariableArity() && !invokesVariableArityAsArray()) {
767          // arguments to normal parameters
768          List list = new List();
769          for (int i = 0; i < decl().getNumParameter() - 1; i++) {
770            list.add(getArg(i).treeCopyNoTransform());
771          }
772          // arguments to variable arity parameters
773          List last = new List();
774          for (int i = decl().getNumParameter() - 1; i < getNumArg(); i++) {
775            last.add(getArg(i).treeCopyNoTransform());
776          }
777          // build an array holding arguments
778          Access typeAccess = decl().lastParameter().type().elementType().createQualifiedAccess();
779          for (int i = 0; i < decl().lastParameter().type().dimension(); i++) {
780            typeAccess = new ArrayTypeAccess(typeAccess);
781          }
782          list.add(new ArrayCreationExpr(typeAccess, new Opt(new ArrayInit(last))));
783          // replace argument list with augemented argument list
784          setArgList(list);
785        }
786        refined_Transformations_ClassInstanceExpr_transformation();
787      }
788      /**
789       * @apilevel internal
790       */
791      protected java.util.Map isDAafterInstance_Variable_values;
792      /**
793       * @apilevel internal
794       */
795      private void isDAafterInstance_Variable_reset() {
796        isDAafterInstance_Variable_values = null;
797      }
798      /**
799       * @attribute syn
800       * @aspect DA
801       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:462
802       */
803      @ASTNodeAnnotation.Attribute
804      public boolean isDAafterInstance(Variable v) {
805        Object _parameters = v;
806        if (isDAafterInstance_Variable_values == null) isDAafterInstance_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
807        ASTNode$State state = state();
808        if (isDAafterInstance_Variable_values.containsKey(_parameters)) {
809          return (Boolean) isDAafterInstance_Variable_values.get(_parameters);
810        }
811        boolean intermediate = state.INTERMEDIATE_VALUE;
812        state.INTERMEDIATE_VALUE = false;
813        int num = state.boundariesCrossed;
814        boolean isFinal = this.is$Final();
815        boolean isDAafterInstance_Variable_value = isDAafterInstance_compute(v);
816        if (isFinal && num == state().boundariesCrossed) {
817          isDAafterInstance_Variable_values.put(_parameters, isDAafterInstance_Variable_value);
818        } else {
819        }
820        state.INTERMEDIATE_VALUE |= intermediate;
821    
822        return isDAafterInstance_Variable_value;
823      }
824      /**
825       * @apilevel internal
826       */
827      private boolean isDAafterInstance_compute(Variable v) {
828          if (getNumArg() == 0) {
829            return isDAbefore(v);
830          }
831          return getArg(getNumArg()-1).isDAafter(v);
832        }
833      /**
834       * @attribute syn
835       * @aspect DA
836       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259
837       */
838      @ASTNodeAnnotation.Attribute
839      public boolean isDAafter(Variable v) {
840        boolean isDAafter_Variable_value = isDAafterInstance(v);
841    
842        return isDAafter_Variable_value;
843      }
844      /**
845       * @apilevel internal
846       */
847      protected java.util.Map computeDAbefore_int_Variable_values;
848      /**
849       * @apilevel internal
850       */
851      private void computeDAbefore_int_Variable_reset() {
852        computeDAbefore_int_Variable_values = null;
853      }
854      /**
855       * @attribute syn
856       * @aspect DA
857       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:470
858       */
859      @ASTNodeAnnotation.Attribute
860      public boolean computeDAbefore(int i, Variable v) {
861        java.util.List _parameters = new java.util.ArrayList(2);
862        _parameters.add(i);
863        _parameters.add(v);
864        if (computeDAbefore_int_Variable_values == null) computeDAbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
865        ASTNode$State state = state();
866        if (computeDAbefore_int_Variable_values.containsKey(_parameters)) {
867          return (Boolean) computeDAbefore_int_Variable_values.get(_parameters);
868        }
869        boolean intermediate = state.INTERMEDIATE_VALUE;
870        state.INTERMEDIATE_VALUE = false;
871        int num = state.boundariesCrossed;
872        boolean isFinal = this.is$Final();
873        boolean computeDAbefore_int_Variable_value = i == 0 ? isDAbefore(v) : getArg(i-1).isDAafter(v);
874        if (isFinal && num == state().boundariesCrossed) {
875          computeDAbefore_int_Variable_values.put(_parameters, computeDAbefore_int_Variable_value);
876        } else {
877        }
878        state.INTERMEDIATE_VALUE |= intermediate;
879    
880        return computeDAbefore_int_Variable_value;
881      }
882      /**
883       * @attribute syn
884       * @aspect DU
885       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:964
886       */
887      @ASTNodeAnnotation.Attribute
888      public boolean isDUafterInstance(Variable v) {
889        {
890            if (getNumArg() == 0) {
891              return isDUbefore(v);
892            }
893            return getArg(getNumArg()-1).isDUafter(v);
894          }
895      }
896      /**
897       * @attribute syn
898       * @aspect DU
899       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783
900       */
901      @ASTNodeAnnotation.Attribute
902      public boolean isDUafter(Variable v) {
903        boolean isDUafter_Variable_value = isDUafterInstance(v);
904    
905        return isDUafter_Variable_value;
906      }
907      /**
908       * @apilevel internal
909       */
910      protected java.util.Map computeDUbefore_int_Variable_values;
911      /**
912       * @apilevel internal
913       */
914      private void computeDUbefore_int_Variable_reset() {
915        computeDUbefore_int_Variable_values = null;
916      }
917      /**
918       * @attribute syn
919       * @aspect DU
920       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:972
921       */
922      @ASTNodeAnnotation.Attribute
923      public boolean computeDUbefore(int i, Variable v) {
924        java.util.List _parameters = new java.util.ArrayList(2);
925        _parameters.add(i);
926        _parameters.add(v);
927        if (computeDUbefore_int_Variable_values == null) computeDUbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
928        ASTNode$State state = state();
929        if (computeDUbefore_int_Variable_values.containsKey(_parameters)) {
930          return (Boolean) computeDUbefore_int_Variable_values.get(_parameters);
931        }
932        boolean intermediate = state.INTERMEDIATE_VALUE;
933        state.INTERMEDIATE_VALUE = false;
934        int num = state.boundariesCrossed;
935        boolean isFinal = this.is$Final();
936        boolean computeDUbefore_int_Variable_value = i == 0 ? isDUbefore(v) : getArg(i-1).isDUafter(v);
937        if (isFinal && num == state().boundariesCrossed) {
938          computeDUbefore_int_Variable_values.put(_parameters, computeDUbefore_int_Variable_value);
939        } else {
940        }
941        state.INTERMEDIATE_VALUE |= intermediate;
942    
943        return computeDUbefore_int_Variable_value;
944      }
945      /**
946       * @attribute syn
947       * @aspect ConstructScope
948       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:75
949       */
950      @ASTNodeAnnotation.Attribute
951      public boolean applicableAndAccessible(ConstructorDecl decl) {
952        boolean applicableAndAccessible_ConstructorDecl_value = decl.applicable(getArgList()) && decl.accessibleFrom(hostType())
953              && (!decl.isProtected() || hasTypeDecl() || decl.hostPackage().equals(hostPackage()));
954    
955        return applicableAndAccessible_ConstructorDecl_value;
956      }
957      /**
958       * @apilevel internal
959       */
960      protected boolean decls_computed = false;
961      /**
962       * @apilevel internal
963       */
964      protected SimpleSet decls_value;
965      /**
966       * @apilevel internal
967       */
968      private void decls_reset() {
969        decls_computed = false;
970        decls_value = null;
971      }
972      /**
973       * @attribute syn
974       * @aspect ConstructScope
975       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:99
976       */
977      @ASTNodeAnnotation.Attribute
978      public SimpleSet decls() {
979        ASTNode$State state = state();
980        if (decls_computed) {
981          return decls_value;
982        }
983        boolean intermediate = state.INTERMEDIATE_VALUE;
984        state.INTERMEDIATE_VALUE = false;
985        int num = state.boundariesCrossed;
986        boolean isFinal = this.is$Final();
987        decls_value = decls_compute();
988        if (isFinal && num == state().boundariesCrossed) {
989          decls_computed = true;
990        } else {
991        }
992        state.INTERMEDIATE_VALUE |= intermediate;
993    
994        return decls_value;
995      }
996      /**
997       * @apilevel internal
998       */
999      private SimpleSet decls_compute() {
1000          TypeDecl typeDecl = hasTypeDecl() ? getTypeDecl() : getAccess().type();
1001          return chooseConstructor(typeDecl.constructors(), getArgList());
1002        }
1003      /**
1004       * @apilevel internal
1005       */
1006      protected boolean decl_computed = false;
1007      /**
1008       * @apilevel internal
1009       */
1010      protected ConstructorDecl decl_value;
1011      /**
1012       * @apilevel internal
1013       */
1014      private void decl_reset() {
1015        decl_computed = false;
1016        decl_value = null;
1017      }
1018      /**
1019       * @attribute syn
1020       * @aspect ConstructScope
1021       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:104
1022       */
1023      @ASTNodeAnnotation.Attribute
1024      public ConstructorDecl decl() {
1025        ASTNode$State state = state();
1026        if (decl_computed) {
1027          return decl_value;
1028        }
1029        boolean intermediate = state.INTERMEDIATE_VALUE;
1030        state.INTERMEDIATE_VALUE = false;
1031        int num = state.boundariesCrossed;
1032        boolean isFinal = this.is$Final();
1033        decl_value = decl_compute();
1034        if (isFinal && num == state().boundariesCrossed) {
1035          decl_computed = true;
1036        } else {
1037        }
1038        state.INTERMEDIATE_VALUE |= intermediate;
1039    
1040        return decl_value;
1041      }
1042      /**
1043       * @apilevel internal
1044       */
1045      private ConstructorDecl decl_compute() {
1046          SimpleSet decls = decls();
1047          if (decls.size() == 1) {
1048            return (ConstructorDecl) decls.iterator().next();
1049          } else {
1050            return unknownConstructor();
1051          }
1052        }
1053      /**
1054       * @attribute syn
1055       * @aspect TypeScopePropagation
1056       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:553
1057       */
1058      @ASTNodeAnnotation.Attribute
1059      public SimpleSet qualifiedLookupType(String name) {
1060        {
1061            SimpleSet c = keepAccessibleTypes(type().memberTypes(name));
1062            if (!c.isEmpty()) {
1063              return c;
1064            }
1065            if (type().name().equals(name)) {
1066              return SimpleSet.emptySet.add(type());
1067            }
1068            return SimpleSet.emptySet;
1069          }
1070      }
1071      /**
1072       * @apilevel internal
1073       */
1074      protected java.util.Map localLookupType_String_values;
1075      /**
1076       * @apilevel internal
1077       */
1078      private void localLookupType_String_reset() {
1079        localLookupType_String_values = null;
1080      }
1081      /**
1082       * @attribute syn
1083       * @aspect TypeScopePropagation
1084       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:593
1085       */
1086      @ASTNodeAnnotation.Attribute
1087      public SimpleSet localLookupType(String name) {
1088        Object _parameters = name;
1089        if (localLookupType_String_values == null) localLookupType_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1090        ASTNode$State state = state();
1091        if (localLookupType_String_values.containsKey(_parameters)) {
1092          return (SimpleSet) localLookupType_String_values.get(_parameters);
1093        }
1094        boolean intermediate = state.INTERMEDIATE_VALUE;
1095        state.INTERMEDIATE_VALUE = false;
1096        int num = state.boundariesCrossed;
1097        boolean isFinal = this.is$Final();
1098        SimpleSet localLookupType_String_value = hasTypeDecl() && getTypeDecl().name().equals(name)
1099              ? SimpleSet.emptySet.add(getTypeDecl())
1100              : SimpleSet.emptySet;
1101        if (isFinal && num == state().boundariesCrossed) {
1102          localLookupType_String_values.put(_parameters, localLookupType_String_value);
1103        } else {
1104        }
1105        state.INTERMEDIATE_VALUE |= intermediate;
1106    
1107        return localLookupType_String_value;
1108      }
1109      /**
1110       * @attribute syn
1111       * @aspect NameCheck
1112       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:177
1113       */
1114      @ASTNodeAnnotation.Attribute
1115      public boolean validArgs() {
1116        {
1117            for (int i = 0; i < getNumArg(); i++) {
1118              if (!getArg(i).isPolyExpression() && getArg(i).type().isUnknown()) {
1119                return false;
1120              }
1121            }
1122            return true;
1123          }
1124      }
1125      /**
1126       * @return <code>true</code> if there is any printable body decl
1127       * @attribute syn
1128       * @aspect PrettyPrintUtil
1129       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:224
1130       */
1131      @ASTNodeAnnotation.Attribute
1132      public boolean hasPrintableBodyDecl() {
1133        {
1134            TypeDecl decl = getTypeDecl();
1135            for (int i = 0; i < decl.getNumBodyDecl(); ++i) {
1136              if (decl.getBodyDecl(i) instanceof ConstructorDecl) {
1137                ConstructorDecl cd = (ConstructorDecl) decl.getBodyDecl(i);
1138                if (!cd.isImplicitConstructor()) {
1139                  return true;
1140                }
1141              } else {
1142                return true;
1143              }
1144            }
1145            return false;
1146          }
1147      }
1148      /**
1149       * @attribute syn
1150       * @aspect PrettyPrintUtil
1151       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:239
1152       */
1153      @ASTNodeAnnotation.Attribute
1154      public List<BodyDecl> bodyDecls() {
1155        List<BodyDecl> bodyDecls_value = getTypeDecl().getBodyDeclList();
1156    
1157        return bodyDecls_value;
1158      }
1159      /**
1160       * Defines the expected kind of name for the left hand side in a qualified
1161       * expression.
1162       * @attribute syn
1163       * @aspect SyntacticClassification
1164       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:58
1165       */
1166      @ASTNodeAnnotation.Attribute
1167      public NameType predNameType() {
1168        NameType predNameType_value = NameType.EXPRESSION_NAME;
1169    
1170        return predNameType_value;
1171      }
1172      /**
1173       * @apilevel internal
1174       */
1175      protected boolean type_computed = false;
1176      /**
1177       * @apilevel internal
1178       */
1179      protected TypeDecl type_value;
1180      /**
1181       * @apilevel internal
1182       */
1183      private void type_reset() {
1184        type_computed = false;
1185        type_value = null;
1186      }
1187      /**
1188       * @attribute syn
1189       * @aspect TypeAnalysis
1190       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302
1191       */
1192      @ASTNodeAnnotation.Attribute
1193      public TypeDecl type() {
1194        ASTNode$State state = state();
1195        if (type_computed) {
1196          return type_value;
1197        }
1198        boolean intermediate = state.INTERMEDIATE_VALUE;
1199        state.INTERMEDIATE_VALUE = false;
1200        int num = state.boundariesCrossed;
1201        boolean isFinal = this.is$Final();
1202        type_value = hasTypeDecl() ? getTypeDecl() : getAccess().type();
1203        if (isFinal && num == state().boundariesCrossed) {
1204          type_computed = true;
1205        } else {
1206        }
1207        state.INTERMEDIATE_VALUE |= intermediate;
1208    
1209        return type_value;
1210      }
1211      /**
1212       * @attribute syn
1213       * @aspect TypeCheck
1214       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:603
1215       */
1216      @ASTNodeAnnotation.Attribute
1217      public boolean noEnclosingInstance() {
1218        boolean noEnclosingInstance_value = isQualified() ? qualifier().staticContextQualifier() : inStaticContext();
1219    
1220        return noEnclosingInstance_value;
1221      }
1222      /**
1223       * @attribute syn
1224       * @aspect MethodSignature15
1225       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:547
1226       */
1227      @ASTNodeAnnotation.Attribute
1228      public int arity() {
1229        int arity_value = getNumArg();
1230    
1231        return arity_value;
1232      }
1233      /**
1234       * @attribute syn
1235       * @aspect VariableArityParameters
1236       * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:79
1237       */
1238      @ASTNodeAnnotation.Attribute
1239      public boolean invokesVariableArityAsArray() {
1240        {
1241            if (!decl().isVariableArity()) {
1242              return false;
1243            }
1244            if (arity() != decl().arity()) {
1245              return false;
1246            }
1247            return getArg(getNumArg()-1).type().methodInvocationConversionTo(decl().lastParameter().type());
1248          }
1249      }
1250      /**
1251       * @attribute syn
1252       * @aspect PreciseRethrow
1253       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149
1254       */
1255      @ASTNodeAnnotation.Attribute
1256      public boolean modifiedInScope(Variable var) {
1257        {
1258            for (int i = 0; i < getNumArg(); ++i) {
1259              if (getArg(i).modifiedInScope(var)) {
1260                return true;
1261              }
1262            }
1263            if (hasTypeDecl()) {
1264              return getTypeDecl().modifiedInScope(var);
1265            } else {
1266              return false;
1267            }
1268          }
1269      }
1270      /**
1271       * @apilevel internal
1272       */
1273      protected boolean stmtCompatible_computed = false;
1274      /**
1275       * @apilevel internal
1276       */
1277      protected boolean stmtCompatible_value;
1278      /**
1279       * @apilevel internal
1280       */
1281      private void stmtCompatible_reset() {
1282        stmtCompatible_computed = false;
1283      }
1284      /**
1285       * @attribute syn
1286       * @aspect StmtCompatible
1287       * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:139
1288       */
1289      @ASTNodeAnnotation.Attribute
1290      public boolean stmtCompatible() {
1291        ASTNode$State state = state();
1292        if (stmtCompatible_computed) {
1293          return stmtCompatible_value;
1294        }
1295        boolean intermediate = state.INTERMEDIATE_VALUE;
1296        state.INTERMEDIATE_VALUE = false;
1297        int num = state.boundariesCrossed;
1298        boolean isFinal = this.is$Final();
1299        stmtCompatible_value = true;
1300        if (isFinal && num == state().boundariesCrossed) {
1301          stmtCompatible_computed = true;
1302        } else {
1303        }
1304        state.INTERMEDIATE_VALUE |= intermediate;
1305    
1306        return stmtCompatible_value;
1307      }
1308      /**
1309       * @apilevel internal
1310       */
1311      protected java.util.Map compatibleStrictContext_TypeDecl_values;
1312      /**
1313       * @apilevel internal
1314       */
1315      private void compatibleStrictContext_TypeDecl_reset() {
1316        compatibleStrictContext_TypeDecl_values = null;
1317      }
1318      /**
1319       * @attribute syn
1320       * @aspect MethodSignature18
1321       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:32
1322       */
1323      @ASTNodeAnnotation.Attribute
1324      public boolean compatibleStrictContext(TypeDecl type) {
1325        Object _parameters = type;
1326        if (compatibleStrictContext_TypeDecl_values == null) compatibleStrictContext_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1327        ASTNode$State state = state();
1328        if (compatibleStrictContext_TypeDecl_values.containsKey(_parameters)) {
1329          return (Boolean) compatibleStrictContext_TypeDecl_values.get(_parameters);
1330        }
1331        boolean intermediate = state.INTERMEDIATE_VALUE;
1332        state.INTERMEDIATE_VALUE = false;
1333        int num = state.boundariesCrossed;
1334        boolean isFinal = this.is$Final();
1335        boolean compatibleStrictContext_TypeDecl_value = isPolyExpression()
1336              ? assignConversionTo(type)
1337              : super.compatibleStrictContext(type);
1338        if (isFinal && num == state().boundariesCrossed) {
1339          compatibleStrictContext_TypeDecl_values.put(_parameters, compatibleStrictContext_TypeDecl_value);
1340        } else {
1341        }
1342        state.INTERMEDIATE_VALUE |= intermediate;
1343    
1344        return compatibleStrictContext_TypeDecl_value;
1345      }
1346      /**
1347       * @apilevel internal
1348       */
1349      protected java.util.Map compatibleLooseContext_TypeDecl_values;
1350      /**
1351       * @apilevel internal
1352       */
1353      private void compatibleLooseContext_TypeDecl_reset() {
1354        compatibleLooseContext_TypeDecl_values = null;
1355      }
1356      /**
1357       * @attribute syn
1358       * @aspect MethodSignature18
1359       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:79
1360       */
1361      @ASTNodeAnnotation.Attribute
1362      public boolean compatibleLooseContext(TypeDecl type) {
1363        Object _parameters = type;
1364        if (compatibleLooseContext_TypeDecl_values == null) compatibleLooseContext_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1365        ASTNode$State state = state();
1366        if (compatibleLooseContext_TypeDecl_values.containsKey(_parameters)) {
1367          return (Boolean) compatibleLooseContext_TypeDecl_values.get(_parameters);
1368        }
1369        boolean intermediate = state.INTERMEDIATE_VALUE;
1370        state.INTERMEDIATE_VALUE = false;
1371        int num = state.boundariesCrossed;
1372        boolean isFinal = this.is$Final();
1373        boolean compatibleLooseContext_TypeDecl_value = isPolyExpression()
1374              ? assignConversionTo(type)
1375              : super.compatibleLooseContext(type);
1376        if (isFinal && num == state().boundariesCrossed) {
1377          compatibleLooseContext_TypeDecl_values.put(_parameters, compatibleLooseContext_TypeDecl_value);
1378        } else {
1379        }
1380        state.INTERMEDIATE_VALUE |= intermediate;
1381    
1382        return compatibleLooseContext_TypeDecl_value;
1383      }
1384      /**
1385       * @apilevel internal
1386       */
1387      protected boolean isBooleanExpression_computed = false;
1388      /**
1389       * @apilevel internal
1390       */
1391      protected boolean isBooleanExpression_value;
1392      /**
1393       * @apilevel internal
1394       */
1395      private void isBooleanExpression_reset() {
1396        isBooleanExpression_computed = false;
1397      }
1398      /**
1399       * @attribute syn
1400       * @aspect PolyExpressions
1401       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:29
1402       */
1403      @ASTNodeAnnotation.Attribute
1404      public boolean isBooleanExpression() {
1405        ASTNode$State state = state();
1406        if (isBooleanExpression_computed) {
1407          return isBooleanExpression_value;
1408        }
1409        boolean intermediate = state.INTERMEDIATE_VALUE;
1410        state.INTERMEDIATE_VALUE = false;
1411        int num = state.boundariesCrossed;
1412        boolean isFinal = this.is$Final();
1413        isBooleanExpression_value = isBooleanExpression_compute();
1414        if (isFinal && num == state().boundariesCrossed) {
1415          isBooleanExpression_computed = true;
1416        } else {
1417        }
1418        state.INTERMEDIATE_VALUE |= intermediate;
1419    
1420        return isBooleanExpression_value;
1421      }
1422      /**
1423       * @apilevel internal
1424       */
1425      private boolean isBooleanExpression_compute() {
1426          if (getAccess() instanceof TypeAccess) {
1427            TypeAccess typeAccess = (TypeAccess) getAccess();
1428            return typeAccess.name().equals("Boolean");
1429          }
1430          return false;
1431        }
1432      /**
1433       * @apilevel internal
1434       */
1435      protected boolean isPolyExpression_computed = false;
1436      /**
1437       * @apilevel internal
1438       */
1439      protected boolean isPolyExpression_value;
1440      /**
1441       * @apilevel internal
1442       */
1443      private void isPolyExpression_reset() {
1444        isPolyExpression_computed = false;
1445      }
1446      /**
1447       * @attribute syn
1448       * @aspect PolyExpressions
1449       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:80
1450       */
1451      @ASTNodeAnnotation.Attribute
1452      public boolean isPolyExpression() {
1453        ASTNode$State state = state();
1454        if (isPolyExpression_computed) {
1455          return isPolyExpression_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        isPolyExpression_value = (getAccess() instanceof DiamondAccess) && (assignmentContext() || invocationContext());
1462        if (isFinal && num == state().boundariesCrossed) {
1463          isPolyExpression_computed = true;
1464        } else {
1465        }
1466        state.INTERMEDIATE_VALUE |= intermediate;
1467    
1468        return isPolyExpression_value;
1469      }
1470      /**
1471       * @apilevel internal
1472       */
1473      protected java.util.Map assignConversionTo_TypeDecl_values;
1474      /**
1475       * @apilevel internal
1476       */
1477      private void assignConversionTo_TypeDecl_reset() {
1478        assignConversionTo_TypeDecl_values = null;
1479      }
1480      /**
1481       * @attribute syn
1482       * @aspect PolyExpressions
1483       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:142
1484       */
1485      @ASTNodeAnnotation.Attribute
1486      public boolean assignConversionTo(TypeDecl type) {
1487        Object _parameters = type;
1488        if (assignConversionTo_TypeDecl_values == null) assignConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1489        ASTNode$State state = state();
1490        if (assignConversionTo_TypeDecl_values.containsKey(_parameters)) {
1491          return (Boolean) assignConversionTo_TypeDecl_values.get(_parameters);
1492        }
1493        boolean intermediate = state.INTERMEDIATE_VALUE;
1494        state.INTERMEDIATE_VALUE = false;
1495        int num = state.boundariesCrossed;
1496        boolean isFinal = this.is$Final();
1497        boolean assignConversionTo_TypeDecl_value = assignConversionTo_compute(type);
1498        if (isFinal && num == state().boundariesCrossed) {
1499          assignConversionTo_TypeDecl_values.put(_parameters, assignConversionTo_TypeDecl_value);
1500        } else {
1501        }
1502        state.INTERMEDIATE_VALUE |= intermediate;
1503    
1504        return assignConversionTo_TypeDecl_value;
1505      }
1506      /**
1507       * @apilevel internal
1508       */
1509      private boolean assignConversionTo_compute(TypeDecl type) {
1510          if (!isPolyExpression()) {
1511            return super.assignConversionTo(type);
1512          } else {
1513            return ((DiamondAccess) getAccess()).getTypeAccess().type().assignConversionTo(
1514                type, ((DiamondAccess)getAccess()).getTypeAccess());
1515          }
1516        }
1517      /**
1518       * @attribute inh
1519       * @aspect ExceptionHandling
1520       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:85
1521       */
1522      /**
1523       * @attribute inh
1524       * @aspect ExceptionHandling
1525       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:85
1526       */
1527      @ASTNodeAnnotation.Attribute
1528      public boolean handlesException(TypeDecl exceptionType) {
1529        boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType);
1530    
1531        return handlesException_TypeDecl_value;
1532      }
1533      /**
1534       * @attribute inh
1535       * @aspect ConstructScope
1536       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:48
1537       */
1538      /**
1539       * @attribute inh
1540       * @aspect ConstructScope
1541       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:48
1542       */
1543      @ASTNodeAnnotation.Attribute
1544      public TypeDecl typeObject() {
1545        TypeDecl typeObject_value = getParent().Define_typeObject(this, null);
1546    
1547        return typeObject_value;
1548      }
1549      /**
1550       * @attribute inh
1551       * @aspect ConstructScope
1552       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:113
1553       */
1554      /**
1555       * @attribute inh
1556       * @aspect ConstructScope
1557       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:113
1558       */
1559      @ASTNodeAnnotation.Attribute
1560      public ConstructorDecl unknownConstructor() {
1561        ConstructorDecl unknownConstructor_value = getParent().Define_unknownConstructor(this, null);
1562    
1563        return unknownConstructor_value;
1564      }
1565      /**
1566       * @attribute inh
1567       * @aspect TypeCheck
1568       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:585
1569       */
1570      /**
1571       * @attribute inh
1572       * @aspect TypeCheck
1573       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:585
1574       */
1575      @ASTNodeAnnotation.Attribute
1576      public TypeDecl enclosingInstance() {
1577        TypeDecl enclosingInstance_value = getParent().Define_enclosingInstance(this, null);
1578    
1579        return enclosingInstance_value;
1580      }
1581      /**
1582       * @attribute inh
1583       * @aspect TypeHierarchyCheck
1584       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:164
1585       */
1586      /**
1587       * @attribute inh
1588       * @aspect TypeHierarchyCheck
1589       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:164
1590       */
1591      @ASTNodeAnnotation.Attribute
1592      public boolean inExplicitConstructorInvocation() {
1593        boolean inExplicitConstructorInvocation_value = getParent().Define_inExplicitConstructorInvocation(this, null);
1594    
1595        return inExplicitConstructorInvocation_value;
1596      }
1597      /**
1598       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:33
1599       * @apilevel internal
1600       */
1601      public TypeDecl Define_superType(ASTNode caller, ASTNode child) {
1602        if (caller == getTypeDeclOptNoTransform()) {
1603          // @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:34
1604          return getAccess().type();
1605        }
1606        else {
1607          return getParent().Define_superType(this, caller);
1608        }
1609      }
1610      protected boolean canDefine_superType(ASTNode caller, ASTNode child) {
1611        return true;
1612      }
1613      /**
1614       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:37
1615       * @apilevel internal
1616       */
1617      public ConstructorDecl Define_constructorDecl(ASTNode caller, ASTNode child) {
1618        if (caller == getTypeDeclOptNoTransform()) {
1619          // @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:117
1620          {
1621              Collection c = getAccess().type().constructors();
1622              SimpleSet maxSpecific = chooseConstructor(c, getArgList());
1623              if (maxSpecific.size() == 1) {
1624                return (ConstructorDecl) maxSpecific.iterator().next();
1625              }
1626              return unknownConstructor();
1627            }
1628        }
1629        else {
1630          return getParent().Define_constructorDecl(this, caller);
1631        }
1632      }
1633      protected boolean canDefine_constructorDecl(ASTNode caller, ASTNode child) {
1634        return true;
1635      }
1636      /**
1637       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
1638       * @apilevel internal
1639       */
1640      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1641        if (caller == getTypeDeclOptNoTransform()) {
1642          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:472
1643          return isDAafterInstance(v);
1644        }
1645        else if (caller == getArgListNoTransform()) {
1646          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:469
1647          int i = caller.getIndexOfChild(child);
1648          return computeDAbefore(i, v);
1649        }
1650        else {
1651          return getParent().Define_isDAbefore(this, caller, v);
1652        }
1653      }
1654      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1655        return true;
1656      }
1657      /**
1658       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
1659       * @apilevel internal
1660       */
1661      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
1662        if (caller == getArgListNoTransform()) {
1663          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:971
1664          int i = caller.getIndexOfChild(child);
1665          return computeDUbefore(i, v);
1666        }
1667        else {
1668          return getParent().Define_isDUbefore(this, caller, v);
1669        }
1670      }
1671      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
1672        return true;
1673      }
1674      /**
1675       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115
1676       * @apilevel internal
1677       */
1678      public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) {
1679        if (caller == getArgListNoTransform()) {
1680          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:126
1681          int childIndex = caller.getIndexOfChild(child);
1682          return unqualifiedScope().hasPackage(packageName);
1683        }
1684        else {
1685          return getParent().Define_hasPackage(this, caller, packageName);
1686        }
1687      }
1688      protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) {
1689        return true;
1690      }
1691      /**
1692       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197
1693       * @apilevel internal
1694       */
1695      public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) {
1696        if (caller == getTypeDeclOptNoTransform()) {
1697          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:526
1698          {
1699              SimpleSet c = localLookupType(name);
1700              if (!c.isEmpty()) {
1701                return c;
1702              }
1703              c = lookupType(name);
1704              if (!c.isEmpty()) {
1705                return c;
1706              }
1707              return unqualifiedScope().lookupType(name);
1708            }
1709        }
1710        else if (caller == getAccessNoTransform()) {
1711          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:516
1712          {
1713              SimpleSet c = lookupType(name);
1714              if (c.size() == 1) {
1715                if (isQualified()) {
1716                  c = keepInnerClasses(c);
1717                }
1718              }
1719              return c;
1720            }
1721        }
1722        else if (caller == getArgListNoTransform()) {
1723          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:334
1724          int childIndex = caller.getIndexOfChild(child);
1725          return unqualifiedScope().lookupType(name);
1726        }
1727        else {
1728          return getParent().Define_lookupType(this, caller, name);
1729        }
1730      }
1731      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) {
1732        return true;
1733      }
1734      /**
1735       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
1736       * @apilevel internal
1737       */
1738      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
1739        if (caller == getArgListNoTransform()) {
1740          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:227
1741          int childIndex = caller.getIndexOfChild(child);
1742          return unqualifiedScope().lookupVariable(name);
1743        }
1744        else {
1745          return getParent().Define_lookupVariable(this, caller, name);
1746        }
1747      }
1748      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
1749        return true;
1750      }
1751      /**
1752       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
1753       * @apilevel internal
1754       */
1755      public NameType Define_nameType(ASTNode caller, ASTNode child) {
1756        if (caller == getArgListNoTransform()) {
1757          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:150
1758          int childIndex = caller.getIndexOfChild(child);
1759          return NameType.EXPRESSION_NAME;
1760        }
1761        else if (caller == getTypeDeclOptNoTransform()) {
1762          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:149
1763          return NameType.TYPE_NAME;
1764        }
1765        else if (caller == getAccessNoTransform()) {
1766          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:148
1767          return NameType.TYPE_NAME;
1768        }
1769        else {
1770          return getParent().Define_nameType(this, caller);
1771        }
1772      }
1773      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
1774        return true;
1775      }
1776      /**
1777       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:240
1778       * @apilevel internal
1779       */
1780      public boolean Define_isAnonymous(ASTNode caller, ASTNode child) {
1781        if (caller == getTypeDeclOptNoTransform()) {
1782          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:241
1783          return true;
1784        }
1785        else {
1786          return getParent().Define_isAnonymous(this, caller);
1787        }
1788      }
1789      protected boolean canDefine_isAnonymous(ASTNode caller, ASTNode child) {
1790        return true;
1791      }
1792      /**
1793       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:577
1794       * @apilevel internal
1795       */
1796      public boolean Define_isMemberType(ASTNode caller, ASTNode child) {
1797        if (caller == getTypeDeclOptNoTransform()) {
1798          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:581
1799          return false;
1800        }
1801        else {
1802          return getParent().Define_isMemberType(this, caller);
1803        }
1804      }
1805      protected boolean canDefine_isMemberType(ASTNode caller, ASTNode child) {
1806        return true;
1807      }
1808      /**
1809       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:71
1810       * @apilevel internal
1811       */
1812      public TypeDecl Define_hostType(ASTNode caller, ASTNode child) {
1813        if (caller == getTypeDeclOptNoTransform()) {
1814          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:628
1815          return hostType();
1816        }
1817        else {
1818          return getParent().Define_hostType(this, caller);
1819        }
1820      }
1821      protected boolean canDefine_hostType(ASTNode caller, ASTNode child) {
1822        return true;
1823      }
1824      /**
1825       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182
1826       * @apilevel internal
1827       */
1828      public boolean Define_inStaticContext(ASTNode caller, ASTNode child) {
1829        if (caller == getTypeDeclOptNoTransform()) {
1830          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:196
1831          return isQualified() ?
1832              qualifier().staticContextQualifier() : inStaticContext();
1833        }
1834        else {
1835          return getParent().Define_inStaticContext(this, caller);
1836        }
1837      }
1838      protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) {
1839        return true;
1840      }
1841      /**
1842       * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:90
1843       * @apilevel internal
1844       */
1845      public ClassInstanceExpr Define_getClassInstanceExpr(ASTNode caller, ASTNode child) {
1846        if (caller == getAccessNoTransform()) {
1847          // @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:91
1848          return this;
1849        }
1850        else {
1851          return getParent().Define_getClassInstanceExpr(this, caller);
1852        }
1853      }
1854      protected boolean canDefine_getClassInstanceExpr(ASTNode caller, ASTNode child) {
1855        return true;
1856      }
1857      /**
1858       * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:401
1859       * @apilevel internal
1860       */
1861      public boolean Define_isAnonymousDecl(ASTNode caller, ASTNode child) {
1862        if (caller == getAccessNoTransform()) {
1863          // @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:406
1864          return hasTypeDecl();
1865        }
1866        else {
1867          return getParent().Define_isAnonymousDecl(this, caller);
1868        }
1869      }
1870      protected boolean canDefine_isAnonymousDecl(ASTNode caller, ASTNode child) {
1871        return true;
1872      }
1873      /**
1874       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30
1875       * @apilevel internal
1876       */
1877      public TypeDecl Define_targetType(ASTNode caller, ASTNode child) {
1878        if (caller == getArgListNoTransform()) {
1879          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:113
1880          int i = caller.getIndexOfChild(child);
1881          {
1882              ConstructorDecl decl = decl();
1883              if (unknownConstructor() == decl) {
1884                return decl.type().unknownType();
1885              }
1886          
1887              if (decl.isVariableArity() && i >= decl.arity() - 1) {
1888                return decl.getParameter(decl.arity() - 1).type().componentType();
1889              } else {
1890                return decl.getParameter(i).type();
1891              }
1892            }
1893        }
1894        else {
1895          return getParent().Define_targetType(this, caller);
1896        }
1897      }
1898      protected boolean canDefine_targetType(ASTNode caller, ASTNode child) {
1899        return true;
1900      }
1901      /**
1902       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:58
1903       * @apilevel internal
1904       */
1905      public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) {
1906        if (caller == getAccessNoTransform()) {
1907          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:181
1908          return targetType();
1909        }
1910        else {
1911          return getParent().Define_assignConvertedType(this, caller);
1912        }
1913      }
1914      protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) {
1915        return true;
1916      }
1917      /**
1918       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196
1919       * @apilevel internal
1920       */
1921      public boolean Define_assignmentContext(ASTNode caller, ASTNode child) {
1922        if (caller == getArgListNoTransform()) {
1923          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:325
1924          int childIndex = caller.getIndexOfChild(child);
1925          return false;
1926        }
1927        else {
1928          return getParent().Define_assignmentContext(this, caller);
1929        }
1930      }
1931      protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) {
1932        return true;
1933      }
1934      /**
1935       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197
1936       * @apilevel internal
1937       */
1938      public boolean Define_invocationContext(ASTNode caller, ASTNode child) {
1939        if (caller == getArgListNoTransform()) {
1940          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:326
1941          int childIndex = caller.getIndexOfChild(child);
1942          return true;
1943        }
1944        else {
1945          return getParent().Define_invocationContext(this, caller);
1946        }
1947      }
1948      protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) {
1949        return true;
1950      }
1951      /**
1952       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198
1953       * @apilevel internal
1954       */
1955      public boolean Define_castContext(ASTNode caller, ASTNode child) {
1956        if (caller == getArgListNoTransform()) {
1957          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:327
1958          int childIndex = caller.getIndexOfChild(child);
1959          return false;
1960        }
1961        else {
1962          return getParent().Define_castContext(this, caller);
1963        }
1964      }
1965      protected boolean canDefine_castContext(ASTNode caller, ASTNode child) {
1966        return true;
1967      }
1968      /**
1969       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199
1970       * @apilevel internal
1971       */
1972      public boolean Define_stringContext(ASTNode caller, ASTNode child) {
1973        if (caller == getArgListNoTransform()) {
1974          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:328
1975          int childIndex = caller.getIndexOfChild(child);
1976          return false;
1977        }
1978        else {
1979          return getParent().Define_stringContext(this, caller);
1980        }
1981      }
1982      protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) {
1983        return true;
1984      }
1985      /**
1986       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200
1987       * @apilevel internal
1988       */
1989      public boolean Define_numericContext(ASTNode caller, ASTNode child) {
1990        if (caller == getArgListNoTransform()) {
1991          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:329
1992          int childIndex = caller.getIndexOfChild(child);
1993          return false;
1994        }
1995        else {
1996          return getParent().Define_numericContext(this, caller);
1997        }
1998      }
1999      protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) {
2000        return true;
2001      }
2002      /**
2003       * @apilevel internal
2004       */
2005      public ASTNode rewriteTo() {
2006        return super.rewriteTo();
2007      }
2008    }