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