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:79
027     * @production VarDeclStmt : {@link Stmt} ::= <span class="component">{@link Modifiers}</span> <span class="component">TypeAccess:{@link Access}</span> <span class="component">{@link VariableDecl}*</span> <span class="component">SingleDecl:{@link VariableDeclaration}*</span>;
028    
029     */
030    public class VarDeclStmt extends Stmt implements Cloneable {
031      /**
032       * @aspect ErrorCheck
033       * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:250
034       */
035      public void collectErrors() {
036        // check reachability of the multi-declaration
037        checkUnreachableStmt();
038    
039        // delegate other error checks to NTA single variable declarations
040        getSingleDeclList().collectErrors();
041      }
042      /**
043       * @aspect Java4PrettyPrint
044       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:165
045       */
046      public void prettyPrint(PrettyPrinter out) {
047        out.print(getModifiers());
048        out.print(getTypeAccess());
049        out.print(" ");
050        out.join(getVariableDecls(), new PrettyPrinter.Joiner() {
051          @Override
052          public void printSeparator(PrettyPrinter out) {
053            out.print(", ");
054          }
055        });
056        out.print(";");
057      }
058      /**
059       * @aspect CreateBCode
060       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:269
061       */
062      public void createBCode(CodeGeneration gen) {
063        gen.addLineNumberEntryAtCurrentPC(this);// generate line number entry
064        for (VariableDeclaration decl: getSingleDeclList()) {
065          decl.createBCode(gen);
066        }
067      }
068      /**
069       * @declaredat ASTNode:1
070       */
071      public VarDeclStmt() {
072        super();
073      }
074      /**
075       * Initializes the child array to the correct size.
076       * Initializes List and Opt nta children.
077       * @apilevel internal
078       * @ast method
079       * @declaredat ASTNode:10
080       */
081      public void init$Children() {
082        children = new ASTNode[4];
083        setChild(new List(), 2);
084        setChild(new List(), 3);
085      }
086      /**
087       * @declaredat ASTNode:15
088       */
089      public VarDeclStmt(Modifiers p0, Access p1, List<VariableDecl> p2) {
090        setChild(p0, 0);
091        setChild(p1, 1);
092        setChild(p2, 2);
093      }
094      /**
095       * @apilevel low-level
096       * @declaredat ASTNode:23
097       */
098      protected int numChildren() {
099        return 3;
100      }
101      /**
102       * @apilevel internal
103       * @declaredat ASTNode:29
104       */
105      public boolean mayHaveRewrite() {
106        return false;
107      }
108      /**
109       * @apilevel internal
110       * @declaredat ASTNode:35
111       */
112      public void flushAttrCache() {
113        super.flushAttrCache();
114        isDAafter_Variable_reset();
115        isDUafter_Variable_reset();
116        canCompleteNormally_reset();
117        getSingleDeclList_reset();
118        localSize_reset();
119      }
120      /**
121       * @apilevel internal
122       * @declaredat ASTNode:46
123       */
124      public void flushCollectionCache() {
125        super.flushCollectionCache();
126      }
127      /**
128       * @apilevel internal
129       * @declaredat ASTNode:52
130       */
131      public void flushRewriteCache() {
132        super.flushRewriteCache();
133      }
134      /**
135       * @apilevel internal
136       * @declaredat ASTNode:58
137       */
138      public VarDeclStmt clone() throws CloneNotSupportedException {
139        VarDeclStmt node = (VarDeclStmt) super.clone();
140        return node;
141      }
142      /**
143       * @apilevel internal
144       * @declaredat ASTNode:65
145       */
146      public VarDeclStmt copy() {
147        try {
148          VarDeclStmt node = (VarDeclStmt) clone();
149          node.parent = null;
150          if (children != null) {
151            node.children = (ASTNode[]) children.clone();
152          }
153          return node;
154        } catch (CloneNotSupportedException e) {
155          throw new Error("Error: clone not supported for " + getClass().getName());
156        }
157      }
158      /**
159       * Create a deep copy of the AST subtree at this node.
160       * The copy is dangling, i.e. has no parent.
161       * @return dangling copy of the subtree at this node
162       * @apilevel low-level
163       * @deprecated Please use treeCopy or treeCopyNoTransform instead
164       * @declaredat ASTNode:84
165       */
166      @Deprecated
167      public VarDeclStmt fullCopy() {
168        return treeCopyNoTransform();
169      }
170      /**
171       * Create a deep copy of the AST subtree at this node.
172       * The copy is dangling, i.e. has no parent.
173       * @return dangling copy of the subtree at this node
174       * @apilevel low-level
175       * @declaredat ASTNode:94
176       */
177      public VarDeclStmt treeCopyNoTransform() {
178        VarDeclStmt tree = (VarDeclStmt) copy();
179        if (children != null) {
180          for (int i = 0; i < children.length; ++i) {
181            switch (i) {
182            case 3:
183              tree.children[i] = new List();
184              continue;
185            }
186            ASTNode child = (ASTNode) children[i];
187            if (child != null) {
188              child = child.treeCopyNoTransform();
189              tree.setChild(child, i);
190            }
191          }
192        }
193        return tree;
194      }
195      /**
196       * Create a deep copy of the AST subtree at this node.
197       * The subtree of this node is traversed to trigger rewrites before copy.
198       * The copy is dangling, i.e. has no parent.
199       * @return dangling copy of the subtree at this node
200       * @apilevel low-level
201       * @declaredat ASTNode:119
202       */
203      public VarDeclStmt treeCopy() {
204        doFullTraversal();
205        return treeCopyNoTransform();
206      }
207      /**
208       * @apilevel internal
209       * @declaredat ASTNode:126
210       */
211      protected boolean is$Equal(ASTNode node) {
212        return super.is$Equal(node);    
213      }
214      /**
215       * Replaces the Modifiers child.
216       * @param node The new node to replace the Modifiers child.
217       * @apilevel high-level
218       */
219      public void setModifiers(Modifiers node) {
220        setChild(node, 0);
221      }
222      /**
223       * Retrieves the Modifiers child.
224       * @return The current node used as the Modifiers child.
225       * @apilevel high-level
226       */
227      @ASTNodeAnnotation.Child(name="Modifiers")
228      public Modifiers getModifiers() {
229        return (Modifiers) getChild(0);
230      }
231      /**
232       * Retrieves the Modifiers child.
233       * <p><em>This method does not invoke AST transformations.</em></p>
234       * @return The current node used as the Modifiers child.
235       * @apilevel low-level
236       */
237      public Modifiers getModifiersNoTransform() {
238        return (Modifiers) getChildNoTransform(0);
239      }
240      /**
241       * Replaces the TypeAccess child.
242       * @param node The new node to replace the TypeAccess child.
243       * @apilevel high-level
244       */
245      public void setTypeAccess(Access node) {
246        setChild(node, 1);
247      }
248      /**
249       * Retrieves the TypeAccess child.
250       * @return The current node used as the TypeAccess child.
251       * @apilevel high-level
252       */
253      @ASTNodeAnnotation.Child(name="TypeAccess")
254      public Access getTypeAccess() {
255        return (Access) getChild(1);
256      }
257      /**
258       * Retrieves the TypeAccess child.
259       * <p><em>This method does not invoke AST transformations.</em></p>
260       * @return The current node used as the TypeAccess child.
261       * @apilevel low-level
262       */
263      public Access getTypeAccessNoTransform() {
264        return (Access) getChildNoTransform(1);
265      }
266      /**
267       * Replaces the VariableDecl list.
268       * @param list The new list node to be used as the VariableDecl list.
269       * @apilevel high-level
270       */
271      public void setVariableDeclList(List<VariableDecl> list) {
272        setChild(list, 2);
273      }
274      /**
275       * Retrieves the number of children in the VariableDecl list.
276       * @return Number of children in the VariableDecl list.
277       * @apilevel high-level
278       */
279      public int getNumVariableDecl() {
280        return getVariableDeclList().getNumChild();
281      }
282      /**
283       * Retrieves the number of children in the VariableDecl list.
284       * Calling this method will not trigger rewrites.
285       * @return Number of children in the VariableDecl list.
286       * @apilevel low-level
287       */
288      public int getNumVariableDeclNoTransform() {
289        return getVariableDeclListNoTransform().getNumChildNoTransform();
290      }
291      /**
292       * Retrieves the element at index {@code i} in the VariableDecl list.
293       * @param i Index of the element to return.
294       * @return The element at position {@code i} in the VariableDecl list.
295       * @apilevel high-level
296       */
297      public VariableDecl getVariableDecl(int i) {
298        return (VariableDecl) getVariableDeclList().getChild(i);
299      }
300      /**
301       * Check whether the VariableDecl list has any children.
302       * @return {@code true} if it has at least one child, {@code false} otherwise.
303       * @apilevel high-level
304       */
305      public boolean hasVariableDecl() {
306        return getVariableDeclList().getNumChild() != 0;
307      }
308      /**
309       * Append an element to the VariableDecl list.
310       * @param node The element to append to the VariableDecl list.
311       * @apilevel high-level
312       */
313      public void addVariableDecl(VariableDecl node) {
314        List<VariableDecl> list = (parent == null) ? getVariableDeclListNoTransform() : getVariableDeclList();
315        list.addChild(node);
316      }
317      /**
318       * @apilevel low-level
319       */
320      public void addVariableDeclNoTransform(VariableDecl node) {
321        List<VariableDecl> list = getVariableDeclListNoTransform();
322        list.addChild(node);
323      }
324      /**
325       * Replaces the VariableDecl list element at index {@code i} with the new node {@code node}.
326       * @param node The new node to replace the old list element.
327       * @param i The list index of the node to be replaced.
328       * @apilevel high-level
329       */
330      public void setVariableDecl(VariableDecl node, int i) {
331        List<VariableDecl> list = getVariableDeclList();
332        list.setChild(node, i);
333      }
334      /**
335       * Retrieves the VariableDecl list.
336       * @return The node representing the VariableDecl list.
337       * @apilevel high-level
338       */
339      @ASTNodeAnnotation.ListChild(name="VariableDecl")
340      public List<VariableDecl> getVariableDeclList() {
341        List<VariableDecl> list = (List<VariableDecl>) getChild(2);
342        return list;
343      }
344      /**
345       * Retrieves the VariableDecl list.
346       * <p><em>This method does not invoke AST transformations.</em></p>
347       * @return The node representing the VariableDecl list.
348       * @apilevel low-level
349       */
350      public List<VariableDecl> getVariableDeclListNoTransform() {
351        return (List<VariableDecl>) getChildNoTransform(2);
352      }
353      /**
354       * Retrieves the VariableDecl list.
355       * @return The node representing the VariableDecl list.
356       * @apilevel high-level
357       */
358      public List<VariableDecl> getVariableDecls() {
359        return getVariableDeclList();
360      }
361      /**
362       * Retrieves the VariableDecl list.
363       * <p><em>This method does not invoke AST transformations.</em></p>
364       * @return The node representing the VariableDecl list.
365       * @apilevel low-level
366       */
367      public List<VariableDecl> getVariableDeclsNoTransform() {
368        return getVariableDeclListNoTransform();
369      }
370      /**
371       * Retrieves the number of children in the SingleDecl list.
372       * @return Number of children in the SingleDecl list.
373       * @apilevel high-level
374       */
375      public int getNumSingleDecl() {
376        return getSingleDeclList().getNumChild();
377      }
378      /**
379       * Retrieves the number of children in the SingleDecl list.
380       * Calling this method will not trigger rewrites.
381       * @return Number of children in the SingleDecl list.
382       * @apilevel low-level
383       */
384      public int getNumSingleDeclNoTransform() {
385        return getSingleDeclListNoTransform().getNumChildNoTransform();
386      }
387      /**
388       * Retrieves the element at index {@code i} in the SingleDecl list.
389       * @param i Index of the element to return.
390       * @return The element at position {@code i} in the SingleDecl list.
391       * @apilevel high-level
392       */
393      public VariableDeclaration getSingleDecl(int i) {
394        return (VariableDeclaration) getSingleDeclList().getChild(i);
395      }
396      /**
397       * Check whether the SingleDecl list has any children.
398       * @return {@code true} if it has at least one child, {@code false} otherwise.
399       * @apilevel high-level
400       */
401      public boolean hasSingleDecl() {
402        return getSingleDeclList().getNumChild() != 0;
403      }
404      /**
405       * Append an element to the SingleDecl list.
406       * @param node The element to append to the SingleDecl list.
407       * @apilevel high-level
408       */
409      public void addSingleDecl(VariableDeclaration node) {
410        List<VariableDeclaration> list = (parent == null) ? getSingleDeclListNoTransform() : getSingleDeclList();
411        list.addChild(node);
412      }
413      /**
414       * @apilevel low-level
415       */
416      public void addSingleDeclNoTransform(VariableDeclaration node) {
417        List<VariableDeclaration> list = getSingleDeclListNoTransform();
418        list.addChild(node);
419      }
420      /**
421       * Replaces the SingleDecl list element at index {@code i} with the new node {@code node}.
422       * @param node The new node to replace the old list element.
423       * @param i The list index of the node to be replaced.
424       * @apilevel high-level
425       */
426      public void setSingleDecl(VariableDeclaration node, int i) {
427        List<VariableDeclaration> list = getSingleDeclList();
428        list.setChild(node, i);
429      }
430      /**
431       * Retrieves the child position of the SingleDecl list.
432       * @return The the child position of the SingleDecl list.
433       * @apilevel low-level
434       */
435      protected int getSingleDeclListChildPosition() {
436        return 3;
437      }
438      /**
439       * Retrieves the SingleDecl list.
440       * <p><em>This method does not invoke AST transformations.</em></p>
441       * @return The node representing the SingleDecl list.
442       * @apilevel low-level
443       */
444      public List<VariableDeclaration> getSingleDeclListNoTransform() {
445        return (List<VariableDeclaration>) getChildNoTransform(3);
446      }
447      /**
448       * Retrieves the SingleDecl list.
449       * @return The node representing the SingleDecl list.
450       * @apilevel high-level
451       */
452      public List<VariableDeclaration> getSingleDecls() {
453        return getSingleDeclList();
454      }
455      /**
456       * Retrieves the SingleDecl list.
457       * <p><em>This method does not invoke AST transformations.</em></p>
458       * @return The node representing the SingleDecl list.
459       * @apilevel low-level
460       */
461      public List<VariableDeclaration> getSingleDeclsNoTransform() {
462        return getSingleDeclListNoTransform();
463      }
464      /**
465       * @apilevel internal
466       */
467      protected java.util.Map isDAafter_Variable_values;
468      /**
469       * @apilevel internal
470       */
471      private void isDAafter_Variable_reset() {
472        isDAafter_Variable_values = null;
473      }
474      /**
475       * @attribute syn
476       * @aspect DA
477       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
478       */
479      @ASTNodeAnnotation.Attribute
480      public boolean isDAafter(Variable v) {
481        Object _parameters = v;
482        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
483        ASTNode$State state = state();
484        if (isDAafter_Variable_values.containsKey(_parameters)) {
485          return (Boolean) isDAafter_Variable_values.get(_parameters);
486        }
487        boolean intermediate = state.INTERMEDIATE_VALUE;
488        state.INTERMEDIATE_VALUE = false;
489        int num = state.boundariesCrossed;
490        boolean isFinal = this.is$Final();
491        boolean isDAafter_Variable_value = getSingleDecl(getNumSingleDecl()-1).isDAafter(v);
492        if (isFinal && num == state().boundariesCrossed) {
493          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
494        } else {
495        }
496        state.INTERMEDIATE_VALUE |= intermediate;
497    
498        return isDAafter_Variable_value;
499      }
500      /**
501       * @apilevel internal
502       */
503      protected java.util.Map isDUafter_Variable_values;
504      /**
505       * @apilevel internal
506       */
507      private void isDUafter_Variable_reset() {
508        isDUafter_Variable_values = null;
509      }
510      /**
511       * @attribute syn
512       * @aspect DU
513       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
514       */
515      @ASTNodeAnnotation.Attribute
516      public boolean isDUafter(Variable v) {
517        Object _parameters = v;
518        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
519        ASTNode$State state = state();
520        if (isDUafter_Variable_values.containsKey(_parameters)) {
521          return (Boolean) isDUafter_Variable_values.get(_parameters);
522        }
523        boolean intermediate = state.INTERMEDIATE_VALUE;
524        state.INTERMEDIATE_VALUE = false;
525        int num = state.boundariesCrossed;
526        boolean isFinal = this.is$Final();
527        boolean isDUafter_Variable_value = getSingleDecl(getNumSingleDecl()-1).isDUafter(v);
528        if (isFinal && num == state().boundariesCrossed) {
529          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
530        } else {
531        }
532        state.INTERMEDIATE_VALUE |= intermediate;
533    
534        return isDUafter_Variable_value;
535      }
536      /**
537       * @attribute syn
538       * @aspect VariableScope
539       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:205
540       */
541      @ASTNodeAnnotation.Attribute
542      public VariableDeclaration variableDeclaration(String name) {
543        {
544            for (VariableDeclaration decl: getSingleDeclList()) {
545              if (decl.declaresVariable(name)) {
546                return decl;
547              }
548            }
549            return null;
550          }
551      }
552      /**
553       * @attribute syn
554       * @aspect TypeAnalysis
555       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:279
556       */
557      @ASTNodeAnnotation.Attribute
558      public TypeDecl type() {
559        TypeDecl type_value = getTypeAccess().type();
560    
561        return type_value;
562      }
563      /**
564       * @apilevel internal
565       */
566      protected boolean canCompleteNormally_computed = false;
567      /**
568       * @apilevel internal
569       */
570      protected boolean canCompleteNormally_value;
571      /**
572       * @apilevel internal
573       */
574      private void canCompleteNormally_reset() {
575        canCompleteNormally_computed = false;
576      }
577      /**
578       * @attribute syn
579       * @aspect UnreachableStatements
580       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53
581       */
582      @ASTNodeAnnotation.Attribute
583      public boolean canCompleteNormally() {
584        ASTNode$State state = state();
585        if (canCompleteNormally_computed) {
586          return canCompleteNormally_value;
587        }
588        boolean intermediate = state.INTERMEDIATE_VALUE;
589        state.INTERMEDIATE_VALUE = false;
590        int num = state.boundariesCrossed;
591        boolean isFinal = this.is$Final();
592        canCompleteNormally_value = reachable();
593        if (isFinal && num == state().boundariesCrossed) {
594          canCompleteNormally_computed = true;
595        } else {
596        }
597        state.INTERMEDIATE_VALUE |= intermediate;
598    
599        return canCompleteNormally_value;
600      }
601      /**
602       * @apilevel internal
603       */
604      protected boolean getSingleDeclList_computed = false;
605      /**
606       * @apilevel internal
607       */
608      protected List<VariableDeclaration> getSingleDeclList_value;
609      /**
610       * @apilevel internal
611       */
612      private void getSingleDeclList_reset() {
613        getSingleDeclList_computed = false;
614        getSingleDeclList_value = null;
615      }
616      /**
617       * @attribute syn nta
618       * @aspect VariableDeclarationTransformation
619       * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:163
620       */
621      @ASTNodeAnnotation.Attribute
622      public List<VariableDeclaration> getSingleDeclList() {
623        ASTNode$State state = state();
624        if (getSingleDeclList_computed) {
625          return (List<VariableDeclaration>) getChild(getSingleDeclListChildPosition());
626        }
627        boolean intermediate = state.INTERMEDIATE_VALUE;
628        state.INTERMEDIATE_VALUE = false;
629        int num = state.boundariesCrossed;
630        boolean isFinal = this.is$Final();
631        getSingleDeclList_value = getSingleDeclList_compute();
632        setChild(getSingleDeclList_value, getSingleDeclListChildPosition());
633        if (isFinal && num == state().boundariesCrossed) {
634          getSingleDeclList_computed = true;
635        } else {
636        }
637        state.INTERMEDIATE_VALUE |= intermediate;
638    
639        List<VariableDeclaration> node = (List<VariableDeclaration>) this.getChild(getSingleDeclListChildPosition());
640        return node;
641      }
642      /**
643       * @apilevel internal
644       */
645      private List<VariableDeclaration> getSingleDeclList_compute() {
646          List<VariableDeclaration> decls = new List<VariableDeclaration>();
647          for (int i = 0; i < getNumVariableDecl(); ++i) {
648            VariableDecl varDecl = getVariableDecl(i);
649            VariableDeclaration decl = varDecl.createVariableDeclarationFrom(getModifiers(), getTypeAccess());
650            decls.add(decl);
651          }
652          return decls;
653        }
654      /**
655       * @apilevel internal
656       */
657      protected boolean localSize_computed = false;
658      /**
659       * @apilevel internal
660       */
661      protected int localSize_value;
662      /**
663       * @apilevel internal
664       */
665      private void localSize_reset() {
666        localSize_computed = false;
667      }
668      /**
669       * Computes size required for local variables of this statement.
670       * NB: only relevant for variable declaration statements.
671       * @return local size for declared variables
672       * @attribute syn
673       * @aspect LocalNum
674       * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:38
675       */
676      @ASTNodeAnnotation.Attribute
677      public int localSize() {
678        ASTNode$State state = state();
679        if (localSize_computed) {
680          return localSize_value;
681        }
682        boolean intermediate = state.INTERMEDIATE_VALUE;
683        state.INTERMEDIATE_VALUE = false;
684        int num = state.boundariesCrossed;
685        boolean isFinal = this.is$Final();
686        localSize_value = localSize_compute();
687        if (isFinal && num == state().boundariesCrossed) {
688          localSize_computed = true;
689        } else {
690        }
691        state.INTERMEDIATE_VALUE |= intermediate;
692    
693        return localSize_value;
694      }
695      /**
696       * @apilevel internal
697       */
698      private int localSize_compute() {
699          int size = 0;
700          for (VariableDeclaration decl: getSingleDeclList()) {
701            size += decl.localSize();
702          }
703          return size;
704        }
705      /**
706       * @attribute syn
707       * @aspect PreciseRethrow
708       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
709       */
710      @ASTNodeAnnotation.Attribute
711      public boolean modifiedInScope(Variable var) {
712        {
713            for (VariableDeclaration decl: getSingleDeclList()) {
714              if (decl.modifiedInScope(var)) {
715                return true;
716              }
717            }
718            return false;
719          }
720      }
721      /**
722       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:71
723       * @apilevel internal
724       */
725      public boolean Define_isIncOrDec(ASTNode caller, ASTNode child) {
726        if (caller == getSingleDeclListNoTransform()) {
727          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:75
728          int childIndex = caller.getIndexOfChild(child);
729          return false;
730        }
731        else {
732          return getParent().Define_isIncOrDec(this, caller);
733        }
734      }
735      protected boolean canDefine_isIncOrDec(ASTNode caller, ASTNode child) {
736        return true;
737      }
738      /**
739       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
740       * @apilevel internal
741       */
742      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
743        if (caller == getSingleDeclListNoTransform()) {
744          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:488
745          int index = caller.getIndexOfChild(child);
746          return index == 0 ? isDAbefore(v) : getSingleDecl(index - 1).isDAafter(v);
747        }
748        else {
749          return getParent().Define_isDAbefore(this, caller, v);
750        }
751      }
752      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
753        return true;
754      }
755      /**
756       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
757       * @apilevel internal
758       */
759      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
760        if (caller == getSingleDeclListNoTransform()) {
761          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:988
762          int index = caller.getIndexOfChild(child);
763          return index == 0 ? isDUbefore(v) : getSingleDecl(index - 1).isDUafter(v);
764        }
765        else {
766          return getParent().Define_isDUbefore(this, caller, v);
767        }
768      }
769      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
770        return true;
771      }
772      /**
773       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
774       * @apilevel internal
775       */
776      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
777        if (caller == getSingleDeclListNoTransform()) {
778          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:112
779          int index = caller.getIndexOfChild(child);
780          {
781              for (int i = index; i >= 0; --i) {
782                if (getSingleDecl(i).declaresVariable(name)) {
783                  return getSingleDecl(i);
784                }
785              }
786              return lookupVariable(name);
787            }
788        }
789        else {
790          return getParent().Define_lookupVariable(this, caller, name);
791        }
792      }
793      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
794        return true;
795      }
796      /**
797       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
798       * @apilevel internal
799       */
800      public NameType Define_nameType(ASTNode caller, ASTNode child) {
801        if (caller == getTypeAccessNoTransform()) {
802          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:111
803          return NameType.TYPE_NAME;
804        }
805        else {
806          return getParent().Define_nameType(this, caller);
807        }
808      }
809      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
810        return true;
811      }
812      /**
813       * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:601
814       * @apilevel internal
815       */
816      public TypeDecl Define_declType(ASTNode caller, ASTNode child) {
817        if (caller == getVariableDeclListNoTransform()) {
818          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:284
819          int childIndex = caller.getIndexOfChild(child);
820          return null;
821        }
822        else {
823          return getParent().Define_declType(this, caller);
824        }
825      }
826      protected boolean canDefine_declType(ASTNode caller, ASTNode child) {
827        return true;
828      }
829      /**
830       * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64
831       * @apilevel internal
832       */
833      public int Define_localNum(ASTNode caller, ASTNode child) {
834        if (caller == getSingleDeclListNoTransform()) {
835          // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:52
836          int index = caller.getIndexOfChild(child);
837          {
838              if (index == 0) {
839                return localNum();
840              } else {
841                return getSingleDecl(index-1).localNum() + getSingleDecl(index-1).localSize();
842              }
843            }
844        }
845        else {
846          return getParent().Define_localNum(this, caller);
847        }
848      }
849      protected boolean canDefine_localNum(ASTNode caller, ASTNode child) {
850        return true;
851      }
852      /**
853       * @apilevel internal
854       */
855      public ASTNode rewriteTo() {
856        return super.rewriteTo();
857      }
858    }