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:184
027     * @production ConditionalExpr : {@link Expr} ::= <span class="component">Condition:{@link Expr}</span> <span class="component">TrueExpr:{@link Expr}</span> <span class="component">FalseExpr:{@link Expr}</span>;
028    
029     */
030    public class ConditionalExpr extends Expr implements Cloneable {
031      /**
032       * @aspect Java4PrettyPrint
033       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:177
034       */
035      public void prettyPrint(PrettyPrinter out) {
036        out.print(getCondition());
037        out.print(" ? ");
038        out.print(getTrueExpr());
039        out.print(" : ");
040        out.print(getFalseExpr());
041      }
042      /**
043       * @aspect TypeCheck
044       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:648
045       */
046      public void typeCheck() {
047        if (!getCondition().type().isBoolean()) {
048          error("The first operand of a conditional expression must be a boolean");
049        }
050        if (type().isUnknown() && !getTrueExpr().type().isUnknown() && !getFalseExpr().type().isUnknown()) {
051          error("The types of the second and third operand in this conditional expression do not match");
052        }
053      }
054      /**
055       * @aspect CreateBCode
056       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1076
057       */
058      public void createBCode(CodeGeneration gen) {
059        int end_label = -1;
060        int false_label = -1;
061        if (!getCondition().isConstant()) {
062          false_label = gen.constantPool().newLabel();
063          getCondition().branchFalse(gen, false_label);
064        }
065        if (getCondition().canBeTrue()) {
066          getTrueExpr().createBCode(gen);
067          getTrueExpr().type().emitCastTo(gen, type());
068          if (getCondition().canBeFalse()) {
069            end_label = gen.constantPool().newLabel();
070            gen.emitGoto(end_label);
071            gen.changeStackDepth(-type().variableSize());
072          }
073        }
074        if (false_label != -1) {
075          gen.addLabel(false_label);
076        }
077        if (getCondition().canBeFalse()) {
078          getFalseExpr().createBCode(gen);
079          getFalseExpr().type().emitCastTo(gen, type());
080        }
081        if (end_label != -1) {
082          gen.addLabel(end_label);
083        }
084      }
085      /**
086       * @aspect CreateBCode
087       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1169
088       */
089      public void branchTrue(CodeGeneration gen, int target) {
090        // branch when true
091        int else_label = -1;
092        int end_label = -1;
093        if (!getCondition().isConstant()) {
094          else_label = gen.constantPool().newLabel();
095          getCondition().branchFalse(gen, else_label);
096        }
097        if (getCondition().canBeTrue()) {
098          getTrueExpr().branchTrue(gen, target);
099          if (getCondition().canBeFalse() && getTrueExpr().canBeFalse()) {
100            end_label = gen.constantPool().newLabel();
101            gen.emitGoto(end_label);
102            //gen.GOTO(end_label);
103          }
104        }
105        if (else_label != -1) {
106          gen.addLabel(else_label);
107        }
108        if (getCondition().canBeFalse()) {
109          getFalseExpr().branchTrue(gen, target);
110        }
111        if (end_label != -1) {
112          gen.addLabel(end_label);
113        }
114      }
115      /**
116       * @aspect CreateBCode
117       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1284
118       */
119      public void branchFalse(CodeGeneration gen, int target) {
120        // branch when false
121        int else_label = -1;
122        int end_label = -1;
123        if (!getCondition().isConstant()) {
124          else_label = gen.constantPool().newLabel();
125          getCondition().branchFalse(gen, else_label);
126        }
127        if (getCondition().canBeTrue()) {
128          getTrueExpr().branchFalse(gen, target);
129          if (getCondition().canBeFalse() && getTrueExpr().canBeTrue()) {
130            end_label = gen.constantPool().newLabel();
131            gen.emitGoto(end_label);
132            //gen.GOTO(end_label);
133          }
134        }
135        if (else_label != -1) {
136          gen.addLabel(else_label);
137        }
138        if (getCondition().canBeFalse()) {
139          getFalseExpr().branchFalse(gen, target);
140        }
141        if (end_label != -1) {
142          gen.addLabel(end_label);
143        }
144      }
145      /**
146       * @aspect AutoBoxingCodegen
147       * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:464
148       */
149      public void emitBooleanCondition(CodeGeneration gen) {
150        super.emitBooleanCondition(gen);
151        if (type().isReferenceType()) {
152          type().emitBoxingOperation(gen);
153        }
154      }
155      /**
156       * @declaredat ASTNode:1
157       */
158      public ConditionalExpr() {
159        super();
160      }
161      /**
162       * Initializes the child array to the correct size.
163       * Initializes List and Opt nta children.
164       * @apilevel internal
165       * @ast method
166       * @declaredat ASTNode:10
167       */
168      public void init$Children() {
169        children = new ASTNode[3];
170      }
171      /**
172       * @declaredat ASTNode:13
173       */
174      public ConditionalExpr(Expr p0, Expr p1, Expr p2) {
175        setChild(p0, 0);
176        setChild(p1, 1);
177        setChild(p2, 2);
178      }
179      /**
180       * @apilevel low-level
181       * @declaredat ASTNode:21
182       */
183      protected int numChildren() {
184        return 3;
185      }
186      /**
187       * @apilevel internal
188       * @declaredat ASTNode:27
189       */
190      public boolean mayHaveRewrite() {
191        return false;
192      }
193      /**
194       * @apilevel internal
195       * @declaredat ASTNode:33
196       */
197      public void flushAttrCache() {
198        super.flushAttrCache();
199        constant_reset();
200        isConstant_reset();
201        booleanOperator_reset();
202        type_reset();
203        compatibleStrictContext_TypeDecl_reset();
204        compatibleLooseContext_TypeDecl_reset();
205        pertinentToApplicability_Expr_BodyDecl_int_reset();
206        moreSpecificThan_TypeDecl_TypeDecl_reset();
207        potentiallyCompatible_TypeDecl_BodyDecl_reset();
208        isBooleanExpression_reset();
209        isBooleanConditional_reset();
210        isNumericExpression_reset();
211        isNumericConditional_reset();
212        isReferenceConditional_reset();
213        isPolyExpression_reset();
214        assignConversionTo_TypeDecl_reset();
215      }
216      /**
217       * @apilevel internal
218       * @declaredat ASTNode:55
219       */
220      public void flushCollectionCache() {
221        super.flushCollectionCache();
222      }
223      /**
224       * @apilevel internal
225       * @declaredat ASTNode:61
226       */
227      public void flushRewriteCache() {
228        super.flushRewriteCache();
229      }
230      /**
231       * @apilevel internal
232       * @declaredat ASTNode:67
233       */
234      public ConditionalExpr clone() throws CloneNotSupportedException {
235        ConditionalExpr node = (ConditionalExpr) super.clone();
236        return node;
237      }
238      /**
239       * @apilevel internal
240       * @declaredat ASTNode:74
241       */
242      public ConditionalExpr copy() {
243        try {
244          ConditionalExpr node = (ConditionalExpr) clone();
245          node.parent = null;
246          if (children != null) {
247            node.children = (ASTNode[]) children.clone();
248          }
249          return node;
250        } catch (CloneNotSupportedException e) {
251          throw new Error("Error: clone not supported for " + getClass().getName());
252        }
253      }
254      /**
255       * Create a deep copy of the AST subtree at this node.
256       * The copy is dangling, i.e. has no parent.
257       * @return dangling copy of the subtree at this node
258       * @apilevel low-level
259       * @deprecated Please use treeCopy or treeCopyNoTransform instead
260       * @declaredat ASTNode:93
261       */
262      @Deprecated
263      public ConditionalExpr fullCopy() {
264        return treeCopyNoTransform();
265      }
266      /**
267       * Create a deep copy of the AST subtree at this node.
268       * The copy is dangling, i.e. has no parent.
269       * @return dangling copy of the subtree at this node
270       * @apilevel low-level
271       * @declaredat ASTNode:103
272       */
273      public ConditionalExpr treeCopyNoTransform() {
274        ConditionalExpr tree = (ConditionalExpr) copy();
275        if (children != null) {
276          for (int i = 0; i < children.length; ++i) {
277            ASTNode child = (ASTNode) children[i];
278            if (child != null) {
279              child = child.treeCopyNoTransform();
280              tree.setChild(child, i);
281            }
282          }
283        }
284        return tree;
285      }
286      /**
287       * Create a deep copy of the AST subtree at this node.
288       * The subtree of this node is traversed to trigger rewrites before copy.
289       * The copy is dangling, i.e. has no parent.
290       * @return dangling copy of the subtree at this node
291       * @apilevel low-level
292       * @declaredat ASTNode:123
293       */
294      public ConditionalExpr treeCopy() {
295        doFullTraversal();
296        return treeCopyNoTransform();
297      }
298      /**
299       * @apilevel internal
300       * @declaredat ASTNode:130
301       */
302      protected boolean is$Equal(ASTNode node) {
303        return super.is$Equal(node);    
304      }
305      /**
306       * Replaces the Condition child.
307       * @param node The new node to replace the Condition child.
308       * @apilevel high-level
309       */
310      public void setCondition(Expr node) {
311        setChild(node, 0);
312      }
313      /**
314       * Retrieves the Condition child.
315       * @return The current node used as the Condition child.
316       * @apilevel high-level
317       */
318      @ASTNodeAnnotation.Child(name="Condition")
319      public Expr getCondition() {
320        return (Expr) getChild(0);
321      }
322      /**
323       * Retrieves the Condition child.
324       * <p><em>This method does not invoke AST transformations.</em></p>
325       * @return The current node used as the Condition child.
326       * @apilevel low-level
327       */
328      public Expr getConditionNoTransform() {
329        return (Expr) getChildNoTransform(0);
330      }
331      /**
332       * Replaces the TrueExpr child.
333       * @param node The new node to replace the TrueExpr child.
334       * @apilevel high-level
335       */
336      public void setTrueExpr(Expr node) {
337        setChild(node, 1);
338      }
339      /**
340       * Retrieves the TrueExpr child.
341       * @return The current node used as the TrueExpr child.
342       * @apilevel high-level
343       */
344      @ASTNodeAnnotation.Child(name="TrueExpr")
345      public Expr getTrueExpr() {
346        return (Expr) getChild(1);
347      }
348      /**
349       * Retrieves the TrueExpr child.
350       * <p><em>This method does not invoke AST transformations.</em></p>
351       * @return The current node used as the TrueExpr child.
352       * @apilevel low-level
353       */
354      public Expr getTrueExprNoTransform() {
355        return (Expr) getChildNoTransform(1);
356      }
357      /**
358       * Replaces the FalseExpr child.
359       * @param node The new node to replace the FalseExpr child.
360       * @apilevel high-level
361       */
362      public void setFalseExpr(Expr node) {
363        setChild(node, 2);
364      }
365      /**
366       * Retrieves the FalseExpr child.
367       * @return The current node used as the FalseExpr child.
368       * @apilevel high-level
369       */
370      @ASTNodeAnnotation.Child(name="FalseExpr")
371      public Expr getFalseExpr() {
372        return (Expr) getChild(2);
373      }
374      /**
375       * Retrieves the FalseExpr child.
376       * <p><em>This method does not invoke AST transformations.</em></p>
377       * @return The current node used as the FalseExpr child.
378       * @apilevel low-level
379       */
380      public Expr getFalseExprNoTransform() {
381        return (Expr) getChildNoTransform(2);
382      }
383      /**
384       * @aspect TypeAnalysis
385       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:391
386       */
387      private TypeDecl refined_TypeAnalysis_ConditionalExpr_type()
388    {
389        TypeDecl trueType = getTrueExpr().type();
390        TypeDecl falseType = getFalseExpr().type();
391    
392        if (trueType == falseType) {
393          return trueType;
394        }
395    
396        if (trueType.isNumericType() && falseType.isNumericType()) {
397          if (trueType.isByte() && falseType.isShort()) {
398            return falseType;
399          }
400          if (trueType.isShort() && falseType.isByte()) {
401            return trueType;
402          }
403          if ((trueType.isByte() || trueType.isShort() || trueType.isChar())
404              && falseType.isInt() && getFalseExpr().isConstant()
405              && getFalseExpr().representableIn(trueType)) {
406            return trueType;
407          }
408          if ((falseType.isByte() || falseType.isShort() || falseType.isChar())
409              && trueType.isInt() && getTrueExpr().isConstant()
410              && getTrueExpr().representableIn(falseType)) {
411            return falseType;
412          }
413          return trueType.binaryNumericPromotion(falseType);
414        } else if (trueType.isBoolean() && falseType.isBoolean()) {
415          return trueType;
416        } else if (trueType.isReferenceType() && falseType.isNull()) {
417          return trueType;
418        } else if (trueType.isNull() && falseType.isReferenceType()) {
419          return falseType;
420        } else if (trueType.isReferenceType() && falseType.isReferenceType()) {
421          if (trueType.assignConversionTo(falseType, null)) {
422            return falseType;
423          }
424          if (falseType.assignConversionTo(trueType, null)) {
425            return trueType;
426          }
427          return unknownType();
428        } else {
429          return unknownType();
430        }
431      }
432      /**
433       * @aspect AutoBoxing
434       * @declaredat /home/jesper/git/extendj/java5/frontend/AutoBoxing.jrag:248
435       */
436      private TypeDecl refined_AutoBoxing_ConditionalExpr_type()
437    {
438        TypeDecl trueType = getTrueExpr().type();
439        TypeDecl falseType = getFalseExpr().type();
440        if (trueType.isBoolean() && falseType.isBoolean()) {
441          if (trueType == falseType) {
442            return trueType;
443          }
444          if (trueType.isReferenceType()) {
445            return trueType.unboxed();
446          }
447          return trueType;
448        }
449        return refined_TypeAnalysis_ConditionalExpr_type();
450      }
451      /**
452       * @apilevel internal
453       */
454      protected boolean constant_computed = false;
455      /**
456       * @apilevel internal
457       */
458      protected Constant constant_value;
459      /**
460       * @apilevel internal
461       */
462      private void constant_reset() {
463        constant_computed = false;
464        constant_value = null;
465      }
466      /**
467       * @attribute syn
468       * @aspect ConstantExpression
469       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:66
470       */
471      @ASTNodeAnnotation.Attribute
472      public Constant constant() {
473        ASTNode$State state = state();
474        if (constant_computed) {
475          return constant_value;
476        }
477        boolean intermediate = state.INTERMEDIATE_VALUE;
478        state.INTERMEDIATE_VALUE = false;
479        int num = state.boundariesCrossed;
480        boolean isFinal = this.is$Final();
481        constant_value = type().questionColon(getCondition().constant(), getTrueExpr().constant(),getFalseExpr().constant());
482        if (isFinal && num == state().boundariesCrossed) {
483          constant_computed = true;
484        } else {
485        }
486        state.INTERMEDIATE_VALUE |= intermediate;
487    
488        return constant_value;
489      }
490      /**
491       * @apilevel internal
492       */
493      protected boolean isConstant_computed = false;
494      /**
495       * @apilevel internal
496       */
497      protected boolean isConstant_value;
498      /**
499       * @apilevel internal
500       */
501      private void isConstant_reset() {
502        isConstant_computed = false;
503      }
504      /**
505       * @attribute syn
506       * @aspect ConstantExpression
507       * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:265
508       */
509      @ASTNodeAnnotation.Attribute
510      public boolean isConstant() {
511        ASTNode$State state = state();
512        if (isConstant_computed) {
513          return isConstant_value;
514        }
515        boolean intermediate = state.INTERMEDIATE_VALUE;
516        state.INTERMEDIATE_VALUE = false;
517        int num = state.boundariesCrossed;
518        boolean isFinal = this.is$Final();
519        isConstant_value = getCondition().isConstant() && getTrueExpr().isConstant() && getFalseExpr().isConstant();
520        if (isFinal && num == state().boundariesCrossed) {
521          isConstant_computed = true;
522        } else {
523        }
524        state.INTERMEDIATE_VALUE |= intermediate;
525    
526        return isConstant_value;
527      }
528      /**
529       * @apilevel internal
530       */
531      protected boolean booleanOperator_computed = false;
532      /**
533       * @apilevel internal
534       */
535      protected boolean booleanOperator_value;
536      /**
537       * @apilevel internal
538       */
539      private void booleanOperator_reset() {
540        booleanOperator_computed = false;
541      }
542      /**
543       * @attribute syn
544       * @aspect DA
545       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:253
546       */
547      @ASTNodeAnnotation.Attribute
548      public boolean booleanOperator() {
549        ASTNode$State state = state();
550        if (booleanOperator_computed) {
551          return booleanOperator_value;
552        }
553        boolean intermediate = state.INTERMEDIATE_VALUE;
554        state.INTERMEDIATE_VALUE = false;
555        int num = state.boundariesCrossed;
556        boolean isFinal = this.is$Final();
557        booleanOperator_value = getTrueExpr().type().isBoolean() && getFalseExpr().type().isBoolean();
558        if (isFinal && num == state().boundariesCrossed) {
559          booleanOperator_computed = true;
560        } else {
561        }
562        state.INTERMEDIATE_VALUE |= intermediate;
563    
564        return booleanOperator_value;
565      }
566      /**
567       * @attribute syn
568       * @aspect DA
569       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:374
570       */
571      @ASTNodeAnnotation.Attribute
572      public boolean isDAafterTrue(Variable v) {
573        boolean isDAafterTrue_Variable_value = isFalse() || (getTrueExpr().isDAafterTrue(v) && getFalseExpr().isDAafterTrue(v));
574    
575        return isDAafterTrue_Variable_value;
576      }
577      /**
578       * @attribute syn
579       * @aspect DA
580       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:375
581       */
582      @ASTNodeAnnotation.Attribute
583      public boolean isDAafterFalse(Variable v) {
584        boolean isDAafterFalse_Variable_value = isTrue() || (getTrueExpr().isDAafterFalse(v) && getFalseExpr().isDAafterFalse(v));
585    
586        return isDAafterFalse_Variable_value;
587      }
588      /**
589       * @attribute syn
590       * @aspect DA
591       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259
592       */
593      @ASTNodeAnnotation.Attribute
594      public boolean isDAafter(Variable v) {
595        boolean isDAafter_Variable_value = booleanOperator() ? isDAafterTrue(v) && isDAafterFalse(v) : getTrueExpr().isDAafter(v) && getFalseExpr().isDAafter(v);
596    
597        return isDAafter_Variable_value;
598      }
599      /**
600       * @attribute syn
601       * @aspect DU
602       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:791
603       */
604      @ASTNodeAnnotation.Attribute
605      public boolean isDUafterTrue(Variable v) {
606        boolean isDUafterTrue_Variable_value = getTrueExpr().isDUafterTrue(v) && getFalseExpr().isDUafterTrue(v);
607    
608        return isDUafterTrue_Variable_value;
609      }
610      /**
611       * @attribute syn
612       * @aspect DU
613       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:792
614       */
615      @ASTNodeAnnotation.Attribute
616      public boolean isDUafterFalse(Variable v) {
617        boolean isDUafterFalse_Variable_value = getTrueExpr().isDUafterFalse(v) && getFalseExpr().isDUafterFalse(v);
618    
619        return isDUafterFalse_Variable_value;
620      }
621      /**
622       * @attribute syn
623       * @aspect DU
624       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783
625       */
626      @ASTNodeAnnotation.Attribute
627      public boolean isDUafter(Variable v) {
628        boolean isDUafter_Variable_value = booleanOperator() ? isDUafterTrue(v) && isDUafterFalse(v) : getTrueExpr().isDUafter(v) && getFalseExpr().isDUafter(v);
629    
630        return isDUafter_Variable_value;
631      }
632      /**
633       * @apilevel internal
634       */
635      protected boolean type_computed = false;
636      /**
637       * @apilevel internal
638       */
639      protected TypeDecl type_value;
640      /**
641       * @apilevel internal
642       */
643      private void type_reset() {
644        type_computed = false;
645        type_value = null;
646      }
647      /**
648       * @attribute syn
649       * @aspect TypeAnalysis
650       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302
651       */
652      @ASTNodeAnnotation.Attribute
653      public TypeDecl type() {
654        ASTNode$State state = state();
655        if (type_computed) {
656          return type_value;
657        }
658        boolean intermediate = state.INTERMEDIATE_VALUE;
659        state.INTERMEDIATE_VALUE = false;
660        int num = state.boundariesCrossed;
661        boolean isFinal = this.is$Final();
662        type_value = type_compute();
663        if (isFinal && num == state().boundariesCrossed) {
664          type_computed = true;
665        } else {
666        }
667        state.INTERMEDIATE_VALUE |= intermediate;
668    
669        return type_value;
670      }
671      /**
672       * @apilevel internal
673       */
674      private TypeDecl type_compute() {
675          TypeDecl type = refined_AutoBoxing_ConditionalExpr_type();
676          TypeDecl trueType = getTrueExpr().type();
677          TypeDecl falseType = getFalseExpr().type();
678      
679          if (type.isUnknown()) {
680            if (!trueType.isReferenceType() && !trueType.boxed().isUnknown()) {
681              trueType = trueType.boxed();
682            }
683            if (!falseType.isReferenceType() && !falseType.boxed().isUnknown()) {
684              falseType = falseType.boxed();
685            }
686      
687            ArrayList<TypeDecl> list = new ArrayList<TypeDecl>();
688            list.add(trueType);
689            list.add(falseType);
690            return type.lookupLUBType(list);
691          }
692          return type;
693        }
694      /**
695       * @attribute syn
696       * @aspect CreateBCode
697       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1022
698       */
699      @ASTNodeAnnotation.Attribute
700      public boolean canBeTrue() {
701        boolean canBeTrue_value = type().isBoolean()
702              && (getCondition().canBeTrue() && getTrueExpr().canBeTrue()
703                  || getCondition().canBeFalse() && getFalseExpr().canBeTrue());
704    
705        return canBeTrue_value;
706      }
707      /**
708       * @attribute syn
709       * @aspect CreateBCode
710       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1034
711       */
712      @ASTNodeAnnotation.Attribute
713      public boolean canBeFalse() {
714        boolean canBeFalse_value = type().isBoolean()
715              && (getCondition().canBeTrue() && getTrueExpr().canBeFalse()
716                  || getCondition().canBeFalse() && getFalseExpr().canBeFalse());
717    
718        return canBeFalse_value;
719      }
720      /**
721       * @attribute syn
722       * @aspect PreciseRethrow
723       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149
724       */
725      @ASTNodeAnnotation.Attribute
726      public boolean modifiedInScope(Variable var) {
727        boolean modifiedInScope_Variable_value = getCondition().modifiedInScope(var)
728              || getTrueExpr().modifiedInScope(var)
729              || getFalseExpr().modifiedInScope(var);
730    
731        return modifiedInScope_Variable_value;
732      }
733      /**
734       * @apilevel internal
735       */
736      protected java.util.Map compatibleStrictContext_TypeDecl_values;
737      /**
738       * @apilevel internal
739       */
740      private void compatibleStrictContext_TypeDecl_reset() {
741        compatibleStrictContext_TypeDecl_values = null;
742      }
743      /**
744       * @attribute syn
745       * @aspect MethodSignature18
746       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:32
747       */
748      @ASTNodeAnnotation.Attribute
749      public boolean compatibleStrictContext(TypeDecl type) {
750        Object _parameters = type;
751        if (compatibleStrictContext_TypeDecl_values == null) compatibleStrictContext_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
752        ASTNode$State state = state();
753        if (compatibleStrictContext_TypeDecl_values.containsKey(_parameters)) {
754          return (Boolean) compatibleStrictContext_TypeDecl_values.get(_parameters);
755        }
756        boolean intermediate = state.INTERMEDIATE_VALUE;
757        state.INTERMEDIATE_VALUE = false;
758        int num = state.boundariesCrossed;
759        boolean isFinal = this.is$Final();
760        boolean compatibleStrictContext_TypeDecl_value = compatibleStrictContext_compute(type);
761        if (isFinal && num == state().boundariesCrossed) {
762          compatibleStrictContext_TypeDecl_values.put(_parameters, compatibleStrictContext_TypeDecl_value);
763        } else {
764        }
765        state.INTERMEDIATE_VALUE |= intermediate;
766    
767        return compatibleStrictContext_TypeDecl_value;
768      }
769      /**
770       * @apilevel internal
771       */
772      private boolean compatibleStrictContext_compute(TypeDecl type) {
773          if (isPolyExpression()) {
774            return getTrueExpr().compatibleStrictContext(type)
775                && getFalseExpr().compatibleStrictContext(type);
776          } else {
777            return super.compatibleStrictContext(type);
778          }
779        }
780      /**
781       * @apilevel internal
782       */
783      protected java.util.Map compatibleLooseContext_TypeDecl_values;
784      /**
785       * @apilevel internal
786       */
787      private void compatibleLooseContext_TypeDecl_reset() {
788        compatibleLooseContext_TypeDecl_values = null;
789      }
790      /**
791       * @attribute syn
792       * @aspect MethodSignature18
793       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:79
794       */
795      @ASTNodeAnnotation.Attribute
796      public boolean compatibleLooseContext(TypeDecl type) {
797        Object _parameters = type;
798        if (compatibleLooseContext_TypeDecl_values == null) compatibleLooseContext_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
799        ASTNode$State state = state();
800        if (compatibleLooseContext_TypeDecl_values.containsKey(_parameters)) {
801          return (Boolean) compatibleLooseContext_TypeDecl_values.get(_parameters);
802        }
803        boolean intermediate = state.INTERMEDIATE_VALUE;
804        state.INTERMEDIATE_VALUE = false;
805        int num = state.boundariesCrossed;
806        boolean isFinal = this.is$Final();
807        boolean compatibleLooseContext_TypeDecl_value = compatibleLooseContext_compute(type);
808        if (isFinal && num == state().boundariesCrossed) {
809          compatibleLooseContext_TypeDecl_values.put(_parameters, compatibleLooseContext_TypeDecl_value);
810        } else {
811        }
812        state.INTERMEDIATE_VALUE |= intermediate;
813    
814        return compatibleLooseContext_TypeDecl_value;
815      }
816      /**
817       * @apilevel internal
818       */
819      private boolean compatibleLooseContext_compute(TypeDecl type) {
820          if (isPolyExpression()) {
821            return getTrueExpr().compatibleLooseContext(type)
822                && getFalseExpr().compatibleLooseContext(type);
823          } else {
824            return super.compatibleLooseContext(type);
825          }
826        }
827      /**
828       * @apilevel internal
829       */
830      protected java.util.Map pertinentToApplicability_Expr_BodyDecl_int_values;
831      /**
832       * @apilevel internal
833       */
834      private void pertinentToApplicability_Expr_BodyDecl_int_reset() {
835        pertinentToApplicability_Expr_BodyDecl_int_values = null;
836      }
837      /**
838       * @attribute syn
839       * @aspect MethodSignature18
840       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:107
841       */
842      @ASTNodeAnnotation.Attribute
843      public boolean pertinentToApplicability(Expr access, BodyDecl decl, int argIndex) {
844        java.util.List _parameters = new java.util.ArrayList(3);
845        _parameters.add(access);
846        _parameters.add(decl);
847        _parameters.add(argIndex);
848        if (pertinentToApplicability_Expr_BodyDecl_int_values == null) pertinentToApplicability_Expr_BodyDecl_int_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
849        ASTNode$State state = state();
850        if (pertinentToApplicability_Expr_BodyDecl_int_values.containsKey(_parameters)) {
851          return (Boolean) pertinentToApplicability_Expr_BodyDecl_int_values.get(_parameters);
852        }
853        boolean intermediate = state.INTERMEDIATE_VALUE;
854        state.INTERMEDIATE_VALUE = false;
855        int num = state.boundariesCrossed;
856        boolean isFinal = this.is$Final();
857        boolean pertinentToApplicability_Expr_BodyDecl_int_value = getFalseExpr().pertinentToApplicability(access, decl, argIndex)
858              && getTrueExpr().pertinentToApplicability(access, decl, argIndex);
859        if (isFinal && num == state().boundariesCrossed) {
860          pertinentToApplicability_Expr_BodyDecl_int_values.put(_parameters, pertinentToApplicability_Expr_BodyDecl_int_value);
861        } else {
862        }
863        state.INTERMEDIATE_VALUE |= intermediate;
864    
865        return pertinentToApplicability_Expr_BodyDecl_int_value;
866      }
867      /**
868       * @apilevel internal
869       */
870      protected java.util.Map moreSpecificThan_TypeDecl_TypeDecl_values;
871      /**
872       * @apilevel internal
873       */
874      private void moreSpecificThan_TypeDecl_TypeDecl_reset() {
875        moreSpecificThan_TypeDecl_TypeDecl_values = null;
876      }
877      /**
878       * Computes which type is more specific for a specific argument, as defined in 15.12.2.5
879       * @param type1
880       * @param type2
881       * @return {@code true} if type1 is more specific than type2, {@code false} otherwise
882       * @attribute syn
883       * @aspect MethodSignature18
884       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:233
885       */
886      @ASTNodeAnnotation.Attribute
887      public boolean moreSpecificThan(TypeDecl type1, TypeDecl type2) {
888        java.util.List _parameters = new java.util.ArrayList(2);
889        _parameters.add(type1);
890        _parameters.add(type2);
891        if (moreSpecificThan_TypeDecl_TypeDecl_values == null) moreSpecificThan_TypeDecl_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
892        ASTNode$State state = state();
893        if (moreSpecificThan_TypeDecl_TypeDecl_values.containsKey(_parameters)) {
894          return (Boolean) moreSpecificThan_TypeDecl_TypeDecl_values.get(_parameters);
895        }
896        boolean intermediate = state.INTERMEDIATE_VALUE;
897        state.INTERMEDIATE_VALUE = false;
898        int num = state.boundariesCrossed;
899        boolean isFinal = this.is$Final();
900        boolean moreSpecificThan_TypeDecl_TypeDecl_value = moreSpecificThan_compute(type1, type2);
901        if (isFinal && num == state().boundariesCrossed) {
902          moreSpecificThan_TypeDecl_TypeDecl_values.put(_parameters, moreSpecificThan_TypeDecl_TypeDecl_value);
903        } else {
904        }
905        state.INTERMEDIATE_VALUE |= intermediate;
906    
907        return moreSpecificThan_TypeDecl_TypeDecl_value;
908      }
909      /**
910       * @apilevel internal
911       */
912      private boolean moreSpecificThan_compute(TypeDecl type1, TypeDecl type2) {
913          if (super.moreSpecificThan(type1, type2)) {
914            return true;
915          }
916          return getTrueExpr().moreSpecificThan(type1, type2) && getFalseExpr().moreSpecificThan(type1, type2);
917        }
918      /**
919       * @apilevel internal
920       */
921      protected java.util.Map potentiallyCompatible_TypeDecl_BodyDecl_values;
922      /**
923       * @apilevel internal
924       */
925      private void potentiallyCompatible_TypeDecl_BodyDecl_reset() {
926        potentiallyCompatible_TypeDecl_BodyDecl_values = null;
927      }
928      /**
929       * @attribute syn
930       * @aspect MethodSignature18
931       * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:466
932       */
933      @ASTNodeAnnotation.Attribute
934      public boolean potentiallyCompatible(TypeDecl type, BodyDecl candidateDecl) {
935        java.util.List _parameters = new java.util.ArrayList(2);
936        _parameters.add(type);
937        _parameters.add(candidateDecl);
938        if (potentiallyCompatible_TypeDecl_BodyDecl_values == null) potentiallyCompatible_TypeDecl_BodyDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
939        ASTNode$State state = state();
940        if (potentiallyCompatible_TypeDecl_BodyDecl_values.containsKey(_parameters)) {
941          return (Boolean) potentiallyCompatible_TypeDecl_BodyDecl_values.get(_parameters);
942        }
943        boolean intermediate = state.INTERMEDIATE_VALUE;
944        state.INTERMEDIATE_VALUE = false;
945        int num = state.boundariesCrossed;
946        boolean isFinal = this.is$Final();
947        boolean potentiallyCompatible_TypeDecl_BodyDecl_value = potentiallyCompatible_compute(type, candidateDecl);
948        if (isFinal && num == state().boundariesCrossed) {
949          potentiallyCompatible_TypeDecl_BodyDecl_values.put(_parameters, potentiallyCompatible_TypeDecl_BodyDecl_value);
950        } else {
951        }
952        state.INTERMEDIATE_VALUE |= intermediate;
953    
954        return potentiallyCompatible_TypeDecl_BodyDecl_value;
955      }
956      /**
957       * @apilevel internal
958       */
959      private boolean potentiallyCompatible_compute(TypeDecl type, BodyDecl candidateDecl) {
960          if (!isPolyExpression()) {
961            return true;
962          }
963          return getTrueExpr().potentiallyCompatible(type, candidateDecl)
964              && getFalseExpr().potentiallyCompatible(type, candidateDecl);
965        }
966      /**
967       * @apilevel internal
968       */
969      protected boolean isBooleanExpression_computed = false;
970      /**
971       * @apilevel internal
972       */
973      protected boolean isBooleanExpression_value;
974      /**
975       * @apilevel internal
976       */
977      private void isBooleanExpression_reset() {
978        isBooleanExpression_computed = false;
979      }
980      /**
981       * @attribute syn
982       * @aspect PolyExpressions
983       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:29
984       */
985      @ASTNodeAnnotation.Attribute
986      public boolean isBooleanExpression() {
987        ASTNode$State state = state();
988        if (isBooleanExpression_computed) {
989          return isBooleanExpression_value;
990        }
991        boolean intermediate = state.INTERMEDIATE_VALUE;
992        state.INTERMEDIATE_VALUE = false;
993        int num = state.boundariesCrossed;
994        boolean isFinal = this.is$Final();
995        isBooleanExpression_value = isBooleanConditional();
996        if (isFinal && num == state().boundariesCrossed) {
997          isBooleanExpression_computed = true;
998        } else {
999        }
1000        state.INTERMEDIATE_VALUE |= intermediate;
1001    
1002        return isBooleanExpression_value;
1003      }
1004      /**
1005       * @apilevel internal
1006       */
1007      protected boolean isBooleanConditional_computed = false;
1008      /**
1009       * @apilevel internal
1010       */
1011      protected boolean isBooleanConditional_value;
1012      /**
1013       * @apilevel internal
1014       */
1015      private void isBooleanConditional_reset() {
1016        isBooleanConditional_computed = false;
1017      }
1018      /**
1019       * @attribute syn
1020       * @aspect PolyExpressions
1021       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:55
1022       */
1023      @ASTNodeAnnotation.Attribute
1024      public boolean isBooleanConditional() {
1025        ASTNode$State state = state();
1026        if (isBooleanConditional_computed) {
1027          return isBooleanConditional_value;
1028        }
1029        boolean intermediate = state.INTERMEDIATE_VALUE;
1030        state.INTERMEDIATE_VALUE = false;
1031        int num = state.boundariesCrossed;
1032        boolean isFinal = this.is$Final();
1033        isBooleanConditional_value = getTrueExpr().isBooleanExpression() && getFalseExpr().isBooleanExpression();
1034        if (isFinal && num == state().boundariesCrossed) {
1035          isBooleanConditional_computed = true;
1036        } else {
1037        }
1038        state.INTERMEDIATE_VALUE |= intermediate;
1039    
1040        return isBooleanConditional_value;
1041      }
1042      /**
1043       * @apilevel internal
1044       */
1045      protected boolean isNumericExpression_computed = false;
1046      /**
1047       * @apilevel internal
1048       */
1049      protected boolean isNumericExpression_value;
1050      /**
1051       * @apilevel internal
1052       */
1053      private void isNumericExpression_reset() {
1054        isNumericExpression_computed = false;
1055      }
1056      /**
1057       * @attribute syn
1058       * @aspect PolyExpressions
1059       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:59
1060       */
1061      @ASTNodeAnnotation.Attribute
1062      public boolean isNumericExpression() {
1063        ASTNode$State state = state();
1064        if (isNumericExpression_computed) {
1065          return isNumericExpression_value;
1066        }
1067        boolean intermediate = state.INTERMEDIATE_VALUE;
1068        state.INTERMEDIATE_VALUE = false;
1069        int num = state.boundariesCrossed;
1070        boolean isFinal = this.is$Final();
1071        isNumericExpression_value = isNumericConditional();
1072        if (isFinal && num == state().boundariesCrossed) {
1073          isNumericExpression_computed = true;
1074        } else {
1075        }
1076        state.INTERMEDIATE_VALUE |= intermediate;
1077    
1078        return isNumericExpression_value;
1079      }
1080      /**
1081       * @apilevel internal
1082       */
1083      protected boolean isNumericConditional_computed = false;
1084      /**
1085       * @apilevel internal
1086       */
1087      protected boolean isNumericConditional_value;
1088      /**
1089       * @apilevel internal
1090       */
1091      private void isNumericConditional_reset() {
1092        isNumericConditional_computed = false;
1093      }
1094      /**
1095       * @attribute syn
1096       * @aspect PolyExpressions
1097       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:74
1098       */
1099      @ASTNodeAnnotation.Attribute
1100      public boolean isNumericConditional() {
1101        ASTNode$State state = state();
1102        if (isNumericConditional_computed) {
1103          return isNumericConditional_value;
1104        }
1105        boolean intermediate = state.INTERMEDIATE_VALUE;
1106        state.INTERMEDIATE_VALUE = false;
1107        int num = state.boundariesCrossed;
1108        boolean isFinal = this.is$Final();
1109        isNumericConditional_value = getTrueExpr().isNumericExpression() && getFalseExpr().isNumericExpression();
1110        if (isFinal && num == state().boundariesCrossed) {
1111          isNumericConditional_computed = true;
1112        } else {
1113        }
1114        state.INTERMEDIATE_VALUE |= intermediate;
1115    
1116        return isNumericConditional_value;
1117      }
1118      /**
1119       * @apilevel internal
1120       */
1121      protected boolean isReferenceConditional_computed = false;
1122      /**
1123       * @apilevel internal
1124       */
1125      protected boolean isReferenceConditional_value;
1126      /**
1127       * @apilevel internal
1128       */
1129      private void isReferenceConditional_reset() {
1130        isReferenceConditional_computed = false;
1131      }
1132      /**
1133       * @attribute syn
1134       * @aspect PolyExpressions
1135       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:77
1136       */
1137      @ASTNodeAnnotation.Attribute
1138      public boolean isReferenceConditional() {
1139        ASTNode$State state = state();
1140        if (isReferenceConditional_computed) {
1141          return isReferenceConditional_value;
1142        }
1143        boolean intermediate = state.INTERMEDIATE_VALUE;
1144        state.INTERMEDIATE_VALUE = false;
1145        int num = state.boundariesCrossed;
1146        boolean isFinal = this.is$Final();
1147        isReferenceConditional_value = !isBooleanConditional() && !isNumericConditional();
1148        if (isFinal && num == state().boundariesCrossed) {
1149          isReferenceConditional_computed = true;
1150        } else {
1151        }
1152        state.INTERMEDIATE_VALUE |= intermediate;
1153    
1154        return isReferenceConditional_value;
1155      }
1156      /**
1157       * @apilevel internal
1158       */
1159      protected boolean isPolyExpression_computed = false;
1160      /**
1161       * @apilevel internal
1162       */
1163      protected boolean isPolyExpression_value;
1164      /**
1165       * @apilevel internal
1166       */
1167      private void isPolyExpression_reset() {
1168        isPolyExpression_computed = false;
1169      }
1170      /**
1171       * @attribute syn
1172       * @aspect PolyExpressions
1173       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:80
1174       */
1175      @ASTNodeAnnotation.Attribute
1176      public boolean isPolyExpression() {
1177        ASTNode$State state = state();
1178        if (isPolyExpression_computed) {
1179          return isPolyExpression_value;
1180        }
1181        boolean intermediate = state.INTERMEDIATE_VALUE;
1182        state.INTERMEDIATE_VALUE = false;
1183        int num = state.boundariesCrossed;
1184        boolean isFinal = this.is$Final();
1185        isPolyExpression_value = isReferenceConditional() && (assignmentContext() || invocationContext());
1186        if (isFinal && num == state().boundariesCrossed) {
1187          isPolyExpression_computed = true;
1188        } else {
1189        }
1190        state.INTERMEDIATE_VALUE |= intermediate;
1191    
1192        return isPolyExpression_value;
1193      }
1194      /**
1195       * @apilevel internal
1196       */
1197      protected java.util.Map assignConversionTo_TypeDecl_values;
1198      /**
1199       * @apilevel internal
1200       */
1201      private void assignConversionTo_TypeDecl_reset() {
1202        assignConversionTo_TypeDecl_values = null;
1203      }
1204      /**
1205       * @attribute syn
1206       * @aspect PolyExpressions
1207       * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:142
1208       */
1209      @ASTNodeAnnotation.Attribute
1210      public boolean assignConversionTo(TypeDecl type) {
1211        Object _parameters = type;
1212        if (assignConversionTo_TypeDecl_values == null) assignConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
1213        ASTNode$State state = state();
1214        if (assignConversionTo_TypeDecl_values.containsKey(_parameters)) {
1215          return (Boolean) assignConversionTo_TypeDecl_values.get(_parameters);
1216        }
1217        boolean intermediate = state.INTERMEDIATE_VALUE;
1218        state.INTERMEDIATE_VALUE = false;
1219        int num = state.boundariesCrossed;
1220        boolean isFinal = this.is$Final();
1221        boolean assignConversionTo_TypeDecl_value = assignConversionTo_compute(type);
1222        if (isFinal && num == state().boundariesCrossed) {
1223          assignConversionTo_TypeDecl_values.put(_parameters, assignConversionTo_TypeDecl_value);
1224        } else {
1225        }
1226        state.INTERMEDIATE_VALUE |= intermediate;
1227    
1228        return assignConversionTo_TypeDecl_value;
1229      }
1230      /**
1231       * @apilevel internal
1232       */
1233      private boolean assignConversionTo_compute(TypeDecl type) {
1234          if (!isPolyExpression()) {
1235            return type().assignConversionTo(type, this);
1236          } else {
1237            return getTrueExpr().assignConversionTo(type) && getFalseExpr().assignConversionTo(type);
1238          }
1239        }
1240      /**
1241       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
1242       * @apilevel internal
1243       */
1244      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1245        if (caller == getFalseExprNoTransform()) {
1246          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:428
1247          return getCondition().isDAafterFalse(v);
1248        }
1249        else if (caller == getTrueExprNoTransform()) {
1250          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:427
1251          return getCondition().isDAafterTrue(v);
1252        }
1253        else if (caller == getConditionNoTransform()) {
1254          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:426
1255          return isDAbefore(v);
1256        }
1257        else {
1258          return getParent().Define_isDAbefore(this, caller, v);
1259        }
1260      }
1261      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
1262        return true;
1263      }
1264      /**
1265       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
1266       * @apilevel internal
1267       */
1268      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
1269        if (caller == getFalseExprNoTransform()) {
1270          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:919
1271          return getCondition().isDUafterFalse(v);
1272        }
1273        else if (caller == getTrueExprNoTransform()) {
1274          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:918
1275          return getCondition().isDUafterTrue(v);
1276        }
1277        else if (caller == getConditionNoTransform()) {
1278          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:917
1279          return isDUbefore(v);
1280        }
1281        else {
1282          return getParent().Define_isDUbefore(this, caller, v);
1283        }
1284      }
1285      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
1286        return true;
1287      }
1288      /**
1289       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30
1290       * @apilevel internal
1291       */
1292      public TypeDecl Define_targetType(ASTNode caller, ASTNode child) {
1293        if (caller == getFalseExprNoTransform()) {
1294          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:35
1295          return targetType();
1296        }
1297        else if (caller == getTrueExprNoTransform()) {
1298          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:34
1299          return targetType();
1300        }
1301        else {
1302          return getParent().Define_targetType(this, caller);
1303        }
1304      }
1305      protected boolean canDefine_targetType(ASTNode caller, ASTNode child) {
1306        return true;
1307      }
1308      /**
1309       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196
1310       * @apilevel internal
1311       */
1312      public boolean Define_assignmentContext(ASTNode caller, ASTNode child) {
1313        if (caller == getFalseExprNoTransform()) {
1314          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:273
1315          return isPolyExpression() ? assignmentContext() : false;
1316        }
1317        else if (caller == getTrueExprNoTransform()) {
1318          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:265
1319          return isPolyExpression() ? assignmentContext() : false;
1320        }
1321        else if (caller == getConditionNoTransform()) {
1322          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:258
1323          return false;
1324        }
1325        else {
1326          return getParent().Define_assignmentContext(this, caller);
1327        }
1328      }
1329      protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) {
1330        return true;
1331      }
1332      /**
1333       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197
1334       * @apilevel internal
1335       */
1336      public boolean Define_invocationContext(ASTNode caller, ASTNode child) {
1337        if (caller == getFalseExprNoTransform()) {
1338          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:275
1339          return isPolyExpression() ? invocationContext() : false;
1340        }
1341        else if (caller == getTrueExprNoTransform()) {
1342          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:267
1343          return isPolyExpression() ? invocationContext() : false;
1344        }
1345        else if (caller == getConditionNoTransform()) {
1346          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:259
1347          return false;
1348        }
1349        else {
1350          return getParent().Define_invocationContext(this, caller);
1351        }
1352      }
1353      protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) {
1354        return true;
1355      }
1356      /**
1357       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198
1358       * @apilevel internal
1359       */
1360      public boolean Define_castContext(ASTNode caller, ASTNode child) {
1361        if (caller == getFalseExprNoTransform()) {
1362          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:278
1363          return false;
1364        }
1365        else if (caller == getTrueExprNoTransform()) {
1366          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:270
1367          return false;
1368        }
1369        else if (caller == getConditionNoTransform()) {
1370          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:260
1371          return false;
1372        }
1373        else {
1374          return getParent().Define_castContext(this, caller);
1375        }
1376      }
1377      protected boolean canDefine_castContext(ASTNode caller, ASTNode child) {
1378        return true;
1379      }
1380      /**
1381       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200
1382       * @apilevel internal
1383       */
1384      public boolean Define_numericContext(ASTNode caller, ASTNode child) {
1385        if (caller == getFalseExprNoTransform()) {
1386          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:280
1387          return false;
1388        }
1389        else if (caller == getTrueExprNoTransform()) {
1390          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:272
1391          return false;
1392        }
1393        else if (caller == getConditionNoTransform()) {
1394          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:261
1395          return false;
1396        }
1397        else {
1398          return getParent().Define_numericContext(this, caller);
1399        }
1400      }
1401      protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) {
1402        return true;
1403      }
1404      /**
1405       * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199
1406       * @apilevel internal
1407       */
1408      public boolean Define_stringContext(ASTNode caller, ASTNode child) {
1409        if (caller == getFalseExprNoTransform()) {
1410          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:279
1411          return false;
1412        }
1413        else if (caller == getTrueExprNoTransform()) {
1414          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:271
1415          return false;
1416        }
1417        else if (caller == getConditionNoTransform()) {
1418          // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:262
1419          return false;
1420        }
1421        else {
1422          return getParent().Define_stringContext(this, caller);
1423        }
1424      }
1425      protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) {
1426        return true;
1427      }
1428      /**
1429       * @apilevel internal
1430       */
1431      public ASTNode rewriteTo() {
1432        return super.rewriteTo();
1433      }
1434    }