001    /* This file was generated with JastAdd2 (http://jastadd.org) version R20130213 */
002    package AST;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.*;
007    import beaver.*;
008    import java.util.ArrayList;
009    import java.util.zip.*;
010    import java.io.*;
011    import java.io.FileNotFoundException;
012    import java.util.Collection;
013    /**
014     * @production EnhancedForStmt : {@link BranchTargetStmt} ::= <span class="component">{@link VariableDeclaration}</span> <span class="component">{@link Expr}</span> <span class="component">{@link Stmt}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.ast:1
017     */
018    public class EnhancedForStmt extends BranchTargetStmt implements Cloneable, VariableScope {
019      /**
020       * @apilevel low-level
021       */
022      public void flushCache() {
023      }
024      /**
025       * @apilevel internal
026       */
027      public void flushCollectionCache() {
028      }
029      /**
030       * @apilevel internal
031       */
032      @SuppressWarnings({"unchecked", "cast"})
033      public EnhancedForStmt clone() throws CloneNotSupportedException {
034        EnhancedForStmt node = (EnhancedForStmt)super.clone();
035        node.targetOf_ContinueStmt_values = null;
036        node.targetOf_BreakStmt_values = null;
037        node.canCompleteNormally_computed = false;
038        node.isDAafter_Variable_values = null;
039        node.isDUafter_Variable_values = null;
040        node.cond_label_computed = false;
041        node.update_label_computed = false;
042        node.end_label_computed = false;
043        node.extraLocalIndex_computed = false;
044        node.in$Circle(false);
045        node.is$Final(false);
046        return node;
047      }
048    /**
049     * @apilevel internal
050     */
051      @SuppressWarnings({"unchecked", "cast"})
052    public EnhancedForStmt copy() {
053      
054      try {
055        EnhancedForStmt node = (EnhancedForStmt) clone();
056        node.parent = null;
057        if(children != null)
058          node.children = (ASTNode[]) children.clone();
059        
060        return node;
061      } catch (CloneNotSupportedException e) {
062        throw new Error("Error: clone not supported for " + getClass().getName());
063      }
064      
065    }/**
066     * Create a deep copy of the AST subtree at this node.
067     * The copy is dangling, i.e. has no parent.
068     * @return dangling copy of the subtree at this node
069     * @apilevel low-level
070     */
071      @SuppressWarnings({"unchecked", "cast"})
072    public EnhancedForStmt fullCopy() {
073      
074      EnhancedForStmt tree = (EnhancedForStmt) copy();
075      if (children != null) {
076        for (int i = 0; i < children.length; ++i) {
077          
078          ASTNode child = (ASTNode) children[i];
079          if(child != null) {
080            child = child.fullCopy();
081            tree.setChild(child, i);
082          }
083        }
084      }
085      return tree;
086      
087    }  /**
088       * @ast method 
089       * @aspect EnhancedFor
090       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:15
091       */
092      public void typeCheck() {
093                if (!getExpr().type().isArrayDecl() && !getExpr().type().isIterable()) {
094                        error("type " + getExpr().type().name() + 
095                              " of expression in foreach is neither array type nor java.lang.Iterable");
096                }       
097        else if(getExpr().type().isArrayDecl() && !getExpr().type().componentType().assignConversionTo(getVariableDeclaration().type(), null))
098          error("parameter of type " + getVariableDeclaration().type().typeName() + " can not be assigned an element of type " + getExpr().type().componentType().typeName()); 
099        else if(getExpr().type().isIterable() && !getExpr().type().isUnknown()) {
100          MethodDecl iterator = (MethodDecl)getExpr().type().memberMethods("iterator").iterator().next();
101          MethodDecl next = (MethodDecl)iterator.type().memberMethods("next").iterator().next();
102          TypeDecl componentType = next.type();
103          if(!componentType.assignConversionTo(getVariableDeclaration().type(), null))
104            error("parameter of type " + getVariableDeclaration().type().typeName() + " can not be assigned an element of type " + componentType.typeName()); 
105        }
106       }
107      /**
108       * @ast method 
109       * @aspect EnhancedFor
110       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:58
111       */
112      public void toString(StringBuffer s) {
113        s.append(indent());
114        s.append("for (");
115        getVariableDeclaration().getModifiers().toString(s);
116        getVariableDeclaration().getTypeAccess().toString(s);
117        s.append(" " + getVariableDeclaration().name());
118        s.append(" : ");
119        getExpr().toString(s);
120        s.append(") ");
121        getStmt().toString(s);
122      }
123      /**
124       * @ast method 
125       * @aspect EnhancedForToBytecode
126       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:24
127       */
128      public void createBCode(CodeGeneration gen) {
129        if(getExpr().type().isArrayDecl()) {
130          getExpr().createBCode(gen);
131          gen.emitStoreReference(extraLocalIndex());
132          IntegerLiteral.push(gen, 0);
133          gen.emit(Bytecode.ISTORE).add(extraLocalIndex()+1);
134          gen.addLabel(cond_label());
135          gen.emit(Bytecode.ILOAD).add(extraLocalIndex()+1);
136          gen.emitLoadReference(extraLocalIndex());
137          gen.emit(Bytecode.ARRAYLENGTH);
138          gen.emitCompare(Bytecode.IF_ICMPGE, end_label());
139          gen.emitLoadReference(extraLocalIndex());
140          gen.emit(Bytecode.ILOAD).add(extraLocalIndex()+1);
141          gen.emit(getExpr().type().componentType().arrayLoad());
142          getExpr().type().componentType().emitCastTo(gen, getVariableDeclaration().type());
143          getVariableDeclaration().type().emitStoreLocal(gen, getVariableDeclaration().localNum());
144          getStmt().createBCode(gen);
145          gen.addLabel(update_label());
146          gen.emit(Bytecode.IINC).add(extraLocalIndex()+1).add(1);
147          gen.emitGoto(cond_label());
148          gen.addLabel(end_label());
149        }
150        else {
151          getExpr().createBCode(gen);
152          iteratorMethod().emitInvokeMethod(gen, lookupType("java.lang", "Iterable"));
153          gen.emitStoreReference(extraLocalIndex());
154          gen.addLabel(cond_label());
155          gen.emitLoadReference(extraLocalIndex());
156          hasNextMethod().emitInvokeMethod(gen, lookupType("java.util", "Iterator"));
157          gen.emitCompare(Bytecode.IFEQ, end_label());
158          gen.emitLoadReference(extraLocalIndex());
159          nextMethod().emitInvokeMethod(gen, lookupType("java.util", "Iterator"));
160          VariableDeclaration obj = getVariableDeclaration();
161          if (!obj.type().boxed().isUnknown()) {
162            gen.emitCheckCast(obj.type().boxed());
163            obj.type().boxed().emitCastTo(gen, obj.type());
164            obj.type().emitStoreLocal(gen, obj.localNum());
165          } else {
166            gen.emitCheckCast(obj.type());
167            gen.emitStoreReference(obj.localNum());
168          }
169          getStmt().createBCode(gen);
170          gen.addLabel(update_label());        
171          gen.emitGoto(cond_label());
172          gen.addLabel(end_label());
173        }
174      }
175      /**
176       * @ast method 
177       * @aspect EnhancedForToBytecode
178       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:72
179       */
180      private MethodDecl iteratorMethod() {
181        TypeDecl typeDecl = lookupType("java.lang", "Iterable");
182               for (Iterator iter = typeDecl.memberMethods("iterator").iterator(); iter.hasNext();) {
183                       MethodDecl m = (MethodDecl)iter.next();
184                       if (m.getNumParameter() == 0) {
185                               return m;
186          }
187        }
188        throw new Error("Could not find java.lang.Iterable.iterator()");
189      }
190      /**
191       * @ast method 
192       * @aspect EnhancedForToBytecode
193       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:82
194       */
195      private MethodDecl hasNextMethod() {
196        TypeDecl typeDecl = lookupType("java.util", "Iterator");
197               for (Iterator iter = typeDecl.memberMethods("hasNext").iterator(); iter.hasNext();) {
198                       MethodDecl m = (MethodDecl)iter.next();
199                       if (m.getNumParameter() == 0) {
200                               return m;
201          }
202        }
203        throw new Error("Could not find java.util.Collection.hasNext()");
204      }
205      /**
206       * @ast method 
207       * @aspect EnhancedForToBytecode
208       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:92
209       */
210      private MethodDecl nextMethod() {
211        TypeDecl typeDecl = lookupType("java.util", "Iterator");
212               for (Iterator iter = typeDecl.memberMethods("next").iterator(); iter.hasNext();) {
213                       MethodDecl m = (MethodDecl)iter.next();
214                       if (m.getNumParameter() == 0) {
215                               return m;
216          }
217        }
218        throw new Error("Could not find java.util.Collection.next()");
219      }
220      /**
221       * @ast method 
222       * 
223       */
224      public EnhancedForStmt() {
225        super();
226    
227    
228      }
229      /**
230       * Initializes the child array to the correct size.
231       * Initializes List and Opt nta children.
232       * @apilevel internal
233       * @ast method
234       * @ast method 
235       * 
236       */
237      public void init$Children() {
238        children = new ASTNode[3];
239      }
240      /**
241       * @ast method 
242       * 
243       */
244      public EnhancedForStmt(VariableDeclaration p0, Expr p1, Stmt p2) {
245        setChild(p0, 0);
246        setChild(p1, 1);
247        setChild(p2, 2);
248      }
249      /**
250       * @apilevel low-level
251       * @ast method 
252       * 
253       */
254      protected int numChildren() {
255        return 3;
256      }
257      /**
258       * @apilevel internal
259       * @ast method 
260       * 
261       */
262      public boolean mayHaveRewrite() {
263        return false;
264      }
265      /**
266       * Replaces the VariableDeclaration child.
267       * @param node The new node to replace the VariableDeclaration child.
268       * @apilevel high-level
269       * @ast method 
270       * 
271       */
272      public void setVariableDeclaration(VariableDeclaration node) {
273        setChild(node, 0);
274      }
275      /**
276       * Retrieves the VariableDeclaration child.
277       * @return The current node used as the VariableDeclaration child.
278       * @apilevel high-level
279       * @ast method 
280       * 
281       */
282      public VariableDeclaration getVariableDeclaration() {
283        return (VariableDeclaration)getChild(0);
284      }
285      /**
286       * Retrieves the VariableDeclaration child.
287       * <p><em>This method does not invoke AST transformations.</em></p>
288       * @return The current node used as the VariableDeclaration child.
289       * @apilevel low-level
290       * @ast method 
291       * 
292       */
293      public VariableDeclaration getVariableDeclarationNoTransform() {
294        return (VariableDeclaration)getChildNoTransform(0);
295      }
296      /**
297       * Replaces the Expr child.
298       * @param node The new node to replace the Expr child.
299       * @apilevel high-level
300       * @ast method 
301       * 
302       */
303      public void setExpr(Expr node) {
304        setChild(node, 1);
305      }
306      /**
307       * Retrieves the Expr child.
308       * @return The current node used as the Expr child.
309       * @apilevel high-level
310       * @ast method 
311       * 
312       */
313      public Expr getExpr() {
314        return (Expr)getChild(1);
315      }
316      /**
317       * Retrieves the Expr child.
318       * <p><em>This method does not invoke AST transformations.</em></p>
319       * @return The current node used as the Expr child.
320       * @apilevel low-level
321       * @ast method 
322       * 
323       */
324      public Expr getExprNoTransform() {
325        return (Expr)getChildNoTransform(1);
326      }
327      /**
328       * Replaces the Stmt child.
329       * @param node The new node to replace the Stmt child.
330       * @apilevel high-level
331       * @ast method 
332       * 
333       */
334      public void setStmt(Stmt node) {
335        setChild(node, 2);
336      }
337      /**
338       * Retrieves the Stmt child.
339       * @return The current node used as the Stmt child.
340       * @apilevel high-level
341       * @ast method 
342       * 
343       */
344      public Stmt getStmt() {
345        return (Stmt)getChild(2);
346      }
347      /**
348       * Retrieves the Stmt child.
349       * <p><em>This method does not invoke AST transformations.</em></p>
350       * @return The current node used as the Stmt child.
351       * @apilevel low-level
352       * @ast method 
353       * 
354       */
355      public Stmt getStmtNoTransform() {
356        return (Stmt)getChildNoTransform(2);
357      }
358      /**
359       * @attribute syn
360       * @aspect EnhancedFor
361       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:50
362       */
363      public SimpleSet localLookupVariable(String name) {
364        ASTNode$State state = state();
365        try {
366               if(getVariableDeclaration().name().equals(name)) {
367          return SimpleSet.emptySet.add(getVariableDeclaration());
368        }
369         return lookupVariable(name);
370       }
371        finally {
372        }
373      }
374      protected java.util.Map targetOf_ContinueStmt_values;
375      /**
376       * @attribute syn
377       * @aspect EnhancedFor
378       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:75
379       */
380      @SuppressWarnings({"unchecked", "cast"})
381      public boolean targetOf(ContinueStmt stmt) {
382        Object _parameters = stmt;
383        if(targetOf_ContinueStmt_values == null) targetOf_ContinueStmt_values = new java.util.HashMap(4);
384        if(targetOf_ContinueStmt_values.containsKey(_parameters)) {
385          return ((Boolean)targetOf_ContinueStmt_values.get(_parameters)).booleanValue();
386        }
387          ASTNode$State state = state();
388      int num = state.boundariesCrossed;
389      boolean isFinal = this.is$Final();
390        boolean targetOf_ContinueStmt_value = targetOf_compute(stmt);
391      if(isFinal && num == state().boundariesCrossed){ targetOf_ContinueStmt_values.put(_parameters, Boolean.valueOf(targetOf_ContinueStmt_value)); }
392            return targetOf_ContinueStmt_value;
393      }
394      /**
395       * @apilevel internal
396       */
397      private boolean targetOf_compute(ContinueStmt stmt) {  return !stmt.hasLabel();  }
398      protected java.util.Map targetOf_BreakStmt_values;
399      /**
400       * @attribute syn
401       * @aspect EnhancedFor
402       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:76
403       */
404      @SuppressWarnings({"unchecked", "cast"})
405      public boolean targetOf(BreakStmt stmt) {
406        Object _parameters = stmt;
407        if(targetOf_BreakStmt_values == null) targetOf_BreakStmt_values = new java.util.HashMap(4);
408        if(targetOf_BreakStmt_values.containsKey(_parameters)) {
409          return ((Boolean)targetOf_BreakStmt_values.get(_parameters)).booleanValue();
410        }
411          ASTNode$State state = state();
412      int num = state.boundariesCrossed;
413      boolean isFinal = this.is$Final();
414        boolean targetOf_BreakStmt_value = targetOf_compute(stmt);
415      if(isFinal && num == state().boundariesCrossed){ targetOf_BreakStmt_values.put(_parameters, Boolean.valueOf(targetOf_BreakStmt_value)); }
416            return targetOf_BreakStmt_value;
417      }
418      /**
419       * @apilevel internal
420       */
421      private boolean targetOf_compute(BreakStmt stmt) {  return !stmt.hasLabel();  }
422      /**
423       * @apilevel internal
424       */
425      protected boolean canCompleteNormally_computed = false;
426      /**
427       * @apilevel internal
428       */
429      protected boolean canCompleteNormally_value;
430      /**
431       * @attribute syn
432       * @aspect EnhancedFor
433       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:79
434       */
435      @SuppressWarnings({"unchecked", "cast"})
436      public boolean canCompleteNormally() {
437        if(canCompleteNormally_computed) {
438          return canCompleteNormally_value;
439        }
440          ASTNode$State state = state();
441      int num = state.boundariesCrossed;
442      boolean isFinal = this.is$Final();
443        canCompleteNormally_value = canCompleteNormally_compute();
444      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
445            return canCompleteNormally_value;
446      }
447      /**
448       * @apilevel internal
449       */
450      private boolean canCompleteNormally_compute() {  return reachable();  }
451      protected java.util.Map isDAafter_Variable_values;
452      /**
453       * @attribute syn
454       * @aspect EnhancedFor
455       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:83
456       */
457      @SuppressWarnings({"unchecked", "cast"})
458      public boolean isDAafter(Variable v) {
459        Object _parameters = v;
460        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
461        if(isDAafter_Variable_values.containsKey(_parameters)) {
462          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
463        }
464          ASTNode$State state = state();
465      int num = state.boundariesCrossed;
466      boolean isFinal = this.is$Final();
467        boolean isDAafter_Variable_value = isDAafter_compute(v);
468      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
469            return isDAafter_Variable_value;
470      }
471      /**
472       * @apilevel internal
473       */
474      private boolean isDAafter_compute(Variable v) {
475        if(!getExpr().isDAafter(v))
476          return false;
477        /*
478        for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
479          BreakStmt stmt = (BreakStmt)iter.next();
480          if(!stmt.isDAafterReachedFinallyBlocks(v))
481            return false;
482        }
483        */
484        return true;
485      }
486      protected java.util.Map isDUafter_Variable_values;
487      /**
488       * @attribute syn
489       * @aspect EnhancedFor
490       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:99
491       */
492      @SuppressWarnings({"unchecked", "cast"})
493      public boolean isDUafter(Variable v) {
494        Object _parameters = v;
495        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
496        if(isDUafter_Variable_values.containsKey(_parameters)) {
497          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
498        }
499          ASTNode$State state = state();
500      int num = state.boundariesCrossed;
501      boolean isFinal = this.is$Final();
502        boolean isDUafter_Variable_value = isDUafter_compute(v);
503      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
504            return isDUafter_Variable_value;
505      }
506      /**
507       * @apilevel internal
508       */
509      private boolean isDUafter_compute(Variable v) {
510        if(!getExpr().isDUafter(v))
511          return false;
512        for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
513          BreakStmt stmt = (BreakStmt)iter.next();
514          if(!stmt.isDUafterReachedFinallyBlocks(v))
515            return false;
516        }
517        return true;
518      }
519      /**
520       * @attribute syn
521       * @aspect NameCheck
522       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:401
523       */
524      public boolean continueLabel() {
525        ASTNode$State state = state();
526        try {  return true;  }
527        finally {
528        }
529      }
530      /**
531       * @apilevel internal
532       */
533      protected boolean cond_label_computed = false;
534      /**
535       * @apilevel internal
536       */
537      protected int cond_label_value;
538      /**
539       * @attribute syn
540       * @aspect EnhancedForToBytecode
541       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:12
542       */
543      @SuppressWarnings({"unchecked", "cast"})
544      public int cond_label() {
545        if(cond_label_computed) {
546          return cond_label_value;
547        }
548          ASTNode$State state = state();
549      int num = state.boundariesCrossed;
550      boolean isFinal = this.is$Final();
551        cond_label_value = cond_label_compute();
552      if(isFinal && num == state().boundariesCrossed){ cond_label_computed = true; }
553            return cond_label_value;
554      }
555      /**
556       * @apilevel internal
557       */
558      private int cond_label_compute() {  return hostType().constantPool().newLabel();  }
559      /**
560       * @apilevel internal
561       */
562      protected boolean update_label_computed = false;
563      /**
564       * @apilevel internal
565       */
566      protected int update_label_value;
567      /**
568       * @attribute syn
569       * @aspect EnhancedForToBytecode
570       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:13
571       */
572      @SuppressWarnings({"unchecked", "cast"})
573      public int update_label() {
574        if(update_label_computed) {
575          return update_label_value;
576        }
577          ASTNode$State state = state();
578      int num = state.boundariesCrossed;
579      boolean isFinal = this.is$Final();
580        update_label_value = update_label_compute();
581      if(isFinal && num == state().boundariesCrossed){ update_label_computed = true; }
582            return update_label_value;
583      }
584      /**
585       * @apilevel internal
586       */
587      private int update_label_compute() {  return hostType().constantPool().newLabel();  }
588      /**
589       * @apilevel internal
590       */
591      protected boolean end_label_computed = false;
592      /**
593       * @apilevel internal
594       */
595      protected int end_label_value;
596      /**
597       * @attribute syn
598       * @aspect EnhancedForToBytecode
599       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:14
600       */
601      @SuppressWarnings({"unchecked", "cast"})
602      public int end_label() {
603        if(end_label_computed) {
604          return end_label_value;
605        }
606          ASTNode$State state = state();
607      int num = state.boundariesCrossed;
608      boolean isFinal = this.is$Final();
609        end_label_value = end_label_compute();
610      if(isFinal && num == state().boundariesCrossed){ end_label_computed = true; }
611            return end_label_value;
612      }
613      /**
614       * @apilevel internal
615       */
616      private int end_label_compute() {  return hostType().constantPool().newLabel();  }
617      /**
618       * @apilevel internal
619       */
620      protected boolean extraLocalIndex_computed = false;
621      /**
622       * @apilevel internal
623       */
624      protected int extraLocalIndex_value;
625      /**
626       * @attribute syn
627       * @aspect EnhancedForToBytecode
628       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:16
629       */
630      @SuppressWarnings({"unchecked", "cast"})
631      public int extraLocalIndex() {
632        if(extraLocalIndex_computed) {
633          return extraLocalIndex_value;
634        }
635          ASTNode$State state = state();
636      int num = state.boundariesCrossed;
637      boolean isFinal = this.is$Final();
638        extraLocalIndex_value = extraLocalIndex_compute();
639      if(isFinal && num == state().boundariesCrossed){ extraLocalIndex_computed = true; }
640            return extraLocalIndex_value;
641      }
642      /**
643       * @apilevel internal
644       */
645      private int extraLocalIndex_compute() {  return localNum();  }
646      /**
647       * @attribute syn
648       * @aspect CreateBCode
649       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1398
650       */
651      public int break_label() {
652        ASTNode$State state = state();
653        try {  return end_label();  }
654        finally {
655        }
656      }
657      /**
658       * @attribute syn
659       * @aspect CreateBCode
660       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1417
661       */
662      public int continue_label() {
663        ASTNode$State state = state();
664        try {  return update_label();  }
665        finally {
666        }
667      }
668      /**
669       * @attribute syn
670       * @aspect PreciseRethrow
671       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
672       */
673      public boolean modifiedInScope(Variable var) {
674        ASTNode$State state = state();
675        try {  return getStmt().modifiedInScope(var);  }
676        finally {
677        }
678      }
679      /**
680       * @attribute inh
681       * @aspect EnhancedFor
682       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:38
683       */
684      @SuppressWarnings({"unchecked", "cast"})
685      public SimpleSet lookupVariable(String name) {
686          ASTNode$State state = state();
687        SimpleSet lookupVariable_String_value = getParent().Define_SimpleSet_lookupVariable(this, null, name);
688            return lookupVariable_String_value;
689      }
690      /**
691       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:41
692       * @apilevel internal
693       */
694      public SimpleSet Define_SimpleSet_lookupVariable(ASTNode caller, ASTNode child, String name) {
695        if(caller == getStmtNoTransform()) {
696          return localLookupVariable(name);
697        }
698        else if(caller == getExprNoTransform()) {
699          return localLookupVariable(name);
700        }
701        else if(caller == getVariableDeclarationNoTransform()) {
702          return localLookupVariable(name);
703        }
704        else {      return getParent().Define_SimpleSet_lookupVariable(this, caller, name);
705        }
706      }
707      /**
708       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:43
709       * @apilevel internal
710       */
711      public NameType Define_NameType_nameType(ASTNode caller, ASTNode child) {
712        if(caller == getVariableDeclarationNoTransform()) {
713          return NameType.TYPE_NAME;
714        }
715        else {      return getParent().Define_NameType_nameType(this, caller);
716        }
717      }
718      /**
719       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:48
720       * @apilevel internal
721       */
722      public VariableScope Define_VariableScope_outerScope(ASTNode caller, ASTNode child) {
723        if(caller == getStmtNoTransform()) {
724          return this;
725        }
726        else if(caller == getExprNoTransform()) {
727          return this;
728        }
729        else if(caller == getVariableDeclarationNoTransform()) {
730          return this;
731        }
732        else {      return getParent().Define_VariableScope_outerScope(this, caller);
733        }
734      }
735      /**
736       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:71
737       * @apilevel internal
738       */
739      public boolean Define_boolean_isMethodParameter(ASTNode caller, ASTNode child) {
740        if(caller == getVariableDeclarationNoTransform()) {
741          return false;
742        }
743        else {      return getParent().Define_boolean_isMethodParameter(this, caller);
744        }
745      }
746      /**
747       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:72
748       * @apilevel internal
749       */
750      public boolean Define_boolean_isConstructorParameter(ASTNode caller, ASTNode child) {
751        if(caller == getVariableDeclarationNoTransform()) {
752          return false;
753        }
754        else {      return getParent().Define_boolean_isConstructorParameter(this, caller);
755        }
756      }
757      /**
758       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:73
759       * @apilevel internal
760       */
761      public boolean Define_boolean_isExceptionHandlerParameter(ASTNode caller, ASTNode child) {
762        if(caller == getVariableDeclarationNoTransform()) {
763          return false;
764        }
765        else {      return getParent().Define_boolean_isExceptionHandlerParameter(this, caller);
766        }
767      }
768      /**
769       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:80
770       * @apilevel internal
771       */
772      public boolean Define_boolean_reachable(ASTNode caller, ASTNode child) {
773        if(caller == getStmtNoTransform()) {
774          return reachable();
775        }
776        else {      return getParent().Define_boolean_reachable(this, caller);
777        }
778      }
779      /**
780       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:97
781       * @apilevel internal
782       */
783      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
784        if(caller == getStmtNoTransform()) {
785          return getExpr().isDAafter(v);
786        }
787        else if(caller == getExprNoTransform()) {
788          return v == getVariableDeclaration() || isDAbefore(v);
789        }
790        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
791        }
792      }
793      /**
794       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:111
795       * @apilevel internal
796       */
797      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
798        if(caller == getStmtNoTransform()) {
799          return getExpr().isDUafter(v);
800        }
801        else if(caller == getExprNoTransform()) {
802          return v != getVariableDeclaration() && isDUbefore(v);
803        }
804        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
805        }
806      }
807      /**
808       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/EnhancedFor.jrag:113
809       * @apilevel internal
810       */
811      public boolean Define_boolean_insideLoop(ASTNode caller, ASTNode child) {
812        if(caller == getStmtNoTransform()) {
813          return true;
814        }
815        else {      return getParent().Define_boolean_insideLoop(this, caller);
816        }
817      }
818      /**
819       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/EnhancedForCodegen.jrag:18
820       * @apilevel internal
821       */
822      public int Define_int_localNum(ASTNode caller, ASTNode child) {
823        if(caller == getStmtNoTransform()) {
824          return getVariableDeclaration().localNum() + getVariableDeclaration().type().size();
825        }
826        else if(caller == getVariableDeclarationNoTransform()) {
827          return localNum() + (getExpr().type().isArrayDecl() ? 2 : 1);
828        }
829        else {      return getParent().Define_int_localNum(this, caller);
830        }
831      }
832      /**
833       * @apilevel internal
834       */
835      public ASTNode rewriteTo() {
836        return super.rewriteTo();
837      }
838    }