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 }