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:19
027     * @production MethodAccess : {@link Access} ::= <span class="component">&lt;ID:String&gt;</span> <span class="component">Arg:{@link Expr}*</span>;
028    
029     */
030    public class MethodAccess extends Access implements Cloneable {
031      /**
032       * @aspect AnonymousClasses
033       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:138
034       */
035      protected void collectExceptions(Collection c, ASTNode target) {
036        super.collectExceptions(c, target);
037        for (int i = 0; i < decl().getNumException(); i++) {
038          c.add(decl().getException(i).type());
039        }
040      }
041      /**
042       * @aspect ExceptionHandling
043       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:90
044       */
045      public void exceptionHandling() {
046        for (Iterator iter = exceptionCollection().iterator(); iter.hasNext(); ) {
047          TypeDecl exceptionType = (TypeDecl) iter.next();
048          if (exceptionType.isCheckedException() && !handlesException(exceptionType)) {
049            errorf("%s.%s invoked in %s may throw uncaught exception %s",
050                decl().hostType().fullName(), this.name(),
051                hostType().fullName(), exceptionType.fullName());
052          }
053        }
054      }
055      /**
056       * @aspect ExceptionHandling
057       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:308
058       */
059      protected boolean reachedException(TypeDecl catchType) {
060        for (Iterator iter = exceptionCollection().iterator(); iter.hasNext(); ) {
061          TypeDecl exceptionType = (TypeDecl) iter.next();
062          if (catchType.mayCatch(exceptionType)) {
063            return true;
064          }
065        }
066        return super.reachedException(catchType);
067      }
068      /**
069       * @aspect LookupMethod
070       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:165
071       */
072      private static SimpleSet removeInstanceMethods(SimpleSet c) {
073        SimpleSet set = SimpleSet.emptySet;
074        for (Iterator iter = c.iterator(); iter.hasNext(); ) {
075          MethodDecl m = (MethodDecl) iter.next();
076          if (m.isStatic()) {
077            set = set.add(m);
078          }
079        }
080        return set;
081      }
082      /**
083       * @aspect MethodDecl
084       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:247
085       */
086      public boolean applicable(MethodDecl decl) {
087        if (getNumArg() != decl.getNumParameter()) {
088          return false;
089        }
090        if (!name().equals(decl.name())) {
091          return false;
092        }
093        for (int i = 0; i < getNumArg(); i++) {
094          if (!getArg(i).type().instanceOf(decl.getParameter(i).type())) {
095            return false;
096          }
097        }
098        return true;
099      }
100      /**
101       * @aspect NodeConstructors
102       * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:67
103       */
104      public MethodAccess(String name, List args, int start, int end) {
105        this(name, args);
106        setStart(start);
107        setEnd(end);
108      }
109      /**
110       * @aspect Java4PrettyPrint
111       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:626
112       */
113      public void prettyPrint(PrettyPrinter out) {
114        out.print(getID());
115        out.print("(");
116        out.join(getArgList(), new PrettyPrinter.Joiner() {
117          @Override
118          public void printSeparator(PrettyPrinter out) {
119            out.print(", ");
120          }
121        });
122        out.print(")");
123      }
124      /**
125       * @aspect TypeHierarchyCheck
126       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:44
127       */
128      public void nameCheck() {
129        if (isQualified() && qualifier().isPackageAccess() && !qualifier().isUnknown()) {
130          errorf("The method %s can not be qualified by a package name.", decl().fullSignature());
131        }
132        if (isQualified() && decl().isAbstract() && qualifier().isSuperAccess()) {
133          error("may not access abstract methods in superclass");
134        }
135        if (decls().isEmpty() && (!isQualified() || !qualifier().isUnknown())) {
136          StringBuilder sb = new StringBuilder();
137          sb.append("no method named " + name());
138          sb.append("(");
139          for (int i = 0; i < getNumArg(); i++) {
140            TypeDecl argType = getArg(i).type();
141            if (argType.isVoid()) {
142              // error will be reported for the void argument in typeCheck
143              // so we return now to avoid confusing double errors
144              return;
145            }
146            if (i != 0) {
147              sb.append(", ");
148            }
149            sb.append(argType.typeName());
150          }
151          sb.append(")" + " in " + methodHost() + " matches.");
152          if (singleCandidateDecl() != null) {
153            sb.append(" However, there is a method " + singleCandidateDecl().fullSignature());
154          }
155          error(sb.toString());
156        }
157        if (decls().size() > 1) {
158          boolean allAbstract = true;
159          for (Iterator iter = decls().iterator(); iter.hasNext() && allAbstract; ) {
160             MethodDecl m = (MethodDecl) iter.next();
161            if (!m.isAbstract() && !m.hostType().isObject()) {
162              allAbstract = false;
163            }
164          }
165          if (!allAbstract && validArgs()) {
166            StringBuilder sb = new StringBuilder();
167            sb.append("several most specific methods for " + this.prettyPrint() + "\n");
168            for (Iterator iter = decls().iterator(); iter.hasNext(); ) {
169              MethodDecl m = (MethodDecl) iter.next();
170              sb.append("    " + m.fullSignature() + " in " + m.hostType().typeName() + "\n");
171            }
172            error(sb.toString());
173          }
174    
175        }
176      }
177      /**
178       * @aspect CreateBCode
179       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:636
180       */
181      protected void createLoadQualifier(CodeGeneration gen) {
182        MethodDecl m = decl();
183        if (hasPrevExpr()) {
184          // load explicit qualifier
185          prevExpr().createBCode(gen);
186          // pop qualifier stack element for class variables
187          // this qualifier must be computed to ensure side effects
188          if (m.isStatic() && !prevExpr().isTypeAccess()) {
189            prevExpr().type().emitPop(gen);
190          }
191        } else if (!m.isStatic()) {
192          // load implicit this qualifier
193          emitThis(gen, methodQualifierType());
194        }
195      }
196      /**
197       * @aspect InnerClasses
198       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:77
199       */
200      private TypeDecl refined_InnerClasses_MethodAccess_methodQualifierType() {
201        if (hasPrevExpr()) {
202          return prevExpr().type();
203        }
204        TypeDecl typeDecl = hostType();
205        while (typeDecl != null && !typeDecl.hasMethod(name())) {
206          typeDecl = typeDecl.enclosingType();
207        }
208        if (typeDecl != null) {
209          return typeDecl;
210        }
211        return decl().hostType();
212      }
213      /**
214       * @aspect InnerClasses
215       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:147
216       */
217      public TypeDecl superAccessorTarget() {
218        TypeDecl targetDecl = prevExpr().type();
219        TypeDecl enclosing = hostType();
220        do {
221          enclosing = enclosing.enclosingType();
222        } while (!enclosing.instanceOf(targetDecl));
223        return enclosing;
224      }
225      /**
226       * @aspect Transformations
227       * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:72
228       */
229      public void refined_Transformations_MethodAccess_transformation() {
230        MethodDecl m = decl();
231    
232        if (requiresAccessor()) {
233          /* Access to private methods in enclosing types:
234          The original MethodAccess is replaced with an access to an accessor method
235          built by createAccessor(). This method is built lazily and differs from
236          normal MethodDeclarations in the following ways:
237          1) The method in the class file should always be static and the signature
238             is thus changed to include a possible this reference as the first argument.
239          2) The method is always invoked using INVOKESTATIC
240          3) The flags must indicate that the method is static and package private
241          */
242          super.transformation();
243          this.replaceWith(decl().createAccessor(methodQualifierType()).createBoundAccess(getArgList()));
244          return;
245        } else if (!m.isStatic() && isQualified() && prevExpr().isSuperAccess() && !hostType().instanceOf(prevExpr().type())) {
246          decl().createSuperAccessor(superAccessorTarget());
247        }
248        super.transformation();
249      }
250      /**
251       * @aspect Annotations
252       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:412
253       */
254      public void checkModifiers() {
255        if (decl().isDeprecated() &&
256          !withinDeprecatedAnnotation() &&
257          hostType().topLevelType() != decl().hostType().topLevelType() &&
258          !withinSuppressWarnings("deprecation"))
259            warning(decl().signature() + " in " + decl().hostType().typeName() + " has been deprecated");
260      }
261      /**
262       * @aspect MethodSignature15
263       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:44
264       */
265      protected SimpleSet potentiallyApplicable(Collection candidates) {
266        SimpleSet potentiallyApplicable = SimpleSet.emptySet;
267        // select potentially applicable methods
268        for (Iterator iter = candidates.iterator(); iter.hasNext(); ) {
269          MethodDecl decl = (MethodDecl) iter.next();
270          if (potentiallyApplicable(decl) && accessible(decl)) {
271            if (decl.isGeneric()) {
272              GenericMethodDecl gm = decl.genericDecl();
273              decl = gm.lookupParMethodDecl(
274                  inferTypeArguments(
275                      gm.type(),
276                      gm.getParameterList(),
277                      getArgList(),
278                      gm.getTypeParameterList()));
279            }
280            potentiallyApplicable = potentiallyApplicable.add(decl);
281          }
282        }
283        return potentiallyApplicable;
284      }
285      /**
286       * @aspect MethodSignature15
287       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:65
288       */
289      protected SimpleSet applicableBySubtyping(SimpleSet potentiallyApplicable) {
290        SimpleSet maxSpecific = SimpleSet.emptySet;
291        for (Iterator iter = potentiallyApplicable.iterator(); iter.hasNext(); ) {
292          MethodDecl decl = (MethodDecl) iter.next();
293          if (applicableBySubtyping(decl)) {
294            maxSpecific = mostSpecific(maxSpecific, decl);
295          }
296        }
297        return maxSpecific;
298      }
299      /**
300       * @aspect MethodSignature15
301       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:76
302       */
303      protected SimpleSet applicableByMethodInvocationConversion(
304          SimpleSet potentiallyApplicable, SimpleSet maxSpecific) {
305        if (maxSpecific.isEmpty()) {
306          for (Iterator iter = potentiallyApplicable.iterator(); iter.hasNext(); ) {
307            MethodDecl decl = (MethodDecl) iter.next();
308            if (applicableByMethodInvocationConversion(decl)) {
309              maxSpecific = mostSpecific(maxSpecific, decl);
310            }
311          }
312        }
313        return maxSpecific;
314      }
315      /**
316       * @aspect MethodSignature15
317       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:89
318       */
319      protected SimpleSet applicableVariableArity(SimpleSet potentiallyApplicable,
320          SimpleSet maxSpecific) {
321        if (maxSpecific.isEmpty()) {
322          for (Iterator iter = potentiallyApplicable.iterator(); iter.hasNext(); ) {
323            MethodDecl decl = (MethodDecl) iter.next();
324            if (decl.isVariableArity() && applicableVariableArity(decl)) {
325              maxSpecific = mostSpecific(maxSpecific, decl);
326            }
327          }
328        }
329        return maxSpecific;
330      }
331      /**
332       * @aspect SafeVarargs
333       * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:88
334       */
335      public void checkWarnings() {
336    
337        MethodDecl decl = decl();
338        if (decl.getNumParameter() == 0 || decl.getNumParameter() > getNumArg()) {
339          return;
340        }
341    
342        ParameterDeclaration param = decl.getParameter(decl.getNumParameter()-1);
343        if (!withinSuppressWarnings("unchecked")
344            && !decl.hasAnnotationSafeVarargs()
345            && param.isVariableArity()
346            && !param.type().isReifiable()) {
347          warning("unchecked array creation for variable " + "arity parameter of " + decl().name());
348        }
349      }
350      /**
351       * @aspect MethodSignature18
352       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:702
353       */
354      protected boolean moreSpecificThan(MethodDecl m1, MethodDecl m2) {
355        if (m1 instanceof ParMethodDecl) {
356          return m1.moreSpecificThan(m2);
357        }
358        if (m1.getNumParameter() == 0) {
359          return false;
360        }
361        if (!m1.isVariableArity() && !m2.isVariableArity()) {
362          for (int i = 0; i < m1.getNumParameter(); i++) {
363            if (!getArg(i).moreSpecificThan(m1.getParameter(i).type(), m2.getParameter(i).type())) {
364              return false;
365            }
366          }
367          return true;
368        }
369    
370        int num = getNumArg();
371        for (int i = 0; i < num; i++) {
372          TypeDecl t1 = i < m1.getNumParameter() - 1
373              ? m1.getParameter(i).type()
374              : m1.getParameter(m1.getNumParameter()-1).type().componentType();
375          TypeDecl t2 = i < m2.getNumParameter() - 1
376              ? m2.getParameter(i).type()
377              : m2.getParameter(m2.getNumParameter()-1).type().componentType();
378          if (!getArg(i).moreSpecificThan(t1, t2)) {
379              return false;
380          }
381    
382        }
383        num++;
384        if (m2.getNumParameter() == num) {
385          TypeDecl t1 = num < m1.getNumParameter() - 1
386              ? m1.getParameter(num).type()
387              : m1.getParameter(m1.getNumParameter()-1).type().componentType();
388          TypeDecl t2 = num < m2.getNumParameter() - 1
389              ? m2.getParameter(num).type()
390              : m2.getParameter(m2.getNumParameter()-1).type().componentType();
391          if (!t1.instanceOf(t2) && !t1.withinBounds(t2, Parameterization.RAW)) {
392            return false;
393          }
394        }
395        return true;
396      }
397      /**
398       * @declaredat ASTNode:1
399       */
400      public MethodAccess() {
401        super();
402      }
403      /**
404       * Initializes the child array to the correct size.
405       * Initializes List and Opt nta children.
406       * @apilevel internal
407       * @ast method
408       * @declaredat ASTNode:10
409       */
410      public void init$Children() {
411        children = new ASTNode[1];
412        setChild(new List(), 0);
413      }
414      /**
415       * @declaredat ASTNode:14
416       */
417      public MethodAccess(String p0, List<Expr> p1) {
418        setID(p0);
419        setChild(p1, 0);
420      }
421      /**
422       * @declaredat ASTNode:18
423       */
424      public MethodAccess(beaver.Symbol p0, List<Expr> p1) {
425        setID(p0);
426        setChild(p1, 0);
427      }
428      /**
429       * @apilevel low-level
430       * @declaredat ASTNode:25
431       */
432      protected int numChildren() {
433        return 1;
434      }
435      /**
436       * @apilevel internal
437       * @declaredat ASTNode:31
438       */
439      public boolean mayHaveRewrite() {
440        return false;
441      }
442      /**
443       * @apilevel internal
444       * @declaredat ASTNode:37
445       */
446      public void flushAttrCache() {
447        super.flushAttrCache();
448        computeDAbefore_int_Variable_reset();
449        computeDUbefore_int_Variable_reset();
450        exceptionCollection_reset();
451        decls_reset();
452        decl_reset();
453        type_reset();
454        stmtCompatible_reset();
455        isBooleanExpression_reset();
456        isNumericExpression_reset();
457        isPolyExpression_reset();
458      }
459      /**
460       * @apilevel internal
461       * @declaredat ASTNode:53
462       */
463      public void flushCollectionCache() {
464        super.flushCollectionCache();
465      }
466      /**
467       * @apilevel internal
468       * @declaredat ASTNode:59
469       */
470      public void flushRewriteCache() {
471        super.flushRewriteCache();
472      }
473      /**
474       * @apilevel internal
475       * @declaredat ASTNode:65
476       */
477      public MethodAccess clone() throws CloneNotSupportedException {
478        MethodAccess node = (MethodAccess) super.clone();
479        return node;
480      }
481      /**
482       * @apilevel internal
483       * @declaredat ASTNode:72
484       */
485      public MethodAccess copy() {
486        try {
487          MethodAccess node = (MethodAccess) clone();
488          node.parent = null;
489          if (children != null) {
490            node.children = (ASTNode[]) children.clone();
491          }
492          return node;
493        } catch (CloneNotSupportedException e) {
494          throw new Error("Error: clone not supported for " + getClass().getName());
495        }
496      }
497      /**
498       * Create a deep copy of the AST subtree at this node.
499       * The copy is dangling, i.e. has no parent.
500       * @return dangling copy of the subtree at this node
501       * @apilevel low-level
502       * @deprecated Please use treeCopy or treeCopyNoTransform instead
503       * @declaredat ASTNode:91
504       */
505      @Deprecated
506      public MethodAccess fullCopy() {
507        return treeCopyNoTransform();
508      }
509      /**
510       * Create a deep copy of the AST subtree at this node.
511       * The copy is dangling, i.e. has no parent.
512       * @return dangling copy of the subtree at this node
513       * @apilevel low-level
514       * @declaredat ASTNode:101
515       */
516      public MethodAccess treeCopyNoTransform() {
517        MethodAccess tree = (MethodAccess) copy();
518        if (children != null) {
519          for (int i = 0; i < children.length; ++i) {
520            ASTNode child = (ASTNode) children[i];
521            if (child != null) {
522              child = child.treeCopyNoTransform();
523              tree.setChild(child, i);
524            }
525          }
526        }
527        return tree;
528      }
529      /**
530       * Create a deep copy of the AST subtree at this node.
531       * The subtree of this node is traversed to trigger rewrites before copy.
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:121
536       */
537      public MethodAccess treeCopy() {
538        doFullTraversal();
539        return treeCopyNoTransform();
540      }
541      /**
542       * @apilevel internal
543       * @declaredat ASTNode:128
544       */
545      protected boolean is$Equal(ASTNode node) {
546        return super.is$Equal(node) && (tokenString_ID == ((MethodAccess)node).tokenString_ID);    
547      }
548      /**
549       * Replaces the lexeme ID.
550       * @param value The new value for the lexeme ID.
551       * @apilevel high-level
552       */
553      public void setID(String value) {
554        tokenString_ID = value;
555      }
556      /**
557       * @apilevel internal
558       */
559      protected String tokenString_ID;
560      /**
561       */
562      public int IDstart;
563      /**
564       */
565      public int IDend;
566      /**
567       * JastAdd-internal setter for lexeme ID using the Beaver parser.
568       * @param symbol Symbol containing the new value for the lexeme ID
569       * @apilevel internal
570       */
571      public void setID(beaver.Symbol symbol) {
572        if (symbol.value != null && !(symbol.value instanceof String))
573        throw new UnsupportedOperationException("setID is only valid for String lexemes");
574        tokenString_ID = (String)symbol.value;
575        IDstart = symbol.getStart();
576        IDend = symbol.getEnd();
577      }
578      /**
579       * Retrieves the value for the lexeme ID.
580       * @return The value for the lexeme ID.
581       * @apilevel high-level
582       */
583      @ASTNodeAnnotation.Token(name="ID")
584      public String getID() {
585        return tokenString_ID != null ? tokenString_ID : "";
586      }
587      /**
588       * Replaces the Arg list.
589       * @param list The new list node to be used as the Arg list.
590       * @apilevel high-level
591       */
592      public void setArgList(List<Expr> list) {
593        setChild(list, 0);
594      }
595      /**
596       * Retrieves the number of children in the Arg list.
597       * @return Number of children in the Arg list.
598       * @apilevel high-level
599       */
600      public int getNumArg() {
601        return getArgList().getNumChild();
602      }
603      /**
604       * Retrieves the number of children in the Arg list.
605       * Calling this method will not trigger rewrites.
606       * @return Number of children in the Arg list.
607       * @apilevel low-level
608       */
609      public int getNumArgNoTransform() {
610        return getArgListNoTransform().getNumChildNoTransform();
611      }
612      /**
613       * Retrieves the element at index {@code i} in the Arg list.
614       * @param i Index of the element to return.
615       * @return The element at position {@code i} in the Arg list.
616       * @apilevel high-level
617       */
618      public Expr getArg(int i) {
619        return (Expr) getArgList().getChild(i);
620      }
621      /**
622       * Check whether the Arg list has any children.
623       * @return {@code true} if it has at least one child, {@code false} otherwise.
624       * @apilevel high-level
625       */
626      public boolean hasArg() {
627        return getArgList().getNumChild() != 0;
628      }
629      /**
630       * Append an element to the Arg list.
631       * @param node The element to append to the Arg list.
632       * @apilevel high-level
633       */
634      public void addArg(Expr node) {
635        List<Expr> list = (parent == null) ? getArgListNoTransform() : getArgList();
636        list.addChild(node);
637      }
638      /**
639       * @apilevel low-level
640       */
641      public void addArgNoTransform(Expr node) {
642        List<Expr> list = getArgListNoTransform();
643        list.addChild(node);
644      }
645      /**
646       * Replaces the Arg list element at index {@code i} with the new node {@code node}.
647       * @param node The new node to replace the old list element.
648       * @param i The list index of the node to be replaced.
649       * @apilevel high-level
650       */
651      public void setArg(Expr node, int i) {
652        List<Expr> list = getArgList();
653        list.setChild(node, i);
654      }
655      /**
656       * Retrieves the Arg list.
657       * @return The node representing the Arg list.
658       * @apilevel high-level
659       */
660      @ASTNodeAnnotation.ListChild(name="Arg")
661      public List<Expr> getArgList() {
662        List<Expr> list = (List<Expr>) getChild(0);
663        return list;
664      }
665      /**
666       * Retrieves the Arg list.
667       * <p><em>This method does not invoke AST transformations.</em></p>
668       * @return The node representing the Arg list.
669       * @apilevel low-level
670       */
671      public List<Expr> getArgListNoTransform() {
672        return (List<Expr>) getChildNoTransform(0);
673      }
674      /**
675       * Retrieves the Arg list.
676       * @return The node representing the Arg list.
677       * @apilevel high-level
678       */
679      public List<Expr> getArgs() {
680        return getArgList();
681      }
682      /**
683       * Retrieves the Arg list.
684       * <p><em>This method does not invoke AST transformations.</em></p>
685       * @return The node representing the Arg list.
686       * @apilevel low-level
687       */
688      public List<Expr> getArgsNoTransform() {
689        return getArgListNoTransform();
690      }
691      /**
692       * @aspect MethodSignature15
693       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:33
694       */
695        protected SimpleSet maxSpecific(Collection candidates) {
696        SimpleSet potentiallyApplicable = potentiallyApplicable(candidates);
697        // first phase
698        SimpleSet maxSpecific = applicableBySubtyping(potentiallyApplicable);
699        // second phase
700        maxSpecific = applicableByMethodInvocationConversion(potentiallyApplicable, maxSpecific);
701        // third phase
702        maxSpecific = applicableVariableArity(potentiallyApplicable, maxSpecific);
703        return maxSpecific;
704      }
705      /**
706       * @aspect MethodSignature15
707       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:551
708       */
709        public void typeCheck() {
710        for (int i = 0; i < getNumArg(); ++i) {
711          if (getArg(i).type().isVoid()) {
712            errorf("expression '%s' has type void and is not a valid method argument",
713                getArg(i).prettyPrint());
714          }
715        }
716        if (isQualified() && decl().isAbstract() && qualifier().isSuperAccess()) {
717          error("may not access abstract methods in superclass");
718        }
719        if (!decl().isVariableArity() || invokesVariableArityAsArray()) {
720          for (int i = 0; i < decl().getNumParameter(); i++) {
721            TypeDecl exprType = getArg(i).type();
722            TypeDecl parmType = decl().getParameter(i).type();
723            if (!exprType.methodInvocationConversionTo(parmType) &&
724                !exprType.isUnknown() && !parmType.isUnknown()) {
725              errorf("argument '%s' of type %s is not compatible with the method parameter type %s",
726                  getArg(i).prettyPrint(), exprType.typeName(), parmType.typeName());
727            }
728          }
729        }
730      }
731      /**
732       * @aspect GenericsCodegen
733       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:180
734       */
735        protected TypeDecl refined_GenericsCodegen_MethodAccess_methodQualifierType() {
736        TypeDecl typeDecl = refined_InnerClasses_MethodAccess_methodQualifierType();
737        if (typeDecl == null) {
738          return null;
739        }
740        typeDecl = typeDecl.erasure();
741        MethodDecl m = decl().sourceMethodDecl();
742        Collection methods = typeDecl.memberMethods(m.name());
743        if (!methods.contains(decl()) && !methods.contains(m)) {
744          return m.hostType();
745        }
746        return typeDecl.erasure();
747      }
748      /**
749       * @aspect MethodSignature18
750       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:746
751       */
752       
753      private SimpleSet mostSpecific(SimpleSet maxSpecific, MethodDecl decl) {
754        SimpleSet newMax;
755        if (maxSpecific.isEmpty()) {
756          newMax = maxSpecific.add(decl);
757        } else {
758          boolean foundStricter = false;
759          newMax = SimpleSet.emptySet;
760          Iterator<MethodDecl> iter = maxSpecific.iterator();
761          while (iter.hasNext()) {
762            MethodDecl toCompare = iter.next();
763            if (!(moreSpecificThan(decl, toCompare) && !moreSpecificThan(toCompare, decl))) {
764              newMax = newMax.add(toCompare);
765            }
766    
767            if (!moreSpecificThan(decl, toCompare) && moreSpecificThan(toCompare, decl)) {
768              foundStricter = true;
769            }
770    
771          }
772    
773          if (!foundStricter) {
774            newMax = newMax.add(decl);
775          }
776        }
777        return newMax;
778      }
779      /**
780       * @aspect GenericsCodegen
781       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:131
782       */
783        public void refined_GenericsCodegen_MethodAccess_createBCode(CodeGeneration gen) {
784        MethodDecl decl = decl().erasedMethod();
785        createLoadQualifier(gen);
786    
787        if (program().options().hasOption("-debug")) {
788          if (decl.type().isUnknown()) {
789            System.err.println("Could not bind " + this);
790            for (int i = 0; i < getNumArg(); ++i) {
791              System.err.println("Argument " + getArg(i)
792                  + " is of type " + getArg(i).type().typeName());
793              if (getArg(i).varDecl() != null) {
794                System.err.println(getArg(i).varDecl() + " in "
795                    + getArg(i).varDecl().hostType().typeName());
796              }
797            }
798            if (isQualified()) {
799              System.err.println("Qualifier " + qualifier()
800                  + " is of type " + qualifier().type().typeName());
801            }
802            throw new Error("Could not bind " + this);
803          }
804          if (decl.getNumParameter() != getNumArg()) {
805            System.out.println(this
806                + " does not have the same number of arguments as " + decl);
807          }
808        }
809    
810        for (int i = 0; i < getNumArg(); ++i) {
811          getArg(i).createBCode(gen);
812          // The cast or boxing/unboxing operation must know the bound rather than the erased type.
813          getArg(i).type().emitCastTo(gen, decl().getParameter(i).type()); // MethodInvocationConversion
814        }
815    
816        if (!decl.isStatic() && isQualified() && prevExpr().isSuperAccess()) {
817          if (!hostType().instanceOf(prevExpr().type())) {
818            /* Should this be decl instead? possible copy/paste error? */
819            decl().createSuperAccessor(superAccessorTarget()).emitInvokeMethod(gen, superAccessorTarget());
820          } else {
821            decl.emitInvokeSpecialMethod(gen, methodQualifierType());
822          }
823        } else {
824          decl.emitInvokeMethod(gen, methodQualifierType());
825        }
826    
827        if (decl.type() != decl().type()) {
828          gen.emitCheckCast(decl().type());
829        }
830      }
831      /**
832       * @aspect VariableArityParametersCodegen
833       * @declaredat /home/jesper/git/extendj/java5/backend/VariableArityParametersCodegen.jrag:37
834       */
835        public void refined_VariableArityParametersCodegen_MethodAccess_transformation() {
836        if (decl().isVariableArity() && !invokesVariableArityAsArray()) {
837          // arguments to normal parameters
838          List list = new List();
839          for (int i = 0; i < decl().getNumParameter() - 1; i++) {
840            list.add(getArg(i).treeCopyNoTransform());
841          }
842          // arguments to variable arity parameters
843          List last = new List();
844          for (int i = decl().getNumParameter() - 1; i < getNumArg(); i++) {
845            last.add(getArg(i).treeCopyNoTransform());
846          }
847          // build an array holding arguments
848          Access typeAccess = decl().lastParameter().type().elementType().createQualifiedAccess();
849          for (int i = 0; i < decl().lastParameter().type().dimension(); i++) {
850            typeAccess = new ArrayTypeAccess(typeAccess);
851          }
852          list.add(new ArrayCreationExpr(typeAccess, new Opt(new ArrayInit(last))));
853          // replace argument list with augemented argument list
854          setArgList(list);
855        }
856        refined_Transformations_MethodAccess_transformation();
857      }
858      /**
859       * @aspect Java8CreateBCode
860       * @declaredat /home/jesper/git/extendj/java8/backend/CreateBCode.jrag:55
861       */
862       
863      public void createBCode(CodeGeneration gen) {
864        MethodDecl decl = decl().erasedMethod();
865        createLoadQualifier(gen);
866    
867        if (program().options().hasOption("-debug")) {
868          if (decl.type().isUnknown()) {
869            System.err.println("Could not bind " + this);
870            for (int i = 0; i < getNumArg(); ++i) {
871              System.err.println("Argument " + getArg(i)
872                  + " is of type " + getArg(i).type().typeName());
873              if (getArg(i).varDecl() != null) {
874                System.err.println(getArg(i).varDecl() + " in "
875                    + getArg(i).varDecl().hostType().typeName());
876              }
877            }
878            if (isQualified()) {
879              System.err.println("Qualifier " + qualifier()
880                  + " is of type " + qualifier().type().typeName());
881            }
882            throw new Error("Could not bind " + this);
883          }
884          if (decl.getNumParameter() != getNumArg()) {
885            System.out.println(this
886                + " does not have the same number of arguments as " + decl);
887          }
888        }
889    
890        for (int i = 0; i < getNumArg(); ++i) {
891          getArg(i).createBCode(gen);
892          // the cast or boxing/unboxing operation must know the bound rather than the erased type
893          getArg(i).type().emitCastTo(gen, decl().getParameter(i).type()); // MethodInvocationConversion
894        }
895    
896        if (!decl.isStatic() && isQualified() && prevExpr().isSuperAccess()) {
897          if (!hostType().instanceOf(prevExpr().type()) && !prevExpr().type().isInterfaceDecl()) {
898            /* should this be decl instead? possible copy/paste error? */
899            decl().createSuperAccessor(superAccessorTarget()).emitInvokeMethod(gen, superAccessorTarget());
900          } else {
901            decl.emitInvokeSpecialMethod(gen, methodQualifierType());
902          }
903        } else {
904          decl.emitInvokeMethod(gen, methodQualifierType());
905        }
906    
907        if (decl.type() != decl().type()) {
908          gen.emitCheckCast(decl().type());
909        }
910      }
911      /**
912       * @aspect StaticImportsCodegen
913       * @declaredat /home/jesper/git/extendj/java5/backend/StaticImportsCodegen.jrag:40
914       */
915        protected TypeDecl methodQualifierType() {
916        TypeDecl typeDecl = refined_GenericsCodegen_MethodAccess_methodQualifierType();
917        if (typeDecl != null) {
918          return typeDecl;
919        }
920        return decl().hostType();
921      }
922      /**
923       * @aspect Transformations
924       * @declaredat /home/jesper/git/extendj/java8/backend/Transformations.jrag:46
925       */
926       
927      public void transformation() {
928        if (decl().isVariableArity() && !invokesVariableArityAsArray()) {
929          // arguments to normal parameters
930          List list = new List();
931          for (int i = 0; i < decl().getNumParameter() - 1; i++)
932            list.add(getArg(i).treeCopyNoTransform());
933          // arguments to variable arity parameters
934          List last = new List();
935          for (int i = decl().getNumParameter() - 1; i < getNumArg(); i++)
936            last.add(getArg(i).treeCopyNoTransform());
937          // build an array holding arguments
938          Access typeAccess = decl().lastParameter().type().elementType().createQualifiedAccess();
939          for (int i = 0; i < decl().lastParameter().type().dimension(); i++)
940            typeAccess = new ArrayTypeAccess(typeAccess);
941          list.add(new ArrayCreationExpr(typeAccess, new Opt(new ArrayInit(last))));
942          // replace argument list with augemented argument list
943          setArgList(list);
944        }
945        MethodDecl m = decl();
946    
947    
948        /*if (!isQualified() && !m.isStatic()) {
949          TypeDecl typeDecl = hostType();
950          while (typeDecl != null && !typeDecl.hasMethod(name())) {
951            typeDecl = typeDecl.enclosingType();
952          }
953          ASTNode result = this.replaceWith(typeDecl.createQualifiedAccess().qualifiesAccess(new ThisAccess("this")).qualifiesAccess(new MethodAccess(name(), getArgList())));
954          result.transformation();
955          return;
956        }*/
957    
958        if (requiresAccessor()) {
959          /* Access to private methods in enclosing types:
960          The original MethodAccess is replaced with an access to an accessor method
961          built by createAccessor(). This method is built lazily and differs from
962          normal MethodDeclarations in the following ways:
963          1) The method in the class file should always be static and the signature
964             is thus changed to include a possible this reference as the first argument.
965          2) The method is always invoked using INVOKESTATIC
966          3) The flags must indicate that the method is static and package private
967          */
968          super.transformation();
969          this.replaceWith(decl().createAccessor(methodQualifierType()).createBoundAccess(getArgList()));
970          return;
971        } else if (!m.isStatic() && isQualified()
972            && prevExpr().isSuperAccess()
973            && !hostType().instanceOf(prevExpr().type())
974            && !prevExpr().type().isInterfaceDecl()) {
975          decl().createSuperAccessor(superAccessorTarget());
976        }
977        super.transformation();
978      }
979      /**
980       * @aspect TypeAnalysis
981       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:310
982       */
983      private TypeDecl refined_TypeAnalysis_MethodAccess_type()
984    { return decl().type(); }
985      /**
986       * @apilevel internal
987       */
988      protected java.util.Map computeDAbefore_int_Variable_values;
989      /**
990       * @apilevel internal
991       */
992      private void computeDAbefore_int_Variable_reset() {
993        computeDAbefore_int_Variable_values = null;
994      }
995      /**
996       * @attribute syn
997       * @aspect DA
998       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:451
999       */
1000      @ASTNodeAnnotation.Attribute
1001      public boolean computeDAbefore(int i, Variable v) {
1002        java.util.List _parameters = new java.util.ArrayList(2);
1003        _parameters.add(i);
1004        _parameters.add(v);
1005        if (computeDAbefore_int_Variable_values == null) computeDAbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1006        ASTNode$State state = state();
1007        if (computeDAbefore_int_Variable_values.containsKey(_parameters)) {
1008          return (Boolean) computeDAbefore_int_Variable_values.get(_parameters);
1009        }
1010        boolean intermediate = state.INTERMEDIATE_VALUE;
1011        state.INTERMEDIATE_VALUE = false;
1012        int num = state.boundariesCrossed;
1013        boolean isFinal = this.is$Final();
1014        boolean computeDAbefore_int_Variable_value = i == 0 ? isDAbefore(v) : getArg(i-1).isDAafter(v);
1015        if (isFinal && num == state().boundariesCrossed) {
1016          computeDAbefore_int_Variable_values.put(_parameters, computeDAbefore_int_Variable_value);
1017        } else {
1018        }
1019        state.INTERMEDIATE_VALUE |= intermediate;
1020    
1021        return computeDAbefore_int_Variable_value;
1022      }
1023      /**
1024       * @attribute syn
1025       * @aspect DA
1026       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259
1027       */
1028      @ASTNodeAnnotation.Attribute
1029      public boolean isDAafter(Variable v) {
1030        boolean isDAafter_Variable_value = getNumArg() == 0 ? isDAbefore(v) : getArg(getNumArg()-1).isDAafter(v);
1031    
1032        return isDAafter_Variable_value;
1033      }
1034      /**
1035       * @attribute syn
1036       * @aspect DA
1037       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:374
1038       */
1039      @ASTNodeAnnotation.Attribute
1040      public boolean isDAafterTrue(Variable v) {
1041        boolean isDAafterTrue_Variable_value = isFalse() || (getNumArg() == 0 ? isDAbefore(v) : getArg(getNumArg()-1).isDAafter(v));
1042    
1043        return isDAafterTrue_Variable_value;
1044      }
1045      /**
1046       * @attribute syn
1047       * @aspect DA
1048       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:375
1049       */
1050      @ASTNodeAnnotation.Attribute
1051      public boolean isDAafterFalse(Variable v) {
1052        boolean isDAafterFalse_Variable_value = isTrue() || (getNumArg() == 0 ? isDAbefore(v) : getArg(getNumArg()-1).isDAafter(v));
1053    
1054        return isDAafterFalse_Variable_value;
1055      }
1056      /**
1057       * @apilevel internal
1058       */
1059      protected java.util.Map computeDUbefore_int_Variable_values;
1060      /**
1061       * @apilevel internal
1062       */
1063      private void computeDUbefore_int_Variable_reset() {
1064        computeDUbefore_int_Variable_values = null;
1065      }
1066      /**
1067       * @attribute syn
1068       * @aspect DU
1069       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:959
1070       */
1071      @ASTNodeAnnotation.Attribute
1072      public boolean computeDUbefore(int i, Variable v) {
1073        java.util.List _parameters = new java.util.ArrayList(2);
1074        _parameters.add(i);
1075        _parameters.add(v);
1076        if (computeDUbefore_int_Variable_values == null) computeDUbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1077        ASTNode$State state = state();
1078        if (computeDUbefore_int_Variable_values.containsKey(_parameters)) {
1079          return (Boolean) computeDUbefore_int_Variable_values.get(_parameters);
1080        }
1081        boolean intermediate = state.INTERMEDIATE_VALUE;
1082        state.INTERMEDIATE_VALUE = false;
1083        int num = state.boundariesCrossed;
1084        boolean isFinal = this.is$Final();
1085        boolean computeDUbefore_int_Variable_value = i == 0 ? isDUbefore(v) : getArg(i-1).isDUafter(v);
1086        if (isFinal && num == state().boundariesCrossed) {
1087          computeDUbefore_int_Variable_values.put(_parameters, computeDUbefore_int_Variable_value);
1088        } else {
1089        }
1090        state.INTERMEDIATE_VALUE |= intermediate;
1091    
1092        return computeDUbefore_int_Variable_value;
1093      }
1094      /**
1095       * @attribute syn
1096       * @aspect DU
1097       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783
1098       */
1099      @ASTNodeAnnotation.Attribute
1100      public boolean isDUafter(Variable v) {
1101        boolean isDUafter_Variable_value = getNumArg() == 0 ? isDUbefore(v) : getArg(getNumArg()-1).isDUafter(v);
1102    
1103        return isDUafter_Variable_value;
1104      }
1105      /**
1106       * @attribute syn
1107       * @aspect DU
1108       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:791
1109       */
1110      @ASTNodeAnnotation.Attribute
1111      public boolean isDUafterTrue(Variable v) {
1112        boolean isDUafterTrue_Variable_value = isFalse() || (getNumArg() == 0 ? isDUbefore(v) : getArg(getNumArg()-1).isDUafter(v));
1113    
1114        return isDUafterTrue_Variable_value;
1115      }
1116      /**
1117       * @attribute syn
1118       * @aspect DU
1119       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:792
1120       */
1121      @ASTNodeAnnotation.Attribute
1122      public boolean isDUafterFalse(Variable v) {
1123        boolean isDUafterFalse_Variable_value = isTrue() || (getNumArg() == 0 ? isDUbefore(v) : getArg(getNumArg()-1).isDUafter(v));
1124    
1125        return isDUafterFalse_Variable_value;
1126      }
1127      /**
1128       * @apilevel internal
1129       */
1130      protected boolean exceptionCollection_computed = false;
1131      /**
1132       * @apilevel internal
1133       */
1134      protected Collection exceptionCollection_value;
1135      /**
1136       * @apilevel internal
1137       */
1138      private void exceptionCollection_reset() {
1139        exceptionCollection_computed = false;
1140        exceptionCollection_value = null;
1141      }
1142      /**
1143       * @attribute syn
1144       * @aspect ExceptionHandling
1145       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:101
1146       */
1147      @ASTNodeAnnotation.Attribute
1148      public Collection exceptionCollection() {
1149        ASTNode$State state = state();
1150        if (exceptionCollection_computed) {
1151          return exceptionCollection_value;
1152        }
1153        boolean intermediate = state.INTERMEDIATE_VALUE;
1154        state.INTERMEDIATE_VALUE = false;
1155        int num = state.boundariesCrossed;
1156        boolean isFinal = this.is$Final();
1157        exceptionCollection_value = exceptionCollection_compute();
1158        if (isFinal && num == state().boundariesCrossed) {
1159          exceptionCollection_computed = true;
1160        } else {
1161        }
1162        state.INTERMEDIATE_VALUE |= intermediate;
1163    
1164        return exceptionCollection_value;
1165      }
1166      /**
1167       * @apilevel internal
1168       */
1169      private Collection exceptionCollection_compute() {
1170          //System.out.println("Computing exceptionCollection for " + name());
1171          HashSet set = new HashSet();
1172          Iterator iter = decls().iterator();
1173          if (!iter.hasNext()) {
1174            return set;
1175          }
1176      
1177          MethodDecl m = (MethodDecl) iter.next();
1178          //System.out.println("Processing first found method " + m.signature() + " in " + m.hostType().fullName());
1179      
1180          for (int i = 0; i < m.getNumException(); i++) {
1181            TypeDecl exceptionType = m.getException(i).type();
1182            set.add(exceptionType);
1183          }
1184          while (iter.hasNext()) {
1185            HashSet first = new HashSet();
1186            first.addAll(set);
1187            HashSet second = new HashSet();
1188            m = (MethodDecl) iter.next();
1189            //System.out.println("Processing the next method " + m.signature() + " in " + m.hostType().fullName());
1190            for (int i = 0; i < m.getNumException(); i++) {
1191              TypeDecl exceptionType = m.getException(i).type();
1192              second.add(exceptionType);
1193            }
1194            set = new HashSet();
1195            for (Iterator i1 = first.iterator(); i1.hasNext(); ) {
1196              TypeDecl firstType = (TypeDecl) i1.next();
1197              for (Iterator i2 = second.iterator(); i2.hasNext(); ) {
1198                TypeDecl secondType = (TypeDecl) i2.next();
1199                if (firstType.instanceOf(secondType)) {
1200                  set.add(firstType);
1201                } else if (secondType.instanceOf(firstType)) {
1202                  set.add(secondType);
1203                }
1204              }
1205            }
1206          }
1207          return set;
1208        }
1209      /**
1210       * @attribute syn
1211       * @aspect LookupMethod
1212       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:105
1213       */
1214      @ASTNodeAnnotation.Attribute
1215      public MethodDecl singleCandidateDecl() {
1216        {
1217            MethodDecl result = null;
1218            for (Iterator iter = lookupMethod(name()).iterator(); iter.hasNext(); ) {
1219              MethodDecl m = (MethodDecl) iter.next();
1220              if (result == null) {
1221                result = m;
1222              } else if (m.getNumParameter() == getNumArg() && result.getNumParameter() != getNumArg()) {
1223                result = m;
1224              }
1225            }
1226            return result;
1227          }
1228      }
1229      /**
1230       * @apilevel internal
1231       */
1232      protected boolean decls_computed = false;
1233      /**
1234       * @apilevel internal
1235       */
1236      protected SimpleSet decls_value;
1237      /**
1238       * @apilevel internal
1239       */
1240      private void decls_reset() {
1241        decls_computed = false;
1242        decls_value = null;
1243      }
1244      /**
1245       * @attribute syn
1246       * @aspect LookupMethod
1247       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:138
1248       */
1249      @ASTNodeAnnotation.Attribute
1250      public SimpleSet decls() {
1251        ASTNode$State state = state();
1252        if (decls_computed) {
1253          return decls_value;
1254        }
1255        boolean intermediate = state.INTERMEDIATE_VALUE;
1256        state.INTERMEDIATE_VALUE = false;
1257        int num = state.boundariesCrossed;
1258        boolean isFinal = this.is$Final();
1259        decls_value = decls_compute();
1260        if (isFinal && num == state().boundariesCrossed) {
1261          decls_computed = true;
1262        } else {
1263        }
1264        state.INTERMEDIATE_VALUE |= intermediate;
1265    
1266        return decls_value;
1267      }
1268      /**
1269       * @apilevel internal
1270       */
1271      private SimpleSet decls_compute() {
1272          SimpleSet maxSpecific = maxSpecific(lookupMethod(name()));
1273          if (isQualified() ? qualifier().staticContextQualifier() : inStaticContext()) {
1274            maxSpecific = removeInstanceMethods(maxSpecific);
1275          }
1276          return maxSpecific;
1277        }
1278      /**
1279       * @apilevel internal
1280       */
1281      protected boolean decl_computed = false;
1282      /**
1283       * @apilevel internal
1284       */
1285      protected MethodDecl decl_value;
1286      /**
1287       * @apilevel internal
1288       */
1289      private void decl_reset() {
1290        decl_computed = false;
1291        decl_value = null;
1292      }
1293      /**
1294       * @attribute syn
1295       * @aspect LookupMethod
1296       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:146
1297       */
1298      @ASTNodeAnnotation.Attribute
1299      public MethodDecl decl() {
1300        ASTNode$State state = state();
1301        if (decl_computed) {
1302          return decl_value;
1303        }
1304        boolean intermediate = state.INTERMEDIATE_VALUE;
1305        state.INTERMEDIATE_VALUE = false;
1306        int num = state.boundariesCrossed;
1307        boolean isFinal = this.is$Final();
1308        decl_value = decl_compute();
1309        if (isFinal && num == state().boundariesCrossed) {
1310          decl_computed = true;
1311        } else {
1312        }
1313        state.INTERMEDIATE_VALUE |= intermediate;
1314    
1315        return decl_value;
1316      }
1317      /**
1318       * @apilevel internal
1319       */
1320      private MethodDecl decl_compute() {
1321          SimpleSet decls = decls();
1322          if (decls.size() == 1) {
1323            return (MethodDecl) decls.iterator().next();
1324          }
1325      
1326          // 8.4.6.4 - only return the first method in case of multply inherited abstract methods
1327          boolean allAbstract = true;
1328          for (Iterator iter = decls.iterator(); iter.hasNext() && allAbstract; ) {
1329            MethodDecl m = (MethodDecl) iter.next();
1330            if (!m.isAbstract() && !m.hostType().isObject()) {
1331              allAbstract = false;
1332            }
1333          }
1334          if (decls.size() > 1 && allAbstract) {
1335            return (MethodDecl) decls.iterator().next();
1336          }
1337          return unknownMethod();
1338        }
1339      /**
1340       * @attribute syn
1341       * @aspect MethodDecl
1342       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:262
1343       */
1344      @ASTNodeAnnotation.Attribute
1345      public boolean accessible(MethodDecl m) {
1346        {
1347            if (!isQualified()) {
1348              return true;
1349            }
1350            if (!m.accessibleFrom(hostType())) {
1351              return false;
1352            }
1353            // the method is not accessible if the type is not accessible
1354            if (!qualifier().type().accessibleFrom(hostType())) {
1355              return false;
1356            }
1357            // 6.6.2.1 -  include qualifier type for protected access
1358            if (m.isProtected() && !m.hostPackage().equals(hostPackage())
1359                && !m.isStatic() && !qualifier().isSuperAccess()) {
1360              return hostType().mayAccess(this, m);
1361            }
1362            return true;
1363          }
1364      }
1365      /**
1366       * @attribute syn
1367       * @aspect NameCheck
1368       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:88
1369       */
1370      @ASTNodeAnnotation.Attribute
1371      public boolean validArgs() {
1372        {
1373            for (int i = 0; i < getNumArg(); i++) {
1374              if (!getArg(i).isPolyExpression() && getArg(i).type().isUnknown()) {
1375                return false;
1376              }
1377            }
1378                return true;
1379          }
1380      }
1381      /**
1382       * @attribute syn
1383       * @aspect Names
1384       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:37
1385       */
1386      @ASTNodeAnnotation.Attribute
1387      public String name() {
1388        String name_value = getID();
1389    
1390        return name_value;
1391      }
1392      /**
1393       * @attribute syn
1394       * @aspect AccessTypes
1395       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:39
1396       */
1397      @ASTNodeAnnotation.Attribute
1398      public boolean isMethodAccess() {
1399        boolean isMethodAccess_value = true;
1400    
1401        return isMethodAccess_value;
1402      }
1403      /**
1404       * Defines the expected kind of name for the left hand side in a qualified
1405       * expression.
1406       * @attribute syn
1407       * @aspect SyntacticClassification
1408       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:58
1409       */
1410      @ASTNodeAnnotation.Attribute
1411      public NameType predNameType() {
1412        NameType predNameType_value = NameType.AMBIGUOUS_NAME;
1413    
1414        return predNameType_value;
1415      }
1416      /**
1417       * @apilevel internal
1418       */
1419      protected boolean type_computed = false;
1420      /**
1421       * @apilevel internal
1422       */
1423      protected TypeDecl type_value;
1424      /**
1425       * @apilevel internal
1426       */
1427      private void type_reset() {
1428        type_computed = false;
1429        type_value = null;
1430      }
1431      /**
1432       * @attribute syn
1433       * @aspect TypeAnalysis
1434       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302
1435       */
1436      @ASTNodeAnnotation.Attribute
1437      public TypeDecl type() {
1438        ASTNode$State state = state();
1439        if (type_computed) {
1440          return type_value;
1441        }
1442        boolean intermediate = state.INTERMEDIATE_VALUE;
1443        state.INTERMEDIATE_VALUE = false;
1444        int num = state.boundariesCrossed;
1445        boolean isFinal = this.is$Final();
1446        type_value = type_compute();
1447        if (isFinal && num == state().boundariesCrossed) {
1448          type_computed = true;
1449        } else {
1450        }
1451        state.INTERMEDIATE_VALUE |= intermediate;
1452    
1453        return type_value;
1454      }
1455      /**
1456       * @apilevel internal
1457       */
1458      private TypeDecl type_compute() {
1459          if (getNumArg() == 0 && name().equals("getClass") && decl().hostType().isObject()) {
1460            TypeDecl typeClass = lookupType("java.lang", "Class");
1461            if (typeClass instanceof GenericClassDecl) {
1462              TypeDecl bound = isQualified() ? qualifier().type() : hostType();
1463              ArrayList<TypeDecl> args = new ArrayList<TypeDecl>();
1464              args.add(bound.erasure().asWildcardExtends());
1465              return ((GenericClassDecl) typeClass).lookupParTypeDecl(args);
1466            }
1467          }
1468          // Legacy getClass access using non-generic java.lang.Class.
1469          return refined_TypeAnalysis_MethodAccess_type();
1470        }
1471      /**
1472       * @attribute syn
1473       * @aspect InnerClasses
1474       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:445
1475       */
1476      @ASTNodeAnnotation.Attribute
1477      public boolean requiresAccessor() {
1478        {
1479            MethodDecl m = decl();
1480            if (m.isPrivate() && m.hostType() != hostType()) {
1481              return true;
1482            }
1483            if (m.isProtected() && !m.hostPackage().equals(hostPackage()) && !hostType().hasMethod(m.name())) {
1484              return true;
1485            }
1486            return false;
1487          }
1488      }
1489      /**
1490       * @attribute syn
1491       * @aspect MethodSignature15
1492       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:279
1493       */
1494      @ASTNodeAnnotation.Attribute
1495      public boolean applicableBySubtyping(MethodDecl m) {
1496        {
1497            if (m.getNumParameter() != getNumArg()) {
1498              return false;
1499            }
1500            for (int i = 0; i < m.getNumParameter(); i++) {
1501              if (!getArg(i).pertinentToApplicability(this, m, i)) {
1502                continue;
1503              } else if (!getArg(i).compatibleStrictContext(m.getParameter(i).type())) {
1504                return false;
1505              }
1506            }
1507            return true;
1508          }
1509      }
1510      /**
1511       * @attribute syn
1512       * @aspect MethodSignature15
1513       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:319
1514       */
1515      @ASTNodeAnnotation.Attribute
1516      public boolean applicableByMethodInvocationConversion(MethodDecl m) {
1517        {
1518            if (m.getNumParameter() != getNumArg()) {
1519              return false;
1520            }
1521            for (int i = 0; i < m.getNumParameter(); i++) {
1522              if (!getArg(i).pertinentToApplicability(this, m, i)) {
1523                continue;
1524              } else if (!getArg(i).compatibleLooseContext(m.getParameter(i).type())) {
1525                return false;
1526              }
1527            }
1528            return true;
1529          }
1530      }
1531      /**
1532       * @attribute syn
1533       * @aspect MethodSignature15
1534       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:343
1535       */
1536      @ASTNodeAnnotation.Attribute
1537      public boolean applicableVariableArity(MethodDecl m) {
1538        {
1539            for (int i = 0; i < m.getNumParameter() - 1; i++) {
1540              if (!getArg(i).pertinentToApplicability(this, m, i)) {
1541                continue;
1542              }
1543              if (!getArg(i).compatibleLooseContext(m.getParameter(i).type())) {
1544                return false;
1545              }
1546            }
1547            for (int i = m.getNumParameter() - 1; i < getNumArg(); i++) {
1548              if (!getArg(i).pertinentToApplicability(this, m, i)) {
1549                continue;
1550              }
1551              if (!getArg(i).compatibleLooseContext(m.lastParameter().type().componentType())) {
1552                return false;
1553              }
1554            }
1555            return true;
1556          }
1557      }
1558      /**
1559       * A member method is potentially applicable to a method invocation if and
1560       * only if all of the following are true:
1561       * <ul>
1562       * <li>The name of the member is identical to the name of the method in the
1563       * method invocation.
1564       * <li>The member is accessible (\ufffd6.6) to the class or interface in which
1565       * the method invocation appears.
1566       * <li>The arity of the member is lesser or equal to the arity of the
1567       * method invocation.
1568       * <li>If the member is a variable arity method with arity n, the arity of
1569       * the method invocation is greater or equal to n-1.
1570       * <li>If the member is a fixed arity method with arity n, the arity of the
1571       * method invocation is equal to n.
1572       * <li>If the method invocation includes explicit type parameters, and the
1573       * member is a generic method, then the number of actual type parameters is
1574       * equal to the number of formal type parameters.
1575       * </ul>
1576       * @attribute syn
1577       * @aspect MethodSignature15
1578       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:438
1579       */
1580      @ASTNodeAnnotation.Attribute
1581      public boolean potentiallyApplicable(MethodDecl m) {
1582        {
1583            if (!m.name().equals(name())) {
1584              return false;
1585            }
1586            if (!m.accessibleFrom(hostType())) {
1587              return false;
1588            }
1589            if (!m.isVariableArity()) {
1590              if (arity() != m.arity()) {
1591                return false;
1592              }
1593              for (int i = 0; i < getNumArg(); i++) {
1594                if (!getArg(i).potentiallyCompatible(m.getParameter(i).type(), m)) {
1595                  return false;
1596                }
1597              }
1598            }
1599            if (m.isVariableArity()) {
1600              if (!(arity() >= m.arity()-1)) {
1601                return false;
1602              }
1603              for (int i = 0; i < m.arity() - 2; i++) {
1604                if (!getArg(i).potentiallyCompatible(m.getParameter(i).type(), m)) {
1605                  return false;
1606                }
1607              }
1608              TypeDecl varArgType = m.getParameter(m.arity()-1).type();
1609              if (arity() == m.arity()) {
1610                if (!getArg(arity()-1).potentiallyCompatible(varArgType, m)
1611                    && !getArg(arity()-1).potentiallyCompatible(varArgType.componentType(), m)) {
1612                  return false;
1613                }
1614              } else if (arity() > m.arity()) {
1615                for (int i = m.arity()-1; i < arity(); i++) {
1616                  if (!getArg(i).potentiallyCompatible(varArgType.componentType(), m)) {
1617                    return false;
1618                  }
1619                }
1620              }
1621            }
1622        
1623            if (m.isGeneric()) {
1624              GenericMethodDecl gm = m.genericDecl();
1625              ArrayList<TypeDecl> typeArguments = inferTypeArguments(
1626                  gm.type(),
1627                  gm.getParameterList(),
1628                  getArgList(),
1629                  gm.getTypeParameterList());
1630              if (!typeArguments.isEmpty()) {
1631                if (gm.getNumTypeParameter() != typeArguments.size()) {
1632                  return false;
1633                }
1634                Parameterization par = new SimpleParameterization(gm.getTypeParameterList(), typeArguments);
1635                for (int i = 0; i < gm.getNumTypeParameter(); i++) {
1636                  if (!((TypeDecl) typeArguments.get(i)).withinBounds(gm.original().getTypeParameter(i), par)) {
1637                    return false;
1638                  }
1639                }
1640              }
1641            }
1642        
1643            return true;
1644          }
1645      }
1646      /**
1647       * @attribute syn
1648       * @aspect MethodSignature15
1649       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:474
1650       */
1651      @ASTNodeAnnotation.Attribute
1652      public int arity() {
1653        int arity_value = getNumArg();
1654    
1655        return arity_value;
1656      }
1657      /**
1658       * @attribute syn
1659       * @aspect VariableArityParameters
1660       * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:61
1661       */
1662      @ASTNodeAnnotation.Attribute
1663      public boolean invokesVariableArityAsArray() {
1664        {
1665            if (!decl().isVariableArity()) {
1666              return false;
1667            }
1668            if (arity() != decl().arity()) {
1669              return false;
1670            }
1671            return getArg(getNumArg()-1).type().methodInvocationConversionTo(decl().lastParameter().type());
1672          }
1673      }
1674      /**
1675       * @attribute syn
1676       * @aspect PreciseRethrow
1677       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149
1678       */
1679      @ASTNodeAnnotation.Attribute
1680      public boolean modifiedInScope(Variable var) {
1681        {
1682            for (int i = 0; i < getNumArg(); ++i) {
1683              if (getArg(i).modifiedInScope(var)) {
1684                return true;
1685              }
1686            }
1687            return false;
1688          }
1689      }
1690      /**
1691       * @apilevel internal
1692       */
1693      protected boolean stmtCompatible_computed = false;
1694      /**
1695       * @apilevel internal
1696       */
1697      protected boolean stmtCompatible_value;
1698      /**
1699       * @apilevel internal
1700       */
1701      private void stmtCompatible_reset() {
1702        stmtCompatible_computed = false;
1703      }
1704      /**
1705       * @attribute syn
1706       * @aspect StmtCompatible
1707       * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:145
1708       */
1709      @ASTNodeAnnotation.Attribute
1710      public boolean stmtCompatible() {
1711        ASTNode$State state = state();
1712        if (stmtCompatible_computed) {
1713          return stmtCompatible_value;
1714        }
1715        boolean intermediate = state.INTERMEDIATE_VALUE;
1716        state.INTERMEDIATE_VALUE = false;
1717        int num = state.boundariesCrossed;
1718        boolean isFinal = this.is$Final();
1719        stmtCompatible_value = true;
1720        if (isFinal && num == state().boundariesCrossed) {
1721          stmtCompatible_computed = true;
1722        } else {
1723        }
1724        state.INTERMEDIATE_VALUE |= intermediate;
1725    
1726        return stmtCompatible_value;
1727      }
1728      /**
1729       * @apilevel internal
1730       */
1731      protected boolean isBooleanExpression_computed = false;
1732      /**
1733       * @apilevel internal
1734       */
1735      protected boolean isBooleanExpression_value;
1736      /**
1737       * @apilevel internal
1738       */
1739      private void isBooleanExpression_reset() {
1740        isBooleanExpression_computed = false;
1741      }
1742      /**
1743       * @attribute syn
1744       * @aspect PolyExpressions
1745       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:29
1746       */
1747      @ASTNodeAnnotation.Attribute
1748      public boolean isBooleanExpression() {
1749        ASTNode$State state = state();
1750        if (isBooleanExpression_computed) {
1751          return isBooleanExpression_value;
1752        }
1753        boolean intermediate = state.INTERMEDIATE_VALUE;
1754        state.INTERMEDIATE_VALUE = false;
1755        int num = state.boundariesCrossed;
1756        boolean isFinal = this.is$Final();
1757        isBooleanExpression_value = isBooleanExpression_compute();
1758        if (isFinal && num == state().boundariesCrossed) {
1759          isBooleanExpression_computed = true;
1760        } else {
1761        }
1762        state.INTERMEDIATE_VALUE |= intermediate;
1763    
1764        return isBooleanExpression_value;
1765      }
1766      /**
1767       * @apilevel internal
1768       */
1769      private boolean isBooleanExpression_compute() {
1770          MethodDecl decl = decl();
1771          if (decl instanceof ParMethodDecl) {
1772            return ((ParMethodDecl) decl).genericMethodDecl().type().isBoolean();
1773          } else {
1774            return decl.type().isBoolean();
1775          }
1776        }
1777      /**
1778       * @apilevel internal
1779       */
1780      protected boolean isNumericExpression_computed = false;
1781      /**
1782       * @apilevel internal
1783       */
1784      protected boolean isNumericExpression_value;
1785      /**
1786       * @apilevel internal
1787       */
1788      private void isNumericExpression_reset() {
1789        isNumericExpression_computed = false;
1790      }
1791      /**
1792       * @attribute syn
1793       * @aspect PolyExpressions
1794       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:59
1795       */
1796      @ASTNodeAnnotation.Attribute
1797      public boolean isNumericExpression() {
1798        ASTNode$State state = state();
1799        if (isNumericExpression_computed) {
1800          return isNumericExpression_value;
1801        }
1802        boolean intermediate = state.INTERMEDIATE_VALUE;
1803        state.INTERMEDIATE_VALUE = false;
1804        int num = state.boundariesCrossed;
1805        boolean isFinal = this.is$Final();
1806        isNumericExpression_value = isNumericExpression_compute();
1807        if (isFinal && num == state().boundariesCrossed) {
1808          isNumericExpression_computed = true;
1809        } else {
1810        }
1811        state.INTERMEDIATE_VALUE |= intermediate;
1812    
1813        return isNumericExpression_value;
1814      }
1815      /**
1816       * @apilevel internal
1817       */
1818      private boolean isNumericExpression_compute() {
1819          MethodDecl decl = decl();
1820          if (decl instanceof ParMethodDecl) {
1821            return ((ParMethodDecl) decl).genericMethodDecl().type().isNumericType();
1822          } else {
1823            return decl.type().isNumericType();
1824          }
1825        }
1826      /**
1827       * @apilevel internal
1828       */
1829      protected boolean isPolyExpression_computed = false;
1830      /**
1831       * @apilevel internal
1832       */
1833      protected boolean isPolyExpression_value;
1834      /**
1835       * @apilevel internal
1836       */
1837      private void isPolyExpression_reset() {
1838        isPolyExpression_computed = false;
1839      }
1840      /**
1841       * @attribute syn
1842       * @aspect PolyExpressions
1843       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:80
1844       */
1845      @ASTNodeAnnotation.Attribute
1846      public boolean isPolyExpression() {
1847        ASTNode$State state = state();
1848        if (isPolyExpression_computed) {
1849          return isPolyExpression_value;
1850        }
1851        boolean intermediate = state.INTERMEDIATE_VALUE;
1852        state.INTERMEDIATE_VALUE = false;
1853        int num = state.boundariesCrossed;
1854        boolean isFinal = this.is$Final();
1855        isPolyExpression_value = isPolyExpression_compute();
1856        if (isFinal && num == state().boundariesCrossed) {
1857          isPolyExpression_computed = true;
1858        } else {
1859        }
1860        state.INTERMEDIATE_VALUE |= intermediate;
1861    
1862        return isPolyExpression_value;
1863      }
1864      /**
1865       * @apilevel internal
1866       */
1867      private boolean isPolyExpression_compute() {
1868          if (!assignmentContext() && !invocationContext()) {
1869            return false;
1870          }
1871          if (!decl().isGeneric()) {
1872            return false;
1873          }
1874          GenericMethodDecl genericDecl = decl().genericDecl();
1875          return genericDecl.typeVariableInReturn();
1876        }
1877      /**
1878       * @attribute inh
1879       * @aspect ExceptionHandling
1880       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:76
1881       */
1882      /**
1883       * @attribute inh
1884       * @aspect ExceptionHandling
1885       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:76
1886       */
1887      @ASTNodeAnnotation.Attribute
1888      public boolean handlesException(TypeDecl exceptionType) {
1889        boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType);
1890    
1891        return handlesException_TypeDecl_value;
1892      }
1893      /**
1894       * @attribute inh
1895       * @aspect LookupMethod
1896       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:37
1897       */
1898      /**
1899       * @attribute inh
1900       * @aspect LookupMethod
1901       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:37
1902       */
1903      @ASTNodeAnnotation.Attribute
1904      public MethodDecl unknownMethod() {
1905        MethodDecl unknownMethod_value = getParent().Define_unknownMethod(this, null);
1906    
1907        return unknownMethod_value;
1908      }
1909      /**
1910       * @attribute inh
1911       * @aspect TypeHierarchyCheck
1912       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:161
1913       */
1914      /**
1915       * @attribute inh
1916       * @aspect TypeHierarchyCheck
1917       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:161
1918       */
1919      @ASTNodeAnnotation.Attribute
1920      public boolean inExplicitConstructorInvocation() {
1921        boolean inExplicitConstructorInvocation_value = getParent().Define_inExplicitConstructorInvocation(this, null);
1922    
1923        return inExplicitConstructorInvocation_value;
1924      }
1925      /**
1926       * @attribute inh
1927       * @aspect SuppressWarnings
1928       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:40
1929       */
1930      /**
1931       * @attribute inh
1932       * @aspect SuppressWarnings
1933       * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:40
1934       */
1935      @ASTNodeAnnotation.Attribute
1936      public boolean withinSuppressWarnings(String annot) {
1937        boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot);
1938    
1939        return withinSuppressWarnings_String_value;
1940      }
1941      /**
1942       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
1943       * @apilevel internal
1944       */
1945      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1946        if (caller == getArgListNoTransform()) {
1947          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:450
1948          int i = caller.getIndexOfChild(child);
1949          return computeDAbefore(i, v);
1950        }
1951        else {
1952          return getParent().Define_isDAbefore(this, caller, v);
1953        }
1954      }
1955      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1956        return true;
1957      }
1958      /**
1959       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
1960       * @apilevel internal
1961       */
1962      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
1963        if (caller == getArgListNoTransform()) {
1964          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:958
1965          int i = caller.getIndexOfChild(child);
1966          return computeDUbefore(i, v);
1967        }
1968        else {
1969          return getParent().Define_isDUbefore(this, caller, v);
1970        }
1971      }
1972      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
1973        return true;
1974      }
1975      /**
1976       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46
1977       * @apilevel internal
1978       */
1979      public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) {
1980        if (caller == getArgListNoTransform()) {
1981          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:50
1982          int childIndex = caller.getIndexOfChild(child);
1983          return unqualifiedScope().lookupMethod(name);
1984        }
1985        else {
1986          return getParent().Define_lookupMethod(this, caller, name);
1987        }
1988      }
1989      protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) {
1990        return true;
1991      }
1992      /**
1993       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115
1994       * @apilevel internal
1995       */
1996      public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) {
1997        if (caller == getArgListNoTransform()) {
1998          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:116
1999          int childIndex = caller.getIndexOfChild(child);
2000          return unqualifiedScope().hasPackage(packageName);
2001        }
2002        else {
2003          return getParent().Define_hasPackage(this, caller, packageName);
2004        }
2005      }
2006      protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) {
2007        return true;
2008      }
2009      /**
2010       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197
2011       * @apilevel internal
2012       */
2013      public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) {
2014        if (caller == getArgListNoTransform()) {
2015          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:330
2016          int childIndex = caller.getIndexOfChild(child);
2017          return unqualifiedScope().lookupType(name);
2018        }
2019        else {
2020          return getParent().Define_lookupType(this, caller, name);
2021        }
2022      }
2023      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) {
2024        return true;
2025      }
2026      /**
2027       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
2028       * @apilevel internal
2029       */
2030      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
2031        if (caller == getArgListNoTransform()) {
2032          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:218
2033          int childIndex = caller.getIndexOfChild(child);
2034          return unqualifiedScope().lookupVariable(name);
2035        }
2036        else {
2037          return getParent().Define_lookupVariable(this, caller, name);
2038        }
2039      }
2040      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
2041        return true;
2042      }
2043      /**
2044       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
2045       * @apilevel internal
2046       */
2047      public NameType Define_nameType(ASTNode caller, ASTNode child) {
2048        if (caller == getArgListNoTransform()) {
2049          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:143
2050          int childIndex = caller.getIndexOfChild(child);
2051          return NameType.EXPRESSION_NAME;
2052        }
2053        else {
2054          return getParent().Define_nameType(this, caller);
2055        }
2056      }
2057      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
2058        return true;
2059      }
2060      /**
2061       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:32
2062       * @apilevel internal
2063       */
2064      public String Define_methodHost(ASTNode caller, ASTNode child) {
2065        int childIndex = this.getIndexOfChild(caller);
2066        return unqualifiedScope().methodHost();
2067      }
2068      protected boolean canDefine_methodHost(ASTNode caller, ASTNode child) {
2069        return true;
2070      }
2071      /**
2072       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:58
2073       * @apilevel internal
2074       */
2075      public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) {
2076        if (caller == getArgListNoTransform()) {
2077          // @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:66
2078          int childIndex = caller.getIndexOfChild(child);
2079          return typeObject();
2080        }
2081        else {
2082          return getParent().Define_assignConvertedType(this, caller);
2083        }
2084      }
2085      protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) {
2086        return true;
2087      }
2088      /**
2089       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30
2090       * @apilevel internal
2091       */
2092      public TypeDecl Define_targetType(ASTNode caller, ASTNode child) {
2093        if (caller == getArgListNoTransform()) {
2094          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:87
2095          int i = caller.getIndexOfChild(child);
2096          {
2097              MethodDecl decl = decl();
2098              if (decl.unknownMethod() == decl) {
2099                return decl.type().unknownType();
2100              }
2101          
2102              if (decl.isVariableArity() && i >= decl.arity() - 1) {
2103                return decl.getParameter(decl.arity() - 1).type().componentType();
2104              } else {
2105                return decl.getParameter(i).type();
2106              }
2107            }
2108        }
2109        else {
2110          return getParent().Define_targetType(this, caller);
2111        }
2112      }
2113      protected boolean canDefine_targetType(ASTNode caller, ASTNode child) {
2114        return true;
2115      }
2116      /**
2117       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196
2118       * @apilevel internal
2119       */
2120      public boolean Define_assignmentContext(ASTNode caller, ASTNode child) {
2121        if (caller == getArgListNoTransform()) {
2122          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:331
2123          int childIndex = caller.getIndexOfChild(child);
2124          return false;
2125        }
2126        else {
2127          return getParent().Define_assignmentContext(this, caller);
2128        }
2129      }
2130      protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) {
2131        return true;
2132      }
2133      /**
2134       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197
2135       * @apilevel internal
2136       */
2137      public boolean Define_invocationContext(ASTNode caller, ASTNode child) {
2138        if (caller == getArgListNoTransform()) {
2139          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:332
2140          int childIndex = caller.getIndexOfChild(child);
2141          return true;
2142        }
2143        else {
2144          return getParent().Define_invocationContext(this, caller);
2145        }
2146      }
2147      protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) {
2148        return true;
2149      }
2150      /**
2151       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198
2152       * @apilevel internal
2153       */
2154      public boolean Define_castContext(ASTNode caller, ASTNode child) {
2155        if (caller == getArgListNoTransform()) {
2156          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:333
2157          int childIndex = caller.getIndexOfChild(child);
2158          return false;
2159        }
2160        else {
2161          return getParent().Define_castContext(this, caller);
2162        }
2163      }
2164      protected boolean canDefine_castContext(ASTNode caller, ASTNode child) {
2165        return true;
2166      }
2167      /**
2168       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199
2169       * @apilevel internal
2170       */
2171      public boolean Define_stringContext(ASTNode caller, ASTNode child) {
2172        if (caller == getArgListNoTransform()) {
2173          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:334
2174          int childIndex = caller.getIndexOfChild(child);
2175          return false;
2176        }
2177        else {
2178          return getParent().Define_stringContext(this, caller);
2179        }
2180      }
2181      protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) {
2182        return true;
2183      }
2184      /**
2185       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200
2186       * @apilevel internal
2187       */
2188      public boolean Define_numericContext(ASTNode caller, ASTNode child) {
2189        if (caller == getArgListNoTransform()) {
2190          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:335
2191          int childIndex = caller.getIndexOfChild(child);
2192          return false;
2193        }
2194        else {
2195          return getParent().Define_numericContext(this, caller);
2196        }
2197      }
2198      protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) {
2199        return true;
2200      }
2201      /**
2202       * @apilevel internal
2203       */
2204      public ASTNode rewriteTo() {
2205        return super.rewriteTo();
2206      }
2207    }