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