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:204
027     * @production WhileStmt : {@link BranchTargetStmt} ::= <span class="component">Condition:{@link Expr}</span> <span class="component">{@link Stmt}</span>;
028    
029     */
030    public class WhileStmt extends BranchTargetStmt implements Cloneable {
031      /**
032       * @aspect PrettyPrintUtil
033       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:194
034       */
035      public void prettyPrint(PrettyPrinter out) {
036        out.print("while (");
037        out.print(getCondition());
038        out.print(") ");
039        if (getStmt() instanceof Block) {
040          out.print(getStmt());
041        } else {
042          out.print("{");
043          out.println();
044          out.indent(1);
045          out.print(getStmt());
046          out.println();
047          out.print("}");
048        }
049      }
050      /**
051       * @aspect TypeCheck
052       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:378
053       */
054      public void typeCheck() {
055        TypeDecl cond = getCondition().type();
056        if (!cond.isBoolean()) {
057          errorf("the type of \"%s\" is %s which is not boolean",
058              getCondition().prettyPrint(), cond.name());
059        }
060      }
061      /**
062       * @aspect CreateBCode
063       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1565
064       */
065      public void createBCode(CodeGeneration gen) {
066        super.createBCode(gen);
067        gen.addLabel(cond_label());
068        if (!getCondition().isConstant()) {
069          getCondition().branchFalse(gen, end_label());
070        }
071        gen.addLabel(stmt_label());
072        if (getCondition().canBeTrue()) {
073          getStmt().createBCode(gen);
074          if (getStmt().canCompleteNormally()) {
075            gen.emitGoto(cond_label());
076          }
077        }
078        gen.addLabel(end_label());
079      }
080      /**
081       * @declaredat ASTNode:1
082       */
083      public WhileStmt() {
084        super();
085      }
086      /**
087       * Initializes the child array to the correct size.
088       * Initializes List and Opt nta children.
089       * @apilevel internal
090       * @ast method
091       * @declaredat ASTNode:10
092       */
093      public void init$Children() {
094        children = new ASTNode[2];
095      }
096      /**
097       * @declaredat ASTNode:13
098       */
099      public WhileStmt(Expr p0, Stmt p1) {
100        setChild(p0, 0);
101        setChild(p1, 1);
102      }
103      /**
104       * @apilevel low-level
105       * @declaredat ASTNode:20
106       */
107      protected int numChildren() {
108        return 2;
109      }
110      /**
111       * @apilevel internal
112       * @declaredat ASTNode:26
113       */
114      public boolean mayHaveRewrite() {
115        return false;
116      }
117      /**
118       * @apilevel internal
119       * @declaredat ASTNode:32
120       */
121      public void flushAttrCache() {
122        super.flushAttrCache();
123        isDAafter_Variable_reset();
124        isDUafter_Variable_reset();
125        isDUbeforeCondition_Variable_reset();
126        canCompleteNormally_reset();
127        cond_label_reset();
128        end_label_reset();
129        stmt_label_reset();
130      }
131      /**
132       * @apilevel internal
133       * @declaredat ASTNode:45
134       */
135      public void flushCollectionCache() {
136        super.flushCollectionCache();
137      }
138      /**
139       * @apilevel internal
140       * @declaredat ASTNode:51
141       */
142      public void flushRewriteCache() {
143        super.flushRewriteCache();
144      }
145      /**
146       * @apilevel internal
147       * @declaredat ASTNode:57
148       */
149      public WhileStmt clone() throws CloneNotSupportedException {
150        WhileStmt node = (WhileStmt) super.clone();
151        return node;
152      }
153      /**
154       * @apilevel internal
155       * @declaredat ASTNode:64
156       */
157      public WhileStmt copy() {
158        try {
159          WhileStmt node = (WhileStmt) clone();
160          node.parent = null;
161          if (children != null) {
162            node.children = (ASTNode[]) children.clone();
163          }
164          return node;
165        } catch (CloneNotSupportedException e) {
166          throw new Error("Error: clone not supported for " + getClass().getName());
167        }
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       * @deprecated Please use treeCopy or treeCopyNoTransform instead
175       * @declaredat ASTNode:83
176       */
177      @Deprecated
178      public WhileStmt fullCopy() {
179        return treeCopyNoTransform();
180      }
181      /**
182       * Create a deep copy of the AST subtree at this node.
183       * The copy is dangling, i.e. has no parent.
184       * @return dangling copy of the subtree at this node
185       * @apilevel low-level
186       * @declaredat ASTNode:93
187       */
188      public WhileStmt treeCopyNoTransform() {
189        WhileStmt tree = (WhileStmt) copy();
190        if (children != null) {
191          for (int i = 0; i < children.length; ++i) {
192            ASTNode child = (ASTNode) children[i];
193            if (child != null) {
194              child = child.treeCopyNoTransform();
195              tree.setChild(child, i);
196            }
197          }
198        }
199        return tree;
200      }
201      /**
202       * Create a deep copy of the AST subtree at this node.
203       * The subtree of this node is traversed to trigger rewrites before copy.
204       * The copy is dangling, i.e. has no parent.
205       * @return dangling copy of the subtree at this node
206       * @apilevel low-level
207       * @declaredat ASTNode:113
208       */
209      public WhileStmt treeCopy() {
210        doFullTraversal();
211        return treeCopyNoTransform();
212      }
213      /**
214       * @apilevel internal
215       * @declaredat ASTNode:120
216       */
217      protected boolean is$Equal(ASTNode node) {
218        return super.is$Equal(node);    
219      }
220      /**
221       * Replaces the Condition child.
222       * @param node The new node to replace the Condition child.
223       * @apilevel high-level
224       */
225      public void setCondition(Expr node) {
226        setChild(node, 0);
227      }
228      /**
229       * Retrieves the Condition child.
230       * @return The current node used as the Condition child.
231       * @apilevel high-level
232       */
233      @ASTNodeAnnotation.Child(name="Condition")
234      public Expr getCondition() {
235        return (Expr) getChild(0);
236      }
237      /**
238       * Retrieves the Condition child.
239       * <p><em>This method does not invoke AST transformations.</em></p>
240       * @return The current node used as the Condition child.
241       * @apilevel low-level
242       */
243      public Expr getConditionNoTransform() {
244        return (Expr) getChildNoTransform(0);
245      }
246      /**
247       * Replaces the Stmt child.
248       * @param node The new node to replace the Stmt child.
249       * @apilevel high-level
250       */
251      public void setStmt(Stmt node) {
252        setChild(node, 1);
253      }
254      /**
255       * Retrieves the Stmt child.
256       * @return The current node used as the Stmt child.
257       * @apilevel high-level
258       */
259      @ASTNodeAnnotation.Child(name="Stmt")
260      public Stmt getStmt() {
261        return (Stmt) getChild(1);
262      }
263      /**
264       * Retrieves the Stmt child.
265       * <p><em>This method does not invoke AST transformations.</em></p>
266       * @return The current node used as the Stmt child.
267       * @apilevel low-level
268       */
269      public Stmt getStmtNoTransform() {
270        return (Stmt) getChildNoTransform(1);
271      }
272      /**
273       * @return <code>true</code> if this statement is a potential
274       * branch target of the given branch statement.
275       * @attribute syn
276       * @aspect BranchTarget
277       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:217
278       */
279      @ASTNodeAnnotation.Attribute
280      public boolean potentialTargetOf(Stmt branch) {
281        boolean potentialTargetOf_Stmt_value = branch.canBranchTo(this);
282    
283        return potentialTargetOf_Stmt_value;
284      }
285      /**
286       * @apilevel internal
287       */
288      protected java.util.Map isDAafter_Variable_values;
289      /**
290       * @apilevel internal
291       */
292      private void isDAafter_Variable_reset() {
293        isDAafter_Variable_values = null;
294      }
295      /**
296       * @attribute syn
297       * @aspect DA
298       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
299       */
300      @ASTNodeAnnotation.Attribute
301      public boolean isDAafter(Variable v) {
302        Object _parameters = v;
303        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
304        ASTNode$State state = state();
305        if (isDAafter_Variable_values.containsKey(_parameters)) {
306          return (Boolean) isDAafter_Variable_values.get(_parameters);
307        }
308        boolean intermediate = state.INTERMEDIATE_VALUE;
309        state.INTERMEDIATE_VALUE = false;
310        int num = state.boundariesCrossed;
311        boolean isFinal = this.is$Final();
312        boolean isDAafter_Variable_value = isDAafter_compute(v);
313        if (isFinal && num == state().boundariesCrossed) {
314          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
315        } else {
316        }
317        state.INTERMEDIATE_VALUE |= intermediate;
318    
319        return isDAafter_Variable_value;
320      }
321      /**
322       * @apilevel internal
323       */
324      private boolean isDAafter_compute(Variable v) {
325          if (!getCondition().isDAafterFalse(v)) {
326            return false;
327          }
328          for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
329            BreakStmt stmt = (BreakStmt) iter.next();
330            if (!stmt.isDAafterReachedFinallyBlocks(v)) {
331              return false;
332            }
333          }
334          return true;
335        }
336      /**
337       * @apilevel internal
338       */
339      protected java.util.Map isDUafter_Variable_values;
340      /**
341       * @apilevel internal
342       */
343      private void isDUafter_Variable_reset() {
344        isDUafter_Variable_values = null;
345      }
346      /**
347       * @attribute syn
348       * @aspect DU
349       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
350       */
351      @ASTNodeAnnotation.Attribute
352      public boolean isDUafter(Variable v) {
353        Object _parameters = v;
354        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
355        ASTNode$State state = state();
356        if (isDUafter_Variable_values.containsKey(_parameters)) {
357          return (Boolean) isDUafter_Variable_values.get(_parameters);
358        }
359        boolean intermediate = state.INTERMEDIATE_VALUE;
360        state.INTERMEDIATE_VALUE = false;
361        int num = state.boundariesCrossed;
362        boolean isFinal = this.is$Final();
363        boolean isDUafter_Variable_value = isDUafter_compute(v);
364        if (isFinal && num == state().boundariesCrossed) {
365          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
366        } else {
367        }
368        state.INTERMEDIATE_VALUE |= intermediate;
369    
370        return isDUafter_Variable_value;
371      }
372      /**
373       * @apilevel internal
374       */
375      private boolean isDUafter_compute(Variable v) {
376          if (!isDUbeforeCondition(v)) {
377            // start a circular evaluation here
378            return false;
379          }
380          if (!getCondition().isDUafterFalse(v)) {
381            return false;
382          }
383          for (Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
384            BreakStmt stmt = (BreakStmt) iter.next();
385            if (!stmt.isDUafterReachedFinallyBlocks(v)) {
386              return false;
387            }
388          }
389          return true;
390        }
391      /**
392       * @apilevel internal
393       */
394      private void isDUbeforeCondition_Variable_reset() {
395        isDUbeforeCondition_Variable_values = null;
396      }
397      protected java.util.Map isDUbeforeCondition_Variable_values;
398      @ASTNodeAnnotation.Attribute
399      public boolean isDUbeforeCondition(Variable v) {
400        Object _parameters = v;
401        if (isDUbeforeCondition_Variable_values == null) isDUbeforeCondition_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
402        ASTNode$State.CircularValue _value;
403        if (isDUbeforeCondition_Variable_values.containsKey(_parameters)) {
404          Object _o = isDUbeforeCondition_Variable_values.get(_parameters);
405          if (!(_o instanceof ASTNode$State.CircularValue)) {
406            return (Boolean) _o;
407          } else {
408            _value = (ASTNode$State.CircularValue) _o;
409          }
410        } else {
411          _value = new ASTNode$State.CircularValue();
412          isDUbeforeCondition_Variable_values.put(_parameters, _value);
413          _value.value = true;
414        }
415        ASTNode$State state = state();
416        boolean new_isDUbeforeCondition_Variable_value;
417        if (!state.IN_CIRCLE) {
418          state.IN_CIRCLE = true;
419          int num = state.boundariesCrossed;
420          boolean isFinal = this.is$Final();
421          // TODO: fixme
422          // state().CIRCLE_INDEX = 1;
423          do {
424            _value.visited = state.CIRCLE_INDEX;
425            state.CHANGE = false;
426            new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v);
427            if (new_isDUbeforeCondition_Variable_value != ((Boolean)_value.value)) {
428              state.CHANGE = true;
429              _value.value = new_isDUbeforeCondition_Variable_value;
430            }
431            state.CIRCLE_INDEX++;
432          } while (state.CHANGE);
433          if (isFinal && num == state().boundariesCrossed) {
434            isDUbeforeCondition_Variable_values.put(_parameters, new_isDUbeforeCondition_Variable_value);
435          } else {
436            isDUbeforeCondition_Variable_values.remove(_parameters);
437            state.RESET_CYCLE = true;
438            boolean $tmp = isDUbeforeCondition_compute(v);
439            state.RESET_CYCLE = false;
440          }
441          state.IN_CIRCLE = false;
442          state.INTERMEDIATE_VALUE = false;
443          return new_isDUbeforeCondition_Variable_value;
444        }
445        if (state.CIRCLE_INDEX != _value.visited) {
446          _value.visited = state.CIRCLE_INDEX;
447          new_isDUbeforeCondition_Variable_value = isDUbeforeCondition_compute(v);
448          if (state.RESET_CYCLE) {
449            isDUbeforeCondition_Variable_values.remove(_parameters);
450          }
451          else if (new_isDUbeforeCondition_Variable_value != ((Boolean)_value.value)) {
452            state.CHANGE = true;
453            _value.value = new_isDUbeforeCondition_Variable_value;
454          }
455          state.INTERMEDIATE_VALUE = true;
456          return new_isDUbeforeCondition_Variable_value;
457        }
458        state.INTERMEDIATE_VALUE = true;
459        return (Boolean) _value.value;
460      }
461      /**
462       * @apilevel internal
463       */
464      private boolean isDUbeforeCondition_compute(Variable v) {
465          // 1st
466          if (!isDUbefore(v)) {
467            return false;
468          } else if (!getStmt().isDUafter(v)) {
469            return false;
470          } else {
471            for (Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
472              ContinueStmt stmt = (ContinueStmt) iter.next();
473              if (!stmt.isDUafterReachedFinallyBlocks(v)) {
474                return false;
475              }
476            }
477          }
478          return true;
479        }
480      /**
481       * @attribute syn
482       * @aspect NameCheck
483       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:478
484       */
485      @ASTNodeAnnotation.Attribute
486      public boolean continueLabel() {
487        boolean continueLabel_value = true;
488    
489        return continueLabel_value;
490      }
491      /**
492       * @apilevel internal
493       */
494      protected boolean canCompleteNormally_computed = false;
495      /**
496       * @apilevel internal
497       */
498      protected boolean canCompleteNormally_value;
499      /**
500       * @apilevel internal
501       */
502      private void canCompleteNormally_reset() {
503        canCompleteNormally_computed = false;
504      }
505      /**
506       * @attribute syn
507       * @aspect UnreachableStatements
508       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53
509       */
510      @ASTNodeAnnotation.Attribute
511      public boolean canCompleteNormally() {
512        ASTNode$State state = state();
513        if (canCompleteNormally_computed) {
514          return canCompleteNormally_value;
515        }
516        boolean intermediate = state.INTERMEDIATE_VALUE;
517        state.INTERMEDIATE_VALUE = false;
518        int num = state.boundariesCrossed;
519        boolean isFinal = this.is$Final();
520        canCompleteNormally_value = reachable() && (!getCondition().isConstant() || !getCondition().isTrue()) || reachableBreak();
521        if (isFinal && num == state().boundariesCrossed) {
522          canCompleteNormally_computed = true;
523        } else {
524        }
525        state.INTERMEDIATE_VALUE |= intermediate;
526    
527        return canCompleteNormally_value;
528      }
529      /**
530       * @apilevel internal
531       */
532      protected boolean cond_label_computed = false;
533      /**
534       * @apilevel internal
535       */
536      protected int cond_label_value;
537      /**
538       * @apilevel internal
539       */
540      private void cond_label_reset() {
541        cond_label_computed = false;
542      }
543      /**
544       * @attribute syn
545       * @aspect CreateBCode
546       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1561
547       */
548      @ASTNodeAnnotation.Attribute
549      public int cond_label() {
550        ASTNode$State state = state();
551        if (cond_label_computed) {
552          return cond_label_value;
553        }
554        boolean intermediate = state.INTERMEDIATE_VALUE;
555        state.INTERMEDIATE_VALUE = false;
556        int num = state.boundariesCrossed;
557        boolean isFinal = this.is$Final();
558        cond_label_value = hostType().constantPool().newLabel();
559        if (isFinal && num == state().boundariesCrossed) {
560          cond_label_computed = true;
561        } else {
562        }
563        state.INTERMEDIATE_VALUE |= intermediate;
564    
565        return cond_label_value;
566      }
567      /**
568       * @apilevel internal
569       */
570      protected boolean end_label_computed = false;
571      /**
572       * @apilevel internal
573       */
574      protected int end_label_value;
575      /**
576       * @apilevel internal
577       */
578      private void end_label_reset() {
579        end_label_computed = false;
580      }
581      /**
582       * @attribute syn
583       * @aspect CreateBCode
584       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1562
585       */
586      @ASTNodeAnnotation.Attribute
587      public int end_label() {
588        ASTNode$State state = state();
589        if (end_label_computed) {
590          return end_label_value;
591        }
592        boolean intermediate = state.INTERMEDIATE_VALUE;
593        state.INTERMEDIATE_VALUE = false;
594        int num = state.boundariesCrossed;
595        boolean isFinal = this.is$Final();
596        end_label_value = hostType().constantPool().newLabel();
597        if (isFinal && num == state().boundariesCrossed) {
598          end_label_computed = true;
599        } else {
600        }
601        state.INTERMEDIATE_VALUE |= intermediate;
602    
603        return end_label_value;
604      }
605      /**
606       * @apilevel internal
607       */
608      protected boolean stmt_label_computed = false;
609      /**
610       * @apilevel internal
611       */
612      protected int stmt_label_value;
613      /**
614       * @apilevel internal
615       */
616      private void stmt_label_reset() {
617        stmt_label_computed = false;
618      }
619      /**
620       * @attribute syn
621       * @aspect CreateBCode
622       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1563
623       */
624      @ASTNodeAnnotation.Attribute
625      public int stmt_label() {
626        ASTNode$State state = state();
627        if (stmt_label_computed) {
628          return stmt_label_value;
629        }
630        boolean intermediate = state.INTERMEDIATE_VALUE;
631        state.INTERMEDIATE_VALUE = false;
632        int num = state.boundariesCrossed;
633        boolean isFinal = this.is$Final();
634        stmt_label_value = hostType().constantPool().newLabel();
635        if (isFinal && num == state().boundariesCrossed) {
636          stmt_label_computed = true;
637        } else {
638        }
639        state.INTERMEDIATE_VALUE |= intermediate;
640    
641        return stmt_label_value;
642      }
643      /**
644       * @attribute syn
645       * @aspect CreateBCode
646       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1621
647       */
648      @ASTNodeAnnotation.Attribute
649      public int break_label() {
650        int break_label_value = end_label();
651    
652        return break_label_value;
653      }
654      /**
655       * @attribute syn
656       * @aspect CreateBCode
657       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1645
658       */
659      @ASTNodeAnnotation.Attribute
660      public int continue_label() {
661        int continue_label_value = cond_label();
662    
663        return continue_label_value;
664      }
665      /**
666       * @attribute syn
667       * @aspect PreciseRethrow
668       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
669       */
670      @ASTNodeAnnotation.Attribute
671      public boolean modifiedInScope(Variable var) {
672        boolean modifiedInScope_Variable_value = getStmt().modifiedInScope(var);
673    
674        return modifiedInScope_Variable_value;
675      }
676      /**
677       * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227
678       * @apilevel internal
679       */
680      public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) {
681        int childIndex = this.getIndexOfChild(caller);
682        return branch.canBranchTo(this) ? this : branchTarget(branch);
683      }
684      protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) {
685        return true;
686      }
687      /**
688       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
689       * @apilevel internal
690       */
691      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
692        if (caller == getStmtNoTransform()) {
693          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:659
694          return getCondition().isDAafterTrue(v);
695        }
696        else if (caller == getConditionNoTransform()) {
697          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:658
698          return isDAbefore(v);
699        }
700        else {
701          return getParent().Define_isDAbefore(this, caller, v);
702        }
703      }
704      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
705        return true;
706      }
707      /**
708       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
709       * @apilevel internal
710       */
711      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
712        if (caller == getStmtNoTransform()) {
713          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1234
714          return getCondition().isDUafterTrue(v);
715        }
716        else if (caller == getConditionNoTransform()) {
717          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1213
718          return isDUbeforeCondition(v);
719        }
720        else {
721          return getParent().Define_isDUbefore(this, caller, v);
722        }
723      }
724      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
725        return true;
726      }
727      /**
728       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:441
729       * @apilevel internal
730       */
731      public boolean Define_insideLoop(ASTNode caller, ASTNode child) {
732        if (caller == getStmtNoTransform()) {
733          // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:446
734          return true;
735        }
736        else {
737          return getParent().Define_insideLoop(this, caller);
738        }
739      }
740      protected boolean canDefine_insideLoop(ASTNode caller, ASTNode child) {
741        return true;
742      }
743      /**
744       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52
745       * @apilevel internal
746       */
747      public boolean Define_reachable(ASTNode caller, ASTNode child) {
748        if (caller == getStmtNoTransform()) {
749          // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:135
750          return reachable() && !getCondition().isFalse();
751        }
752        else {
753          return getParent().Define_reachable(this, caller);
754        }
755      }
756      protected boolean canDefine_reachable(ASTNode caller, ASTNode child) {
757        return true;
758      }
759      /**
760       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:283
761       * @apilevel internal
762       */
763      public boolean Define_reportUnreachable(ASTNode caller, ASTNode child) {
764        if (caller == getStmtNoTransform()) {
765          // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:215
766          return reachable();
767        }
768        else {
769          return getParent().Define_reportUnreachable(this, caller);
770        }
771      }
772      protected boolean canDefine_reportUnreachable(ASTNode caller, ASTNode child) {
773        return true;
774      }
775      /**
776       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30
777       * @apilevel internal
778       */
779      public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
780        if (caller == getStmtNoTransform()) {
781          // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:54
782          return false;
783        }
784        else {
785          return getParent().Define_inhModifiedInScope(this, caller, var);
786        }
787      }
788      protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
789        return true;
790      }
791      /**
792       * @apilevel internal
793       */
794      public ASTNode rewriteTo() {
795        return super.rewriteTo();
796      }
797    }