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:15
027     * @production AbstractDot : {@link Access} ::= <span class="component">Left:{@link Expr}</span> <span class="component">Right:{@link Access}</span>;
028    
029     */
030    public class AbstractDot extends Access implements Cloneable {
031      /**
032       * @aspect Java4PrettyPrint
033       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:498
034       */
035      public void prettyPrint(PrettyPrinter out) {
036        if (needsDot()) {
037          out.print(getLeft());
038          out.print(".");
039          out.print(getRight());
040        } else {
041          out.print(getLeft());
042          out.print(getRight());
043        }
044      }
045      /**
046       * @aspect QualifiedNames
047       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:165
048       */
049      public Access extractLast() {
050        return getRightNoTransform();
051      }
052      /**
053       * @aspect QualifiedNames
054       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:169
055       */
056      public void replaceLast(Access access) {
057        setRight(access);
058      }
059      /**
060       * @aspect CodeGeneration
061       * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:354
062       */
063      public void emitStore(CodeGeneration gen) { lastAccess().emitStore(gen); }
064      /**
065       * @aspect CreateBCode
066       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:430
067       */
068      public void createAssignSimpleLoadDest(CodeGeneration gen) {
069        lastAccess().createAssignSimpleLoadDest(gen);
070      }
071      /**
072       * @aspect CreateBCode
073       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:446
074       */
075      public void createPushAssignmentResult(CodeGeneration gen) {
076        lastAccess().createPushAssignmentResult(gen);
077      }
078      /**
079       * @aspect CreateBCode
080       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:466
081       */
082      public void createAssignLoadDest(CodeGeneration gen) {
083        lastAccess().createAssignLoadDest(gen);
084      }
085      /**
086       * @aspect CreateBCode
087       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:514
088       */
089      public void createBCode(CodeGeneration gen) {
090        lastAccess().createBCode(gen);
091      }
092      /**
093       * @aspect CreateBCode
094       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1130
095       */
096      public void branchTrue(CodeGeneration gen, int target) {
097        // branch when true
098        lastAccess().branchTrue(gen, target);
099      }
100      /**
101       * @aspect CreateBCode
102       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1245
103       */
104      public void branchFalse(CodeGeneration gen, int target) {
105        // branch when false
106        lastAccess().branchFalse(gen, target);
107      }
108      /**
109       * @declaredat ASTNode:1
110       */
111      public AbstractDot() {
112        super();
113      }
114      /**
115       * Initializes the child array to the correct size.
116       * Initializes List and Opt nta children.
117       * @apilevel internal
118       * @ast method
119       * @declaredat ASTNode:10
120       */
121      public void init$Children() {
122        children = new ASTNode[2];
123      }
124      /**
125       * @declaredat ASTNode:13
126       */
127      public AbstractDot(Expr p0, Access p1) {
128        setChild(p0, 0);
129        setChild(p1, 1);
130      }
131      /**
132       * @apilevel low-level
133       * @declaredat ASTNode:20
134       */
135      protected int numChildren() {
136        return 2;
137      }
138      /**
139       * @apilevel internal
140       * @declaredat ASTNode:26
141       */
142      public boolean mayHaveRewrite() {
143        return false;
144      }
145      /**
146       * @apilevel internal
147       * @declaredat ASTNode:32
148       */
149      public void flushAttrCache() {
150        super.flushAttrCache();
151        isDAafter_Variable_reset();
152        isDUafter_Variable_reset();
153        type_reset();
154        stmtCompatible_reset();
155        isDUbefore_Variable_reset();
156      }
157      /**
158       * @apilevel internal
159       * @declaredat ASTNode:43
160       */
161      public void flushCollectionCache() {
162        super.flushCollectionCache();
163      }
164      /**
165       * @apilevel internal
166       * @declaredat ASTNode:49
167       */
168      public void flushRewriteCache() {
169        super.flushRewriteCache();
170      }
171      /**
172       * @apilevel internal
173       * @declaredat ASTNode:55
174       */
175      public AbstractDot clone() throws CloneNotSupportedException {
176        AbstractDot node = (AbstractDot) super.clone();
177        return node;
178      }
179      /**
180       * @apilevel internal
181       * @declaredat ASTNode:62
182       */
183      public AbstractDot copy() {
184        try {
185          AbstractDot node = (AbstractDot) clone();
186          node.parent = null;
187          if (children != null) {
188            node.children = (ASTNode[]) children.clone();
189          }
190          return node;
191        } catch (CloneNotSupportedException e) {
192          throw new Error("Error: clone not supported for " + getClass().getName());
193        }
194      }
195      /**
196       * Create a deep copy of the AST subtree at this node.
197       * The copy is dangling, i.e. has no parent.
198       * @return dangling copy of the subtree at this node
199       * @apilevel low-level
200       * @deprecated Please use treeCopy or treeCopyNoTransform instead
201       * @declaredat ASTNode:81
202       */
203      @Deprecated
204      public AbstractDot fullCopy() {
205        return treeCopyNoTransform();
206      }
207      /**
208       * Create a deep copy of the AST subtree at this node.
209       * The copy is dangling, i.e. has no parent.
210       * @return dangling copy of the subtree at this node
211       * @apilevel low-level
212       * @declaredat ASTNode:91
213       */
214      public AbstractDot treeCopyNoTransform() {
215        AbstractDot tree = (AbstractDot) copy();
216        if (children != null) {
217          for (int i = 0; i < children.length; ++i) {
218            ASTNode child = (ASTNode) children[i];
219            if (child != null) {
220              child = child.treeCopyNoTransform();
221              tree.setChild(child, i);
222            }
223          }
224        }
225        return tree;
226      }
227      /**
228       * Create a deep copy of the AST subtree at this node.
229       * The subtree of this node is traversed to trigger rewrites before copy.
230       * The copy is dangling, i.e. has no parent.
231       * @return dangling copy of the subtree at this node
232       * @apilevel low-level
233       * @declaredat ASTNode:111
234       */
235      public AbstractDot treeCopy() {
236        doFullTraversal();
237        return treeCopyNoTransform();
238      }
239      /**
240       * @apilevel internal
241       * @declaredat ASTNode:118
242       */
243      protected boolean is$Equal(ASTNode node) {
244        return super.is$Equal(node);    
245      }
246      /**
247       * Replaces the Left child.
248       * @param node The new node to replace the Left child.
249       * @apilevel high-level
250       */
251      public void setLeft(Expr node) {
252        setChild(node, 0);
253      }
254      /**
255       * Retrieves the Left child.
256       * @return The current node used as the Left child.
257       * @apilevel high-level
258       */
259      @ASTNodeAnnotation.Child(name="Left")
260      public Expr getLeft() {
261        return (Expr) getChild(0);
262      }
263      /**
264       * Retrieves the Left child.
265       * <p><em>This method does not invoke AST transformations.</em></p>
266       * @return The current node used as the Left child.
267       * @apilevel low-level
268       */
269      public Expr getLeftNoTransform() {
270        return (Expr) getChildNoTransform(0);
271      }
272      /**
273       * Replaces the Right child.
274       * @param node The new node to replace the Right child.
275       * @apilevel high-level
276       */
277      public void setRight(Access node) {
278        setChild(node, 1);
279      }
280      /**
281       * Retrieves the Right child.
282       * @return The current node used as the Right child.
283       * @apilevel high-level
284       */
285      @ASTNodeAnnotation.Child(name="Right")
286      public Access getRight() {
287        return (Access) getChild(1);
288      }
289      /**
290       * Retrieves the Right child.
291       * <p><em>This method does not invoke AST transformations.</em></p>
292       * @return The current node used as the Right child.
293       * @apilevel low-level
294       */
295      public Access getRightNoTransform() {
296        return (Access) getChildNoTransform(1);
297      }
298      /**
299       * @attribute syn
300       * @aspect ConstantExpression
301       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:32
302       */
303      @ASTNodeAnnotation.Attribute
304      public Constant constant() {
305        Constant constant_value = lastAccess().constant();
306    
307        return constant_value;
308      }
309      /**
310       * @attribute syn
311       * @aspect ConstantExpression
312       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:254
313       */
314      @ASTNodeAnnotation.Attribute
315      public boolean isConstant() {
316        boolean isConstant_value = lastAccess().isConstant();
317    
318        return isConstant_value;
319      }
320      /**
321       * @attribute syn
322       * @aspect DefiniteAssignment
323       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:81
324       */
325      @ASTNodeAnnotation.Attribute
326      public Variable varDecl() {
327        Variable varDecl_value = lastAccess().varDecl();
328    
329        return varDecl_value;
330      }
331      /**
332       * @attribute syn
333       * @aspect DA
334       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:374
335       */
336      @ASTNodeAnnotation.Attribute
337      public boolean isDAafterTrue(Variable v) {
338        boolean isDAafterTrue_Variable_value = isDAafter(v);
339    
340        return isDAafterTrue_Variable_value;
341      }
342      /**
343       * @attribute syn
344       * @aspect DA
345       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:375
346       */
347      @ASTNodeAnnotation.Attribute
348      public boolean isDAafterFalse(Variable v) {
349        boolean isDAafterFalse_Variable_value = isDAafter(v);
350    
351        return isDAafterFalse_Variable_value;
352      }
353      /**
354       * @apilevel internal
355       */
356      protected java.util.Map isDAafter_Variable_values;
357      /**
358       * @apilevel internal
359       */
360      private void isDAafter_Variable_reset() {
361        isDAafter_Variable_values = null;
362      }
363      /**
364       * @attribute syn
365       * @aspect DA
366       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:262
367       */
368      @ASTNodeAnnotation.Attribute
369      public boolean isDAafter(Variable v) {
370        Object _parameters = v;
371        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
372        ASTNode$State state = state();
373        if (isDAafter_Variable_values.containsKey(_parameters)) {
374          return (Boolean) isDAafter_Variable_values.get(_parameters);
375        }
376        boolean intermediate = state.INTERMEDIATE_VALUE;
377        state.INTERMEDIATE_VALUE = false;
378        int num = state.boundariesCrossed;
379        boolean isFinal = this.is$Final();
380        boolean isDAafter_Variable_value = lastAccess().isDAafter(v);
381        if (isFinal && num == state().boundariesCrossed) {
382          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
383        } else {
384        }
385        state.INTERMEDIATE_VALUE |= intermediate;
386    
387        return isDAafter_Variable_value;
388      }
389      /**
390       * @attribute syn
391       * @aspect DU
392       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:791
393       */
394      @ASTNodeAnnotation.Attribute
395      public boolean isDUafterTrue(Variable v) {
396        boolean isDUafterTrue_Variable_value = isDUafter(v);
397    
398        return isDUafterTrue_Variable_value;
399      }
400      /**
401       * @attribute syn
402       * @aspect DU
403       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:792
404       */
405      @ASTNodeAnnotation.Attribute
406      public boolean isDUafterFalse(Variable v) {
407        boolean isDUafterFalse_Variable_value = isDUafter(v);
408    
409        return isDUafterFalse_Variable_value;
410      }
411      /**
412       * @apilevel internal
413       */
414      protected java.util.Map isDUafter_Variable_values;
415      /**
416       * @apilevel internal
417       */
418      private void isDUafter_Variable_reset() {
419        isDUafter_Variable_values = null;
420      }
421      /**
422       * @attribute syn
423       * @aspect DU
424       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:789
425       */
426      @ASTNodeAnnotation.Attribute
427      public boolean isDUafter(Variable v) {
428        Object _parameters = v;
429        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
430        ASTNode$State state = state();
431        if (isDUafter_Variable_values.containsKey(_parameters)) {
432          return (Boolean) isDUafter_Variable_values.get(_parameters);
433        }
434        boolean intermediate = state.INTERMEDIATE_VALUE;
435        state.INTERMEDIATE_VALUE = false;
436        int num = state.boundariesCrossed;
437        boolean isFinal = this.is$Final();
438        boolean isDUafter_Variable_value = lastAccess().isDUafter(v);
439        if (isFinal && num == state().boundariesCrossed) {
440          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
441        } else {
442        }
443        state.INTERMEDIATE_VALUE |= intermediate;
444    
445        return isDUafter_Variable_value;
446      }
447      /**
448       * @attribute syn
449       * @aspect PrettyPrintUtil
450       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:267
451       */
452      @ASTNodeAnnotation.Attribute
453      public boolean needsDot() {
454        boolean needsDot_value = !(getRight() instanceof ArrayAccess);
455    
456        return needsDot_value;
457      }
458      /**
459       * @attribute syn
460       * @aspect Names
461       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:72
462       */
463      @ASTNodeAnnotation.Attribute
464      public String typeName() {
465        String typeName_value = lastAccess().typeName();
466    
467        return typeName_value;
468      }
469      /**
470       * @attribute syn
471       * @aspect AccessTypes
472       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:35
473       */
474      @ASTNodeAnnotation.Attribute
475      public boolean isTypeAccess() {
476        boolean isTypeAccess_value = getRight().isTypeAccess();
477    
478        return isTypeAccess_value;
479      }
480      /**
481       * @attribute syn
482       * @aspect AccessTypes
483       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:39
484       */
485      @ASTNodeAnnotation.Attribute
486      public boolean isMethodAccess() {
487        boolean isMethodAccess_value = getRight().isMethodAccess();
488    
489        return isMethodAccess_value;
490      }
491      /**
492       * @attribute syn
493       * @aspect AccessTypes
494       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:43
495       */
496      @ASTNodeAnnotation.Attribute
497      public boolean isFieldAccess() {
498        boolean isFieldAccess_value = getRight().isFieldAccess();
499    
500        return isFieldAccess_value;
501      }
502      /**
503       * @attribute syn
504       * @aspect AccessTypes
505       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:47
506       */
507      @ASTNodeAnnotation.Attribute
508      public boolean isSuperAccess() {
509        boolean isSuperAccess_value = getRight().isSuperAccess();
510    
511        return isSuperAccess_value;
512      }
513      /**
514       * @attribute syn
515       * @aspect AccessTypes
516       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:53
517       */
518      @ASTNodeAnnotation.Attribute
519      public boolean isThisAccess() {
520        boolean isThisAccess_value = getRight().isThisAccess();
521    
522        return isThisAccess_value;
523      }
524      /**
525       * @attribute syn
526       * @aspect AccessTypes
527       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:59
528       */
529      @ASTNodeAnnotation.Attribute
530      public boolean isPackageAccess() {
531        boolean isPackageAccess_value = getRight().isPackageAccess();
532    
533        return isPackageAccess_value;
534      }
535      /**
536       * @attribute syn
537       * @aspect AccessTypes
538       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:63
539       */
540      @ASTNodeAnnotation.Attribute
541      public boolean isArrayAccess() {
542        boolean isArrayAccess_value = getRight().isArrayAccess();
543    
544        return isArrayAccess_value;
545      }
546      /**
547       * @attribute syn
548       * @aspect AccessTypes
549       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:67
550       */
551      @ASTNodeAnnotation.Attribute
552      public boolean isClassAccess() {
553        boolean isClassAccess_value = getRight().isClassAccess();
554    
555        return isClassAccess_value;
556      }
557      /**
558       * @attribute syn
559       * @aspect AccessTypes
560       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:71
561       */
562      @ASTNodeAnnotation.Attribute
563      public boolean isSuperConstructorAccess() {
564        boolean isSuperConstructorAccess_value = getRight().isSuperConstructorAccess();
565    
566        return isSuperConstructorAccess_value;
567      }
568      /**
569       * @attribute syn
570       * @aspect QualifiedNames
571       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:80
572       */
573      @ASTNodeAnnotation.Attribute
574      public boolean isQualified() {
575        boolean isQualified_value = hasParentDot();
576    
577        return isQualified_value;
578      }
579      /**
580       * @attribute syn
581       * @aspect QualifiedNames
582       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:85
583       */
584      @ASTNodeAnnotation.Attribute
585      public Expr leftSide() {
586        Expr leftSide_value = getLeft();
587    
588        return leftSide_value;
589      }
590      /**
591       * @attribute syn
592       * @aspect QualifiedNames
593       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:86
594       */
595      @ASTNodeAnnotation.Attribute
596      public Access rightSide() {
597        Access rightSide_value = getRight() instanceof AbstractDot ?
598            (Access)((AbstractDot) getRight()).getLeft() : (Access) getRight();
599    
600        return rightSide_value;
601      }
602      /**
603       * @attribute syn
604       * @aspect QualifiedNames
605       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:89
606       */
607      @ASTNodeAnnotation.Attribute
608      public Access lastAccess() {
609        Access lastAccess_value = getRight().lastAccess();
610    
611        return lastAccess_value;
612      }
613      /**
614       * @attribute syn
615       * @aspect QualifiedNames
616       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:99
617       */
618      @ASTNodeAnnotation.Attribute
619      public Access nextAccess() {
620        Access nextAccess_value = rightSide();
621    
622        return nextAccess_value;
623      }
624      /**
625       * @attribute syn
626       * @aspect QualifiedNames
627       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:101
628       */
629      @ASTNodeAnnotation.Attribute
630      public Expr prevExpr() {
631        Expr prevExpr_value = leftSide();
632    
633        return prevExpr_value;
634      }
635      /**
636       * @attribute syn
637       * @aspect QualifiedNames
638       * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:113
639       */
640      @ASTNodeAnnotation.Attribute
641      public boolean hasPrevExpr() {
642        boolean hasPrevExpr_value = true;
643    
644        return hasPrevExpr_value;
645      }
646      /**
647       * Defines the expected kind of name for the left hand side in a qualified
648       * expression.
649       * @attribute syn
650       * @aspect SyntacticClassification
651       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:58
652       */
653      @ASTNodeAnnotation.Attribute
654      public NameType predNameType() {
655        NameType predNameType_value = getLeftNoTransform() instanceof Access ?
656            ((Access) getLeftNoTransform()).predNameType() : NameType.NOT_CLASSIFIED;
657    
658        return predNameType_value;
659      }
660      /**
661       * @apilevel internal
662       */
663      protected boolean type_computed = false;
664      /**
665       * @apilevel internal
666       */
667      protected TypeDecl type_value;
668      /**
669       * @apilevel internal
670       */
671      private void type_reset() {
672        type_computed = false;
673        type_value = null;
674      }
675      /**
676       * @attribute syn
677       * @aspect TypeAnalysis
678       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302
679       */
680      @ASTNodeAnnotation.Attribute
681      public TypeDecl type() {
682        ASTNode$State state = state();
683        if (type_computed) {
684          return type_value;
685        }
686        boolean intermediate = state.INTERMEDIATE_VALUE;
687        state.INTERMEDIATE_VALUE = false;
688        int num = state.boundariesCrossed;
689        boolean isFinal = this.is$Final();
690        type_value = lastAccess().type();
691        if (isFinal && num == state().boundariesCrossed) {
692          type_computed = true;
693        } else {
694        }
695        state.INTERMEDIATE_VALUE |= intermediate;
696    
697        return type_value;
698      }
699      /**
700       * @attribute syn
701       * @aspect TypeCheck
702       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:36
703       */
704      @ASTNodeAnnotation.Attribute
705      public boolean isVariable() {
706        boolean isVariable_value = lastAccess().isVariable();
707    
708        return isVariable_value;
709      }
710      /**
711       * @attribute syn
712       * @aspect TypeHierarchyCheck
713       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:199
714       */
715      @ASTNodeAnnotation.Attribute
716      public boolean staticContextQualifier() {
717        boolean staticContextQualifier_value = lastAccess().staticContextQualifier();
718    
719        return staticContextQualifier_value;
720      }
721      /**
722       * @attribute syn
723       * @aspect CreateBCode
724       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:251
725       */
726      @ASTNodeAnnotation.Attribute
727      public boolean needsPop() {
728        boolean needsPop_value = lastAccess().needsPop();
729    
730        return needsPop_value;
731      }
732      /**
733       * @attribute syn
734       * @aspect CreateBCode
735       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:263
736       */
737      @ASTNodeAnnotation.Attribute
738      public boolean isVarAccessWithAccessor() {
739        boolean isVarAccessWithAccessor_value = lastAccess().isVarAccessWithAccessor();
740    
741        return isVarAccessWithAccessor_value;
742      }
743      /**
744       * @attribute syn
745       * @aspect CreateBCode
746       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1022
747       */
748      @ASTNodeAnnotation.Attribute
749      public boolean canBeTrue() {
750        boolean canBeTrue_value = lastAccess().canBeTrue();
751    
752        return canBeTrue_value;
753      }
754      /**
755       * @attribute syn
756       * @aspect CreateBCode
757       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1034
758       */
759      @ASTNodeAnnotation.Attribute
760      public boolean canBeFalse() {
761        boolean canBeFalse_value = lastAccess().canBeFalse();
762    
763        return canBeFalse_value;
764      }
765      /**
766       * Finds the host type declaration of a class access.
767       * Call this attribute only on expressions that return true for
768       * isClassAccess or it may throw an error!
769       * @return The TypeDecl corresponding to the accesssed class
770       * @attribute syn
771       * @aspect AnnotationsCodegen
772       * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:241
773       */
774      @ASTNodeAnnotation.Attribute
775      public TypeDecl classAccess() {
776        {
777            if (getRight() instanceof ClassAccess) {
778              return getLeft().classAccess();
779            } else {
780              return getRight().classAccess();
781            }
782          }
783      }
784      /**
785       * @attribute syn
786       * @aspect PreciseRethrow
787       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149
788       */
789      @ASTNodeAnnotation.Attribute
790      public boolean modifiedInScope(Variable var) {
791        boolean modifiedInScope_Variable_value = getLeft().modifiedInScope(var) || getRight().modifiedInScope(var);
792    
793        return modifiedInScope_Variable_value;
794      }
795      /**
796       * @apilevel internal
797       */
798      protected boolean stmtCompatible_computed = false;
799      /**
800       * @apilevel internal
801       */
802      protected boolean stmtCompatible_value;
803      /**
804       * @apilevel internal
805       */
806      private void stmtCompatible_reset() {
807        stmtCompatible_computed = false;
808      }
809      /**
810       * @attribute syn
811       * @aspect StmtCompatible
812       * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:146
813       */
814      @ASTNodeAnnotation.Attribute
815      public boolean stmtCompatible() {
816        ASTNode$State state = state();
817        if (stmtCompatible_computed) {
818          return stmtCompatible_value;
819        }
820        boolean intermediate = state.INTERMEDIATE_VALUE;
821        state.INTERMEDIATE_VALUE = false;
822        int num = state.boundariesCrossed;
823        boolean isFinal = this.is$Final();
824        stmtCompatible_value = getRight().stmtCompatible();
825        if (isFinal && num == state().boundariesCrossed) {
826          stmtCompatible_computed = true;
827        } else {
828        }
829        state.INTERMEDIATE_VALUE |= intermediate;
830    
831        return stmtCompatible_value;
832      }
833      /**
834       * @attribute inh
835       * @aspect DU
836       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:786
837       */
838      /**
839       * @attribute inh
840       * @aspect DU
841       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:786
842       */
843      @ASTNodeAnnotation.Attribute
844      public boolean isDUbefore(Variable v) {
845        Object _parameters = v;
846        if (isDUbefore_Variable_values == null) isDUbefore_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
847        ASTNode$State state = state();
848        if (isDUbefore_Variable_values.containsKey(_parameters)) {
849          return (Boolean) isDUbefore_Variable_values.get(_parameters);
850        }
851        boolean intermediate = state.INTERMEDIATE_VALUE;
852        state.INTERMEDIATE_VALUE = false;
853        int num = state.boundariesCrossed;
854        boolean isFinal = this.is$Final();
855        boolean isDUbefore_Variable_value = getParent().Define_isDUbefore(this, null, v);
856        if (isFinal && num == state().boundariesCrossed) {
857          isDUbefore_Variable_values.put(_parameters, isDUbefore_Variable_value);
858        } else {
859        }
860        state.INTERMEDIATE_VALUE |= intermediate;
861    
862        return isDUbefore_Variable_value;
863      }
864      /**
865       * @apilevel internal
866       */
867      protected java.util.Map isDUbefore_Variable_values;
868      /**
869       * @apilevel internal
870       */
871      private void isDUbefore_Variable_reset() {
872        isDUbefore_Variable_values = null;
873      }
874      /**
875       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:37
876       * @apilevel internal
877       */
878      public boolean Define_isDest(ASTNode caller, ASTNode child) {
879        if (caller == getLeftNoTransform()) {
880          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:43
881          return false;
882        }
883        else {
884          return getParent().Define_isDest(this, caller);
885        }
886      }
887      protected boolean canDefine_isDest(ASTNode caller, ASTNode child) {
888        return true;
889      }
890      /**
891       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47
892       * @apilevel internal
893       */
894      public boolean Define_isSource(ASTNode caller, ASTNode child) {
895        if (caller == getLeftNoTransform()) {
896          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:53
897          return true;
898        }
899        else {
900          return getParent().Define_isSource(this, caller);
901        }
902      }
903      protected boolean canDefine_isSource(ASTNode caller, ASTNode child) {
904        return true;
905      }
906      /**
907       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
908       * @apilevel internal
909       */
910      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
911        if (caller == getRightNoTransform()) {
912          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:394
913          return getLeft().isDAafter(v);
914        }
915        else {
916          return getParent().Define_isDAbefore(this, caller, v);
917        }
918      }
919      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
920        return true;
921      }
922      /**
923       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
924       * @apilevel internal
925       */
926      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
927        if (caller == getRightNoTransform()) {
928          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:939
929          return getLeft().isDUafter(v);
930        }
931        else {
932          return getParent().Define_isDUbefore(this, caller, v);
933        }
934      }
935      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
936        return true;
937      }
938      /**
939       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:35
940       * @apilevel internal
941       */
942      public Collection Define_lookupConstructor(ASTNode caller, ASTNode child) {
943        if (caller == getRightNoTransform()) {
944          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:38
945          return getLeft().type().constructors();
946        }
947        else {
948          return getParent().Define_lookupConstructor(this, caller);
949        }
950      }
951      protected boolean canDefine_lookupConstructor(ASTNode caller, ASTNode child) {
952        return true;
953      }
954      /**
955       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:40
956       * @apilevel internal
957       */
958      public Collection Define_lookupSuperConstructor(ASTNode caller, ASTNode child) {
959        if (caller == getRightNoTransform()) {
960          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:46
961          return getLeft().type().lookupSuperConstructor();
962        }
963        else {
964          return getParent().Define_lookupSuperConstructor(this, caller);
965        }
966      }
967      protected boolean canDefine_lookupSuperConstructor(ASTNode caller, ASTNode child) {
968        return true;
969      }
970      /**
971       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:40
972       * @apilevel internal
973       */
974      public Expr Define_nestedScope(ASTNode caller, ASTNode child) {
975        if (caller == getLeftNoTransform()) {
976          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:42
977          return isQualified() ? nestedScope() : this;
978        }
979        else if (caller == getRightNoTransform()) {
980          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:41
981          return isQualified() ? nestedScope() : this;
982        }
983        else {
984          return getParent().Define_nestedScope(this, caller);
985        }
986      }
987      protected boolean canDefine_nestedScope(ASTNode caller, ASTNode child) {
988        return true;
989      }
990      /**
991       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46
992       * @apilevel internal
993       */
994      public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) {
995        if (caller == getRightNoTransform()) {
996          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:103
997          return getLeft().type().memberMethods(name);
998        }
999        else {
1000          return getParent().Define_lookupMethod(this, caller, name);
1001        }
1002      }
1003      protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) {
1004        return true;
1005      }
1006      /**
1007       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115
1008       * @apilevel internal
1009       */
1010      public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) {
1011        if (caller == getRightNoTransform()) {
1012          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:110
1013          return getLeft().hasQualifiedPackage(packageName);
1014        }
1015        else {
1016          return getParent().Define_hasPackage(this, caller, packageName);
1017        }
1018      }
1019      protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) {
1020        return true;
1021      }
1022      /**
1023       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197
1024       * @apilevel internal
1025       */
1026      public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) {
1027        if (caller == getRightNoTransform()) {
1028          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:551
1029          return getLeft().qualifiedLookupType(name);
1030        }
1031        else {
1032          return getParent().Define_lookupType(this, caller, name);
1033        }
1034      }
1035      protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) {
1036        return true;
1037      }
1038      /**
1039       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
1040       * @apilevel internal
1041       */
1042      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
1043        if (caller == getRightNoTransform()) {
1044          // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:230
1045          return getLeft().qualifiedLookupVariable(name);
1046        }
1047        else {
1048          return getParent().Define_lookupVariable(this, caller, name);
1049        }
1050      }
1051      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
1052        return true;
1053      }
1054      /**
1055       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
1056       * @apilevel internal
1057       */
1058      public NameType Define_nameType(ASTNode caller, ASTNode child) {
1059        if (caller == getLeftNoTransform()) {
1060          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:85
1061          return getRightNoTransform().predNameType();
1062        }
1063        else {
1064          return getParent().Define_nameType(this, caller);
1065        }
1066      }
1067      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
1068        return true;
1069      }
1070      /**
1071       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:586
1072       * @apilevel internal
1073       */
1074      public TypeDecl Define_enclosingInstance(ASTNode caller, ASTNode child) {
1075        if (caller == getRightNoTransform()) {
1076          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:599
1077          return getLeft().type();
1078        }
1079        else {
1080          return getParent().Define_enclosingInstance(this, caller);
1081        }
1082      }
1083      protected boolean canDefine_enclosingInstance(ASTNode caller, ASTNode child) {
1084        return true;
1085      }
1086      /**
1087       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:32
1088       * @apilevel internal
1089       */
1090      public String Define_methodHost(ASTNode caller, ASTNode child) {
1091        if (caller == getRightNoTransform()) {
1092          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:34
1093          return getLeft().type().typeName();
1094        }
1095        else {
1096          return getParent().Define_methodHost(this, caller);
1097        }
1098      }
1099      protected boolean canDefine_methodHost(ASTNode caller, ASTNode child) {
1100        return true;
1101      }
1102      /**
1103       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30
1104       * @apilevel internal
1105       */
1106      public TypeDecl Define_targetType(ASTNode caller, ASTNode child) {
1107        if (caller == getRightNoTransform()) {
1108          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:36
1109          return targetType();
1110        }
1111        else {
1112          return getParent().Define_targetType(this, caller);
1113        }
1114      }
1115      protected boolean canDefine_targetType(ASTNode caller, ASTNode child) {
1116        return true;
1117      }
1118      /**
1119       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196
1120       * @apilevel internal
1121       */
1122      public boolean Define_assignmentContext(ASTNode caller, ASTNode child) {
1123        if (caller == getLeftNoTransform()) {
1124          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:294
1125          return false;
1126        }
1127        else if (caller == getRightNoTransform()) {
1128          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:288
1129          return assignmentContext();
1130        }
1131        else {
1132          return getParent().Define_assignmentContext(this, caller);
1133        }
1134      }
1135      protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) {
1136        return true;
1137      }
1138      /**
1139       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197
1140       * @apilevel internal
1141       */
1142      public boolean Define_invocationContext(ASTNode caller, ASTNode child) {
1143        if (caller == getLeftNoTransform()) {
1144          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:295
1145          return false;
1146        }
1147        else if (caller == getRightNoTransform()) {
1148          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:289
1149          return invocationContext();
1150        }
1151        else {
1152          return getParent().Define_invocationContext(this, caller);
1153        }
1154      }
1155      protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) {
1156        return true;
1157      }
1158      /**
1159       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198
1160       * @apilevel internal
1161       */
1162      public boolean Define_castContext(ASTNode caller, ASTNode child) {
1163        if (caller == getLeftNoTransform()) {
1164          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:296
1165          return false;
1166        }
1167        else if (caller == getRightNoTransform()) {
1168          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:290
1169          return castContext();
1170        }
1171        else {
1172          return getParent().Define_castContext(this, caller);
1173        }
1174      }
1175      protected boolean canDefine_castContext(ASTNode caller, ASTNode child) {
1176        return true;
1177      }
1178      /**
1179       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199
1180       * @apilevel internal
1181       */
1182      public boolean Define_stringContext(ASTNode caller, ASTNode child) {
1183        if (caller == getLeftNoTransform()) {
1184          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:297
1185          return false;
1186        }
1187        else if (caller == getRightNoTransform()) {
1188          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:291
1189          return stringContext();
1190        }
1191        else {
1192          return getParent().Define_stringContext(this, caller);
1193        }
1194      }
1195      protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) {
1196        return true;
1197      }
1198      /**
1199       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200
1200       * @apilevel internal
1201       */
1202      public boolean Define_numericContext(ASTNode caller, ASTNode child) {
1203        if (caller == getLeftNoTransform()) {
1204          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:298
1205          return false;
1206        }
1207        else if (caller == getRightNoTransform()) {
1208          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:292
1209          return numericContext();
1210        }
1211        else {
1212          return getParent().Define_numericContext(this, caller);
1213        }
1214      }
1215      protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) {
1216        return true;
1217      }
1218      /**
1219       * @apilevel internal
1220       */
1221      public ASTNode rewriteTo() {
1222        return super.rewriteTo();
1223      }
1224    }