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 AbstractDot : {@link Access} ::= <span class="component">Left:{@link Expr}</span> <span class="component">Right:{@link Access}</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:16
017     */
018    public class AbstractDot extends Access 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 AbstractDot clone() throws CloneNotSupportedException {
034        AbstractDot node = (AbstractDot)super.clone();
035        node.isDAafter_Variable_values = null;
036        node.isDUafter_Variable_values = null;
037        node.type_computed = false;
038        node.type_value = null;
039        node.isDUbefore_Variable_values = null;
040        node.in$Circle(false);
041        node.is$Final(false);
042        return node;
043      }
044    /**
045     * @apilevel internal
046     */
047      @SuppressWarnings({"unchecked", "cast"})
048    public AbstractDot copy() {
049      
050      try {
051        AbstractDot node = (AbstractDot) clone();
052        node.parent = null;
053        if(children != null)
054          node.children = (ASTNode[]) children.clone();
055        
056        return node;
057      } catch (CloneNotSupportedException e) {
058        throw new Error("Error: clone not supported for " + getClass().getName());
059      }
060      
061    }/**
062     * Create a deep copy of the AST subtree at this node.
063     * The copy is dangling, i.e. has no parent.
064     * @return dangling copy of the subtree at this node
065     * @apilevel low-level
066     */
067      @SuppressWarnings({"unchecked", "cast"})
068    public AbstractDot fullCopy() {
069      
070      AbstractDot tree = (AbstractDot) copy();
071      if (children != null) {
072        for (int i = 0; i < children.length; ++i) {
073          
074          ASTNode child = (ASTNode) children[i];
075          if(child != null) {
076            child = child.fullCopy();
077            tree.setChild(child, i);
078          }
079        }
080      }
081      return tree;
082      
083    }  /**
084       * @ast method 
085       * @aspect PrettyPrint
086       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:446
087       */
088      public void toString(StringBuffer s) {
089        getLeft().toString(s);
090        if(!nextAccess().isArrayAccess())
091          s.append(".");
092        getRight().toString(s);
093      }
094      /**
095       * @ast method 
096       * @aspect QualifiedNames
097       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:135
098       */
099      public Access extractLast() {
100        return getRightNoTransform();
101     }
102      /**
103       * @ast method 
104       * @aspect QualifiedNames
105       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:138
106       */
107      public void replaceLast(Access access) {
108        setRight(access);
109      }
110      /**
111       * @ast method 
112       * @aspect CodeGeneration
113       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:697
114       */
115      public void emitStore(CodeGeneration gen) { lastAccess().emitStore(gen); }
116      /**
117       * @ast method 
118       * @aspect CreateBCode
119       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:352
120       */
121      public void createAssignSimpleLoadDest(CodeGeneration gen) {
122        lastAccess().createAssignSimpleLoadDest(gen);
123      }
124      /**
125       * @ast method 
126       * @aspect CreateBCode
127       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:368
128       */
129      public void createPushAssignmentResult(CodeGeneration gen) {
130        lastAccess().createPushAssignmentResult(gen);
131      }
132      /**
133       * @ast method 
134       * @aspect CreateBCode
135       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:386
136       */
137      public void createAssignLoadDest(CodeGeneration gen) {
138        lastAccess().createAssignLoadDest(gen);
139      }
140      /**
141       * @ast method 
142       * @aspect CreateBCode
143       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:434
144       */
145      public void createBCode(CodeGeneration gen) {
146        lastAccess().createBCode(gen);
147      }
148      /**
149       * @ast method 
150       * @aspect CreateBCode
151       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1083
152       */
153      public void emitEvalBranch(CodeGeneration gen) { lastAccess().emitEvalBranch(gen); }
154      /**
155       * @ast method 
156       * 
157       */
158      public AbstractDot() {
159        super();
160    
161    
162      }
163      /**
164       * Initializes the child array to the correct size.
165       * Initializes List and Opt nta children.
166       * @apilevel internal
167       * @ast method
168       * @ast method 
169       * 
170       */
171      public void init$Children() {
172        children = new ASTNode[2];
173      }
174      /**
175       * @ast method 
176       * 
177       */
178      public AbstractDot(Expr p0, Access p1) {
179        setChild(p0, 0);
180        setChild(p1, 1);
181      }
182      /**
183       * @apilevel low-level
184       * @ast method 
185       * 
186       */
187      protected int numChildren() {
188        return 2;
189      }
190      /**
191       * @apilevel internal
192       * @ast method 
193       * 
194       */
195      public boolean mayHaveRewrite() {
196        return false;
197      }
198      /**
199       * Replaces the Left child.
200       * @param node The new node to replace the Left child.
201       * @apilevel high-level
202       * @ast method 
203       * 
204       */
205      public void setLeft(Expr node) {
206        setChild(node, 0);
207      }
208      /**
209       * Retrieves the Left child.
210       * @return The current node used as the Left child.
211       * @apilevel high-level
212       * @ast method 
213       * 
214       */
215      public Expr getLeft() {
216        return (Expr)getChild(0);
217      }
218      /**
219       * Retrieves the Left child.
220       * <p><em>This method does not invoke AST transformations.</em></p>
221       * @return The current node used as the Left child.
222       * @apilevel low-level
223       * @ast method 
224       * 
225       */
226      public Expr getLeftNoTransform() {
227        return (Expr)getChildNoTransform(0);
228      }
229      /**
230       * Replaces the Right child.
231       * @param node The new node to replace the Right child.
232       * @apilevel high-level
233       * @ast method 
234       * 
235       */
236      public void setRight(Access node) {
237        setChild(node, 1);
238      }
239      /**
240       * Retrieves the Right child.
241       * @return The current node used as the Right child.
242       * @apilevel high-level
243       * @ast method 
244       * 
245       */
246      public Access getRight() {
247        return (Access)getChild(1);
248      }
249      /**
250       * Retrieves the Right child.
251       * <p><em>This method does not invoke AST transformations.</em></p>
252       * @return The current node used as the Right child.
253       * @apilevel low-level
254       * @ast method 
255       * 
256       */
257      public Access getRightNoTransform() {
258        return (Access)getChildNoTransform(1);
259      }
260      /**
261       * @attribute syn
262       * @aspect ConstantExpression
263       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:91
264       */
265      public Constant constant() {
266        ASTNode$State state = state();
267        try {  return lastAccess().constant();  }
268        finally {
269        }
270      }
271      /**
272       * @attribute syn
273       * @aspect ConstantExpression
274       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/ConstantExpression.jrag:336
275       */
276      public boolean isConstant() {
277        ASTNode$State state = state();
278        try {  return lastAccess().isConstant();  }
279        finally {
280        }
281      }
282      /**
283       * @attribute syn
284       * @aspect DefiniteAssignment
285       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:58
286       */
287      public Variable varDecl() {
288        ASTNode$State state = state();
289        try {  return lastAccess().varDecl();  }
290        finally {
291        }
292      }
293      /*eq Stmt.isDAafter(Variable v) {
294        //System.out.println("### isDAafter reached in " + getClass().getName());
295        //throw new NullPointerException();
296        throw new Error("Can not compute isDAafter for " + getClass().getName() + " at " + errorPrefix());
297      }* @attribute syn
298       * @aspect DA
299       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:332
300       */
301      public boolean isDAafterTrue(Variable v) {
302        ASTNode$State state = state();
303        try {  return isDAafter(v);  }
304        finally {
305        }
306      }
307      /**
308       * @attribute syn
309       * @aspect DA
310       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:333
311       */
312      public boolean isDAafterFalse(Variable v) {
313        ASTNode$State state = state();
314        try {  return isDAafter(v);  }
315        finally {
316        }
317      }
318      protected java.util.Map isDAafter_Variable_values;
319      /**
320       * @attribute syn
321       * @aspect DA
322       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:354
323       */
324      @SuppressWarnings({"unchecked", "cast"})
325      public boolean isDAafter(Variable v) {
326        Object _parameters = v;
327        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
328        if(isDAafter_Variable_values.containsKey(_parameters)) {
329          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
330        }
331          ASTNode$State state = state();
332      int num = state.boundariesCrossed;
333      boolean isFinal = this.is$Final();
334        boolean isDAafter_Variable_value = isDAafter_compute(v);
335      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
336            return isDAafter_Variable_value;
337      }
338      /**
339       * @apilevel internal
340       */
341      private boolean isDAafter_compute(Variable v) {  return lastAccess().isDAafter(v);  }
342      /**
343       * @attribute syn
344       * @aspect DU
345       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:702
346       */
347      public boolean isDUafterTrue(Variable v) {
348        ASTNode$State state = state();
349        try {  return isDUafter(v);  }
350        finally {
351        }
352      }
353      /**
354       * @attribute syn
355       * @aspect DU
356       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:703
357       */
358      public boolean isDUafterFalse(Variable v) {
359        ASTNode$State state = state();
360        try {  return isDUafter(v);  }
361        finally {
362        }
363      }
364      protected java.util.Map isDUafter_Variable_values;
365      /**
366       * @attribute syn
367       * @aspect DU
368       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:835
369       */
370      @SuppressWarnings({"unchecked", "cast"})
371      public boolean isDUafter(Variable v) {
372        Object _parameters = v;
373        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
374        if(isDUafter_Variable_values.containsKey(_parameters)) {
375          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
376        }
377          ASTNode$State state = state();
378      int num = state.boundariesCrossed;
379      boolean isFinal = this.is$Final();
380        boolean isDUafter_Variable_value = isDUafter_compute(v);
381      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
382            return isDUafter_Variable_value;
383      }
384      /**
385       * @apilevel internal
386       */
387      private boolean isDUafter_compute(Variable v) {  return lastAccess().isDUafter(v);  }
388      /**
389       * @attribute syn
390       * @aspect Names
391       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/QualifiedNames.jrag:62
392       */
393      public String typeName() {
394        ASTNode$State state = state();
395        try {  return lastAccess().typeName();  }
396        finally {
397        }
398      }
399      /**
400       * @attribute syn
401       * @aspect AccessTypes
402       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:13
403       */
404      public boolean isTypeAccess() {
405        ASTNode$State state = state();
406        try {  return getRight().isTypeAccess();  }
407        finally {
408        }
409      }
410      /**
411       * @attribute syn
412       * @aspect AccessTypes
413       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:17
414       */
415      public boolean isMethodAccess() {
416        ASTNode$State state = state();
417        try {  return getRight().isMethodAccess();  }
418        finally {
419        }
420      }
421      /**
422       * @attribute syn
423       * @aspect AccessTypes
424       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:21
425       */
426      public boolean isFieldAccess() {
427        ASTNode$State state = state();
428        try {  return getRight().isFieldAccess();  }
429        finally {
430        }
431      }
432      /**
433       * @attribute syn
434       * @aspect AccessTypes
435       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:25
436       */
437      public boolean isSuperAccess() {
438        ASTNode$State state = state();
439        try {  return getRight().isSuperAccess();  }
440        finally {
441        }
442      }
443      /**
444       * @attribute syn
445       * @aspect AccessTypes
446       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:31
447       */
448      public boolean isThisAccess() {
449        ASTNode$State state = state();
450        try {  return getRight().isThisAccess();  }
451        finally {
452        }
453      }
454      /**
455       * @attribute syn
456       * @aspect AccessTypes
457       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:37
458       */
459      public boolean isPackageAccess() {
460        ASTNode$State state = state();
461        try {  return getRight().isPackageAccess();  }
462        finally {
463        }
464      }
465      /**
466       * @attribute syn
467       * @aspect AccessTypes
468       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:41
469       */
470      public boolean isArrayAccess() {
471        ASTNode$State state = state();
472        try {  return getRight().isArrayAccess();  }
473        finally {
474        }
475      }
476      /**
477       * @attribute syn
478       * @aspect AccessTypes
479       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:45
480       */
481      public boolean isClassAccess() {
482        ASTNode$State state = state();
483        try {  return getRight().isClassAccess();  }
484        finally {
485        }
486      }
487      /**
488       * @attribute syn
489       * @aspect AccessTypes
490       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:49
491       */
492      public boolean isSuperConstructorAccess() {
493        ASTNode$State state = state();
494        try {  return getRight().isSuperConstructorAccess();  }
495        finally {
496        }
497      }
498      /**
499       * @attribute syn
500       * @aspect QualifiedNames
501       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:58
502       */
503      public boolean isQualified() {
504        ASTNode$State state = state();
505        try {  return hasParentDot();  }
506        finally {
507        }
508      }
509      /**
510       * @attribute syn
511       * @aspect QualifiedNames
512       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:63
513       */
514      public Expr leftSide() {
515        ASTNode$State state = state();
516        try {  return getLeft();  }
517        finally {
518        }
519      }
520      /**
521       * @attribute syn
522       * @aspect QualifiedNames
523       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:64
524       */
525      public Access rightSide() {
526        ASTNode$State state = state();
527        try {  return getRight/*NoTransform*/() instanceof AbstractDot ? (Access)((AbstractDot)getRight/*NoTransform*/()).getLeft() : (Access)getRight();  }
528        finally {
529        }
530      }
531      /**
532       * @attribute syn
533       * @aspect QualifiedNames
534       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:66
535       */
536      public Access lastAccess() {
537        ASTNode$State state = state();
538        try {  return getRight().lastAccess();  }
539        finally {
540        }
541      }
542      /**
543       * @attribute syn
544       * @aspect QualifiedNames
545       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:75
546       */
547      public Access nextAccess() {
548        ASTNode$State state = state();
549        try {  return rightSide();  }
550        finally {
551        }
552      }
553      /**
554       * @attribute syn
555       * @aspect QualifiedNames
556       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:77
557       */
558      public Expr prevExpr() {
559        ASTNode$State state = state();
560        try {  return leftSide();  }
561        finally {
562        }
563      }
564      /**
565       * @attribute syn
566       * @aspect QualifiedNames
567       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/ResolveAmbiguousNames.jrag:88
568       */
569      public boolean hasPrevExpr() {
570        ASTNode$State state = state();
571        try {  return true;  }
572        finally {
573        }
574      }
575      /**
576       * @attribute syn
577       * @aspect SyntacticClassification
578       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/SyntacticClassification.jrag:56
579       */
580      public NameType predNameType() {
581        ASTNode$State state = state();
582        try {  return getLeft() instanceof Access ? ((Access)getLeft()).predNameType() : NameType.NO_NAME;  }
583        finally {
584        }
585      }
586      /**
587       * @apilevel internal
588       */
589      protected boolean type_computed = false;
590      /**
591       * @apilevel internal
592       */
593      protected TypeDecl type_value;
594      /**
595       * @attribute syn
596       * @aspect TypeAnalysis
597       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:249
598       */
599      @SuppressWarnings({"unchecked", "cast"})
600      public TypeDecl type() {
601        if(type_computed) {
602          return type_value;
603        }
604          ASTNode$State state = state();
605      int num = state.boundariesCrossed;
606      boolean isFinal = this.is$Final();
607        type_value = type_compute();
608      if(isFinal && num == state().boundariesCrossed){ type_computed = true; }
609            return type_value;
610      }
611      /**
612       * @apilevel internal
613       */
614      private TypeDecl type_compute() {  return lastAccess().type();  }
615      /**
616       * @attribute syn
617       * @aspect TypeCheck
618       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:15
619       */
620      public boolean isVariable() {
621        ASTNode$State state = state();
622        try {  return lastAccess().isVariable();  }
623        finally {
624        }
625      }
626      /**
627       * @attribute syn
628       * @aspect TypeHierarchyCheck
629       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeHierarchyCheck.jrag:150
630       */
631      public boolean staticContextQualifier() {
632        ASTNode$State state = state();
633        try {  return lastAccess().staticContextQualifier();  }
634        finally {
635        }
636      }
637      /**
638       * @attribute syn
639       * @aspect CreateBCode
640       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:219
641       */
642      public boolean needsPop() {
643        ASTNode$State state = state();
644        try {  return lastAccess().needsPop();  }
645        finally {
646        }
647      }
648      /**
649       * @attribute syn
650       * @aspect CreateBCode
651       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:231
652       */
653      public boolean isVarAccessWithAccessor() {
654        ASTNode$State state = state();
655        try {  return lastAccess().isVarAccessWithAccessor();  }
656        finally {
657        }
658      }
659      /**
660       * @attribute syn
661       * @aspect CreateBCode
662       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:946
663       */
664      public boolean definesLabel() {
665        ASTNode$State state = state();
666        try {  return getParent().definesLabel();  }
667        finally {
668        }
669      }
670      /**
671       * @attribute syn
672       * @aspect CreateBCode
673       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1007
674       */
675      public boolean canBeTrue() {
676        ASTNode$State state = state();
677        try {  return lastAccess().canBeTrue();  }
678        finally {
679        }
680      }
681      /**
682       * @attribute syn
683       * @aspect CreateBCode
684       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1017
685       */
686      public boolean canBeFalse() {
687        ASTNode$State state = state();
688        try {  return lastAccess().canBeFalse();  }
689        finally {
690        }
691      }
692      protected java.util.Map isDUbefore_Variable_values;
693      /**
694       * @attribute inh
695       * @aspect DU
696       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:697
697       */
698      @SuppressWarnings({"unchecked", "cast"})
699      public boolean isDUbefore(Variable v) {
700        Object _parameters = v;
701        if(isDUbefore_Variable_values == null) isDUbefore_Variable_values = new java.util.HashMap(4);
702        if(isDUbefore_Variable_values.containsKey(_parameters)) {
703          return ((Boolean)isDUbefore_Variable_values.get(_parameters)).booleanValue();
704        }
705          ASTNode$State state = state();
706      int num = state.boundariesCrossed;
707      boolean isFinal = this.is$Final();
708        boolean isDUbefore_Variable_value = getParent().Define_boolean_isDUbefore(this, null, v);
709      if(isFinal && num == state().boundariesCrossed){ isDUbefore_Variable_values.put(_parameters, Boolean.valueOf(isDUbefore_Variable_value)); }
710            return isDUbefore_Variable_value;
711      }
712      /**
713       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:21
714       * @apilevel internal
715       */
716      public boolean Define_boolean_isDest(ASTNode caller, ASTNode child) {
717        if(caller == getLeftNoTransform()) {
718          return false;
719        }
720        else {      return getParent().Define_boolean_isDest(this, caller);
721        }
722      }
723      /**
724       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:31
725       * @apilevel internal
726       */
727      public boolean Define_boolean_isSource(ASTNode caller, ASTNode child) {
728        if(caller == getLeftNoTransform()) {
729          return true;
730        }
731        else {      return getParent().Define_boolean_isSource(this, caller);
732        }
733      }
734      /**
735       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:353
736       * @apilevel internal
737       */
738      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
739        if(caller == getRightNoTransform()) {
740          return getLeft().isDAafter(v);
741        }
742        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
743        }
744      }
745      /**
746       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:834
747       * @apilevel internal
748       */
749      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
750        if(caller == getRightNoTransform()) {
751          return getLeft().isDUafter(v);
752        }
753        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
754        }
755      }
756      /**
757       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:17
758       * @apilevel internal
759       */
760      public Collection Define_Collection_lookupConstructor(ASTNode caller, ASTNode child) {
761        if(caller == getRightNoTransform()) {
762          return getLeft().type().constructors();
763        }
764        else {      return getParent().Define_Collection_lookupConstructor(this, caller);
765        }
766      }
767      /**
768       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupConstructor.jrag:25
769       * @apilevel internal
770       */
771      public Collection Define_Collection_lookupSuperConstructor(ASTNode caller, ASTNode child) {
772        if(caller == getRightNoTransform()) {
773          return getLeft().type().lookupSuperConstructor();
774        }
775        else {      return getParent().Define_Collection_lookupSuperConstructor(this, caller);
776        }
777      }
778      /**
779       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupMethod.jrag:20
780       * @apilevel internal
781       */
782      public Expr Define_Expr_nestedScope(ASTNode caller, ASTNode child) {
783        if(caller == getLeftNoTransform()) {
784          return isQualified() ? nestedScope() : this;
785        }
786        else if(caller == getRightNoTransform()) {
787          return isQualified() ? nestedScope() : this;
788        }
789        else {      return getParent().Define_Expr_nestedScope(this, caller);
790        }
791      }
792      /**
793       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupMethod.jrag:64
794       * @apilevel internal
795       */
796      public Collection Define_Collection_lookupMethod(ASTNode caller, ASTNode child, String name) {
797        if(caller == getRightNoTransform()) {
798          return getLeft().type().memberMethods(name);
799        }
800        else {      return getParent().Define_Collection_lookupMethod(this, caller, name);
801        }
802      }
803      /**
804       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupType.jrag:82
805       * @apilevel internal
806       */
807      public boolean Define_boolean_hasPackage(ASTNode caller, ASTNode child, String packageName) {
808        if(caller == getRightNoTransform()) {
809          return getLeft().hasQualifiedPackage(packageName);
810        }
811        else {      return getParent().Define_boolean_hasPackage(this, caller, packageName);
812        }
813      }
814      /**
815       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupType.jrag:429
816       * @apilevel internal
817       */
818      public SimpleSet Define_SimpleSet_lookupType(ASTNode caller, ASTNode child, String name) {
819        if(caller == getRightNoTransform()) {
820          return getLeft().qualifiedLookupType(name);
821        }
822        else {      return getParent().Define_SimpleSet_lookupType(this, caller, name);
823        }
824      }
825      /**
826       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/LookupVariable.jrag:139
827       * @apilevel internal
828       */
829      public SimpleSet Define_SimpleSet_lookupVariable(ASTNode caller, ASTNode child, String name) {
830        if(caller == getRightNoTransform()) {
831          return getLeft().qualifiedLookupVariable(name);
832        }
833        else {      return getParent().Define_SimpleSet_lookupVariable(this, caller, name);
834        }
835      }
836      /**
837       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/SyntacticClassification.jrag:59
838       * @apilevel internal
839       */
840      public NameType Define_NameType_nameType(ASTNode caller, ASTNode child) {
841        if(caller == getLeftNoTransform()) {
842          return getRight().predNameType();
843        }
844        else {      return getParent().Define_NameType_nameType(this, caller);
845        }
846      }
847      /**
848       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:516
849       * @apilevel internal
850       */
851      public TypeDecl Define_TypeDecl_enclosingInstance(ASTNode caller, ASTNode child) {
852        if(caller == getRightNoTransform()) {
853          return getLeft().type();
854        }
855        else {      return getParent().Define_TypeDecl_enclosingInstance(this, caller);
856        }
857      }
858      /**
859       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeHierarchyCheck.jrag:13
860       * @apilevel internal
861       */
862      public String Define_String_methodHost(ASTNode caller, ASTNode child) {
863        if(caller == getRightNoTransform()) {
864          return getLeft().type().typeName();
865        }
866        else {      return getParent().Define_String_methodHost(this, caller);
867        }
868      }
869      /**
870       * @apilevel internal
871       */
872      public ASTNode rewriteTo() {
873        return super.rewriteTo();
874      }
875    }