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     * @production ASTNode;
027    
028     */
029    public class ASTNode<T extends ASTNode> extends beaver.Symbol implements Cloneable, PrettyPrintable, Iterable<T> {
030      /**
031       * @aspect AccessControl
032       * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:150
033       */
034      public void accessControl() {
035      }
036      /**
037       * @aspect AnonymousClasses
038       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:123
039       */
040      protected void collectExceptions(Collection c, ASTNode target) {
041        for (int i = 0; i < getNumChild(); i++) {
042          getChild(i).collectExceptions(c, target);
043        }
044      }
045      /**
046       * @aspect BranchTarget
047       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:90
048       */
049      public void collectBranches(Collection<Stmt> c) {
050        for (int i = 0; i < getNumChild(); i++) {
051          getChild(i).collectBranches(c);
052        }
053      }
054      /**
055       * @aspect DeclareBeforeUse
056       * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:42
057       */
058      public int varChildIndex(TypeDecl t) {
059        ASTNode node = this;
060        while (node != null && node.getParent() != null && node.getParent().getParent() != t) {
061          node = node.getParent();
062        }
063        if (node == null) {
064          return -1;
065        }
066        return t.getBodyDeclListNoTransform().getIndexOfChild(node);
067      }
068      /**
069       * @aspect DefiniteAssignment
070       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:34
071       */
072      public void definiteAssignment() {
073      }
074      /**
075       * @aspect DA
076       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:495
077       */
078      protected boolean checkDUeverywhere(Variable v) {
079        for (int i = 0; i < getNumChild(); i++) {
080          if (!getChild(i).checkDUeverywhere(v)) {
081            return false;
082          }
083        }
084        return true;
085      }
086      /**
087       * @aspect DA
088       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:627
089       */
090      protected boolean isDescendantTo(ASTNode node) {
091        if (this == node) {
092          return true;
093        }
094        if (getParent() == null) {
095          return false;
096        }
097        return getParent().isDescendantTo(node);
098      }
099      /**
100       * @aspect DumpTree
101       * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:38
102       */
103      private String DUMP_TREE_INDENT = "  ";
104      /**
105       * @aspect DumpTree
106       * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:40
107       */
108      public String dumpTree() {
109        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
110        dumpTree(new PrintStream(bytes));
111        return bytes.toString();
112      }
113      /**
114       * @aspect DumpTree
115       * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:46
116       */
117      public void dumpTree(PrintStream out) {
118        dumpTree(out, "");
119        out.flush();
120      }
121      /**
122       * @aspect DumpTree
123       * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:51
124       */
125      public void dumpTree(PrintStream out, String indent) {
126        out.print(indent + getClass().getSimpleName());
127        out.println(getTokens());
128        String childIndent = indent + DUMP_TREE_INDENT;
129        for (int i = 0; i < getNumChild(); ++i) {
130          ASTNode child = getChild(i);
131          if (child == null)  {
132            out.println(childIndent + "null");
133          } else {
134            child.dumpTree(out, childIndent);
135          }
136        }
137      }
138      /**
139       * @aspect DumpTree
140       * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:65
141       */
142      public String getTokens() {
143        StringBuilder sb = new StringBuilder();
144        Method[] methods = getClass().getMethods();
145        for (Method method : getClass().getMethods()) {
146          ASTNodeAnnotation.Token token = method.getAnnotation(ASTNodeAnnotation.Token.class);
147          if (token != null) {
148            try {
149              sb.append(" " + token.name() + "=\"" + method.invoke(this) + "\"");
150            } catch (IllegalAccessException e) {
151            } catch (InvocationTargetException e) {
152            }
153          }
154        }
155        return sb.toString();
156      }
157      /**
158       * @aspect DumpTree
159       * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:81
160       */
161      public String dumpTreeNoRewrite() {
162        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
163        dumpTreeNoRewrite(new PrintStream(bytes));
164        return bytes.toString();
165      }
166      /**
167       * @aspect DumpTree
168       * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:87
169       */
170      public void dumpTreeNoRewrite(PrintStream out) {
171        dumpTreeNoRewrite(out, "");
172        out.flush();
173      }
174      /**
175       * @aspect DumpTree
176       * @declaredat /home/jesper/git/extendj/java4/frontend/DumpTree.jadd:92
177       */
178      public void dumpTreeNoRewrite(PrintStream out, String indent) {
179        out.print(indent + getClass().getSimpleName());
180        out.println(getTokens());
181        String childIndent = indent + DUMP_TREE_INDENT;
182        for (int i = 0; i < getNumChildNoTransform(); ++i) {
183          ASTNode child = getChildNoTransform(i);
184          if (child == null)  {
185            out.println(childIndent + "null");
186          } else {
187            child.dumpTreeNoRewrite(out, childIndent);
188          }
189        }
190      }
191      /**
192       * @aspect ErrorCheck
193       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:33
194       */
195      protected String sourceFile() {
196        ASTNode node = this;
197        while (node != null && !(node instanceof CompilationUnit)) {
198          node = node.getParent();
199        }
200        if (node == null) {
201          return "Unknown file";
202        }
203        CompilationUnit u = (CompilationUnit) node;
204        return u.relativeName();
205      }
206      /**
207       * @aspect ErrorCheck
208       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:57
209       */
210      public ASTNode setLocation(ASTNode node) {
211        setStart(node.getStart());
212        setEnd(node.getEnd());
213        return this;
214      }
215      /**
216       * @aspect ErrorCheck
217       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:63
218       */
219      public ASTNode setStart(int i) {
220        start = i;
221        return this;
222      }
223      /**
224       * @aspect ErrorCheck
225       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:67
226       */
227      public int start() {
228        return start;
229      }
230      /**
231       * @aspect ErrorCheck
232       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:70
233       */
234      public ASTNode setEnd(int i) {
235        end = i;
236        return this;
237      }
238      /**
239       * @aspect ErrorCheck
240       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:74
241       */
242      public int end() {
243        return end;
244      }
245      /**
246       * @aspect ErrorCheck
247       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:78
248       */
249      public String location() {
250        return "" + lineNumber();
251      }
252      /**
253       * @aspect ErrorCheck
254       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:81
255       */
256      public String errorPrefix() {
257        return sourceFile() + ":" + location() + ":\n" + "  *** Semantic Error: ";
258      }
259      /**
260       * @aspect ErrorCheck
261       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:84
262       */
263      public String warningPrefix() {
264        return sourceFile() + ":" + location() + ":\n" + "  *** WARNING: ";
265      }
266      /**
267       * @aspect ErrorCheck
268       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:198
269       */
270      public void errorf(String messagefmt, Object... args) {
271        error(String.format(messagefmt, args));
272      }
273      /**
274       * @aspect ErrorCheck
275       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:202
276       */
277      public void error(String message) {
278        ASTNode node = this;
279        while (node != null && !(node instanceof CompilationUnit)) {
280          node = node.getParent();
281        }
282        CompilationUnit cu = (CompilationUnit) node;
283        if (getNumChild() == 0 && getStart() != 0 && getEnd() != 0) {
284          int line = getLine(getStart());
285          int column = getColumn(getStart());
286          int endLine = getLine(getEnd());
287          int endColumn = getColumn(getEnd());
288          cu.errors.add(new Problem(sourceFile(), message, line, column, endLine, endColumn,
289              Problem.Severity.ERROR, Problem.Kind.SEMANTIC));
290        } else {
291          cu.errors.add(new Problem(sourceFile(), message, lineNumber(), Problem.Severity.ERROR,
292              Problem.Kind.SEMANTIC));
293        }
294      }
295      /**
296       * @aspect ErrorCheck
297       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:221
298       */
299      public void warning(String s) {
300        ASTNode node = this;
301        while (node != null && !(node instanceof CompilationUnit)) {
302          node = node.getParent();
303        }
304        CompilationUnit cu = (CompilationUnit) node;
305        cu.warnings.add(new Problem(sourceFile(), "WARNING: " + s, lineNumber(), Problem.Severity.WARNING));
306      }
307      /**
308       * @aspect ExceptionHandling
309       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:87
310       */
311      public void exceptionHandling() {
312      }
313      /**
314       * @aspect ExceptionHandling
315       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:271
316       */
317      protected boolean reachedException(TypeDecl type) {
318        for (int i = 0; i < getNumChild(); i++) {
319          if (getChild(i).reachedException(type)) {
320            return true;
321          }
322        }
323        return false;
324      }
325      /**
326       * @aspect LookupMethod
327       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:92
328       */
329      public static Collection removeInstanceMethods(Collection c) {
330        c = new LinkedList(c);
331        for (Iterator iter = c.iterator(); iter.hasNext(); ) {
332          MethodDecl m = (MethodDecl) iter.next();
333          if (!m.isStatic()) {
334            iter.remove();
335          }
336        }
337        return c;
338      }
339      /**
340       * Utility method to put a SimpleSet-item in a signature map.
341       * @aspect MemberMethods
342       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:511
343       */
344      protected static void putSimpleSetElement(Map<String,SimpleSet> map, String key, SimpleSet value) {
345        SimpleSet set = map.get(key);
346        if (set == null) {
347          set = SimpleSet.emptySet;
348        }
349        map.put(key, set.add(value));
350      }
351      /**
352       * @aspect VariableScope
353       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:274
354       */
355      public SimpleSet removeInstanceVariables(SimpleSet oldSet) {
356        SimpleSet newSet = SimpleSet.emptySet;
357        for (Iterator iter = oldSet.iterator(); iter.hasNext(); ) {
358          Variable v = (Variable) iter.next();
359          if (!v.isInstanceVariable()) {
360            newSet = newSet.add(v);
361          }
362        }
363        return newSet;
364      }
365      /**
366       * @aspect Modifiers
367       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:32
368       */
369      void checkModifiers() {
370      }
371      /**
372       * @return a copy of the block as an NTAFinallyBlock
373       * @aspect NTAFinally
374       * @declaredat /home/jesper/git/extendj/java4/frontend/NTAFinally.jrag:35
375       */
376      protected static NTAFinallyBlock ntaFinallyBlock(FinallyHost origin, Stmt branch, Block block) {
377        NTAFinallyBlock ntaBlock = new NTAFinallyBlock(origin);
378        ntaBlock.addStmt((Block) block.treeCopyNoTransform());
379        /*if (!block.canCompleteNormally()) {
380         * // the target block's exit will replace our own exit code
381         * // so we can just goto that block!
382         * ntaBlock.addGoto(block);
383         * } else ...
384         */
385        if (block.canCompleteNormally()) {
386          FinallyHost enclosing = block.enclosingFinally(branch);
387          if (enclosing != null) {
388            ntaBlock.addStmt(ntaFinallyBlock(enclosing, branch, enclosing.getFinallyBlock()));
389          }
390        }
391        return ntaBlock;
392      }
393      /**
394       * @aspect NameCheck
395       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:33
396       */
397      public void nameCheck() {
398      }
399      /**
400       * @aspect NameCheck
401       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:36
402       */
403      public TypeDecl extractSingleType(SimpleSet c) {
404        if (c.size() != 1) {
405          return null;
406        }
407        return (TypeDecl) c.iterator().next();
408      }
409      /**
410       * Pretty-print this ASTNode.
411       * @return pretty-printed representation of this AST node
412       * @aspect PrettyPrintUtil
413       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:41
414       */
415      public String prettyPrint() {
416        ByteArrayOutputStream buf = new ByteArrayOutputStream();
417        prettyPrint(new PrettyPrinter("  ", new PrintStream(buf)));
418        return buf.toString();
419      }
420      /**
421       * Pretty print this AST node to the target PrintStream.
422       * @param out target for pretty printing
423       * @aspect PrettyPrintUtil
424       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:51
425       */
426      public void prettyPrint(PrintStream out) {
427        prettyPrint(new PrettyPrinter("  ", out));
428      }
429      /**
430       * @return the name of the class implementing this AST node
431       * @aspect PrettyPrintUtil
432       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:58
433       */
434      public String toString() {
435        return getClass().getName();
436      }
437      /**
438       * @aspect PrettyPrintUtil
439       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:62
440       */
441      public void prettyPrint(PrettyPrinter out) {
442      }
443      /**
444       * @aspect PrimitiveTypes
445       * @declaredat /home/jesper/git/extendj/java4/frontend/PrimitiveTypes.jrag:32
446       */
447      protected static final String PRIMITIVE_PACKAGE_NAME = "@primitive";
448      /**
449       * @aspect StructuredPrettyPrint
450       * @declaredat /home/jesper/git/extendj/java4/frontend/StructuredPrettyPrint.jadd:32
451       */
452      public String structuredPrettyPrint() throws IOException {
453        ByteArrayOutputStream out = new ByteArrayOutputStream();
454        // First, transform the tree by wrapping all expressions in ParExpr.
455        wrapExprs();
456        prettyPrint(new PrintStream(out, false, "UTF8"));
457        return out.toString().trim();
458      }
459      /**
460       * Hacky way of inserting parens around all expressions.
461       * @aspect StructuredPrettyPrint
462       * @declaredat /home/jesper/git/extendj/java4/frontend/StructuredPrettyPrint.jadd:43
463       */
464      private void wrapExprs() {
465        for (int i = 0; i < getNumChildNoTransform(); ++i) {
466          ASTNode child = getChildNoTransform(i);
467          if (child instanceof Expr &&
468              !(child instanceof ParExpr) &&
469              !(child instanceof Access) &&
470              !(child instanceof Literal)) {
471            child.setParent(null);
472            ParExpr parExpr = new ParExpr((Expr) child);
473            setChild(parExpr, i);
474          }
475          child.wrapExprs();
476        }
477      }
478      /**
479       * @aspect TypeCheck
480       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:33
481       */
482      public void typeCheck() {
483      }
484      /**
485       * @aspect UnreachableStatements
486       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:33
487       */
488      void checkUnreachableStmt() {
489      }
490      /**
491       * @aspect VariableDeclarationTransformation
492       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:154
493       */
494      public void clearLocations() {
495        setStart(0);
496        setEnd(0);
497        for (int i = 0; i < getNumChildNoTransform(); i++) {
498          getChildNoTransform(i).clearLocations();
499        }
500      }
501      /**
502       * @aspect CodeGeneration
503       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:33
504       */
505      public void setSourceLineNumber(int i) {
506        setStart(ASTNode.makePosition(i, 1));
507      }
508      /**
509       * @aspect CodeGeneration
510       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:54
511       */
512      protected int findFirstSourceLineNumber() {
513        if (getStart() != 0) {
514          return getLine(getStart());
515        }
516        for (int i = 0; i < getNumChild(); i++) {
517          int num = getChild(i).findFirstSourceLineNumber();
518          if (num != -1) {
519            return num;
520          }
521        }
522        return -1;
523      }
524      /**
525       * @aspect CodeGeneration
526       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:213
527       */
528      public void error() {
529        Throwable t = new Throwable();
530        StackTraceElement[] ste = new Throwable().getStackTrace();
531        String s = ste[1].toString();
532        throw new Error(s+" Cannot create bytecode for:"+getClass().getName());
533      }
534      /**
535       * @aspect CreateBCode
536       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:232
537       */
538      public void createBCode(CodeGeneration gen) {
539        for (int i=0; i<getNumChild(); i++) {
540          getChild(i).createBCode(gen);
541        }
542      }
543      /**
544       * @aspect FlushCaches
545       * @declaredat /home/jesper/git/extendj/java4/backend/FlushCaches.jrag:33
546       */
547      public void flushCaches() {
548          flushCache();
549          for (int i = 0; i < getNumChild(); i++) {
550            getChild(i).flushCaches();
551          }
552        }
553      /**
554       * @aspect GenerateClassfile
555       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:355
556       */
557      public boolean clear() {
558        boolean empty = true;
559        for (int i = 0; i < getNumChild(); i++) {
560          ASTNode child = getChild(i);
561          if (!child.clear()) {
562            empty = false;
563          } else {
564            if (child instanceof List) {
565              ((ASTNode) this).setChild(new List(), i);
566            } else if (child instanceof Opt) {
567              ((ASTNode) this).setChild(new Opt(), i);
568            }
569            //setChild(null, i);
570          }
571        }
572        if (empty) {
573          setParent(null);
574        }
575        if (flush()) {
576          flushCache();
577        }
578        return empty;
579      }
580      /**
581       * @aspect InnerClasses
582       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:192
583       */
584      public void collectEnclosingVariables(HashSet set, TypeDecl typeDecl) {
585        for (int i = 0; i < getNumChild(); i++) {
586          getChild(i).collectEnclosingVariables(set, typeDecl);
587        }
588      }
589      /**
590       * @aspect Transformations
591       * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:33
592       */
593      public void transformation() {
594        for (int i = 0; i < getNumChild(); i++) {
595            getChild(i).transformation();
596        }
597      }
598      /** Imperative transformation of the AST
599       * This should be removed.
600       * 
601       * Usage: this.replaceWith(replacement)
602       * 
603       * @param replacement node to replace this node with
604       * @return the new node
605       * @deprecated
606       * @aspect Transformations
607       * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:210
608       */
609      @Deprecated
610      protected void replaceWith(ASTNode replacement) {
611         int replacePos = getParent().getIndexOfChild(this);
612         getParent().setChild(replacement, replacePos);
613      }
614      /**
615       * @aspect Enums
616       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:159
617       */
618      protected void transformEnumConstructors() {
619        for (int i = 0; i < getNumChildNoTransform(); i++) {
620          ASTNode child = getChildNoTransform(i);
621          if (child != null) {
622            child.transformEnumConstructors();
623          }
624        }
625      }
626      /**
627       * @aspect Enums
628       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:490
629       */
630      protected void checkEnum(EnumDecl enumDecl) {
631        for (int i = 0; i < getNumChild(); i++) {
632          getChild(i).checkEnum(enumDecl);
633        }
634      }
635      /**
636       * Finds one method with the given name, and no parameters, in the specified
637       * type.
638       * @param type type to search for the method declaration
639       * @param name name of the method
640       * @return method declaration
641       * @aspect EnhancedForToBytecode
642       * @declaredat /home/jesper/git/extendj/java5/backend/EnhancedForCodegen.jrag:110
643       */
644      protected static MethodDecl getMethod(TypeDecl type, String name) {
645        Collection<MethodDecl> methods = (Collection<MethodDecl>) type.memberMethods(name);
646        for (MethodDecl method: methods) {
647          if (method.getNumParameter() == 0) {
648            return method;
649          }
650        }
651        throw new Error("Could not find " + type.typeName() +
652            "." + name + "()");
653      }
654      /**
655       * @aspect UncheckedConversion
656       * @declaredat /home/jesper/git/extendj/java7/frontend/UncheckedConversion.jrag:65
657       */
658      public void checkUncheckedConversion(TypeDecl source, TypeDecl dest) {
659        if (source.isUncheckedConversionTo(dest)) {
660          warning("unchecked conversion from raw type " + source.typeName()
661              + " to generic type " + dest.typeName());
662        }
663      }
664      /**
665       * Checking of the SafeVarargs annotation is only needed for method
666       * declarations.
667       * @aspect Warnings
668       * @declaredat /home/jesper/git/extendj/java7/frontend/Warnings.jadd:60
669       */
670      public void checkWarnings() {
671       }
672      /**
673       * @declaredat ASTNode:1
674       */
675      public ASTNode() {
676        super();
677        init$Children();
678      }
679      /**
680       * Initializes the child array to the correct size.
681       * Initializes List and Opt nta children.
682       * @apilevel internal
683       * @ast method
684       * @declaredat ASTNode:11
685       */
686      public void init$Children() {
687      }
688      /**
689       * @apilevel internal
690       * @declaredat ASTNode:16
691       */
692      private int childIndex;
693      /**
694       * @apilevel low-level
695       * @declaredat ASTNode:21
696       */
697      public int getIndexOfChild(ASTNode node) {
698        if (node == null) {
699          return -1;
700        }
701        if (node.childIndex < numChildren && node == children[node.childIndex]) {
702          return node.childIndex;
703        }
704        for(int i = 0; children != null && i < children.length; i++) {
705          if (children[i] == node) {
706            node.childIndex = i;
707            return i;
708          }
709        }
710        return -1;
711      }
712      /**
713       * @apilevel internal
714       * @declaredat ASTNode:40
715       */
716      public static final boolean generatedWithCacheCycle = false;
717      /**
718       * @apilevel internal
719       * @declaredat ASTNode:44
720       */
721      public static final boolean generatedWithComponentCheck = false;
722      /**
723       * Parent pointer
724       * @apilevel low-level
725       * @declaredat ASTNode:50
726       */
727      protected ASTNode parent;
728      /**
729       * Child array
730       * @apilevel low-level
731       * @declaredat ASTNode:56
732       */
733      protected ASTNode[] children;
734      /**
735       * @apilevel internal
736       * @declaredat ASTNode:62
737       */
738      private static ASTNode$State state = new ASTNode$State();
739      /**
740       * @apilevel internal
741       * @declaredat ASTNode:67
742       */
743      public final ASTNode$State state() {
744        return state;
745      }
746      /**
747       * @apilevel internal
748       * @declaredat ASTNode:74
749       */
750      public boolean in$Circle = false;
751      /**
752       * @apilevel internal
753       * @declaredat ASTNode:79
754       */
755      public boolean in$Circle() {
756        return in$Circle;
757      }
758      /**
759       * @apilevel internal
760       * @declaredat ASTNode:86
761       */
762      public void in$Circle(boolean b) {
763        in$Circle = b;
764      }
765      /**
766       * @apilevel internal
767       * @declaredat ASTNode:93
768       */
769      public boolean is$Final = false;
770      /**
771       * @apilevel internal
772       * @declaredat ASTNode:97
773       */
774      public boolean is$Final() { return is$Final; }
775      /**
776       * @apilevel internal
777       * @declaredat ASTNode:101
778       */
779      public void is$Final(boolean b) { is$Final = b; }
780      /**
781       * @apilevel low-level
782       * @declaredat ASTNode:106
783       */
784      public T getChild(int i) {
785    
786        ASTNode node = this.getChildNoTransform(i);
787        if (node == null) {
788          return null;
789        }
790        if (node.is$Final()) {
791          return (T) node;
792        }
793        if (!node.mayHaveRewrite()) {
794          node.is$Final(this.is$Final());
795          return (T) node;
796        }
797        if (!node.in$Circle()) {
798          int rewriteState;
799          int num = state().boundariesCrossed;
800          do {
801            state().push(ASTNode$State.REWRITE_CHANGE);
802            ASTNode oldNode = node;
803            oldNode.in$Circle(true);
804            node = node.rewriteTo();
805            if (node != oldNode) {
806              this.setChild(node, i);
807            }
808            oldNode.in$Circle(false);
809            rewriteState = state().pop();
810          } while(rewriteState == ASTNode$State.REWRITE_CHANGE);
811          if (rewriteState == ASTNode$State.REWRITE_NOCHANGE && this.is$Final()) {
812            node.is$Final(true);
813            state().boundariesCrossed = num;
814          } else {
815          }
816        } else if (this.is$Final() != node.is$Final()) {
817          state().boundariesCrossed++;
818        } else {
819        }
820        return (T) node;
821    
822    
823      }
824      /**
825       * @apilevel low-level
826       * @declaredat ASTNode:149
827       */
828      public void addChild(T node) {
829        setChild(node, getNumChildNoTransform());
830      }
831      /**
832       * <p><em>This method does not invoke AST transformations.</em></p>
833       * @apilevel low-level
834       * @declaredat ASTNode:156
835       */
836      public final T getChildNoTransform(int i) {
837        if (children == null) {
838          return null;
839        }
840        T child = (T)children[i];
841        return child;
842      }
843      /**
844       * @apilevel low-level
845       * @declaredat ASTNode:166
846       */
847      protected int numChildren;
848      /**
849       * @apilevel low-level
850       * @declaredat ASTNode:171
851       */
852      protected int numChildren() {
853        return numChildren;
854      }
855      /**
856       * @apilevel low-level
857       * @declaredat ASTNode:178
858       */
859      public int getNumChild() {
860        return numChildren();
861      }
862      /**
863       * <p><em>This method does not invoke AST transformations.</em></p>
864       * @apilevel low-level
865       * @declaredat ASTNode:186
866       */
867      public final int getNumChildNoTransform() {
868        return numChildren();
869      }
870      /**
871       * @apilevel low-level
872       * @declaredat ASTNode:192
873       */
874      public void setChild(ASTNode node, int i) {
875        if (children == null) {
876          children = new ASTNode[(i+1>4 || !(this instanceof List))?i+1:4];
877        } else if (i >= children.length) {
878          ASTNode c[] = new ASTNode[i << 1];
879          System.arraycopy(children, 0, c, 0, children.length);
880          children = c;
881        }
882        children[i] = node;
883        if (i >= numChildren) {
884          numChildren = i+1;
885        }
886        if (node != null) {
887          node.setParent(this);
888          node.childIndex = i;
889        }
890      }
891      /**
892       * @apilevel low-level
893       * @declaredat ASTNode:212
894       */
895      public void insertChild(ASTNode node, int i) {
896        if (children == null) {
897          children = new ASTNode[(i+1>4 || !(this instanceof List))?i+1:4];
898          children[i] = node;
899        } else {
900          ASTNode c[] = new ASTNode[children.length + 1];
901          System.arraycopy(children, 0, c, 0, i);
902          c[i] = node;
903          if (i < children.length) {
904            System.arraycopy(children, i, c, i+1, children.length-i);
905            for(int j = i+1; j < c.length; ++j) {
906              if (c[j] != null) {
907                c[j].childIndex = j;
908              }
909            }
910          }
911          children = c;
912        }
913        numChildren++;
914        if (node != null) {
915          node.setParent(this);
916          node.childIndex = i;
917        }
918      }
919      /**
920       * @apilevel low-level
921       * @declaredat ASTNode:239
922       */
923      public void removeChild(int i) {
924        if (children != null) {
925          ASTNode child = (ASTNode) children[i];
926          if (child != null) {
927            child.parent = null;
928            child.childIndex = -1;
929          }
930          // Adding a check of this instance to make sure its a List, a move of children doesn't make
931          // any sense for a node unless its a list. Also, there is a problem if a child of a non-List node is removed
932          // and siblings are moved one step to the right, with null at the end.
933          if (this instanceof List || this instanceof Opt) {
934            System.arraycopy(children, i+1, children, i, children.length-i-1);
935            children[children.length-1] = null;
936            numChildren--;
937            // fix child indices
938            for(int j = i; j < numChildren; ++j) {
939              if (children[j] != null) {
940                child = (ASTNode) children[j];
941                child.childIndex = j;
942              }
943            }
944          } else {
945            children[i] = null;
946          }
947        }
948      }
949      /**
950       * @apilevel low-level
951       * @declaredat ASTNode:268
952       */
953      public ASTNode getParent() {
954        if (parent != null && ((ASTNode) parent).is$Final() != is$Final()) {
955          state().boundariesCrossed++;
956        }
957        return (ASTNode) parent;
958      }
959      /**
960       * @apilevel low-level
961       * @declaredat ASTNode:277
962       */
963      public void setParent(ASTNode node) {
964        parent = node;
965      }
966      /**
967       * @apilevel low-level
968       * @declaredat ASTNode:328
969       */
970      public java.util.Iterator<T> iterator() {
971        return new java.util.Iterator<T>() {
972          private int counter = 0;
973          public boolean hasNext() {
974            return counter < getNumChild();
975          }
976          public T next() {
977            if (hasNext())
978              return (T)getChild(counter++);
979            else
980              return null;
981          }
982          public void remove() {
983            throw new UnsupportedOperationException();
984          }
985        };
986      }
987      /**
988       * @apilevel internal
989       * @declaredat ASTNode:348
990       */
991      public boolean mayHaveRewrite() {
992        return false;
993      }
994      /**
995       * @apilevel low-level
996       * @declaredat ASTNode:354
997       */
998      public void flushTreeCache() {
999        flushCache();
1000        if (children == null) {
1001          return;
1002        }
1003        for (int i = 0; i < children.length; i++) {
1004          if (children[i] != null && ((ASTNode)children[i]).is$Final) {
1005            ((ASTNode)children[i]).flushTreeCache();
1006          }
1007        }
1008      }
1009      /**
1010       * @apilevel low-level
1011       * @declaredat ASTNode:368
1012       */
1013      public void flushCache() {
1014        flushAttrAndCollectionCache();
1015      }
1016      /**
1017       * @apilevel internal
1018       * @declaredat ASTNode:374
1019       */
1020      public void flushAttrAndCollectionCache() {
1021        flushAttrCache();
1022        flushCollectionCache();
1023      }
1024      /**
1025       * @apilevel internal
1026       * @declaredat ASTNode:381
1027       */
1028      public void flushAttrCache() {
1029      }
1030      /**
1031       * @apilevel internal
1032       * @declaredat ASTNode:386
1033       */
1034      public void flushCollectionCache() {
1035      }
1036      /**
1037       * @apilevel internal
1038       * @declaredat ASTNode:391
1039       */
1040      public void flushRewriteCache() {
1041        in$Circle(false);
1042        is$Final(false);
1043      }
1044      /**
1045       * @apilevel internal
1046       * @declaredat ASTNode:398
1047       */
1048      public ASTNode<T> clone() throws CloneNotSupportedException {
1049        ASTNode node = (ASTNode) super.clone();
1050        if (node.is$Final()) {
1051          node.flushAttrAndCollectionCache();
1052        }
1053        node.in$Circle(false);
1054        // flush rewrites
1055        node.is$Final(false);
1056        return node;
1057      }
1058      /**
1059       * @apilevel internal
1060       * @declaredat ASTNode:411
1061       */
1062      public ASTNode<T> copy() {
1063        try {
1064          ASTNode node = (ASTNode) clone();
1065          node.parent = null;
1066          if (children != null) {
1067            node.children = (ASTNode[]) children.clone();
1068          }
1069          return node;
1070        } catch (CloneNotSupportedException e) {
1071          throw new Error("Error: clone not supported for " + getClass().getName());
1072        }
1073      }
1074      /**
1075       * Create a deep copy of the AST subtree at this node.
1076       * The copy is dangling, i.e. has no parent.
1077       * @return dangling copy of the subtree at this node
1078       * @apilevel low-level
1079       * @deprecated Please use treeCopy or treeCopyNoTransform instead
1080       * @declaredat ASTNode:430
1081       */
1082      @Deprecated
1083      public ASTNode<T> fullCopy() {
1084        return treeCopyNoTransform();
1085      }
1086      /**
1087       * Create a deep copy of the AST subtree at this node.
1088       * The copy is dangling, i.e. has no parent.
1089       * @return dangling copy of the subtree at this node
1090       * @apilevel low-level
1091       * @declaredat ASTNode:440
1092       */
1093      public ASTNode<T> treeCopyNoTransform() {
1094        ASTNode tree = (ASTNode) copy();
1095        if (children != null) {
1096          for (int i = 0; i < children.length; ++i) {
1097            ASTNode child = (ASTNode) children[i];
1098            if (child != null) {
1099              child = child.treeCopyNoTransform();
1100              tree.setChild(child, i);
1101            }
1102          }
1103        }
1104        return tree;
1105      }
1106      /**
1107       * Create a deep copy of the AST subtree at this node.
1108       * The subtree of this node is traversed to trigger rewrites before copy.
1109       * The copy is dangling, i.e. has no parent.
1110       * @return dangling copy of the subtree at this node
1111       * @apilevel low-level
1112       * @declaredat ASTNode:460
1113       */
1114      public ASTNode<T> treeCopy() {
1115        doFullTraversal();
1116        return treeCopyNoTransform();
1117      }
1118      /**
1119       * Performs a full traversal of the tree using getChild to trigger rewrites
1120       * @apilevel low-level
1121       * @declaredat ASTNode:468
1122       */
1123      public void doFullTraversal() {
1124        for (int i = 0; i < getNumChild(); i++) {
1125          getChild(i).doFullTraversal();
1126        }
1127      }
1128      /**
1129       * @apilevel internal
1130       * @declaredat ASTNode:476
1131       */
1132      protected boolean is$Equal(ASTNode n1, ASTNode n2) {
1133        if (n1 == null && n2 == null) return true;
1134        if (n1 == null || n2 == null) return false;
1135        return n1.is$Equal(n2);
1136      }
1137      /**
1138       * @apilevel internal
1139       * @declaredat ASTNode:484
1140       */
1141      protected boolean is$Equal(ASTNode node) {
1142        if (getClass() != node.getClass()) {
1143          return false;
1144        }
1145        if (numChildren != node.numChildren) {
1146          return false;
1147        }
1148        for (int i = 0; i < numChildren; i++) {
1149          if (children[i] == null && node.children[i] != null) {
1150            return false;
1151          }
1152          if (!((ASTNode)children[i]).is$Equal(((ASTNode)node.children[i]))) {
1153            return false;
1154          }
1155        }
1156        return true;
1157      }
1158      /**
1159       * The collectErrors method is refined so that it calls
1160       * the checkWarnings method on each ASTNode to report
1161       * unchecked warnings.
1162       * @aspect Warnings
1163       * @declaredat /home/jesper/git/extendj/java7/frontend/Warnings.jadd:42
1164       */
1165        public void collectErrors() {
1166             nameCheck();
1167             typeCheck();
1168             accessControl();
1169             exceptionHandling();
1170             checkUnreachableStmt();
1171             definiteAssignment();
1172             checkModifiers();
1173             checkWarnings();
1174             for(int i = 0; i < getNumChild(); i++) {
1175                     getChild(i).collectErrors();
1176             }
1177     }
1178      /**
1179       * @aspect <NoAspect>
1180       * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaBody.jrag:47
1181       */
1182        protected void collect_contributors_BlockLambdaBody_lambdaReturns() {
1183        for(int i = 0; i < getNumChild(); i++) {
1184          getChild(i).collect_contributors_BlockLambdaBody_lambdaReturns();
1185        }
1186      }
1187      protected void contributeTo_BlockLambdaBody_BlockLambdaBody_lambdaReturns(ArrayList<ReturnStmt> collection) {
1188      }
1189    
1190      /**
1191       * @attribute syn
1192       * @aspect ErrorCheck
1193       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:45
1194       */
1195      @ASTNodeAnnotation.Attribute
1196      public int lineNumber() {
1197        {
1198            ASTNode n = this;
1199            while (n.getParent() != null && n.getStart() == 0) {
1200              n = n.getParent();
1201            }
1202            return getLine(n.getStart());
1203          }
1204      }
1205      /**
1206       * @attribute syn
1207       * @aspect CodeGeneration
1208       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:37
1209       */
1210      @ASTNodeAnnotation.Attribute
1211      public int sourceLineNumber() {
1212        int sourceLineNumber_value = getStart() != 0 ? getLine(getStart()) : -1;
1213    
1214        return sourceLineNumber_value;
1215      }
1216      /**
1217       * @attribute syn
1218       * @aspect GenerateClassfile
1219       * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:379
1220       */
1221      @ASTNodeAnnotation.Attribute
1222      public boolean flush() {
1223        boolean flush_value = true;
1224    
1225        return flush_value;
1226      }
1227      /**
1228       * @attribute syn
1229       * @aspect InnerClasses
1230       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:119
1231       */
1232      @ASTNodeAnnotation.Attribute
1233      public boolean isStringAdd() {
1234        boolean isStringAdd_value = false;
1235    
1236        return isStringAdd_value;
1237      }
1238      /**
1239       * @attribute syn
1240       * @aspect LookupParTypeDecl
1241       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1240
1242       */
1243      @ASTNodeAnnotation.Attribute
1244      public boolean usesTypeVariable() {
1245        {
1246            for (int i = 0; i < getNumChild(); i++) {
1247              if (getChild(i).usesTypeVariable()) {
1248                return true;
1249              }
1250            }
1251            return false;
1252          }
1253      }
1254      /**
1255       * @attribute inh
1256       * @aspect AddOptionsToProgram
1257       * @declaredat /home/jesper/git/extendj/java4/frontend/Options.jadd:39
1258       */
1259      /**
1260       * @attribute inh
1261       * @aspect AddOptionsToProgram
1262       * @declaredat /home/jesper/git/extendj/java4/frontend/Options.jadd:39
1263       */
1264      @ASTNodeAnnotation.Attribute
1265      public Program program() {
1266        Program program_value = getParent().Define_program(this, null);
1267    
1268        return program_value;
1269      }
1270      /**
1271       * @apilevel internal
1272       */
1273      public ASTNode rewriteTo() {
1274        if (state().peek() == ASTNode$State.REWRITE_CHANGE) {
1275          state().pop();
1276          state().push(ASTNode$State.REWRITE_NOCHANGE);
1277        }
1278        return this;
1279      }
1280      /**
1281       * @apilevel internal
1282       */
1283      public TypeDecl Define_superType(ASTNode caller, ASTNode child) {
1284        ASTNode self = this;
1285        ASTNode parent = getParent();
1286        while (parent != null && !parent.canDefine_superType(self, caller)) {
1287          caller = self;
1288          self = parent;
1289          parent = self.getParent();
1290        }
1291        return parent.Define_superType(self, caller);
1292      }
1293    
1294      /**
1295       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:34
1296       * @apilevel internal
1297       * @return {@code true} if this node has an equation for the inherited attribute superType
1298       */
1299      protected boolean canDefine_superType(ASTNode caller, ASTNode child) {
1300        return false;
1301      }
1302      /**
1303       * @apilevel internal
1304       */
1305      public ConstructorDecl Define_constructorDecl(ASTNode caller, ASTNode child) {
1306        ASTNode self = this;
1307        ASTNode parent = getParent();
1308        while (parent != null && !parent.canDefine_constructorDecl(self, caller)) {
1309          caller = self;
1310          self = parent;
1311          parent = self.getParent();
1312        }
1313        return parent.Define_constructorDecl(self, caller);
1314      }
1315    
1316      /**
1317       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:117
1318       * @apilevel internal
1319       * @return {@code true} if this node has an equation for the inherited attribute constructorDecl
1320       */
1321      protected boolean canDefine_constructorDecl(ASTNode caller, ASTNode child) {
1322        return false;
1323      }
1324      /**
1325       * @apilevel internal
1326       */
1327      public TypeDecl Define_componentType(ASTNode caller, ASTNode child) {
1328        ASTNode self = this;
1329        ASTNode parent = getParent();
1330        while (parent != null && !parent.canDefine_componentType(self, caller)) {
1331          caller = self;
1332          self = parent;
1333          parent = self.getParent();
1334        }
1335        return parent.Define_componentType(self, caller);
1336      }
1337    
1338      /**
1339       * @declaredat /home/jesper/git/extendj/java4/frontend/Arrays.jrag:41
1340       * @apilevel internal
1341       * @return {@code true} if this node has an equation for the inherited attribute componentType
1342       */
1343      protected boolean canDefine_componentType(ASTNode caller, ASTNode child) {
1344        return false;
1345      }
1346      /**
1347       * @apilevel internal
1348       */
1349      public LabeledStmt Define_lookupLabel(ASTNode caller, ASTNode child, String name) {
1350        ASTNode self = this;
1351        ASTNode parent = getParent();
1352        while (parent != null && !parent.canDefine_lookupLabel(self, caller, name)) {
1353          caller = self;
1354          self = parent;
1355          parent = self.getParent();
1356        }
1357        return parent.Define_lookupLabel(self, caller, name);
1358      }
1359    
1360      /**
1361       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:252
1362       * @apilevel internal
1363       * @return {@code true} if this node has an equation for the inherited attribute lookupLabel
1364       */
1365      protected boolean canDefine_lookupLabel(ASTNode caller, ASTNode child, String name) {
1366        return false;
1367      }
1368      /**
1369       * @apilevel internal
1370       */
1371      public int Define_blockIndex(ASTNode caller, ASTNode child) {
1372        ASTNode self = this;
1373        ASTNode parent = getParent();
1374        while (parent != null && !parent.canDefine_blockIndex(self, caller)) {
1375          caller = self;
1376          self = parent;
1377          parent = self.getParent();
1378        }
1379        return parent.Define_blockIndex(self, caller);
1380      }
1381    
1382      /**
1383       * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:36
1384       * @apilevel internal
1385       * @return {@code true} if this node has an equation for the inherited attribute blockIndex
1386       */
1387      protected boolean canDefine_blockIndex(ASTNode caller, ASTNode child) {
1388        return false;
1389      }
1390      /**
1391       * @apilevel internal
1392       */
1393      public boolean Define_isDest(ASTNode caller, ASTNode child) {
1394        ASTNode self = this;
1395        ASTNode parent = getParent();
1396        while (parent != null && !parent.canDefine_isDest(self, caller)) {
1397          caller = self;
1398          self = parent;
1399          parent = self.getParent();
1400        }
1401        return parent.Define_isDest(self, caller);
1402      }
1403    
1404      /**
1405       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:67
1406       * @apilevel internal
1407       * @return {@code true} if this node has an equation for the inherited attribute isDest
1408       */
1409      protected boolean canDefine_isDest(ASTNode caller, ASTNode child) {
1410        return false;
1411      }
1412      /**
1413       * @apilevel internal
1414       */
1415      public boolean Define_isSource(ASTNode caller, ASTNode child) {
1416        ASTNode self = this;
1417        ASTNode parent = getParent();
1418        while (parent != null && !parent.canDefine_isSource(self, caller)) {
1419          caller = self;
1420          self = parent;
1421          parent = self.getParent();
1422        }
1423        return parent.Define_isSource(self, caller);
1424      }
1425    
1426      /**
1427       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:66
1428       * @apilevel internal
1429       * @return {@code true} if this node has an equation for the inherited attribute isSource
1430       */
1431      protected boolean canDefine_isSource(ASTNode caller, ASTNode child) {
1432        return false;
1433      }
1434      /**
1435       * @apilevel internal
1436       */
1437      public boolean Define_isIncOrDec(ASTNode caller, ASTNode child) {
1438        ASTNode self = this;
1439        ASTNode parent = getParent();
1440        while (parent != null && !parent.canDefine_isIncOrDec(self, caller)) {
1441          caller = self;
1442          self = parent;
1443          parent = self.getParent();
1444        }
1445        return parent.Define_isIncOrDec(self, caller);
1446      }
1447    
1448      /**
1449       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:74
1450       * @apilevel internal
1451       * @return {@code true} if this node has an equation for the inherited attribute isIncOrDec
1452       */
1453      protected boolean canDefine_isIncOrDec(ASTNode caller, ASTNode child) {
1454        return false;
1455      }
1456      /**
1457       * @apilevel internal
1458       */
1459      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1460        ASTNode self = this;
1461        ASTNode parent = getParent();
1462        while (parent != null && !parent.canDefine_isDAbefore(self, caller, v)) {
1463          caller = self;
1464          self = parent;
1465          parent = self.getParent();
1466        }
1467        return parent.Define_isDAbefore(self, caller, v);
1468      }
1469    
1470      /**
1471       * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:213
1472       * @apilevel internal
1473       * @return {@code true} if this node has an equation for the inherited attribute isDAbefore
1474       */
1475      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1476        return false;
1477      }
1478      /**
1479       * @apilevel internal
1480       */
1481      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
1482        ASTNode self = this;
1483        ASTNode parent = getParent();
1484        while (parent != null && !parent.canDefine_isDUbefore(self, caller, v)) {
1485          caller = self;
1486          self = parent;
1487          parent = self.getParent();
1488        }
1489        return parent.Define_isDUbefore(self, caller, v);
1490      }
1491    
1492      /**
1493       * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:148
1494       * @apilevel internal
1495       * @return {@code true} if this node has an equation for the inherited attribute isDUbefore
1496       */
1497      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
1498        return false;
1499      }
1500      /**
1501       * @apilevel internal
1502       */
1503      public TypeDecl Define_typeException(ASTNode caller, ASTNode child) {
1504        ASTNode self = this;
1505        ASTNode parent = getParent();
1506        while (parent != null && !parent.canDefine_typeException(self, caller)) {
1507          caller = self;
1508          self = parent;
1509          parent = self.getParent();
1510        }
1511        return parent.Define_typeException(self, caller);
1512      }
1513    
1514      /**
1515       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:40
1516       * @apilevel internal
1517       * @return {@code true} if this node has an equation for the inherited attribute typeException
1518       */
1519      protected boolean canDefine_typeException(ASTNode caller, ASTNode child) {
1520        return false;
1521      }
1522      /**
1523       * @apilevel internal
1524       */
1525      public TypeDecl Define_typeRuntimeException(ASTNode caller, ASTNode child) {
1526        ASTNode self = this;
1527        ASTNode parent = getParent();
1528        while (parent != null && !parent.canDefine_typeRuntimeException(self, caller)) {
1529          caller = self;
1530          self = parent;
1531          parent = self.getParent();
1532        }
1533        return parent.Define_typeRuntimeException(self, caller);
1534      }
1535    
1536      /**
1537       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:42
1538       * @apilevel internal
1539       * @return {@code true} if this node has an equation for the inherited attribute typeRuntimeException
1540       */
1541      protected boolean canDefine_typeRuntimeException(ASTNode caller, ASTNode child) {
1542        return false;
1543      }
1544      /**
1545       * @apilevel internal
1546       */
1547      public TypeDecl Define_typeError(ASTNode caller, ASTNode child) {
1548        ASTNode self = this;
1549        ASTNode parent = getParent();
1550        while (parent != null && !parent.canDefine_typeError(self, caller)) {
1551          caller = self;
1552          self = parent;
1553          parent = self.getParent();
1554        }
1555        return parent.Define_typeError(self, caller);
1556      }
1557    
1558      /**
1559       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:44
1560       * @apilevel internal
1561       * @return {@code true} if this node has an equation for the inherited attribute typeError
1562       */
1563      protected boolean canDefine_typeError(ASTNode caller, ASTNode child) {
1564        return false;
1565      }
1566      /**
1567       * @apilevel internal
1568       */
1569      public TypeDecl Define_typeNullPointerException(ASTNode caller, ASTNode child) {
1570        ASTNode self = this;
1571        ASTNode parent = getParent();
1572        while (parent != null && !parent.canDefine_typeNullPointerException(self, caller)) {
1573          caller = self;
1574          self = parent;
1575          parent = self.getParent();
1576        }
1577        return parent.Define_typeNullPointerException(self, caller);
1578      }
1579    
1580      /**
1581       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:46
1582       * @apilevel internal
1583       * @return {@code true} if this node has an equation for the inherited attribute typeNullPointerException
1584       */
1585      protected boolean canDefine_typeNullPointerException(ASTNode caller, ASTNode child) {
1586        return false;
1587      }
1588      /**
1589       * @apilevel internal
1590       */
1591      public TypeDecl Define_typeThrowable(ASTNode caller, ASTNode child) {
1592        ASTNode self = this;
1593        ASTNode parent = getParent();
1594        while (parent != null && !parent.canDefine_typeThrowable(self, caller)) {
1595          caller = self;
1596          self = parent;
1597          parent = self.getParent();
1598        }
1599        return parent.Define_typeThrowable(self, caller);
1600      }
1601    
1602      /**
1603       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:48
1604       * @apilevel internal
1605       * @return {@code true} if this node has an equation for the inherited attribute typeThrowable
1606       */
1607      protected boolean canDefine_typeThrowable(ASTNode caller, ASTNode child) {
1608        return false;
1609      }
1610      /**
1611       * @apilevel internal
1612       */
1613      public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
1614        ASTNode self = this;
1615        ASTNode parent = getParent();
1616        while (parent != null && !parent.canDefine_handlesException(self, caller, exceptionType)) {
1617          caller = self;
1618          self = parent;
1619          parent = self.getParent();
1620        }
1621        return parent.Define_handlesException(self, caller, exceptionType);
1622      }
1623    
1624      /**
1625       * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:150
1626       * @apilevel internal
1627       * @return {@code true} if this node has an equation for the inherited attribute handlesException
1628       */
1629      protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
1630        return false;
1631      }
1632      /**
1633       * @apilevel internal
1634       */
1635      public Collection Define_lookupConstructor(ASTNode caller, ASTNode child) {
1636        ASTNode self = this;
1637        ASTNode parent = getParent();
1638        while (parent != null && !parent.canDefine_lookupConstructor(self, caller)) {
1639          caller = self;
1640          self = parent;
1641          parent = self.getParent();
1642        }
1643        return parent.Define_lookupConstructor(self, caller);
1644      }
1645    
1646      /**
1647       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:37
1648       * @apilevel internal
1649       * @return {@code true} if this node has an equation for the inherited attribute lookupConstructor
1650       */
1651      protected boolean canDefine_lookupConstructor(ASTNode caller, ASTNode child) {
1652        return false;
1653      }
1654      /**
1655       * @apilevel internal
1656       */
1657      public Collection Define_lookupSuperConstructor(ASTNode caller, ASTNode child) {
1658        ASTNode self = this;
1659        ASTNode parent = getParent();
1660        while (parent != null && !parent.canDefine_lookupSuperConstructor(self, caller)) {
1661          caller = self;
1662          self = parent;
1663          parent = self.getParent();
1664        }
1665        return parent.Define_lookupSuperConstructor(self, caller);
1666      }
1667    
1668      /**
1669       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:41
1670       * @apilevel internal
1671       * @return {@code true} if this node has an equation for the inherited attribute lookupSuperConstructor
1672       */
1673      protected boolean canDefine_lookupSuperConstructor(ASTNode caller, ASTNode child) {
1674        return false;
1675      }
1676      /**
1677       * @apilevel internal
1678       */
1679      public Expr Define_nestedScope(ASTNode caller, ASTNode child) {
1680        ASTNode self = this;
1681        ASTNode parent = getParent();
1682        while (parent != null && !parent.canDefine_nestedScope(self, caller)) {
1683          caller = self;
1684          self = parent;
1685          parent = self.getParent();
1686        }
1687        return parent.Define_nestedScope(self, caller);
1688      }
1689    
1690      /**
1691       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:42
1692       * @apilevel internal
1693       * @return {@code true} if this node has an equation for the inherited attribute nestedScope
1694       */
1695      protected boolean canDefine_nestedScope(ASTNode caller, ASTNode child) {
1696        return false;
1697      }
1698      /**
1699       * @apilevel internal
1700       */
1701      public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) {
1702        ASTNode self = this;
1703        ASTNode parent = getParent();
1704        while (parent != null && !parent.canDefine_lookupMethod(self, caller, name)) {
1705          caller = self;
1706          self = parent;
1707          parent = self.getParent();
1708        }
1709        return parent.Define_lookupMethod(self, caller, name);
1710      }
1711    
1712      /**
1713       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:81
1714       * @apilevel internal
1715       * @return {@code true} if this node has an equation for the inherited attribute lookupMethod
1716       */
1717      protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) {
1718        return false;
1719      }
1720      /**
1721       * @apilevel internal
1722       */
1723      public TypeDecl Define_typeObject(ASTNode caller, ASTNode child) {
1724        ASTNode self = this;
1725        ASTNode parent = getParent();
1726        while (parent != null && !parent.canDefine_typeObject(self, caller)) {
1727          caller = self;
1728          self = parent;
1729          parent = self.getParent();
1730        }
1731        return parent.Define_typeObject(self, caller);
1732      }
1733    
1734      /**
1735       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:41
1736       * @apilevel internal
1737       * @return {@code true} if this node has an equation for the inherited attribute typeObject
1738       */
1739      protected boolean canDefine_typeObject(ASTNode caller, ASTNode child) {
1740        return false;
1741      }
1742      /**
1743       * @apilevel internal
1744       */
1745      public TypeDecl Define_typeCloneable(ASTNode caller, ASTNode child) {
1746        ASTNode self = this;
1747        ASTNode parent = getParent();
1748        while (parent != null && !parent.canDefine_typeCloneable(self, caller)) {
1749          caller = self;
1750          self = parent;
1751          parent = self.getParent();
1752        }
1753        return parent.Define_typeCloneable(self, caller);
1754      }
1755    
1756      /**
1757       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:42
1758       * @apilevel internal
1759       * @return {@code true} if this node has an equation for the inherited attribute typeCloneable
1760       */
1761      protected boolean canDefine_typeCloneable(ASTNode caller, ASTNode child) {
1762        return false;
1763      }
1764      /**
1765       * @apilevel internal
1766       */
1767      public TypeDecl Define_typeSerializable(ASTNode caller, ASTNode child) {
1768        ASTNode self = this;
1769        ASTNode parent = getParent();
1770        while (parent != null && !parent.canDefine_typeSerializable(self, caller)) {
1771          caller = self;
1772          self = parent;
1773          parent = self.getParent();
1774        }
1775        return parent.Define_typeSerializable(self, caller);
1776      }
1777    
1778      /**
1779       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:43
1780       * @apilevel internal
1781       * @return {@code true} if this node has an equation for the inherited attribute typeSerializable
1782       */
1783      protected boolean canDefine_typeSerializable(ASTNode caller, ASTNode child) {
1784        return false;
1785      }
1786      /**
1787       * @apilevel internal
1788       */
1789      public TypeDecl Define_typeBoolean(ASTNode caller, ASTNode child) {
1790        ASTNode self = this;
1791        ASTNode parent = getParent();
1792        while (parent != null && !parent.canDefine_typeBoolean(self, caller)) {
1793          caller = self;
1794          self = parent;
1795          parent = self.getParent();
1796        }
1797        return parent.Define_typeBoolean(self, caller);
1798      }
1799    
1800      /**
1801       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:55
1802       * @apilevel internal
1803       * @return {@code true} if this node has an equation for the inherited attribute typeBoolean
1804       */
1805      protected boolean canDefine_typeBoolean(ASTNode caller, ASTNode child) {
1806        return false;
1807      }
1808      /**
1809       * @apilevel internal
1810       */
1811      public TypeDecl Define_typeByte(ASTNode caller, ASTNode child) {
1812        ASTNode self = this;
1813        ASTNode parent = getParent();
1814        while (parent != null && !parent.canDefine_typeByte(self, caller)) {
1815          caller = self;
1816          self = parent;
1817          parent = self.getParent();
1818        }
1819        return parent.Define_typeByte(self, caller);
1820      }
1821    
1822      /**
1823       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:56
1824       * @apilevel internal
1825       * @return {@code true} if this node has an equation for the inherited attribute typeByte
1826       */
1827      protected boolean canDefine_typeByte(ASTNode caller, ASTNode child) {
1828        return false;
1829      }
1830      /**
1831       * @apilevel internal
1832       */
1833      public TypeDecl Define_typeShort(ASTNode caller, ASTNode child) {
1834        ASTNode self = this;
1835        ASTNode parent = getParent();
1836        while (parent != null && !parent.canDefine_typeShort(self, caller)) {
1837          caller = self;
1838          self = parent;
1839          parent = self.getParent();
1840        }
1841        return parent.Define_typeShort(self, caller);
1842      }
1843    
1844      /**
1845       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:57
1846       * @apilevel internal
1847       * @return {@code true} if this node has an equation for the inherited attribute typeShort
1848       */
1849      protected boolean canDefine_typeShort(ASTNode caller, ASTNode child) {
1850        return false;
1851      }
1852      /**
1853       * @apilevel internal
1854       */
1855      public TypeDecl Define_typeChar(ASTNode caller, ASTNode child) {
1856        ASTNode self = this;
1857        ASTNode parent = getParent();
1858        while (parent != null && !parent.canDefine_typeChar(self, caller)) {
1859          caller = self;
1860          self = parent;
1861          parent = self.getParent();
1862        }
1863        return parent.Define_typeChar(self, caller);
1864      }
1865    
1866      /**
1867       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:58
1868       * @apilevel internal
1869       * @return {@code true} if this node has an equation for the inherited attribute typeChar
1870       */
1871      protected boolean canDefine_typeChar(ASTNode caller, ASTNode child) {
1872        return false;
1873      }
1874      /**
1875       * @apilevel internal
1876       */
1877      public TypeDecl Define_typeInt(ASTNode caller, ASTNode child) {
1878        ASTNode self = this;
1879        ASTNode parent = getParent();
1880        while (parent != null && !parent.canDefine_typeInt(self, caller)) {
1881          caller = self;
1882          self = parent;
1883          parent = self.getParent();
1884        }
1885        return parent.Define_typeInt(self, caller);
1886      }
1887    
1888      /**
1889       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:59
1890       * @apilevel internal
1891       * @return {@code true} if this node has an equation for the inherited attribute typeInt
1892       */
1893      protected boolean canDefine_typeInt(ASTNode caller, ASTNode child) {
1894        return false;
1895      }
1896      /**
1897       * @apilevel internal
1898       */
1899      public TypeDecl Define_typeLong(ASTNode caller, ASTNode child) {
1900        ASTNode self = this;
1901        ASTNode parent = getParent();
1902        while (parent != null && !parent.canDefine_typeLong(self, caller)) {
1903          caller = self;
1904          self = parent;
1905          parent = self.getParent();
1906        }
1907        return parent.Define_typeLong(self, caller);
1908      }
1909    
1910      /**
1911       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:60
1912       * @apilevel internal
1913       * @return {@code true} if this node has an equation for the inherited attribute typeLong
1914       */
1915      protected boolean canDefine_typeLong(ASTNode caller, ASTNode child) {
1916        return false;
1917      }
1918      /**
1919       * @apilevel internal
1920       */
1921      public TypeDecl Define_typeFloat(ASTNode caller, ASTNode child) {
1922        ASTNode self = this;
1923        ASTNode parent = getParent();
1924        while (parent != null && !parent.canDefine_typeFloat(self, caller)) {
1925          caller = self;
1926          self = parent;
1927          parent = self.getParent();
1928        }
1929        return parent.Define_typeFloat(self, caller);
1930      }
1931    
1932      /**
1933       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:61
1934       * @apilevel internal
1935       * @return {@code true} if this node has an equation for the inherited attribute typeFloat
1936       */
1937      protected boolean canDefine_typeFloat(ASTNode caller, ASTNode child) {
1938        return false;
1939      }
1940      /**
1941       * @apilevel internal
1942       */
1943      public TypeDecl Define_typeDouble(ASTNode caller, ASTNode child) {
1944        ASTNode self = this;
1945        ASTNode parent = getParent();
1946        while (parent != null && !parent.canDefine_typeDouble(self, caller)) {
1947          caller = self;
1948          self = parent;
1949          parent = self.getParent();
1950        }
1951        return parent.Define_typeDouble(self, caller);
1952      }
1953    
1954      /**
1955       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:62
1956       * @apilevel internal
1957       * @return {@code true} if this node has an equation for the inherited attribute typeDouble
1958       */
1959      protected boolean canDefine_typeDouble(ASTNode caller, ASTNode child) {
1960        return false;
1961      }
1962      /**
1963       * @apilevel internal
1964       */
1965      public TypeDecl Define_typeString(ASTNode caller, ASTNode child) {
1966        ASTNode self = this;
1967        ASTNode parent = getParent();
1968        while (parent != null && !parent.canDefine_typeString(self, caller)) {
1969          caller = self;
1970          self = parent;
1971          parent = self.getParent();
1972        }
1973        return parent.Define_typeString(self, caller);
1974      }
1975    
1976      /**
1977       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:63
1978       * @apilevel internal
1979       * @return {@code true} if this node has an equation for the inherited attribute typeString
1980       */
1981      protected boolean canDefine_typeString(ASTNode caller, ASTNode child) {
1982        return false;
1983      }
1984      /**
1985       * @apilevel internal
1986       */
1987      public TypeDecl Define_typeVoid(ASTNode caller, ASTNode child) {
1988        ASTNode self = this;
1989        ASTNode parent = getParent();
1990        while (parent != null && !parent.canDefine_typeVoid(self, caller)) {
1991          caller = self;
1992          self = parent;
1993          parent = self.getParent();
1994        }
1995        return parent.Define_typeVoid(self, caller);
1996      }
1997    
1998      /**
1999       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:66
2000       * @apilevel internal
2001       * @return {@code true} if this node has an equation for the inherited attribute typeVoid
2002       */
2003      protected boolean canDefine_typeVoid(ASTNode caller, ASTNode child) {
2004        return false;
2005      }
2006      /**
2007       * @apilevel internal
2008       */
2009      public TypeDecl Define_typeNull(ASTNode caller, ASTNode child) {
2010        ASTNode self = this;
2011        ASTNode parent = getParent();
2012        while (parent != null && !parent.canDefine_typeNull(self, caller)) {
2013          caller = self;
2014          self = parent;
2015          parent = self.getParent();
2016        }
2017        return parent.Define_typeNull(self, caller);
2018      }
2019    
2020      /**
2021       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:69
2022       * @apilevel internal
2023       * @return {@code true} if this node has an equation for the inherited attribute typeNull
2024       */
2025      protected boolean canDefine_typeNull(ASTNode caller, ASTNode child) {
2026        return false;
2027      }
2028      /**
2029       * @apilevel internal
2030       */
2031      public TypeDecl Define_unknownType(ASTNode caller, ASTNode child) {
2032        ASTNode self = this;
2033        ASTNode parent = getParent();
2034        while (parent != null && !parent.canDefine_unknownType(self, caller)) {
2035          caller = self;
2036          self = parent;
2037          parent = self.getParent();
2038        }
2039        return parent.Define_unknownType(self, caller);
2040      }
2041    
2042      /**
2043       * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:33
2044       * @apilevel internal
2045       * @return {@code true} if this node has an equation for the inherited attribute unknownType
2046       */
2047      protected boolean canDefine_unknownType(ASTNode caller, ASTNode child) {
2048        return false;
2049      }
2050      /**
2051       * @apilevel internal
2052       */
2053      public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) {
2054        ASTNode self = this;
2055        ASTNode parent = getParent();
2056        while (parent != null && !parent.canDefine_hasPackage(self, caller, packageName)) {
2057          caller = self;
2058          self = parent;
2059          parent = self.getParent();
2060        }
2061        return parent.Define_hasPackage(self, caller, packageName);
2062      }
2063    
2064      /**
2065       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:126
2066       * @apilevel internal
2067       * @return {@code true} if this node has an equation for the inherited attribute hasPackage
2068       */
2069      protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) {
2070        return false;
2071      }
2072      /**
2073       * @apilevel internal
2074       */
2075      public TypeDecl Define_lookupType(ASTNode caller, ASTNode child, String packageName, String typeName) {
2076        ASTNode self = this;
2077        ASTNode parent = getParent();
2078        while (parent != null && !parent.canDefine_lookupType(self, caller, packageName, typeName)) {
2079          caller = self;
2080          self = parent;
2081          parent = self.getParent();
2082        }
2083        return parent.Define_lookupType(self, caller, packageName, typeName);
2084      }
2085    
2086      /**
2087       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:140
2088       * @apilevel internal
2089       * @return {@code true} if this node has an equation for the inherited attribute lookupType
2090       */
2091      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String packageName, String typeName) {
2092        return false;
2093      }
2094      /**
2095       * @apilevel internal
2096       */
2097      public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) {
2098        ASTNode self = this;
2099        ASTNode parent = getParent();
2100        while (parent != null && !parent.canDefine_lookupType(self, caller, name)) {
2101          caller = self;
2102          self = parent;
2103          parent = self.getParent();
2104        }
2105        return parent.Define_lookupType(self, caller, name);
2106      }
2107    
2108      /**
2109       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:332
2110       * @apilevel internal
2111       * @return {@code true} if this node has an equation for the inherited attribute lookupType
2112       */
2113      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) {
2114        return false;
2115      }
2116      /**
2117       * @apilevel internal
2118       */
2119      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
2120        ASTNode self = this;
2121        ASTNode parent = getParent();
2122        while (parent != null && !parent.canDefine_lookupVariable(self, caller, name)) {
2123          caller = self;
2124          self = parent;
2125          parent = self.getParent();
2126        }
2127        return parent.Define_lookupVariable(self, caller, name);
2128      }
2129    
2130      /**
2131       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:33
2132       * @apilevel internal
2133       * @return {@code true} if this node has an equation for the inherited attribute lookupVariable
2134       */
2135      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
2136        return false;
2137      }
2138      /**
2139       * @apilevel internal
2140       */
2141      public boolean Define_mayBePublic(ASTNode caller, ASTNode child) {
2142        ASTNode self = this;
2143        ASTNode parent = getParent();
2144        while (parent != null && !parent.canDefine_mayBePublic(self, caller)) {
2145          caller = self;
2146          self = parent;
2147          parent = self.getParent();
2148        }
2149        return parent.Define_mayBePublic(self, caller);
2150      }
2151    
2152      /**
2153       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:312
2154       * @apilevel internal
2155       * @return {@code true} if this node has an equation for the inherited attribute mayBePublic
2156       */
2157      protected boolean canDefine_mayBePublic(ASTNode caller, ASTNode child) {
2158        return false;
2159      }
2160      /**
2161       * @apilevel internal
2162       */
2163      public boolean Define_mayBeProtected(ASTNode caller, ASTNode child) {
2164        ASTNode self = this;
2165        ASTNode parent = getParent();
2166        while (parent != null && !parent.canDefine_mayBeProtected(self, caller)) {
2167          caller = self;
2168          self = parent;
2169          parent = self.getParent();
2170        }
2171        return parent.Define_mayBeProtected(self, caller);
2172      }
2173    
2174      /**
2175       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:313
2176       * @apilevel internal
2177       * @return {@code true} if this node has an equation for the inherited attribute mayBeProtected
2178       */
2179      protected boolean canDefine_mayBeProtected(ASTNode caller, ASTNode child) {
2180        return false;
2181      }
2182      /**
2183       * @apilevel internal
2184       */
2185      public boolean Define_mayBePrivate(ASTNode caller, ASTNode child) {
2186        ASTNode self = this;
2187        ASTNode parent = getParent();
2188        while (parent != null && !parent.canDefine_mayBePrivate(self, caller)) {
2189          caller = self;
2190          self = parent;
2191          parent = self.getParent();
2192        }
2193        return parent.Define_mayBePrivate(self, caller);
2194      }
2195    
2196      /**
2197       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:314
2198       * @apilevel internal
2199       * @return {@code true} if this node has an equation for the inherited attribute mayBePrivate
2200       */
2201      protected boolean canDefine_mayBePrivate(ASTNode caller, ASTNode child) {
2202        return false;
2203      }
2204      /**
2205       * @apilevel internal
2206       */
2207      public boolean Define_mayBeStatic(ASTNode caller, ASTNode child) {
2208        ASTNode self = this;
2209        ASTNode parent = getParent();
2210        while (parent != null && !parent.canDefine_mayBeStatic(self, caller)) {
2211          caller = self;
2212          self = parent;
2213          parent = self.getParent();
2214        }
2215        return parent.Define_mayBeStatic(self, caller);
2216      }
2217    
2218      /**
2219       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:62
2220       * @apilevel internal
2221       * @return {@code true} if this node has an equation for the inherited attribute mayBeStatic
2222       */
2223      protected boolean canDefine_mayBeStatic(ASTNode caller, ASTNode child) {
2224        return false;
2225      }
2226      /**
2227       * @apilevel internal
2228       */
2229      public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) {
2230        ASTNode self = this;
2231        ASTNode parent = getParent();
2232        while (parent != null && !parent.canDefine_mayBeFinal(self, caller)) {
2233          caller = self;
2234          self = parent;
2235          parent = self.getParent();
2236        }
2237        return parent.Define_mayBeFinal(self, caller);
2238      }
2239    
2240      /**
2241       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:335
2242       * @apilevel internal
2243       * @return {@code true} if this node has an equation for the inherited attribute mayBeFinal
2244       */
2245      protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) {
2246        return false;
2247      }
2248      /**
2249       * @apilevel internal
2250       */
2251      public boolean Define_mayBeAbstract(ASTNode caller, ASTNode child) {
2252        ASTNode self = this;
2253        ASTNode parent = getParent();
2254        while (parent != null && !parent.canDefine_mayBeAbstract(self, caller)) {
2255          caller = self;
2256          self = parent;
2257          parent = self.getParent();
2258        }
2259        return parent.Define_mayBeAbstract(self, caller);
2260      }
2261    
2262      /**
2263       * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:55
2264       * @apilevel internal
2265       * @return {@code true} if this node has an equation for the inherited attribute mayBeAbstract
2266       */
2267      protected boolean canDefine_mayBeAbstract(ASTNode caller, ASTNode child) {
2268        return false;
2269      }
2270      /**
2271       * @apilevel internal
2272       */
2273      public boolean Define_mayBeVolatile(ASTNode caller, ASTNode child) {
2274        ASTNode self = this;
2275        ASTNode parent = getParent();
2276        while (parent != null && !parent.canDefine_mayBeVolatile(self, caller)) {
2277          caller = self;
2278          self = parent;
2279          parent = self.getParent();
2280        }
2281        return parent.Define_mayBeVolatile(self, caller);
2282      }
2283    
2284      /**
2285       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:309
2286       * @apilevel internal
2287       * @return {@code true} if this node has an equation for the inherited attribute mayBeVolatile
2288       */
2289      protected boolean canDefine_mayBeVolatile(ASTNode caller, ASTNode child) {
2290        return false;
2291      }
2292      /**
2293       * @apilevel internal
2294       */
2295      public boolean Define_mayBeTransient(ASTNode caller, ASTNode child) {
2296        ASTNode self = this;
2297        ASTNode parent = getParent();
2298        while (parent != null && !parent.canDefine_mayBeTransient(self, caller)) {
2299          caller = self;
2300          self = parent;
2301          parent = self.getParent();
2302        }
2303        return parent.Define_mayBeTransient(self, caller);
2304      }
2305    
2306      /**
2307       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:308
2308       * @apilevel internal
2309       * @return {@code true} if this node has an equation for the inherited attribute mayBeTransient
2310       */
2311      protected boolean canDefine_mayBeTransient(ASTNode caller, ASTNode child) {
2312        return false;
2313      }
2314      /**
2315       * @apilevel internal
2316       */
2317      public boolean Define_mayBeStrictfp(ASTNode caller, ASTNode child) {
2318        ASTNode self = this;
2319        ASTNode parent = getParent();
2320        while (parent != null && !parent.canDefine_mayBeStrictfp(self, caller)) {
2321          caller = self;
2322          self = parent;
2323          parent = self.getParent();
2324        }
2325        return parent.Define_mayBeStrictfp(self, caller);
2326      }
2327    
2328      /**
2329       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:320
2330       * @apilevel internal
2331       * @return {@code true} if this node has an equation for the inherited attribute mayBeStrictfp
2332       */
2333      protected boolean canDefine_mayBeStrictfp(ASTNode caller, ASTNode child) {
2334        return false;
2335      }
2336      /**
2337       * @apilevel internal
2338       */
2339      public boolean Define_mayBeSynchronized(ASTNode caller, ASTNode child) {
2340        ASTNode self = this;
2341        ASTNode parent = getParent();
2342        while (parent != null && !parent.canDefine_mayBeSynchronized(self, caller)) {
2343          caller = self;
2344          self = parent;
2345          parent = self.getParent();
2346        }
2347        return parent.Define_mayBeSynchronized(self, caller);
2348      }
2349    
2350      /**
2351       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:318
2352       * @apilevel internal
2353       * @return {@code true} if this node has an equation for the inherited attribute mayBeSynchronized
2354       */
2355      protected boolean canDefine_mayBeSynchronized(ASTNode caller, ASTNode child) {
2356        return false;
2357      }
2358      /**
2359       * @apilevel internal
2360       */
2361      public boolean Define_mayBeNative(ASTNode caller, ASTNode child) {
2362        ASTNode self = this;
2363        ASTNode parent = getParent();
2364        while (parent != null && !parent.canDefine_mayBeNative(self, caller)) {
2365          caller = self;
2366          self = parent;
2367          parent = self.getParent();
2368        }
2369        return parent.Define_mayBeNative(self, caller);
2370      }
2371    
2372      /**
2373       * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:319
2374       * @apilevel internal
2375       * @return {@code true} if this node has an equation for the inherited attribute mayBeNative
2376       */
2377      protected boolean canDefine_mayBeNative(ASTNode caller, ASTNode child) {
2378        return false;
2379      }
2380      /**
2381       * @apilevel internal
2382       */
2383      public ASTNode Define_enclosingBlock(ASTNode caller, ASTNode child) {
2384        ASTNode self = this;
2385        ASTNode parent = getParent();
2386        while (parent != null && !parent.canDefine_enclosingBlock(self, caller)) {
2387          caller = self;
2388          self = parent;
2389          parent = self.getParent();
2390        }
2391        return parent.Define_enclosingBlock(self, caller);
2392      }
2393    
2394      /**
2395       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:311
2396       * @apilevel internal
2397       * @return {@code true} if this node has an equation for the inherited attribute enclosingBlock
2398       */
2399      protected boolean canDefine_enclosingBlock(ASTNode caller, ASTNode child) {
2400        return false;
2401      }
2402      /**
2403       * @apilevel internal
2404       */
2405      public VariableScope Define_outerScope(ASTNode caller, ASTNode child) {
2406        ASTNode self = this;
2407        ASTNode parent = getParent();
2408        while (parent != null && !parent.canDefine_outerScope(self, caller)) {
2409          caller = self;
2410          self = parent;
2411          parent = self.getParent();
2412        }
2413        return parent.Define_outerScope(self, caller);
2414      }
2415    
2416      /**
2417       * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:35
2418       * @apilevel internal
2419       * @return {@code true} if this node has an equation for the inherited attribute outerScope
2420       */
2421      protected boolean canDefine_outerScope(ASTNode caller, ASTNode child) {
2422        return false;
2423      }
2424      /**
2425       * @apilevel internal
2426       */
2427      public boolean Define_insideLoop(ASTNode caller, ASTNode child) {
2428        ASTNode self = this;
2429        ASTNode parent = getParent();
2430        while (parent != null && !parent.canDefine_insideLoop(self, caller)) {
2431          caller = self;
2432          self = parent;
2433          parent = self.getParent();
2434        }
2435        return parent.Define_insideLoop(self, caller);
2436      }
2437    
2438      /**
2439       * @declaredat /home/jesper/git/extendj/java5/frontend/EnhancedFor.jrag:150
2440       * @apilevel internal
2441       * @return {@code true} if this node has an equation for the inherited attribute insideLoop
2442       */
2443      protected boolean canDefine_insideLoop(ASTNode caller, ASTNode child) {
2444        return false;
2445      }
2446      /**
2447       * @apilevel internal
2448       */
2449      public boolean Define_insideSwitch(ASTNode caller, ASTNode child) {
2450        ASTNode self = this;
2451        ASTNode parent = getParent();
2452        while (parent != null && !parent.canDefine_insideSwitch(self, caller)) {
2453          caller = self;
2454          self = parent;
2455          parent = self.getParent();
2456        }
2457        return parent.Define_insideSwitch(self, caller);
2458      }
2459    
2460      /**
2461       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:452
2462       * @apilevel internal
2463       * @return {@code true} if this node has an equation for the inherited attribute insideSwitch
2464       */
2465      protected boolean canDefine_insideSwitch(ASTNode caller, ASTNode child) {
2466        return false;
2467      }
2468      /**
2469       * @apilevel internal
2470       */
2471      public Case Define_bind(ASTNode caller, ASTNode child, Case c) {
2472        ASTNode self = this;
2473        ASTNode parent = getParent();
2474        while (parent != null && !parent.canDefine_bind(self, caller, c)) {
2475          caller = self;
2476          self = parent;
2477          parent = self.getParent();
2478        }
2479        return parent.Define_bind(self, caller, c);
2480      }
2481    
2482      /**
2483       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:497
2484       * @apilevel internal
2485       * @return {@code true} if this node has an equation for the inherited attribute bind
2486       */
2487      protected boolean canDefine_bind(ASTNode caller, ASTNode child, Case c) {
2488        return false;
2489      }
2490      /**
2491       * @apilevel internal
2492       */
2493      public Program Define_program(ASTNode caller, ASTNode child) {
2494        ASTNode self = this;
2495        ASTNode parent = getParent();
2496        while (parent != null && !parent.canDefine_program(self, caller)) {
2497          caller = self;
2498          self = parent;
2499          parent = self.getParent();
2500        }
2501        return parent.Define_program(self, caller);
2502      }
2503    
2504      /**
2505       * @declaredat /home/jesper/git/extendj/java4/frontend/Options.jadd:40
2506       * @apilevel internal
2507       * @return {@code true} if this node has an equation for the inherited attribute program
2508       */
2509      protected boolean canDefine_program(ASTNode caller, ASTNode child) {
2510        return false;
2511      }
2512      /**
2513       * @apilevel internal
2514       */
2515      public NameType Define_nameType(ASTNode caller, ASTNode child) {
2516        ASTNode self = this;
2517        ASTNode parent = getParent();
2518        while (parent != null && !parent.canDefine_nameType(self, caller)) {
2519          caller = self;
2520          self = parent;
2521          parent = self.getParent();
2522        }
2523        return parent.Define_nameType(self, caller);
2524      }
2525    
2526      /**
2527       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodReference.jrag:196
2528       * @apilevel internal
2529       * @return {@code true} if this node has an equation for the inherited attribute nameType
2530       */
2531      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
2532        return false;
2533      }
2534      /**
2535       * @apilevel internal
2536       */
2537      public boolean Define_isAnonymous(ASTNode caller, ASTNode child) {
2538        ASTNode self = this;
2539        ASTNode parent = getParent();
2540        while (parent != null && !parent.canDefine_isAnonymous(self, caller)) {
2541          caller = self;
2542          self = parent;
2543          parent = self.getParent();
2544        }
2545        return parent.Define_isAnonymous(self, caller);
2546      }
2547    
2548      /**
2549       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:242
2550       * @apilevel internal
2551       * @return {@code true} if this node has an equation for the inherited attribute isAnonymous
2552       */
2553      protected boolean canDefine_isAnonymous(ASTNode caller, ASTNode child) {
2554        return false;
2555      }
2556      /**
2557       * @apilevel internal
2558       */
2559      public Variable Define_unknownField(ASTNode caller, ASTNode child) {
2560        ASTNode self = this;
2561        ASTNode parent = getParent();
2562        while (parent != null && !parent.canDefine_unknownField(self, caller)) {
2563          caller = self;
2564          self = parent;
2565          parent = self.getParent();
2566        }
2567        return parent.Define_unknownField(self, caller);
2568      }
2569    
2570      /**
2571       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:257
2572       * @apilevel internal
2573       * @return {@code true} if this node has an equation for the inherited attribute unknownField
2574       */
2575      protected boolean canDefine_unknownField(ASTNode caller, ASTNode child) {
2576        return false;
2577      }
2578      /**
2579       * @apilevel internal
2580       */
2581      public MethodDecl Define_unknownMethod(ASTNode caller, ASTNode child) {
2582        ASTNode self = this;
2583        ASTNode parent = getParent();
2584        while (parent != null && !parent.canDefine_unknownMethod(self, caller)) {
2585          caller = self;
2586          self = parent;
2587          parent = self.getParent();
2588        }
2589        return parent.Define_unknownMethod(self, caller);
2590      }
2591    
2592      /**
2593       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:261
2594       * @apilevel internal
2595       * @return {@code true} if this node has an equation for the inherited attribute unknownMethod
2596       */
2597      protected boolean canDefine_unknownMethod(ASTNode caller, ASTNode child) {
2598        return false;
2599      }
2600      /**
2601       * @apilevel internal
2602       */
2603      public ConstructorDecl Define_unknownConstructor(ASTNode caller, ASTNode child) {
2604        ASTNode self = this;
2605        ASTNode parent = getParent();
2606        while (parent != null && !parent.canDefine_unknownConstructor(self, caller)) {
2607          caller = self;
2608          self = parent;
2609          parent = self.getParent();
2610        }
2611        return parent.Define_unknownConstructor(self, caller);
2612      }
2613    
2614      /**
2615       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:268
2616       * @apilevel internal
2617       * @return {@code true} if this node has an equation for the inherited attribute unknownConstructor
2618       */
2619      protected boolean canDefine_unknownConstructor(ASTNode caller, ASTNode child) {
2620        return false;
2621      }
2622      /**
2623       * @apilevel internal
2624       */
2625      public TypeDecl Define_declType(ASTNode caller, ASTNode child) {
2626        ASTNode self = this;
2627        ASTNode parent = getParent();
2628        while (parent != null && !parent.canDefine_declType(self, caller)) {
2629          caller = self;
2630          self = parent;
2631          parent = self.getParent();
2632        }
2633        return parent.Define_declType(self, caller);
2634      }
2635    
2636      /**
2637       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:604
2638       * @apilevel internal
2639       * @return {@code true} if this node has an equation for the inherited attribute declType
2640       */
2641      protected boolean canDefine_declType(ASTNode caller, ASTNode child) {
2642        return false;
2643      }
2644      /**
2645       * @apilevel internal
2646       */
2647      public BodyDecl Define_enclosingBodyDecl(ASTNode caller, ASTNode child) {
2648        ASTNode self = this;
2649        ASTNode parent = getParent();
2650        while (parent != null && !parent.canDefine_enclosingBodyDecl(self, caller)) {
2651          caller = self;
2652          self = parent;
2653          parent = self.getParent();
2654        }
2655        return parent.Define_enclosingBodyDecl(self, caller);
2656      }
2657    
2658      /**
2659       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:565
2660       * @apilevel internal
2661       * @return {@code true} if this node has an equation for the inherited attribute enclosingBodyDecl
2662       */
2663      protected boolean canDefine_enclosingBodyDecl(ASTNode caller, ASTNode child) {
2664        return false;
2665      }
2666      /**
2667       * @apilevel internal
2668       */
2669      public boolean Define_isMemberType(ASTNode caller, ASTNode child) {
2670        ASTNode self = this;
2671        ASTNode parent = getParent();
2672        while (parent != null && !parent.canDefine_isMemberType(self, caller)) {
2673          caller = self;
2674          self = parent;
2675          parent = self.getParent();
2676        }
2677        return parent.Define_isMemberType(self, caller);
2678      }
2679    
2680      /**
2681       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:579
2682       * @apilevel internal
2683       * @return {@code true} if this node has an equation for the inherited attribute isMemberType
2684       */
2685      protected boolean canDefine_isMemberType(ASTNode caller, ASTNode child) {
2686        return false;
2687      }
2688      /**
2689       * @apilevel internal
2690       */
2691      public TypeDecl Define_hostType(ASTNode caller, ASTNode child) {
2692        ASTNode self = this;
2693        ASTNode parent = getParent();
2694        while (parent != null && !parent.canDefine_hostType(self, caller)) {
2695          caller = self;
2696          self = parent;
2697          parent = self.getParent();
2698        }
2699        return parent.Define_hostType(self, caller);
2700      }
2701    
2702      /**
2703       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:632
2704       * @apilevel internal
2705       * @return {@code true} if this node has an equation for the inherited attribute hostType
2706       */
2707      protected boolean canDefine_hostType(ASTNode caller, ASTNode child) {
2708        return false;
2709      }
2710      /**
2711       * @apilevel internal
2712       */
2713      public TypeDecl Define_switchType(ASTNode caller, ASTNode child) {
2714        ASTNode self = this;
2715        ASTNode parent = getParent();
2716        while (parent != null && !parent.canDefine_switchType(self, caller)) {
2717          caller = self;
2718          self = parent;
2719          parent = self.getParent();
2720        }
2721        return parent.Define_switchType(self, caller);
2722      }
2723    
2724      /**
2725       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:421
2726       * @apilevel internal
2727       * @return {@code true} if this node has an equation for the inherited attribute switchType
2728       */
2729      protected boolean canDefine_switchType(ASTNode caller, ASTNode child) {
2730        return false;
2731      }
2732      /**
2733       * @apilevel internal
2734       */
2735      public TypeDecl Define_returnType(ASTNode caller, ASTNode child) {
2736        ASTNode self = this;
2737        ASTNode parent = getParent();
2738        while (parent != null && !parent.canDefine_returnType(self, caller)) {
2739          caller = self;
2740          self = parent;
2741          parent = self.getParent();
2742        }
2743        return parent.Define_returnType(self, caller);
2744      }
2745    
2746      /**
2747       * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:38
2748       * @apilevel internal
2749       * @return {@code true} if this node has an equation for the inherited attribute returnType
2750       */
2751      protected boolean canDefine_returnType(ASTNode caller, ASTNode child) {
2752        return false;
2753      }
2754      /**
2755       * @apilevel internal
2756       */
2757      public TypeDecl Define_enclosingInstance(ASTNode caller, ASTNode child) {
2758        ASTNode self = this;
2759        ASTNode parent = getParent();
2760        while (parent != null && !parent.canDefine_enclosingInstance(self, caller)) {
2761          caller = self;
2762          self = parent;
2763          parent = self.getParent();
2764        }
2765        return parent.Define_enclosingInstance(self, caller);
2766      }
2767    
2768      /**
2769       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:601
2770       * @apilevel internal
2771       * @return {@code true} if this node has an equation for the inherited attribute enclosingInstance
2772       */
2773      protected boolean canDefine_enclosingInstance(ASTNode caller, ASTNode child) {
2774        return false;
2775      }
2776      /**
2777       * @apilevel internal
2778       */
2779      public String Define_methodHost(ASTNode caller, ASTNode child) {
2780        ASTNode self = this;
2781        ASTNode parent = getParent();
2782        while (parent != null && !parent.canDefine_methodHost(self, caller)) {
2783          caller = self;
2784          self = parent;
2785          parent = self.getParent();
2786        }
2787        return parent.Define_methodHost(self, caller);
2788      }
2789    
2790      /**
2791       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:652
2792       * @apilevel internal
2793       * @return {@code true} if this node has an equation for the inherited attribute methodHost
2794       */
2795      protected boolean canDefine_methodHost(ASTNode caller, ASTNode child) {
2796        return false;
2797      }
2798      /**
2799       * @apilevel internal
2800       */
2801      public boolean Define_inExplicitConstructorInvocation(ASTNode caller, ASTNode child) {
2802        ASTNode self = this;
2803        ASTNode parent = getParent();
2804        while (parent != null && !parent.canDefine_inExplicitConstructorInvocation(self, caller)) {
2805          caller = self;
2806          self = parent;
2807          parent = self.getParent();
2808        }
2809        return parent.Define_inExplicitConstructorInvocation(self, caller);
2810      }
2811    
2812      /**
2813       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:171
2814       * @apilevel internal
2815       * @return {@code true} if this node has an equation for the inherited attribute inExplicitConstructorInvocation
2816       */
2817      protected boolean canDefine_inExplicitConstructorInvocation(ASTNode caller, ASTNode child) {
2818        return false;
2819      }
2820      /**
2821       * @apilevel internal
2822       */
2823      public TypeDecl Define_enclosingExplicitConstructorHostType(ASTNode caller, ASTNode child) {
2824        ASTNode self = this;
2825        ASTNode parent = getParent();
2826        while (parent != null && !parent.canDefine_enclosingExplicitConstructorHostType(self, caller)) {
2827          caller = self;
2828          self = parent;
2829          parent = self.getParent();
2830        }
2831        return parent.Define_enclosingExplicitConstructorHostType(self, caller);
2832      }
2833    
2834      /**
2835       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:180
2836       * @apilevel internal
2837       * @return {@code true} if this node has an equation for the inherited attribute enclosingExplicitConstructorHostType
2838       */
2839      protected boolean canDefine_enclosingExplicitConstructorHostType(ASTNode caller, ASTNode child) {
2840        return false;
2841      }
2842      /**
2843       * @apilevel internal
2844       */
2845      public boolean Define_inStaticContext(ASTNode caller, ASTNode child) {
2846        ASTNode self = this;
2847        ASTNode parent = getParent();
2848        while (parent != null && !parent.canDefine_inStaticContext(self, caller)) {
2849          caller = self;
2850          self = parent;
2851          parent = self.getParent();
2852        }
2853        return parent.Define_inStaticContext(self, caller);
2854      }
2855    
2856      /**
2857       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:194
2858       * @apilevel internal
2859       * @return {@code true} if this node has an equation for the inherited attribute inStaticContext
2860       */
2861      protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) {
2862        return false;
2863      }
2864      /**
2865       * @apilevel internal
2866       */
2867      public boolean Define_reportUnreachable(ASTNode caller, ASTNode child) {
2868        ASTNode self = this;
2869        ASTNode parent = getParent();
2870        while (parent != null && !parent.canDefine_reportUnreachable(self, caller)) {
2871          caller = self;
2872          self = parent;
2873          parent = self.getParent();
2874        }
2875        return parent.Define_reportUnreachable(self, caller);
2876      }
2877    
2878      /**
2879       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:284
2880       * @apilevel internal
2881       * @return {@code true} if this node has an equation for the inherited attribute reportUnreachable
2882       */
2883      protected boolean canDefine_reportUnreachable(ASTNode caller, ASTNode child) {
2884        return false;
2885      }
2886      /**
2887       * @apilevel internal
2888       */
2889      public boolean Define_isMethodParameter(ASTNode caller, ASTNode child) {
2890        ASTNode self = this;
2891        ASTNode parent = getParent();
2892        while (parent != null && !parent.canDefine_isMethodParameter(self, caller)) {
2893          caller = self;
2894          self = parent;
2895          parent = self.getParent();
2896        }
2897        return parent.Define_isMethodParameter(self, caller);
2898      }
2899    
2900      /**
2901       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:49
2902       * @apilevel internal
2903       * @return {@code true} if this node has an equation for the inherited attribute isMethodParameter
2904       */
2905      protected boolean canDefine_isMethodParameter(ASTNode caller, ASTNode child) {
2906        return false;
2907      }
2908      /**
2909       * @apilevel internal
2910       */
2911      public boolean Define_isConstructorParameter(ASTNode caller, ASTNode child) {
2912        ASTNode self = this;
2913        ASTNode parent = getParent();
2914        while (parent != null && !parent.canDefine_isConstructorParameter(self, caller)) {
2915          caller = self;
2916          self = parent;
2917          parent = self.getParent();
2918        }
2919        return parent.Define_isConstructorParameter(self, caller);
2920      }
2921    
2922      /**
2923       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:50
2924       * @apilevel internal
2925       * @return {@code true} if this node has an equation for the inherited attribute isConstructorParameter
2926       */
2927      protected boolean canDefine_isConstructorParameter(ASTNode caller, ASTNode child) {
2928        return false;
2929      }
2930      /**
2931       * @apilevel internal
2932       */
2933      public boolean Define_isExceptionHandlerParameter(ASTNode caller, ASTNode child) {
2934        ASTNode self = this;
2935        ASTNode parent = getParent();
2936        while (parent != null && !parent.canDefine_isExceptionHandlerParameter(self, caller)) {
2937          caller = self;
2938          self = parent;
2939          parent = self.getParent();
2940        }
2941        return parent.Define_isExceptionHandlerParameter(self, caller);
2942      }
2943    
2944      /**
2945       * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:51
2946       * @apilevel internal
2947       * @return {@code true} if this node has an equation for the inherited attribute isExceptionHandlerParameter
2948       */
2949      protected boolean canDefine_isExceptionHandlerParameter(ASTNode caller, ASTNode child) {
2950        return false;
2951      }
2952      /**
2953       * @apilevel internal
2954       */
2955      public int Define_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) {
2956        ASTNode self = this;
2957        ASTNode parent = getParent();
2958        while (parent != null && !parent.canDefine_variableScopeEndLabel(self, caller, gen)) {
2959          caller = self;
2960          self = parent;
2961          parent = self.getParent();
2962        }
2963        return parent.Define_variableScopeEndLabel(self, caller, gen);
2964      }
2965    
2966      /**
2967       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:71
2968       * @apilevel internal
2969       * @return {@code true} if this node has an equation for the inherited attribute variableScopeEndLabel
2970       */
2971      protected boolean canDefine_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) {
2972        return false;
2973      }
2974      /**
2975       * @apilevel internal
2976       */
2977      public TypeDecl Define_expectedType(ASTNode caller, ASTNode child) {
2978        ASTNode self = this;
2979        ASTNode parent = getParent();
2980        while (parent != null && !parent.canDefine_expectedType(self, caller)) {
2981          caller = self;
2982          self = parent;
2983          parent = self.getParent();
2984        }
2985        return parent.Define_expectedType(self, caller);
2986      }
2987    
2988      /**
2989       * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:97
2990       * @apilevel internal
2991       * @return {@code true} if this node has an equation for the inherited attribute expectedType
2992       */
2993      protected boolean canDefine_expectedType(ASTNode caller, ASTNode child) {
2994        return false;
2995      }
2996      /**
2997       * @apilevel internal
2998       */
2999      public int Define_localNum(ASTNode caller, ASTNode child) {
3000        ASTNode self = this;
3001        ASTNode parent = getParent();
3002        while (parent != null && !parent.canDefine_localNum(self, caller)) {
3003          caller = self;
3004          self = parent;
3005          parent = self.getParent();
3006        }
3007        return parent.Define_localNum(self, caller);
3008      }
3009    
3010      /**
3011       * @declaredat /home/jesper/git/extendj/java7/backend/TryWithResources.jrag:309
3012       * @apilevel internal
3013       * @return {@code true} if this node has an equation for the inherited attribute localNum
3014       */
3015      protected boolean canDefine_localNum(ASTNode caller, ASTNode child) {
3016        return false;
3017      }
3018      /**
3019       * @apilevel internal
3020       */
3021      public int Define_resultSaveLocalNum(ASTNode caller, ASTNode child) {
3022        ASTNode self = this;
3023        ASTNode parent = getParent();
3024        while (parent != null && !parent.canDefine_resultSaveLocalNum(self, caller)) {
3025          caller = self;
3026          self = parent;
3027          parent = self.getParent();
3028        }
3029        return parent.Define_resultSaveLocalNum(self, caller);
3030      }
3031    
3032      /**
3033       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:102
3034       * @apilevel internal
3035       * @return {@code true} if this node has an equation for the inherited attribute resultSaveLocalNum
3036       */
3037      protected boolean canDefine_resultSaveLocalNum(ASTNode caller, ASTNode child) {
3038        return false;
3039      }
3040      /**
3041       * @apilevel internal
3042       */
3043      public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
3044        ASTNode self = this;
3045        ASTNode parent = getParent();
3046        while (parent != null && !parent.canDefine_mayUseAnnotationTarget(self, caller, name)) {
3047          caller = self;
3048          self = parent;
3049          parent = self.getParent();
3050        }
3051        return parent.Define_mayUseAnnotationTarget(self, caller, name);
3052      }
3053    
3054      /**
3055       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:98
3056       * @apilevel internal
3057       * @return {@code true} if this node has an equation for the inherited attribute mayUseAnnotationTarget
3058       */
3059      protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) {
3060        return false;
3061      }
3062      /**
3063       * @apilevel internal
3064       */
3065      public ElementValue Define_lookupElementTypeValue(ASTNode caller, ASTNode child, String name) {
3066        ASTNode self = this;
3067        ASTNode parent = getParent();
3068        while (parent != null && !parent.canDefine_lookupElementTypeValue(self, caller, name)) {
3069          caller = self;
3070          self = parent;
3071          parent = self.getParent();
3072        }
3073        return parent.Define_lookupElementTypeValue(self, caller, name);
3074      }
3075    
3076      /**
3077       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:225
3078       * @apilevel internal
3079       * @return {@code true} if this node has an equation for the inherited attribute lookupElementTypeValue
3080       */
3081      protected boolean canDefine_lookupElementTypeValue(ASTNode caller, ASTNode child, String name) {
3082        return false;
3083      }
3084      /**
3085       * @apilevel internal
3086       */
3087      public boolean Define_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) {
3088        ASTNode self = this;
3089        ASTNode parent = getParent();
3090        while (parent != null && !parent.canDefine_withinSuppressWarnings(self, caller, annot)) {
3091          caller = self;
3092          self = parent;
3093          parent = self.getParent();
3094        }
3095        return parent.Define_withinSuppressWarnings(self, caller, annot);
3096      }
3097    
3098      /**
3099       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:344
3100       * @apilevel internal
3101       * @return {@code true} if this node has an equation for the inherited attribute withinSuppressWarnings
3102       */
3103      protected boolean canDefine_withinSuppressWarnings(ASTNode caller, ASTNode child, String annot) {
3104        return false;
3105      }
3106      /**
3107       * @apilevel internal
3108       */
3109      public boolean Define_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) {
3110        ASTNode self = this;
3111        ASTNode parent = getParent();
3112        while (parent != null && !parent.canDefine_withinDeprecatedAnnotation(self, caller)) {
3113          caller = self;
3114          self = parent;
3115          parent = self.getParent();
3116        }
3117        return parent.Define_withinDeprecatedAnnotation(self, caller);
3118      }
3119    
3120      /**
3121       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:451
3122       * @apilevel internal
3123       * @return {@code true} if this node has an equation for the inherited attribute withinDeprecatedAnnotation
3124       */
3125      protected boolean canDefine_withinDeprecatedAnnotation(ASTNode caller, ASTNode child) {
3126        return false;
3127      }
3128      /**
3129       * @apilevel internal
3130       */
3131      public Annotation Define_lookupAnnotation(ASTNode caller, ASTNode child, TypeDecl typeDecl) {
3132        ASTNode self = this;
3133        ASTNode parent = getParent();
3134        while (parent != null && !parent.canDefine_lookupAnnotation(self, caller, typeDecl)) {
3135          caller = self;
3136          self = parent;
3137          parent = self.getParent();
3138        }
3139        return parent.Define_lookupAnnotation(self, caller, typeDecl);
3140      }
3141    
3142      /**
3143       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:508
3144       * @apilevel internal
3145       * @return {@code true} if this node has an equation for the inherited attribute lookupAnnotation
3146       */
3147      protected boolean canDefine_lookupAnnotation(ASTNode caller, ASTNode child, TypeDecl typeDecl) {
3148        return false;
3149      }
3150      /**
3151       * @apilevel internal
3152       */
3153      public TypeDecl Define_enclosingAnnotationDecl(ASTNode caller, ASTNode child) {
3154        ASTNode self = this;
3155        ASTNode parent = getParent();
3156        while (parent != null && !parent.canDefine_enclosingAnnotationDecl(self, caller)) {
3157          caller = self;
3158          self = parent;
3159          parent = self.getParent();
3160        }
3161        return parent.Define_enclosingAnnotationDecl(self, caller);
3162      }
3163    
3164      /**
3165       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:545
3166       * @apilevel internal
3167       * @return {@code true} if this node has an equation for the inherited attribute enclosingAnnotationDecl
3168       */
3169      protected boolean canDefine_enclosingAnnotationDecl(ASTNode caller, ASTNode child) {
3170        return false;
3171      }
3172      /**
3173       * @apilevel internal
3174       */
3175      public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) {
3176        ASTNode self = this;
3177        ASTNode parent = getParent();
3178        while (parent != null && !parent.canDefine_assignConvertedType(self, caller)) {
3179          caller = self;
3180          self = parent;
3181          parent = self.getParent();
3182        }
3183        return parent.Define_assignConvertedType(self, caller);
3184      }
3185    
3186      /**
3187       * @declaredat /home/jesper/git/extendj/java8/backend/ToClassInherited.jrag:40
3188       * @apilevel internal
3189       * @return {@code true} if this node has an equation for the inherited attribute assignConvertedType
3190       */
3191      protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) {
3192        return false;
3193      }
3194      /**
3195       * @apilevel internal
3196       */
3197      public boolean Define_inExtendsOrImplements(ASTNode caller, ASTNode child) {
3198        ASTNode self = this;
3199        ASTNode parent = getParent();
3200        while (parent != null && !parent.canDefine_inExtendsOrImplements(self, caller)) {
3201          caller = self;
3202          self = parent;
3203          parent = self.getParent();
3204        }
3205        return parent.Define_inExtendsOrImplements(self, caller);
3206      }
3207    
3208      /**
3209       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:337
3210       * @apilevel internal
3211       * @return {@code true} if this node has an equation for the inherited attribute inExtendsOrImplements
3212       */
3213      protected boolean canDefine_inExtendsOrImplements(ASTNode caller, ASTNode child) {
3214        return false;
3215      }
3216      /**
3217       * @apilevel internal
3218       */
3219      public TypeDecl Define_typeWildcard(ASTNode caller, ASTNode child) {
3220        ASTNode self = this;
3221        ASTNode parent = getParent();
3222        while (parent != null && !parent.canDefine_typeWildcard(self, caller)) {
3223          caller = self;
3224          self = parent;
3225          parent = self.getParent();
3226        }
3227        return parent.Define_typeWildcard(self, caller);
3228      }
3229    
3230      /**
3231       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1490
3232       * @apilevel internal
3233       * @return {@code true} if this node has an equation for the inherited attribute typeWildcard
3234       */
3235      protected boolean canDefine_typeWildcard(ASTNode caller, ASTNode child) {
3236        return false;
3237      }
3238      /**
3239       * @apilevel internal
3240       */
3241      public TypeDecl Define_lookupWildcardExtends(ASTNode caller, ASTNode child, TypeDecl typeDecl) {
3242        ASTNode self = this;
3243        ASTNode parent = getParent();
3244        while (parent != null && !parent.canDefine_lookupWildcardExtends(self, caller, typeDecl)) {
3245          caller = self;
3246          self = parent;
3247          parent = self.getParent();
3248        }
3249        return parent.Define_lookupWildcardExtends(self, caller, typeDecl);
3250      }
3251    
3252      /**
3253       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1499
3254       * @apilevel internal
3255       * @return {@code true} if this node has an equation for the inherited attribute lookupWildcardExtends
3256       */
3257      protected boolean canDefine_lookupWildcardExtends(ASTNode caller, ASTNode child, TypeDecl typeDecl) {
3258        return false;
3259      }
3260      /**
3261       * @apilevel internal
3262       */
3263      public TypeDecl Define_lookupWildcardSuper(ASTNode caller, ASTNode child, TypeDecl typeDecl) {
3264        ASTNode self = this;
3265        ASTNode parent = getParent();
3266        while (parent != null && !parent.canDefine_lookupWildcardSuper(self, caller, typeDecl)) {
3267          caller = self;
3268          self = parent;
3269          parent = self.getParent();
3270        }
3271        return parent.Define_lookupWildcardSuper(self, caller, typeDecl);
3272      }
3273    
3274      /**
3275       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1513
3276       * @apilevel internal
3277       * @return {@code true} if this node has an equation for the inherited attribute lookupWildcardSuper
3278       */
3279      protected boolean canDefine_lookupWildcardSuper(ASTNode caller, ASTNode child, TypeDecl typeDecl) {
3280        return false;
3281      }
3282      /**
3283       * @apilevel internal
3284       */
3285      public LUBType Define_lookupLUBType(ASTNode caller, ASTNode child, Collection bounds) {
3286        ASTNode self = this;
3287        ASTNode parent = getParent();
3288        while (parent != null && !parent.canDefine_lookupLUBType(self, caller, bounds)) {
3289          caller = self;
3290          self = parent;
3291          parent = self.getParent();
3292        }
3293        return parent.Define_lookupLUBType(self, caller, bounds);
3294      }
3295    
3296      /**
3297       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1541
3298       * @apilevel internal
3299       * @return {@code true} if this node has an equation for the inherited attribute lookupLUBType
3300       */
3301      protected boolean canDefine_lookupLUBType(ASTNode caller, ASTNode child, Collection bounds) {
3302        return false;
3303      }
3304      /**
3305       * @apilevel internal
3306       */
3307      public GLBType Define_lookupGLBType(ASTNode caller, ASTNode child, ArrayList bounds) {
3308        ASTNode self = this;
3309        ASTNode parent = getParent();
3310        while (parent != null && !parent.canDefine_lookupGLBType(self, caller, bounds)) {
3311          caller = self;
3312          self = parent;
3313          parent = self.getParent();
3314        }
3315        return parent.Define_lookupGLBType(self, caller, bounds);
3316      }
3317    
3318      /**
3319       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1582
3320       * @apilevel internal
3321       * @return {@code true} if this node has an equation for the inherited attribute lookupGLBType
3322       */
3323      protected boolean canDefine_lookupGLBType(ASTNode caller, ASTNode child, ArrayList bounds) {
3324        return false;
3325      }
3326      /**
3327       * @apilevel internal
3328       */
3329      public TypeDecl Define_genericDecl(ASTNode caller, ASTNode child) {
3330        ASTNode self = this;
3331        ASTNode parent = getParent();
3332        while (parent != null && !parent.canDefine_genericDecl(self, caller)) {
3333          caller = self;
3334          self = parent;
3335          parent = self.getParent();
3336        }
3337        return parent.Define_genericDecl(self, caller);
3338      }
3339    
3340      /**
3341       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:82
3342       * @apilevel internal
3343       * @return {@code true} if this node has an equation for the inherited attribute genericDecl
3344       */
3345      protected boolean canDefine_genericDecl(ASTNode caller, ASTNode child) {
3346        return false;
3347      }
3348      /**
3349       * @apilevel internal
3350       */
3351      public boolean Define_variableArityValid(ASTNode caller, ASTNode child) {
3352        ASTNode self = this;
3353        ASTNode parent = getParent();
3354        while (parent != null && !parent.canDefine_variableArityValid(self, caller)) {
3355          caller = self;
3356          self = parent;
3357          parent = self.getParent();
3358        }
3359        return parent.Define_variableArityValid(self, caller);
3360      }
3361    
3362      /**
3363       * @declaredat /home/jesper/git/extendj/java8/frontend/VariableArityParameters.jrag:30
3364       * @apilevel internal
3365       * @return {@code true} if this node has an equation for the inherited attribute variableArityValid
3366       */
3367      protected boolean canDefine_variableArityValid(ASTNode caller, ASTNode child) {
3368        return false;
3369      }
3370      /**
3371       * @apilevel internal
3372       */
3373      public ClassInstanceExpr Define_getClassInstanceExpr(ASTNode caller, ASTNode child) {
3374        ASTNode self = this;
3375        ASTNode parent = getParent();
3376        while (parent != null && !parent.canDefine_getClassInstanceExpr(self, caller)) {
3377          caller = self;
3378          self = parent;
3379          parent = self.getParent();
3380        }
3381        return parent.Define_getClassInstanceExpr(self, caller);
3382      }
3383    
3384      /**
3385       * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:91
3386       * @apilevel internal
3387       * @return {@code true} if this node has an equation for the inherited attribute getClassInstanceExpr
3388       */
3389      protected boolean canDefine_getClassInstanceExpr(ASTNode caller, ASTNode child) {
3390        return false;
3391      }
3392      /**
3393       * @apilevel internal
3394       */
3395      public boolean Define_isAnonymousDecl(ASTNode caller, ASTNode child) {
3396        ASTNode self = this;
3397        ASTNode parent = getParent();
3398        while (parent != null && !parent.canDefine_isAnonymousDecl(self, caller)) {
3399          caller = self;
3400          self = parent;
3401          parent = self.getParent();
3402        }
3403        return parent.Define_isAnonymousDecl(self, caller);
3404      }
3405    
3406      /**
3407       * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:406
3408       * @apilevel internal
3409       * @return {@code true} if this node has an equation for the inherited attribute isAnonymousDecl
3410       */
3411      protected boolean canDefine_isAnonymousDecl(ASTNode caller, ASTNode child) {
3412        return false;
3413      }
3414      /**
3415       * @apilevel internal
3416       */
3417      public boolean Define_isExplicitGenericConstructorAccess(ASTNode caller, ASTNode child) {
3418        ASTNode self = this;
3419        ASTNode parent = getParent();
3420        while (parent != null && !parent.canDefine_isExplicitGenericConstructorAccess(self, caller)) {
3421          caller = self;
3422          self = parent;
3423          parent = self.getParent();
3424        }
3425        return parent.Define_isExplicitGenericConstructorAccess(self, caller);
3426      }
3427    
3428      /**
3429       * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:422
3430       * @apilevel internal
3431       * @return {@code true} if this node has an equation for the inherited attribute isExplicitGenericConstructorAccess
3432       */
3433      protected boolean canDefine_isExplicitGenericConstructorAccess(ASTNode caller, ASTNode child) {
3434        return false;
3435      }
3436      /**
3437       * @apilevel internal
3438       */
3439      public boolean Define_isCatchParam(ASTNode caller, ASTNode child) {
3440        ASTNode self = this;
3441        ASTNode parent = getParent();
3442        while (parent != null && !parent.canDefine_isCatchParam(self, caller)) {
3443          caller = self;
3444          self = parent;
3445          parent = self.getParent();
3446        }
3447        return parent.Define_isCatchParam(self, caller);
3448      }
3449    
3450      /**
3451       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:210
3452       * @apilevel internal
3453       * @return {@code true} if this node has an equation for the inherited attribute isCatchParam
3454       */
3455      protected boolean canDefine_isCatchParam(ASTNode caller, ASTNode child) {
3456        return false;
3457      }
3458      /**
3459       * @apilevel internal
3460       */
3461      public CatchClause Define_catchClause(ASTNode caller, ASTNode child) {
3462        ASTNode self = this;
3463        ASTNode parent = getParent();
3464        while (parent != null && !parent.canDefine_catchClause(self, caller)) {
3465          caller = self;
3466          self = parent;
3467          parent = self.getParent();
3468        }
3469        return parent.Define_catchClause(self, caller);
3470      }
3471    
3472      /**
3473       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:219
3474       * @apilevel internal
3475       * @return {@code true} if this node has an equation for the inherited attribute catchClause
3476       */
3477      protected boolean canDefine_catchClause(ASTNode caller, ASTNode child) {
3478        return false;
3479      }
3480      /**
3481       * @apilevel internal
3482       */
3483      public boolean Define_resourcePreviouslyDeclared(ASTNode caller, ASTNode child, String name) {
3484        ASTNode self = this;
3485        ASTNode parent = getParent();
3486        while (parent != null && !parent.canDefine_resourcePreviouslyDeclared(self, caller, name)) {
3487          caller = self;
3488          self = parent;
3489          parent = self.getParent();
3490        }
3491        return parent.Define_resourcePreviouslyDeclared(self, caller, name);
3492      }
3493    
3494      /**
3495       * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:184
3496       * @apilevel internal
3497       * @return {@code true} if this node has an equation for the inherited attribute resourcePreviouslyDeclared
3498       */
3499      protected boolean canDefine_resourcePreviouslyDeclared(ASTNode caller, ASTNode child, String name) {
3500        return false;
3501      }
3502      /**
3503       * @apilevel internal
3504       */
3505      public TypeDecl Define_targetType(ASTNode caller, ASTNode child) {
3506        ASTNode self = this;
3507        ASTNode parent = getParent();
3508        while (parent != null && !parent.canDefine_targetType(self, caller)) {
3509          caller = self;
3510          self = parent;
3511          parent = self.getParent();
3512        }
3513        return parent.Define_targetType(self, caller);
3514      }
3515    
3516      /**
3517       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:126
3518       * @apilevel internal
3519       * @return {@code true} if this node has an equation for the inherited attribute targetType
3520       */
3521      protected boolean canDefine_targetType(ASTNode caller, ASTNode child) {
3522        return false;
3523      }
3524      /**
3525       * @apilevel internal
3526       */
3527      public CompilationUnit Define_compilationUnit(ASTNode caller, ASTNode child) {
3528        ASTNode self = this;
3529        ASTNode parent = getParent();
3530        while (parent != null && !parent.canDefine_compilationUnit(self, caller)) {
3531          caller = self;
3532          self = parent;
3533          parent = self.getParent();
3534        }
3535        return parent.Define_compilationUnit(self, caller);
3536      }
3537    
3538      /**
3539       * @declaredat /home/jesper/git/extendj/java4/frontend/ClassPath.jrag:79
3540       * @apilevel internal
3541       * @return {@code true} if this node has an equation for the inherited attribute compilationUnit
3542       */
3543      protected boolean canDefine_compilationUnit(ASTNode caller, ASTNode child) {
3544        return false;
3545      }
3546      /**
3547       * @apilevel internal
3548       */
3549      public SimpleSet Define_allImportedTypes(ASTNode caller, ASTNode child, String name) {
3550        ASTNode self = this;
3551        ASTNode parent = getParent();
3552        while (parent != null && !parent.canDefine_allImportedTypes(self, caller, name)) {
3553          caller = self;
3554          self = parent;
3555          parent = self.getParent();
3556        }
3557        return parent.Define_allImportedTypes(self, caller, name);
3558      }
3559    
3560      /**
3561       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:53
3562       * @apilevel internal
3563       * @return {@code true} if this node has an equation for the inherited attribute allImportedTypes
3564       */
3565      protected boolean canDefine_allImportedTypes(ASTNode caller, ASTNode child, String name) {
3566        return false;
3567      }
3568      /**
3569       * @apilevel internal
3570       */
3571      public String Define_packageName(ASTNode caller, ASTNode child) {
3572        ASTNode self = this;
3573        ASTNode parent = getParent();
3574        while (parent != null && !parent.canDefine_packageName(self, caller)) {
3575          caller = self;
3576          self = parent;
3577          parent = self.getParent();
3578        }
3579        return parent.Define_packageName(self, caller);
3580      }
3581    
3582      /**
3583       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:104
3584       * @apilevel internal
3585       * @return {@code true} if this node has an equation for the inherited attribute packageName
3586       */
3587      protected boolean canDefine_packageName(ASTNode caller, ASTNode child) {
3588        return false;
3589      }
3590      /**
3591       * @apilevel internal
3592       */
3593      public TypeDecl Define_enclosingType(ASTNode caller, ASTNode child) {
3594        ASTNode self = this;
3595        ASTNode parent = getParent();
3596        while (parent != null && !parent.canDefine_enclosingType(self, caller)) {
3597          caller = self;
3598          self = parent;
3599          parent = self.getParent();
3600        }
3601        return parent.Define_enclosingType(self, caller);
3602      }
3603    
3604      /**
3605       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:715
3606       * @apilevel internal
3607       * @return {@code true} if this node has an equation for the inherited attribute enclosingType
3608       */
3609      protected boolean canDefine_enclosingType(ASTNode caller, ASTNode child) {
3610        return false;
3611      }
3612      /**
3613       * @apilevel internal
3614       */
3615      public boolean Define_isNestedType(ASTNode caller, ASTNode child) {
3616        ASTNode self = this;
3617        ASTNode parent = getParent();
3618        while (parent != null && !parent.canDefine_isNestedType(self, caller)) {
3619          caller = self;
3620          self = parent;
3621          parent = self.getParent();
3622        }
3623        return parent.Define_isNestedType(self, caller);
3624      }
3625    
3626      /**
3627       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:714
3628       * @apilevel internal
3629       * @return {@code true} if this node has an equation for the inherited attribute isNestedType
3630       */
3631      protected boolean canDefine_isNestedType(ASTNode caller, ASTNode child) {
3632        return false;
3633      }
3634      /**
3635       * @apilevel internal
3636       */
3637      public boolean Define_isLocalClass(ASTNode caller, ASTNode child) {
3638        ASTNode self = this;
3639        ASTNode parent = getParent();
3640        while (parent != null && !parent.canDefine_isLocalClass(self, caller)) {
3641          caller = self;
3642          self = parent;
3643          parent = self.getParent();
3644        }
3645        return parent.Define_isLocalClass(self, caller);
3646      }
3647    
3648      /**
3649       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:594
3650       * @apilevel internal
3651       * @return {@code true} if this node has an equation for the inherited attribute isLocalClass
3652       */
3653      protected boolean canDefine_isLocalClass(ASTNode caller, ASTNode child) {
3654        return false;
3655      }
3656      /**
3657       * @apilevel internal
3658       */
3659      public String Define_hostPackage(ASTNode caller, ASTNode child) {
3660        ASTNode self = this;
3661        ASTNode parent = getParent();
3662        while (parent != null && !parent.canDefine_hostPackage(self, caller)) {
3663          caller = self;
3664          self = parent;
3665          parent = self.getParent();
3666        }
3667        return parent.Define_hostPackage(self, caller);
3668      }
3669    
3670      /**
3671       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:649
3672       * @apilevel internal
3673       * @return {@code true} if this node has an equation for the inherited attribute hostPackage
3674       */
3675      protected boolean canDefine_hostPackage(ASTNode caller, ASTNode child) {
3676        return false;
3677      }
3678      /**
3679       * @apilevel internal
3680       */
3681      public LambdaExpr Define_enclosingLambda(ASTNode caller, ASTNode child) {
3682        ASTNode self = this;
3683        ASTNode parent = getParent();
3684        while (parent != null && !parent.canDefine_enclosingLambda(self, caller)) {
3685          caller = self;
3686          self = parent;
3687          parent = self.getParent();
3688        }
3689        return parent.Define_enclosingLambda(self, caller);
3690      }
3691    
3692      /**
3693       * @declaredat /home/jesper/git/extendj/java8/backend/ToClassInherited.jrag:34
3694       * @apilevel internal
3695       * @return {@code true} if this node has an equation for the inherited attribute enclosingLambda
3696       */
3697      protected boolean canDefine_enclosingLambda(ASTNode caller, ASTNode child) {
3698        return false;
3699      }
3700      /**
3701       * @apilevel internal
3702       */
3703      public boolean Define_assignmentContext(ASTNode caller, ASTNode child) {
3704        ASTNode self = this;
3705        ASTNode parent = getParent();
3706        while (parent != null && !parent.canDefine_assignmentContext(self, caller)) {
3707          caller = self;
3708          self = parent;
3709          parent = self.getParent();
3710        }
3711        return parent.Define_assignmentContext(self, caller);
3712      }
3713    
3714      /**
3715       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:391
3716       * @apilevel internal
3717       * @return {@code true} if this node has an equation for the inherited attribute assignmentContext
3718       */
3719      protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) {
3720        return false;
3721      }
3722      /**
3723       * @apilevel internal
3724       */
3725      public boolean Define_invocationContext(ASTNode caller, ASTNode child) {
3726        ASTNode self = this;
3727        ASTNode parent = getParent();
3728        while (parent != null && !parent.canDefine_invocationContext(self, caller)) {
3729          caller = self;
3730          self = parent;
3731          parent = self.getParent();
3732        }
3733        return parent.Define_invocationContext(self, caller);
3734      }
3735    
3736      /**
3737       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:392
3738       * @apilevel internal
3739       * @return {@code true} if this node has an equation for the inherited attribute invocationContext
3740       */
3741      protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) {
3742        return false;
3743      }
3744      /**
3745       * @apilevel internal
3746       */
3747      public boolean Define_castContext(ASTNode caller, ASTNode child) {
3748        ASTNode self = this;
3749        ASTNode parent = getParent();
3750        while (parent != null && !parent.canDefine_castContext(self, caller)) {
3751          caller = self;
3752          self = parent;
3753          parent = self.getParent();
3754        }
3755        return parent.Define_castContext(self, caller);
3756      }
3757    
3758      /**
3759       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:393
3760       * @apilevel internal
3761       * @return {@code true} if this node has an equation for the inherited attribute castContext
3762       */
3763      protected boolean canDefine_castContext(ASTNode caller, ASTNode child) {
3764        return false;
3765      }
3766      /**
3767       * @apilevel internal
3768       */
3769      public boolean Define_stringContext(ASTNode caller, ASTNode child) {
3770        ASTNode self = this;
3771        ASTNode parent = getParent();
3772        while (parent != null && !parent.canDefine_stringContext(self, caller)) {
3773          caller = self;
3774          self = parent;
3775          parent = self.getParent();
3776        }
3777        return parent.Define_stringContext(self, caller);
3778      }
3779    
3780      /**
3781       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:394
3782       * @apilevel internal
3783       * @return {@code true} if this node has an equation for the inherited attribute stringContext
3784       */
3785      protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) {
3786        return false;
3787      }
3788      /**
3789       * @apilevel internal
3790       */
3791      public boolean Define_numericContext(ASTNode caller, ASTNode child) {
3792        ASTNode self = this;
3793        ASTNode parent = getParent();
3794        while (parent != null && !parent.canDefine_numericContext(self, caller)) {
3795          caller = self;
3796          self = parent;
3797          parent = self.getParent();
3798        }
3799        return parent.Define_numericContext(self, caller);
3800      }
3801    
3802      /**
3803       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:395
3804       * @apilevel internal
3805       * @return {@code true} if this node has an equation for the inherited attribute numericContext
3806       */
3807      protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) {
3808        return false;
3809      }
3810      /**
3811       * @apilevel internal
3812       */
3813      public int Define_typeVarPosition(ASTNode caller, ASTNode child) {
3814        ASTNode self = this;
3815        ASTNode parent = getParent();
3816        while (parent != null && !parent.canDefine_typeVarPosition(self, caller)) {
3817          caller = self;
3818          self = parent;
3819          parent = self.getParent();
3820        }
3821        return parent.Define_typeVarPosition(self, caller);
3822      }
3823    
3824      /**
3825       * @declaredat /home/jesper/git/extendj/java8/frontend/TypeVariablePositions.jrag:46
3826       * @apilevel internal
3827       * @return {@code true} if this node has an equation for the inherited attribute typeVarPosition
3828       */
3829      protected boolean canDefine_typeVarPosition(ASTNode caller, ASTNode child) {
3830        return false;
3831      }
3832      /**
3833       * @apilevel internal
3834       */
3835      public boolean Define_typeVarInMethod(ASTNode caller, ASTNode child) {
3836        ASTNode self = this;
3837        ASTNode parent = getParent();
3838        while (parent != null && !parent.canDefine_typeVarInMethod(self, caller)) {
3839          caller = self;
3840          self = parent;
3841          parent = self.getParent();
3842        }
3843        return parent.Define_typeVarInMethod(self, caller);
3844      }
3845    
3846      /**
3847       * @declaredat /home/jesper/git/extendj/java8/frontend/TypeVariablePositions.jrag:47
3848       * @apilevel internal
3849       * @return {@code true} if this node has an equation for the inherited attribute typeVarInMethod
3850       */
3851      protected boolean canDefine_typeVarInMethod(ASTNode caller, ASTNode child) {
3852        return false;
3853      }
3854      /**
3855       * @apilevel internal
3856       */
3857      public int Define_genericMethodLevel(ASTNode caller, ASTNode child) {
3858        ASTNode self = this;
3859        ASTNode parent = getParent();
3860        while (parent != null && !parent.canDefine_genericMethodLevel(self, caller)) {
3861          caller = self;
3862          self = parent;
3863          parent = self.getParent();
3864        }
3865        return parent.Define_genericMethodLevel(self, caller);
3866      }
3867    
3868      /**
3869       * @declaredat /home/jesper/git/extendj/java8/frontend/TypeVariablePositions.jrag:50
3870       * @apilevel internal
3871       * @return {@code true} if this node has an equation for the inherited attribute genericMethodLevel
3872       */
3873      protected boolean canDefine_genericMethodLevel(ASTNode caller, ASTNode child) {
3874        return false;
3875      }
3876      /**
3877       * @apilevel internal
3878       */
3879      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) {
3880        ASTNode self = this;
3881        ASTNode parent = getParent();
3882        while (parent != null && !parent.canDefine_isDAbefore(self, caller, v, b)) {
3883          caller = self;
3884          self = parent;
3885          parent = self.getParent();
3886        }
3887        return parent.Define_isDAbefore(self, caller, v, b);
3888      }
3889    
3890      /**
3891       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:274
3892       * @apilevel internal
3893       * @return {@code true} if this node has an equation for the inherited attribute isDAbefore
3894       */
3895      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) {
3896        return false;
3897      }
3898      /**
3899       * @apilevel internal
3900       */
3901      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) {
3902        ASTNode self = this;
3903        ASTNode parent = getParent();
3904        while (parent != null && !parent.canDefine_isDUbefore(self, caller, v, b)) {
3905          caller = self;
3906          self = parent;
3907          parent = self.getParent();
3908        }
3909        return parent.Define_isDUbefore(self, caller, v, b);
3910      }
3911    
3912      /**
3913       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:806
3914       * @apilevel internal
3915       * @return {@code true} if this node has an equation for the inherited attribute isDUbefore
3916       */
3917      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v, BodyDecl b) {
3918        return false;
3919      }
3920      /**
3921       * @apilevel internal
3922       */
3923      public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) {
3924        ASTNode self = this;
3925        ASTNode parent = getParent();
3926        while (parent != null && !parent.canDefine_branchTarget(self, caller, branch)) {
3927          caller = self;
3928          self = parent;
3929          parent = self.getParent();
3930        }
3931        return parent.Define_branchTarget(self, caller, branch);
3932      }
3933    
3934      /**
3935       * @declaredat /home/jesper/git/extendj/java8/frontend/ExtraInheritedEqs.jrag:30
3936       * @apilevel internal
3937       * @return {@code true} if this node has an equation for the inherited attribute branchTarget
3938       */
3939      protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) {
3940        return false;
3941      }
3942      /**
3943       * @apilevel internal
3944       */
3945      public FinallyHost Define_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) {
3946        ASTNode self = this;
3947        ASTNode parent = getParent();
3948        while (parent != null && !parent.canDefine_enclosingFinally(self, caller, branch)) {
3949          caller = self;
3950          self = parent;
3951          parent = self.getParent();
3952        }
3953        return parent.Define_enclosingFinally(self, caller, branch);
3954      }
3955    
3956      /**
3957       * @declaredat /home/jesper/git/extendj/java8/frontend/ExtraInheritedEqs.jrag:29
3958       * @apilevel internal
3959       * @return {@code true} if this node has an equation for the inherited attribute enclosingFinally
3960       */
3961      protected boolean canDefine_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) {
3962        return false;
3963      }
3964      /**
3965       * @apilevel internal
3966       */
3967      public SimpleSet Define_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) {
3968        ASTNode self = this;
3969        ASTNode parent = getParent();
3970        while (parent != null && !parent.canDefine_otherLocalClassDecls(self, caller, name)) {
3971          caller = self;
3972          self = parent;
3973          parent = self.getParent();
3974        }
3975        return parent.Define_otherLocalClassDecls(self, caller, name);
3976      }
3977    
3978      /**
3979       * @declaredat /home/jesper/git/extendj/java8/frontend/ExtraInheritedEqs.jrag:33
3980       * @apilevel internal
3981       * @return {@code true} if this node has an equation for the inherited attribute otherLocalClassDecls
3982       */
3983      protected boolean canDefine_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) {
3984        return false;
3985      }
3986      /**
3987       * @apilevel internal
3988       */
3989      public boolean Define_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) {
3990        ASTNode self = this;
3991        ASTNode parent = getParent();
3992        while (parent != null && !parent.canDefine_leavesMonitor(self, caller, branch, monitor)) {
3993          caller = self;
3994          self = parent;
3995          parent = self.getParent();
3996        }
3997        return parent.Define_leavesMonitor(self, caller, branch, monitor);
3998      }
3999    
4000      /**
4001       * @declaredat /home/jesper/git/extendj/java8/backend/Tmp.jrag:29
4002       * @apilevel internal
4003       * @return {@code true} if this node has an equation for the inherited attribute leavesMonitor
4004       */
4005      protected boolean canDefine_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) {
4006        return false;
4007      }
4008      /**
4009       * @apilevel internal
4010       */
4011      public boolean Define_reachable(ASTNode caller, ASTNode child) {
4012        ASTNode self = this;
4013        ASTNode parent = getParent();
4014        while (parent != null && !parent.canDefine_reachable(self, caller)) {
4015          caller = self;
4016          self = parent;
4017          parent = self.getParent();
4018        }
4019        return parent.Define_reachable(self, caller);
4020      }
4021    
4022      /**
4023       * @declaredat /home/jesper/git/extendj/java8/frontend/UnreachableStatements.jrag:29
4024       * @apilevel internal
4025       * @return {@code true} if this node has an equation for the inherited attribute reachable
4026       */
4027      protected boolean canDefine_reachable(ASTNode caller, ASTNode child) {
4028        return false;
4029      }
4030      /**
4031       * @apilevel internal
4032       */
4033      public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
4034        ASTNode self = this;
4035        ASTNode parent = getParent();
4036        while (parent != null && !parent.canDefine_inhModifiedInScope(self, caller, var)) {
4037          caller = self;
4038          self = parent;
4039          parent = self.getParent();
4040        }
4041        return parent.Define_inhModifiedInScope(self, caller, var);
4042      }
4043    
4044      /**
4045       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:35
4046       * @apilevel internal
4047       * @return {@code true} if this node has an equation for the inherited attribute inhModifiedInScope
4048       */
4049      protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
4050        return false;
4051      }
4052      /**
4053       * @apilevel internal
4054       */
4055      public boolean Define_reachableCatchClause(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
4056        ASTNode self = this;
4057        ASTNode parent = getParent();
4058        while (parent != null && !parent.canDefine_reachableCatchClause(self, caller, exceptionType)) {
4059          caller = self;
4060          self = parent;
4061          parent = self.getParent();
4062        }
4063        return parent.Define_reachableCatchClause(self, caller, exceptionType);
4064      }
4065    
4066      /**
4067       * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:143
4068       * @apilevel internal
4069       * @return {@code true} if this node has an equation for the inherited attribute reachableCatchClause
4070       */
4071      protected boolean canDefine_reachableCatchClause(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
4072        return false;
4073      }
4074      /**
4075       * @apilevel internal
4076       */
4077      public Collection<TypeDecl> Define_caughtExceptions(ASTNode caller, ASTNode child) {
4078        ASTNode self = this;
4079        ASTNode parent = getParent();
4080        while (parent != null && !parent.canDefine_caughtExceptions(self, caller)) {
4081          caller = self;
4082          self = parent;
4083          parent = self.getParent();
4084        }
4085        return parent.Define_caughtExceptions(self, caller);
4086      }
4087    
4088      /**
4089       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:223
4090       * @apilevel internal
4091       * @return {@code true} if this node has an equation for the inherited attribute caughtExceptions
4092       */
4093      protected boolean canDefine_caughtExceptions(ASTNode caller, ASTNode child) {
4094        return false;
4095      }
4096      /**
4097       * @apilevel internal
4098       */
4099      public TypeDecl Define_inferredType(ASTNode caller, ASTNode child) {
4100        ASTNode self = this;
4101        ASTNode parent = getParent();
4102        while (parent != null && !parent.canDefine_inferredType(self, caller)) {
4103          caller = self;
4104          self = parent;
4105          parent = self.getParent();
4106        }
4107        return parent.Define_inferredType(self, caller);
4108      }
4109    
4110      /**
4111       * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:454
4112       * @apilevel internal
4113       * @return {@code true} if this node has an equation for the inherited attribute inferredType
4114       */
4115      protected boolean canDefine_inferredType(ASTNode caller, ASTNode child) {
4116        return false;
4117      }
4118    }