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 WhileStmt : {@link BranchTargetStmt} ::= <span class="component">Condition:{@link Expr}</span> <span class="component">{@link Stmt}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:208
017     */
018    public class WhileStmt extends BranchTargetStmt implements Cloneable {
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 WhileStmt clone() throws CloneNotSupportedException {
034        WhileStmt node = (WhileStmt)super.clone();
035        node.targetOf_ContinueStmt_values = null;
036        node.targetOf_BreakStmt_values = null;
037        node.isDAafter_Variable_values = null;
038        node.isDUafter_Variable_values = null;
039        node.isDUbeforeCondition_Variable_values = null;
040        node.canCompleteNormally_computed = false;
041        node.cond_label_computed = false;
042        node.end_label_computed = false;
043        node.stmt_label_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 WhileStmt copy() {
053      
054      try {
055        WhileStmt node = (WhileStmt) 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 WhileStmt fullCopy() {
073      
074      WhileStmt tree = (WhileStmt) 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 PrettyPrint
090       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:587
091       */
092      public void toString(StringBuffer s) {
093        s.append(indent());
094        s.append("while(");
095        getCondition().toString(s);
096        s.append(")");
097        getStmt().toString(s);
098      }
099      /**
100       * @ast method 
101       * @aspect TypeCheck
102       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:322
103       */
104      public void typeCheck() {
105        TypeDecl cond = getCondition().type();
106        if(!cond.isBoolean()) {
107          error("the type of \"" + getCondition() + "\" is " + cond.name() + " which is not boolean");
108        }
109      }
110      /**
111       * @ast method 
112       * @aspect CreateBCode
113       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1346
114       */
115      public void createBCode(CodeGeneration gen) {
116        super.createBCode(gen);
117        gen.addLabel(cond_label());
118        getCondition().emitEvalBranch(gen);
119        gen.addLabel(stmt_label());
120        if(getCondition().canBeTrue()) {
121          getStmt().createBCode(gen);
122          if(getStmt().canCompleteNormally())
123            gen.emitGoto(cond_label());
124        }
125        gen.addLabel(end_label());
126      }
127      /**
128       * @ast method 
129       * 
130       */
131      public WhileStmt() {
132        super();
133    
134    
135      }
136      /**
137       * Initializes the child array to the correct size.
138       * Initializes List and Opt nta children.
139       * @apilevel internal
140       * @ast method
141       * @ast method 
142       * 
143       */
144      public void init$Children() {
145        children = new ASTNode[2];
146      }
147      /**
148       * @ast method 
149       * 
150       */
151      public WhileStmt(Expr p0, Stmt p1) {
152        setChild(p0, 0);
153        setChild(p1, 1);
154      }
155      /**
156       * @apilevel low-level
157       * @ast method 
158       * 
159       */
160      protected int numChildren() {
161        return 2;
162      }
163      /**
164       * @apilevel internal
165       * @ast method 
166       * 
167       */
168      public boolean mayHaveRewrite() {
169        return false;
170      }
171      /**
172       * Replaces the Condition child.
173       * @param node The new node to replace the Condition child.
174       * @apilevel high-level
175       * @ast method 
176       * 
177       */
178      public void setCondition(Expr node) {
179        setChild(node, 0);
180      }
181      /**
182       * Retrieves the Condition child.
183       * @return The current node used as the Condition child.
184       * @apilevel high-level
185       * @ast method 
186       * 
187       */
188      public Expr getCondition() {
189        return (Expr)getChild(0);
190      }
191      /**
192       * Retrieves the Condition child.
193       * <p><em>This method does not invoke AST transformations.</em></p>
194       * @return The current node used as the Condition child.
195       * @apilevel low-level
196       * @ast method 
197       * 
198       */
199      public Expr getConditionNoTransform() {
200        return (Expr)getChildNoTransform(0);
201      }
202      /**
203       * Replaces the Stmt child.
204       * @param node The new node to replace the Stmt child.
205       * @apilevel high-level
206       * @ast method 
207       * 
208       */
209      public void setStmt(Stmt node) {
210        setChild(node, 1);
211      }
212      /**
213       * Retrieves the Stmt child.
214       * @return The current node used as the Stmt child.
215       * @apilevel high-level
216       * @ast method 
217       * 
218       */
219      public Stmt getStmt() {
220        return (Stmt)getChild(1);
221      }
222      /**
223       * Retrieves the Stmt child.
224       * <p><em>This method does not invoke AST transformations.</em></p>
225       * @return The current node used as the Stmt child.
226       * @apilevel low-level
227       * @ast method 
228       * 
229       */
230      public Stmt getStmtNoTransform() {
231        return (Stmt)getChildNoTransform(1);
232      }
233      protected java.util.Map targetOf_ContinueStmt_values;
234      /**
235       * @attribute syn
236       * @aspect BranchTarget
237       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:69
238       */
239      @SuppressWarnings({"unchecked", "cast"})
240      public boolean targetOf(ContinueStmt stmt) {
241        Object _parameters = stmt;
242        if(targetOf_ContinueStmt_values == null) targetOf_ContinueStmt_values = new java.util.HashMap(4);
243        if(targetOf_ContinueStmt_values.containsKey(_parameters)) {
244          return ((Boolean)targetOf_ContinueStmt_values.get(_parameters)).booleanValue();
245        }
246          ASTNode$State state = state();
247      int num = state.boundariesCrossed;
248      boolean isFinal = this.is$Final();
249        boolean targetOf_ContinueStmt_value = targetOf_compute(stmt);
250      if(isFinal && num == state().boundariesCrossed){ targetOf_ContinueStmt_values.put(_parameters, Boolean.valueOf(targetOf_ContinueStmt_value)); }
251            return targetOf_ContinueStmt_value;
252      }
253      /**
254       * @apilevel internal
255       */
256      private boolean targetOf_compute(ContinueStmt stmt) {  return !stmt.hasLabel();  }
257      protected java.util.Map targetOf_BreakStmt_values;
258      /**
259       * @attribute syn
260       * @aspect BranchTarget
261       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:77
262       */
263      @SuppressWarnings({"unchecked", "cast"})
264      public boolean targetOf(BreakStmt stmt) {
265        Object _parameters = stmt;
266        if(targetOf_BreakStmt_values == null) targetOf_BreakStmt_values = new java.util.HashMap(4);
267        if(targetOf_BreakStmt_values.containsKey(_parameters)) {
268          return ((Boolean)targetOf_BreakStmt_values.get(_parameters)).booleanValue();
269        }
270          ASTNode$State state = state();
271      int num = state.boundariesCrossed;
272      boolean isFinal = this.is$Final();
273        boolean targetOf_BreakStmt_value = targetOf_compute(stmt);
274      if(isFinal && num == state().boundariesCrossed){ targetOf_BreakStmt_values.put(_parameters, Boolean.valueOf(targetOf_BreakStmt_value)); }
275            return targetOf_BreakStmt_value;
276      }
277      /**
278       * @apilevel internal
279       */
280      private boolean targetOf_compute(BreakStmt stmt) {  return !stmt.hasLabel();  }
281      protected java.util.Map isDAafter_Variable_values;
282      /**
283       * @attribute syn
284       * @aspect DA
285       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:576
286       */
287      @SuppressWarnings({"unchecked", "cast"})
288      public boolean isDAafter(Variable v) {
289        Object _parameters = v;
290        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
291        if(isDAafter_Variable_values.containsKey(_parameters)) {
292          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
293        }
294          ASTNode$State state = state();
295      int num = state.boundariesCrossed;
296      boolean isFinal = this.is$Final();
297        boolean isDAafter_Variable_value = isDAafter_compute(v);
298      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
299            return isDAafter_Variable_value;
300      }
301      /**
302       * @apilevel internal
303       */
304      private boolean isDAafter_compute(Variable v) {
305        if(!getCondition().isDAafterFalse(v))
306          return false;
307        for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
308          BreakStmt stmt = (BreakStmt)iter.next();
309          if(!stmt.isDAafterReachedFinallyBlocks(v))
310            return false;
311        }
312        return true;
313      }
314      protected java.util.Map isDUafter_Variable_values;
315      /**
316       * @attribute syn
317       * @aspect DU
318       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1032
319       */
320      @SuppressWarnings({"unchecked", "cast"})
321      public boolean isDUafter(Variable v) {
322        Object _parameters = v;
323        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
324        if(isDUafter_Variable_values.containsKey(_parameters)) {
325          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
326        }
327          ASTNode$State state = state();
328      int num = state.boundariesCrossed;
329      boolean isFinal = this.is$Final();
330        boolean isDUafter_Variable_value = isDUafter_compute(v);
331      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
332            return isDUafter_Variable_value;
333      }
334      /**
335       * @apilevel internal
336       */
337      private boolean isDUafter_compute(Variable v) {
338        if(!isDUbeforeCondition(v)) // start a circular evaluation here
339          return false;
340        if(!getCondition().isDUafterFalse(v))
341          return false;
342        for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
343          BreakStmt stmt = (BreakStmt)iter.next();
344          if(!stmt.isDUafterReachedFinallyBlocks(v))
345            return false;
346        }
347        return true;
348      }
349      protected java.util.Map isDUbeforeCondition_Variable_values;
350      /**
351       * @attribute syn
352       * @aspect DU
353       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1049
354       */
355      @SuppressWarnings({"unchecked", "cast"})
356      public boolean isDUbeforeCondition(Variable v) {
357        Object _parameters = v;
358        if(isDUbeforeCondition_Variable_values == null) isDUbeforeCondition_Variable_values = new java.util.HashMap(4);
359        ASTNode$State.CircularValue _value;
360        if(isDUbeforeCondition_Variable_values.containsKey(_parameters)) {
361          Object _o = isDUbeforeCondition_Variable_values.get(_parameters);
362          if(!(_o instanceof ASTNode$State.CircularValue)) {
363            return ((Boolean)_o).booleanValue();
364          }
365          else
366            _value = (ASTNode$State.CircularValue)_o;
367        }
368        else {
369          _value = new ASTNode$State.CircularValue();
370          isDUbeforeCondition_Variable_values.put(_parameters, _value);
371          _value.value = Boolean.valueOf(true);
372        }
373        ASTNode$State state = state();
374        if (!state.IN_CIRCLE) {
375          state.IN_CIRCLE = true;
376          int num = state.boundariesCrossed;
377          boolean isFinal = this.is$Final();
378          boolean new_isDUbeforeCondition_Variable_value;
379          do {
380            _value.visited = new Integer(state.CIRCLE_INDEX);
381            state.CHANGE = false;
382            new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v);
383            if (new_isDUbeforeCondition_Variable_value!=((Boolean)_value.value).booleanValue()) {
384              state.CHANGE = true;
385              _value.value = Boolean.valueOf(new_isDUbeforeCondition_Variable_value);
386            }
387            state.CIRCLE_INDEX++;
388          } while (state.CHANGE);
389            if(isFinal && num == state().boundariesCrossed) {
390            isDUbeforeCondition_Variable_values.put(_parameters, new_isDUbeforeCondition_Variable_value);
391          }
392          else {
393            isDUbeforeCondition_Variable_values.remove(_parameters);
394          state.RESET_CYCLE = true;
395          isDUbeforeCondition_compute(v);
396          state.RESET_CYCLE = false;
397          }
398          state.IN_CIRCLE = false; 
399          return new_isDUbeforeCondition_Variable_value;
400        }
401        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
402          _value.visited = new Integer(state.CIRCLE_INDEX);
403          boolean new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v);
404          if (state.RESET_CYCLE) {
405            isDUbeforeCondition_Variable_values.remove(_parameters);
406          }
407          else if (new_isDUbeforeCondition_Variable_value!=((Boolean)_value.value).booleanValue()) {
408            state.CHANGE = true;
409            _value.value = new_isDUbeforeCondition_Variable_value;
410          }
411          return new_isDUbeforeCondition_Variable_value;
412        }
413        return ((Boolean)_value.value).booleanValue();
414      }
415      /**
416       * @apilevel internal
417       */
418      private boolean isDUbeforeCondition_compute(Variable v) {
419        // 1st
420        if(!isDUbefore(v))
421          return false;
422        else if(!getStmt().isDUafter(v))
423          return false;
424        else {
425          for(Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
426            ContinueStmt stmt = (ContinueStmt)iter.next();
427            if(!stmt.isDUafterReachedFinallyBlocks(v))
428              return false;
429          }
430        }
431        return true;
432      }
433      /**
434       * @attribute syn
435       * @aspect NameCheck
436       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:401
437       */
438      public boolean continueLabel() {
439        ASTNode$State state = state();
440        try {  return true;  }
441        finally {
442        }
443      }
444      /**
445       * @apilevel internal
446       */
447      protected boolean canCompleteNormally_computed = false;
448      /**
449       * @apilevel internal
450       */
451      protected boolean canCompleteNormally_value;
452      /**
453       * @attribute syn
454       * @aspect UnreachableStatements
455       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:85
456       */
457      @SuppressWarnings({"unchecked", "cast"})
458      public boolean canCompleteNormally() {
459        if(canCompleteNormally_computed) {
460          return canCompleteNormally_value;
461        }
462          ASTNode$State state = state();
463      int num = state.boundariesCrossed;
464      boolean isFinal = this.is$Final();
465        canCompleteNormally_value = canCompleteNormally_compute();
466      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
467            return canCompleteNormally_value;
468      }
469      /**
470       * @apilevel internal
471       */
472      private boolean canCompleteNormally_compute() {  return reachable() && (!getCondition().isConstant() || !getCondition().isTrue()) || reachableBreak();  }
473      /**
474       * @attribute syn
475       * @aspect CreateBCode
476       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:946
477       */
478      public boolean definesLabel() {
479        ASTNode$State state = state();
480        try {  return true;  }
481        finally {
482        }
483      }
484      /**
485       * @apilevel internal
486       */
487      protected boolean cond_label_computed = false;
488      /**
489       * @apilevel internal
490       */
491      protected int cond_label_value;
492      /**
493       * @attribute syn
494       * @aspect CreateBCode
495       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1342
496       */
497      @SuppressWarnings({"unchecked", "cast"})
498      public int cond_label() {
499        if(cond_label_computed) {
500          return cond_label_value;
501        }
502          ASTNode$State state = state();
503      int num = state.boundariesCrossed;
504      boolean isFinal = this.is$Final();
505        cond_label_value = cond_label_compute();
506      if(isFinal && num == state().boundariesCrossed){ cond_label_computed = true; }
507            return cond_label_value;
508      }
509      /**
510       * @apilevel internal
511       */
512      private int cond_label_compute() {  return hostType().constantPool().newLabel();  }
513      /**
514       * @apilevel internal
515       */
516      protected boolean end_label_computed = false;
517      /**
518       * @apilevel internal
519       */
520      protected int end_label_value;
521      /**
522       * @attribute syn
523       * @aspect CreateBCode
524       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1343
525       */
526      @SuppressWarnings({"unchecked", "cast"})
527      public int end_label() {
528        if(end_label_computed) {
529          return end_label_value;
530        }
531          ASTNode$State state = state();
532      int num = state.boundariesCrossed;
533      boolean isFinal = this.is$Final();
534        end_label_value = end_label_compute();
535      if(isFinal && num == state().boundariesCrossed){ end_label_computed = true; }
536            return end_label_value;
537      }
538      /**
539       * @apilevel internal
540       */
541      private int end_label_compute() {  return hostType().constantPool().newLabel();  }
542      /**
543       * @apilevel internal
544       */
545      protected boolean stmt_label_computed = false;
546      /**
547       * @apilevel internal
548       */
549      protected int stmt_label_value;
550      /**
551       * @attribute syn
552       * @aspect CreateBCode
553       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1344
554       */
555      @SuppressWarnings({"unchecked", "cast"})
556      public int stmt_label() {
557        if(stmt_label_computed) {
558          return stmt_label_value;
559        }
560          ASTNode$State state = state();
561      int num = state.boundariesCrossed;
562      boolean isFinal = this.is$Final();
563        stmt_label_value = stmt_label_compute();
564      if(isFinal && num == state().boundariesCrossed){ stmt_label_computed = true; }
565            return stmt_label_value;
566      }
567      /**
568       * @apilevel internal
569       */
570      private int stmt_label_compute() {  return hostType().constantPool().newLabel();  }
571      /**
572       * @attribute syn
573       * @aspect CreateBCode
574       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1398
575       */
576      public int break_label() {
577        ASTNode$State state = state();
578        try {  return end_label();  }
579        finally {
580        }
581      }
582      /**
583       * @attribute syn
584       * @aspect CreateBCode
585       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1417
586       */
587      public int continue_label() {
588        ASTNode$State state = state();
589        try {  return cond_label();  }
590        finally {
591        }
592      }
593      /**
594       * @attribute syn
595       * @aspect PreciseRethrow
596       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
597       */
598      public boolean modifiedInScope(Variable var) {
599        ASTNode$State state = state();
600        try {  return getStmt().modifiedInScope(var);  }
601        finally {
602        }
603      }
604      /**
605       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:587
606       * @apilevel internal
607       */
608      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
609        if(caller == getStmtNoTransform()) {
610          return getCondition().isDAafterTrue(v);
611        }
612        else if(caller == getConditionNoTransform()) {
613          return isDAbefore(v);
614        }
615        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
616        }
617      }
618      /**
619       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1066
620       * @apilevel internal
621       */
622      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
623        if(caller == getStmtNoTransform()) {
624          return getCondition().isDUafterTrue(v);
625        }
626        else if(caller == getConditionNoTransform()) {
627          return isDUbeforeCondition(v);
628        }
629        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
630        }
631      }
632      /**
633       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NameCheck.jrag:371
634       * @apilevel internal
635       */
636      public boolean Define_boolean_insideLoop(ASTNode caller, ASTNode child) {
637        if(caller == getStmtNoTransform()) {
638          return true;
639        }
640        else {      return getParent().Define_boolean_insideLoop(this, caller);
641        }
642      }
643      /**
644       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:86
645       * @apilevel internal
646       */
647      public boolean Define_boolean_reachable(ASTNode caller, ASTNode child) {
648        if(caller == getStmtNoTransform()) {
649          return reachable() && !getCondition().isFalse();
650        }
651        else {      return getParent().Define_boolean_reachable(this, caller);
652        }
653      }
654      /**
655       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:153
656       * @apilevel internal
657       */
658      public boolean Define_boolean_reportUnreachable(ASTNode caller, ASTNode child) {
659        if(caller == getStmtNoTransform()) {
660          return reachable();
661        }
662        else {      return getParent().Define_boolean_reportUnreachable(this, caller);
663        }
664      }
665      /**
666       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:965
667       * @apilevel internal
668       */
669      public int Define_int_condition_false_label(ASTNode caller, ASTNode child) {
670        if(caller == getConditionNoTransform()) {
671          return end_label();
672        }
673        else {      return getParent().Define_int_condition_false_label(this, caller);
674        }
675      }
676      /**
677       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:966
678       * @apilevel internal
679       */
680      public int Define_int_condition_true_label(ASTNode caller, ASTNode child) {
681        if(caller == getConditionNoTransform()) {
682          return stmt_label();
683        }
684        else {      return getParent().Define_int_condition_true_label(this, caller);
685        }
686      }
687      /**
688       * @apilevel internal
689       */
690      public ASTNode rewriteTo() {
691        return super.rewriteTo();
692      }
693    }