001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:193
027     * @production Block : {@link Stmt} ::= <span class="component">{@link Stmt}*</span>;
028    
029     */
030    public class Block extends Stmt implements Cloneable, VariableScope {
031      /**
032       * @aspect Java4PrettyPrint
033       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:455
034       */
035      public void prettyPrint(PrettyPrinter out) {
036        out.print("{");
037        out.println();
038        out.indent(1);
039        out.join(getStmtList(), new PrettyPrinter.Joiner() {
040          @Override
041          public void printSeparator(PrettyPrinter out) {
042            out.println();
043          }
044        });
045        if (!out.isNewLine()) {
046          out.println();
047        }
048        out.print("}");
049      }
050      /**
051       * @aspect CreateBCode
052       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1363
053       */
054      public void createBCode(CodeGeneration gen) {
055        //super.createBCode(gen);
056        for (int i = 0; i < getNumStmt(); i++) {
057          try {
058            getStmt(i).createBCode(gen);
059          } catch (Exception e) {
060            e.printStackTrace();
061            throw new Error("Error generating code for " + errorPrefix() + " " + getStmt(i));
062          }
063        }
064        gen.addVariableScopeLabel(variableScopeEndLabel(gen));
065      }
066      /**
067       * @declaredat ASTNode:1
068       */
069      public Block() {
070        super();
071      }
072      /**
073       * Initializes the child array to the correct size.
074       * Initializes List and Opt nta children.
075       * @apilevel internal
076       * @ast method
077       * @declaredat ASTNode:10
078       */
079      public void init$Children() {
080        children = new ASTNode[1];
081        setChild(new List(), 0);
082      }
083      /**
084       * @declaredat ASTNode:14
085       */
086      public Block(List<Stmt> p0) {
087        setChild(p0, 0);
088      }
089      /**
090       * @apilevel low-level
091       * @declaredat ASTNode:20
092       */
093      protected int numChildren() {
094        return 1;
095      }
096      /**
097       * @apilevel internal
098       * @declaredat ASTNode:26
099       */
100      public boolean mayHaveRewrite() {
101        return false;
102      }
103      /**
104       * @apilevel internal
105       * @declaredat ASTNode:32
106       */
107      public void flushAttrCache() {
108        super.flushAttrCache();
109        checkReturnDA_Variable_reset();
110        isDAafter_Variable_reset();
111        checkReturnDU_Variable_reset();
112        isDUafter_Variable_reset();
113        localVariableDeclaration_String_reset();
114        canCompleteNormally_reset();
115        variableScopeEndLabel_CodeGeneration_reset();
116        lookupType_String_reset();
117        lookupVariable_String_reset();
118      }
119      /**
120       * @apilevel internal
121       * @declaredat ASTNode:47
122       */
123      public void flushCollectionCache() {
124        super.flushCollectionCache();
125      }
126      /**
127       * @apilevel internal
128       * @declaredat ASTNode:53
129       */
130      public void flushRewriteCache() {
131        super.flushRewriteCache();
132      }
133      /**
134       * @apilevel internal
135       * @declaredat ASTNode:59
136       */
137      public Block clone() throws CloneNotSupportedException {
138        Block node = (Block) super.clone();
139        return node;
140      }
141      /**
142       * @apilevel internal
143       * @declaredat ASTNode:66
144       */
145      public Block copy() {
146        try {
147          Block node = (Block) clone();
148          node.parent = null;
149          if (children != null) {
150            node.children = (ASTNode[]) children.clone();
151          }
152          return node;
153        } catch (CloneNotSupportedException e) {
154          throw new Error("Error: clone not supported for " + getClass().getName());
155        }
156      }
157      /**
158       * Create a deep copy of the AST subtree at this node.
159       * The copy is dangling, i.e. has no parent.
160       * @return dangling copy of the subtree at this node
161       * @apilevel low-level
162       * @deprecated Please use treeCopy or treeCopyNoTransform instead
163       * @declaredat ASTNode:85
164       */
165      @Deprecated
166      public Block fullCopy() {
167        return treeCopyNoTransform();
168      }
169      /**
170       * Create a deep copy of the AST subtree at this node.
171       * The copy is dangling, i.e. has no parent.
172       * @return dangling copy of the subtree at this node
173       * @apilevel low-level
174       * @declaredat ASTNode:95
175       */
176      public Block treeCopyNoTransform() {
177        Block tree = (Block) copy();
178        if (children != null) {
179          for (int i = 0; i < children.length; ++i) {
180            ASTNode child = (ASTNode) children[i];
181            if (child != null) {
182              child = child.treeCopyNoTransform();
183              tree.setChild(child, i);
184            }
185          }
186        }
187        return tree;
188      }
189      /**
190       * Create a deep copy of the AST subtree at this node.
191       * The subtree of this node is traversed to trigger rewrites before copy.
192       * The copy is dangling, i.e. has no parent.
193       * @return dangling copy of the subtree at this node
194       * @apilevel low-level
195       * @declaredat ASTNode:115
196       */
197      public Block treeCopy() {
198        doFullTraversal();
199        return treeCopyNoTransform();
200      }
201      /**
202       * @apilevel internal
203       * @declaredat ASTNode:122
204       */
205      protected boolean is$Equal(ASTNode node) {
206        return super.is$Equal(node);    
207      }
208      /**
209       * Replaces the Stmt list.
210       * @param list The new list node to be used as the Stmt list.
211       * @apilevel high-level
212       */
213      public void setStmtList(List<Stmt> list) {
214        setChild(list, 0);
215      }
216      /**
217       * Retrieves the number of children in the Stmt list.
218       * @return Number of children in the Stmt list.
219       * @apilevel high-level
220       */
221      public int getNumStmt() {
222        return getStmtList().getNumChild();
223      }
224      /**
225       * Retrieves the number of children in the Stmt list.
226       * Calling this method will not trigger rewrites.
227       * @return Number of children in the Stmt list.
228       * @apilevel low-level
229       */
230      public int getNumStmtNoTransform() {
231        return getStmtListNoTransform().getNumChildNoTransform();
232      }
233      /**
234       * Retrieves the element at index {@code i} in the Stmt list.
235       * @param i Index of the element to return.
236       * @return The element at position {@code i} in the Stmt list.
237       * @apilevel high-level
238       */
239      public Stmt getStmt(int i) {
240        return (Stmt) getStmtList().getChild(i);
241      }
242      /**
243       * Check whether the Stmt list has any children.
244       * @return {@code true} if it has at least one child, {@code false} otherwise.
245       * @apilevel high-level
246       */
247      public boolean hasStmt() {
248        return getStmtList().getNumChild() != 0;
249      }
250      /**
251       * Append an element to the Stmt list.
252       * @param node The element to append to the Stmt list.
253       * @apilevel high-level
254       */
255      public void addStmt(Stmt node) {
256        List<Stmt> list = (parent == null) ? getStmtListNoTransform() : getStmtList();
257        list.addChild(node);
258      }
259      /**
260       * @apilevel low-level
261       */
262      public void addStmtNoTransform(Stmt node) {
263        List<Stmt> list = getStmtListNoTransform();
264        list.addChild(node);
265      }
266      /**
267       * Replaces the Stmt list element at index {@code i} with the new node {@code node}.
268       * @param node The new node to replace the old list element.
269       * @param i The list index of the node to be replaced.
270       * @apilevel high-level
271       */
272      public void setStmt(Stmt node, int i) {
273        List<Stmt> list = getStmtList();
274        list.setChild(node, i);
275      }
276      /**
277       * Retrieves the Stmt list.
278       * @return The node representing the Stmt list.
279       * @apilevel high-level
280       */
281      @ASTNodeAnnotation.ListChild(name="Stmt")
282      public List<Stmt> getStmtList() {
283        List<Stmt> list = (List<Stmt>) getChild(0);
284        return list;
285      }
286      /**
287       * Retrieves the Stmt list.
288       * <p><em>This method does not invoke AST transformations.</em></p>
289       * @return The node representing the Stmt list.
290       * @apilevel low-level
291       */
292      public List<Stmt> getStmtListNoTransform() {
293        return (List<Stmt>) getChildNoTransform(0);
294      }
295      /**
296       * Retrieves the Stmt list.
297       * @return The node representing the Stmt list.
298       * @apilevel high-level
299       */
300      public List<Stmt> getStmts() {
301        return getStmtList();
302      }
303      /**
304       * Retrieves the Stmt list.
305       * <p><em>This method does not invoke AST transformations.</em></p>
306       * @return The node representing the Stmt list.
307       * @apilevel low-level
308       */
309      public List<Stmt> getStmtsNoTransform() {
310        return getStmtListNoTransform();
311      }
312      /**
313       * @attribute syn
314       * @aspect DeclareBeforeUse
315       * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:38
316       */
317      @ASTNodeAnnotation.Attribute
318      public boolean declaredBeforeUse(VariableDeclaration decl, int indexUse) {
319        boolean declaredBeforeUse_VariableDeclaration_int_value = decl.blockIndex() < indexUse;
320    
321        return declaredBeforeUse_VariableDeclaration_int_value;
322      }
323      /**
324       * @apilevel internal
325       */
326      protected java.util.Map checkReturnDA_Variable_values;
327      /**
328       * @apilevel internal
329       */
330      private void checkReturnDA_Variable_reset() {
331        checkReturnDA_Variable_values = null;
332      }
333      /**
334       * @attribute syn
335       * @aspect DA
336       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:339
337       */
338      @ASTNodeAnnotation.Attribute
339      public boolean checkReturnDA(Variable v) {
340        Object _parameters = v;
341        if (checkReturnDA_Variable_values == null) checkReturnDA_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
342        ASTNode$State state = state();
343        if (checkReturnDA_Variable_values.containsKey(_parameters)) {
344          return (Boolean) checkReturnDA_Variable_values.get(_parameters);
345        }
346        boolean intermediate = state.INTERMEDIATE_VALUE;
347        state.INTERMEDIATE_VALUE = false;
348        int num = state.boundariesCrossed;
349        boolean isFinal = this.is$Final();
350        boolean checkReturnDA_Variable_value = checkReturnDA_compute(v);
351        if (isFinal && num == state().boundariesCrossed) {
352          checkReturnDA_Variable_values.put(_parameters, checkReturnDA_Variable_value);
353        } else {
354        }
355        state.INTERMEDIATE_VALUE |= intermediate;
356    
357        return checkReturnDA_Variable_value;
358      }
359      /**
360       * @apilevel internal
361       */
362      private boolean checkReturnDA_compute(Variable v) {
363          HashSet set = new HashSet();
364          collectBranches(set);
365          for (Iterator iter = set.iterator(); iter.hasNext(); ) {
366            Object o = iter.next();
367            if (o instanceof ReturnStmt) {
368              ReturnStmt stmt = (ReturnStmt) o;
369              if (!stmt.isDAafterReachedFinallyBlocks(v)) {
370                return false;
371              }
372            }
373          }
374          return true;
375        }
376      /**
377       * @apilevel internal
378       */
379      protected java.util.Map isDAafter_Variable_values;
380      /**
381       * @apilevel internal
382       */
383      private void isDAafter_Variable_reset() {
384        isDAafter_Variable_values = null;
385      }
386      /**
387       * @attribute syn
388       * @aspect DA
389       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
390       */
391      @ASTNodeAnnotation.Attribute
392      public boolean isDAafter(Variable v) {
393        Object _parameters = v;
394        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
395        ASTNode$State state = state();
396        if (isDAafter_Variable_values.containsKey(_parameters)) {
397          return (Boolean) isDAafter_Variable_values.get(_parameters);
398        }
399        boolean intermediate = state.INTERMEDIATE_VALUE;
400        state.INTERMEDIATE_VALUE = false;
401        int num = state.boundariesCrossed;
402        boolean isFinal = this.is$Final();
403        boolean isDAafter_Variable_value = getNumStmt() == 0 ? isDAbefore(v) : getStmt(getNumStmt()-1).isDAafter(v);
404        if (isFinal && num == state().boundariesCrossed) {
405          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
406        } else {
407        }
408        state.INTERMEDIATE_VALUE |= intermediate;
409    
410        return isDAafter_Variable_value;
411      }
412      /**
413       * @attribute syn
414       * @aspect DA
415       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:492
416       */
417      @ASTNodeAnnotation.Attribute
418      public boolean isDUeverywhere(Variable v) {
419        boolean isDUeverywhere_Variable_value = isDUbefore(v) && checkDUeverywhere(v);
420    
421        return isDUeverywhere_Variable_value;
422      }
423      /**
424       * @apilevel internal
425       */
426      protected java.util.Map checkReturnDU_Variable_values;
427      /**
428       * @apilevel internal
429       */
430      private void checkReturnDU_Variable_reset() {
431        checkReturnDU_Variable_values = null;
432      }
433      /**
434       * @attribute syn
435       * @aspect DU
436       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:858
437       */
438      @ASTNodeAnnotation.Attribute
439      public boolean checkReturnDU(Variable v) {
440        Object _parameters = v;
441        if (checkReturnDU_Variable_values == null) checkReturnDU_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
442        ASTNode$State state = state();
443        if (checkReturnDU_Variable_values.containsKey(_parameters)) {
444          return (Boolean) checkReturnDU_Variable_values.get(_parameters);
445        }
446        boolean intermediate = state.INTERMEDIATE_VALUE;
447        state.INTERMEDIATE_VALUE = false;
448        int num = state.boundariesCrossed;
449        boolean isFinal = this.is$Final();
450        boolean checkReturnDU_Variable_value = checkReturnDU_compute(v);
451        if (isFinal && num == state().boundariesCrossed) {
452          checkReturnDU_Variable_values.put(_parameters, checkReturnDU_Variable_value);
453        } else {
454        }
455        state.INTERMEDIATE_VALUE |= intermediate;
456    
457        return checkReturnDU_Variable_value;
458      }
459      /**
460       * @apilevel internal
461       */
462      private boolean checkReturnDU_compute(Variable v) {
463          HashSet set = new HashSet();
464          collectBranches(set);
465          for (Iterator iter = set.iterator(); iter.hasNext(); ) {
466            Object o = iter.next();
467            if (o instanceof ReturnStmt) {
468              ReturnStmt stmt = (ReturnStmt) o;
469              if (!stmt.isDUafterReachedFinallyBlocks(v)) {
470                return false;
471              }
472            }
473          }
474          return true;
475        }
476      /**
477       * @apilevel internal
478       */
479      protected java.util.Map isDUafter_Variable_values;
480      /**
481       * @apilevel internal
482       */
483      private void isDUafter_Variable_reset() {
484        isDUafter_Variable_values = null;
485      }
486      /**
487       * @attribute syn
488       * @aspect DU
489       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
490       */
491      @ASTNodeAnnotation.Attribute
492      public boolean isDUafter(Variable v) {
493        Object _parameters = v;
494        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
495        ASTNode$State state = state();
496        if (isDUafter_Variable_values.containsKey(_parameters)) {
497          return (Boolean) isDUafter_Variable_values.get(_parameters);
498        }
499        boolean intermediate = state.INTERMEDIATE_VALUE;
500        state.INTERMEDIATE_VALUE = false;
501        int num = state.boundariesCrossed;
502        boolean isFinal = this.is$Final();
503        boolean isDUafter_Variable_value = getNumStmt() == 0 ? isDUbefore(v) : getStmt(getNumStmt()-1).isDUafter(v);
504        if (isFinal && num == state().boundariesCrossed) {
505          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
506        } else {
507        }
508        state.INTERMEDIATE_VALUE |= intermediate;
509    
510        return isDUafter_Variable_value;
511      }
512      /**
513       * @apilevel internal
514       */
515      protected java.util.Map localVariableDeclaration_String_values;
516      /**
517       * @apilevel internal
518       */
519      private void localVariableDeclaration_String_reset() {
520        localVariableDeclaration_String_values = null;
521      }
522      /**
523       * @attribute syn
524       * @aspect VariableScope
525       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:185
526       */
527      @ASTNodeAnnotation.Attribute
528      public VariableDeclaration localVariableDeclaration(String name) {
529        Object _parameters = name;
530        if (localVariableDeclaration_String_values == null) localVariableDeclaration_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
531        ASTNode$State state = state();
532        if (localVariableDeclaration_String_values.containsKey(_parameters)) {
533          return (VariableDeclaration) localVariableDeclaration_String_values.get(_parameters);
534        }
535        boolean intermediate = state.INTERMEDIATE_VALUE;
536        state.INTERMEDIATE_VALUE = false;
537        int num = state.boundariesCrossed;
538        boolean isFinal = this.is$Final();
539        VariableDeclaration localVariableDeclaration_String_value = localVariableDeclaration_compute(name);
540        if (isFinal && num == state().boundariesCrossed) {
541          localVariableDeclaration_String_values.put(_parameters, localVariableDeclaration_String_value);
542        } else {
543        }
544        state.INTERMEDIATE_VALUE |= intermediate;
545    
546        return localVariableDeclaration_String_value;
547      }
548      /**
549       * @apilevel internal
550       */
551      private VariableDeclaration localVariableDeclaration_compute(String name) {
552          for (Stmt stmt: getStmtList()) {
553            VariableDeclaration decl = stmt.variableDeclaration(name);
554            if (decl != null) {
555              return decl;
556            }
557          }
558          return null;
559        }
560      /**
561       * @attribute syn
562       * @aspect PrettyPrintUtil
563       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:219
564       */
565      @ASTNodeAnnotation.Attribute
566      public boolean hasStmts() {
567        boolean hasStmts_value = getNumStmt() > 0;
568    
569        return hasStmts_value;
570      }
571      /**
572       * @apilevel internal
573       */
574      protected boolean canCompleteNormally_computed = false;
575      /**
576       * @apilevel internal
577       */
578      protected boolean canCompleteNormally_value;
579      /**
580       * @apilevel internal
581       */
582      private void canCompleteNormally_reset() {
583        canCompleteNormally_computed = false;
584      }
585      /**
586       * @attribute syn
587       * @aspect UnreachableStatements
588       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53
589       */
590      @ASTNodeAnnotation.Attribute
591      public boolean canCompleteNormally() {
592        ASTNode$State state = state();
593        if (canCompleteNormally_computed) {
594          return canCompleteNormally_value;
595        }
596        boolean intermediate = state.INTERMEDIATE_VALUE;
597        state.INTERMEDIATE_VALUE = false;
598        int num = state.boundariesCrossed;
599        boolean isFinal = this.is$Final();
600        canCompleteNormally_value = getNumStmt() == 0
601              ? reachable()
602              : getStmt(getNumStmt() - 1).canCompleteNormally();
603        if (isFinal && num == state().boundariesCrossed) {
604          canCompleteNormally_computed = true;
605        } else {
606        }
607        state.INTERMEDIATE_VALUE |= intermediate;
608    
609        return canCompleteNormally_value;
610      }
611      /**
612       * @apilevel internal
613       */
614      protected java.util.Map variableScopeEndLabel_CodeGeneration_values;
615      /**
616       * @apilevel internal
617       */
618      private void variableScopeEndLabel_CodeGeneration_reset() {
619        variableScopeEndLabel_CodeGeneration_values = null;
620      }
621      /**
622       * @attribute syn
623       * @aspect CodeGeneration
624       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:68
625       */
626      @ASTNodeAnnotation.Attribute
627      public int variableScopeEndLabel(CodeGeneration gen) {
628        Object _parameters = gen;
629        if (variableScopeEndLabel_CodeGeneration_values == null) variableScopeEndLabel_CodeGeneration_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
630        ASTNode$State state = state();
631        if (variableScopeEndLabel_CodeGeneration_values.containsKey(_parameters)) {
632          return (Integer) variableScopeEndLabel_CodeGeneration_values.get(_parameters);
633        }
634        boolean intermediate = state.INTERMEDIATE_VALUE;
635        state.INTERMEDIATE_VALUE = false;
636        int num = state.boundariesCrossed;
637        boolean isFinal = this.is$Final();
638        int variableScopeEndLabel_CodeGeneration_value = gen.variableScopeLabel();
639        if (isFinal && num == state().boundariesCrossed) {
640          variableScopeEndLabel_CodeGeneration_values.put(_parameters, variableScopeEndLabel_CodeGeneration_value);
641        } else {
642        }
643        state.INTERMEDIATE_VALUE |= intermediate;
644    
645        return variableScopeEndLabel_CodeGeneration_value;
646      }
647      /**
648       * @attribute syn
649       * @aspect PreciseRethrow
650       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
651       */
652      @ASTNodeAnnotation.Attribute
653      public boolean modifiedInScope(Variable var) {
654        {
655            for (Stmt stmt : getStmtList()) {
656              if (stmt.modifiedInScope(var)) {
657                return true;
658              }
659            }
660            return false;
661          }
662      }
663      /**
664       * @attribute inh
665       * @aspect TypeScopePropagation
666       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:340
667       */
668      /**
669       * @attribute inh
670       * @aspect TypeScopePropagation
671       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:340
672       */
673      @ASTNodeAnnotation.Attribute
674      public SimpleSet lookupType(String name) {
675        Object _parameters = name;
676        if (lookupType_String_values == null) lookupType_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
677        ASTNode$State state = state();
678        if (lookupType_String_values.containsKey(_parameters)) {
679          return (SimpleSet) lookupType_String_values.get(_parameters);
680        }
681        boolean intermediate = state.INTERMEDIATE_VALUE;
682        state.INTERMEDIATE_VALUE = false;
683        int num = state.boundariesCrossed;
684        boolean isFinal = this.is$Final();
685        SimpleSet lookupType_String_value = getParent().Define_lookupType(this, null, name);
686        if (isFinal && num == state().boundariesCrossed) {
687          lookupType_String_values.put(_parameters, lookupType_String_value);
688        } else {
689        }
690        state.INTERMEDIATE_VALUE |= intermediate;
691    
692        return lookupType_String_value;
693      }
694      /**
695       * @apilevel internal
696       */
697      protected java.util.Map lookupType_String_values;
698      /**
699       * @apilevel internal
700       */
701      private void lookupType_String_reset() {
702        lookupType_String_values = null;
703      }
704      /**
705       * @attribute inh
706       * @aspect VariableScope
707       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:38
708       */
709      /**
710       * @attribute inh
711       * @aspect VariableScope
712       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:38
713       */
714      @ASTNodeAnnotation.Attribute
715      public SimpleSet lookupVariable(String name) {
716        Object _parameters = name;
717        if (lookupVariable_String_values == null) lookupVariable_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
718        ASTNode$State state = state();
719        if (lookupVariable_String_values.containsKey(_parameters)) {
720          return (SimpleSet) lookupVariable_String_values.get(_parameters);
721        }
722        boolean intermediate = state.INTERMEDIATE_VALUE;
723        state.INTERMEDIATE_VALUE = false;
724        int num = state.boundariesCrossed;
725        boolean isFinal = this.is$Final();
726        SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name);
727        if (isFinal && num == state().boundariesCrossed) {
728          lookupVariable_String_values.put(_parameters, lookupVariable_String_value);
729        } else {
730        }
731        state.INTERMEDIATE_VALUE |= intermediate;
732    
733        return lookupVariable_String_value;
734      }
735      /**
736       * @apilevel internal
737       */
738      protected java.util.Map lookupVariable_String_values;
739      /**
740       * @apilevel internal
741       */
742      private void lookupVariable_String_reset() {
743        lookupVariable_String_values = null;
744      }
745      /**
746       * @attribute inh
747       * @aspect NameCheck
748       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:525
749       */
750      /**
751       * @attribute inh
752       * @aspect NameCheck
753       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:525
754       */
755      @ASTNodeAnnotation.Attribute
756      public SimpleSet otherLocalClassDecls(String name) {
757        SimpleSet otherLocalClassDecls_String_value = getParent().Define_otherLocalClassDecls(this, null, name);
758    
759        return otherLocalClassDecls_String_value;
760      }
761      /**
762       * @attribute inh
763       * @aspect UnreachableStatements
764       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52
765       */
766      /**
767       * @attribute inh
768       * @aspect UnreachableStatements
769       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52
770       */
771      @ASTNodeAnnotation.Attribute
772      public boolean reachable() {
773        boolean reachable_value = getParent().Define_reachable(this, null);
774    
775        return reachable_value;
776      }
777      /**
778       * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:34
779       * @apilevel internal
780       */
781      public int Define_blockIndex(ASTNode caller, ASTNode child) {
782        if (caller == getStmtListNoTransform()) {
783          // @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:36
784          int index = caller.getIndexOfChild(child);
785          return index;
786        }
787        else {
788          return getParent().Define_blockIndex(this, caller);
789        }
790      }
791      protected boolean canDefine_blockIndex(ASTNode caller, ASTNode child) {
792        return true;
793      }
794      /**
795       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:71
796       * @apilevel internal
797       */
798      public boolean Define_isIncOrDec(ASTNode caller, ASTNode child) {
799        if (caller == getStmtListNoTransform()) {
800          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:74
801          int childIndex = caller.getIndexOfChild(child);
802          return false;
803        }
804        else {
805          return getParent().Define_isIncOrDec(this, caller);
806        }
807      }
808      protected boolean canDefine_isIncOrDec(ASTNode caller, ASTNode child) {
809        return true;
810      }
811      /**
812       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
813       * @apilevel internal
814       */
815      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
816        if (caller == getStmtListNoTransform()) {
817          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:486
818          int index = caller.getIndexOfChild(child);
819          return index == 0 ? isDAbefore(v) : getStmt(index - 1).isDAafter(v);
820        }
821        else {
822          return getParent().Define_isDAbefore(this, caller, v);
823        }
824      }
825      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
826        return true;
827      }
828      /**
829       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
830       * @apilevel internal
831       */
832      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
833        if (caller == getStmtListNoTransform()) {
834          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:986
835          int index = caller.getIndexOfChild(child);
836          return index == 0 ? isDUbefore(v) : getStmt(index - 1).isDUafter(v);
837        }
838        else {
839          return getParent().Define_isDUbefore(this, caller, v);
840        }
841      }
842      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
843        return true;
844      }
845      /**
846       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197
847       * @apilevel internal
848       */
849      public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) {
850        if (caller == getStmtListNoTransform()) {
851          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:500
852          int index = caller.getIndexOfChild(child);
853          {
854              SimpleSet c = SimpleSet.emptySet;
855              for (int i = index; i >= 0 && !(getStmt(i) instanceof Case); i--) {
856                if (getStmt(i) instanceof LocalClassDeclStmt) {
857                  TypeDecl t = ((LocalClassDeclStmt) getStmt(i)).getClassDecl();
858                  if (t.name().equals(name)) {
859                    c = c.add(t);
860                  }
861                }
862              }
863              if (!c.isEmpty()) {
864                return c;
865              }
866              return lookupType(name);
867            }
868        }
869        else {
870          return getParent().Define_lookupType(this, caller, name);
871        }
872      }
873      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) {
874        return true;
875      }
876      /**
877       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
878       * @apilevel internal
879       */
880      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
881        if (caller == getStmtListNoTransform()) {
882          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:125
883          int index = caller.getIndexOfChild(child);
884          {
885              VariableDeclaration v = localVariableDeclaration(name);
886              // declare before use and shadowing
887              if (v != null && declaredBeforeUse(v, index)) {
888                return v;
889              }
890              return lookupVariable(name);
891            }
892        }
893        else {
894          return getParent().Define_lookupVariable(this, caller, name);
895        }
896      }
897      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
898        return true;
899      }
900      /**
901       * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:30
902       * @apilevel internal
903       */
904      public VariableScope Define_outerScope(ASTNode caller, ASTNode child) {
905        if (caller == getStmtListNoTransform()) {
906          // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:367
907          int childIndex = caller.getIndexOfChild(child);
908          return this;
909        }
910        else {
911          return getParent().Define_outerScope(this, caller);
912        }
913      }
914      protected boolean canDefine_outerScope(ASTNode caller, ASTNode child) {
915        return true;
916      }
917      /**
918       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:524
919       * @apilevel internal
920       */
921      public SimpleSet Define_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) {
922        if (caller == getStmtListNoTransform()) {
923          // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:529
924          int index = caller.getIndexOfChild(child);
925          {
926              SimpleSet local = SimpleSet.emptySet;
927              for (int i = index-1; i >= 0 && !(getStmt(i) instanceof Case); --i) {
928                if (getStmt(i) instanceof LocalClassDeclStmt) {
929                  TypeDecl t = ((LocalClassDeclStmt) getStmt(i)).getClassDecl();
930                  if (t.name().equals(name)) {
931                    local = local.add(t);
932                  }
933                }
934              }
935              if (!local.isEmpty()) {
936                return local;
937              } else {
938                return otherLocalClassDecls(name);
939              }
940            }
941        }
942        else {
943          return getParent().Define_otherLocalClassDecls(this, caller, name);
944        }
945      }
946      protected boolean canDefine_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) {
947        return true;
948      }
949      /**
950       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
951       * @apilevel internal
952       */
953      public NameType Define_nameType(ASTNode caller, ASTNode child) {
954        if (caller == getStmtListNoTransform()) {
955          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:138
956          int childIndex = caller.getIndexOfChild(child);
957          return NameType.EXPRESSION_NAME;
958        }
959        else {
960          return getParent().Define_nameType(this, caller);
961        }
962      }
963      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
964        return true;
965      }
966      /**
967       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52
968       * @apilevel internal
969       */
970      public boolean Define_reachable(ASTNode caller, ASTNode child) {
971        if (caller == getStmtListNoTransform()) {
972          // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:72
973          int index = caller.getIndexOfChild(child);
974          return index == 0
975                ? reachable()
976                : getStmt(index-1).canCompleteNormally();
977        }
978        else {
979          return getParent().Define_reachable(this, caller);
980        }
981      }
982      protected boolean canDefine_reachable(ASTNode caller, ASTNode child) {
983        return true;
984      }
985      /**
986       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:283
987       * @apilevel internal
988       */
989      public boolean Define_reportUnreachable(ASTNode caller, ASTNode child) {
990        if (caller == getStmtListNoTransform()) {
991          // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:210
992          int i = caller.getIndexOfChild(child);
993          return i == 0 ? reachable() : getStmt(i-1).reachable();
994        }
995        else {
996          return getParent().Define_reportUnreachable(this, caller);
997        }
998      }
999      protected boolean canDefine_reportUnreachable(ASTNode caller, ASTNode child) {
1000        return true;
1001      }
1002      /**
1003       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:67
1004       * @apilevel internal
1005       */
1006      public int Define_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) {
1007        if (caller == getStmtListNoTransform()) {
1008          // @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:69
1009          int i = caller.getIndexOfChild(child);
1010          return variableScopeEndLabel(gen);
1011        }
1012        else {
1013          return getParent().Define_variableScopeEndLabel(this, caller, gen);
1014        }
1015      }
1016      protected boolean canDefine_variableScopeEndLabel(ASTNode caller, ASTNode child, CodeGeneration gen) {
1017        return true;
1018      }
1019      /**
1020       * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64
1021       * @apilevel internal
1022       */
1023      public int Define_localNum(ASTNode caller, ASTNode child) {
1024        if (caller == getStmtListNoTransform()) {
1025          // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:183
1026          int index = caller.getIndexOfChild(child);
1027          {
1028              if (index == 0) {
1029                return localNum();
1030              } else {
1031                return getStmt(index-1).localNum() + getStmt(index-1).localSize();
1032              }
1033            }
1034        }
1035        else {
1036          return getParent().Define_localNum(this, caller);
1037        }
1038      }
1039      protected boolean canDefine_localNum(ASTNode caller, ASTNode child) {
1040        return true;
1041      }
1042      /**
1043       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30
1044       * @apilevel internal
1045       */
1046      public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
1047        if (caller == getStmtListNoTransform()) {
1048          // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:51
1049          int childIndex = caller.getIndexOfChild(child);
1050          return modifiedInScope(var);
1051        }
1052        else {
1053          return getParent().Define_inhModifiedInScope(this, caller, var);
1054        }
1055      }
1056      protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
1057        return true;
1058      }
1059      /**
1060       * @apilevel internal
1061       */
1062      public ASTNode rewriteTo() {
1063        return super.rewriteTo();
1064      }
1065    }