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:20 027 * @production ConstructorAccess : {@link Access} ::= <span class="component"><ID:String></span> <span class="component">Arg:{@link Expr}*</span>; 028 029 */ 030 public class ConstructorAccess extends Access implements Cloneable { 031 /** 032 * @aspect ExceptionHandling 033 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:142 034 */ 035 public void exceptionHandling() { 036 for (Access exception : decl().getExceptionList()) { 037 TypeDecl exceptionType = exception.type(); 038 if (exceptionType.isCheckedException() && !handlesException(exceptionType)) { 039 errorf("%s may throw uncaught exception %s", 040 this.prettyPrint(), exceptionType.fullName()); 041 } 042 } 043 } 044 /** 045 * @aspect ExceptionHandling 046 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:330 047 */ 048 protected boolean reachedException(TypeDecl catchType) { 049 for (Access exception : decl().getExceptionList()) { 050 TypeDecl exceptionType = exception.type(); 051 if (catchType.mayCatch(exceptionType)) { 052 return true; 053 } 054 } 055 return super.reachedException(catchType); 056 } 057 /** 058 * @aspect NameCheck 059 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:152 060 */ 061 public void nameCheck() { 062 super.nameCheck(); 063 ConstructorDecl decl = (ConstructorDecl) enclosingBodyDecl(); 064 if (((ExprStmt) decl.getConstructorInvocation()).getExpr() == this) { 065 // don't error-check the parsed constructor invocation in case it is not the used one 066 if (decls().isEmpty()) { 067 errorf("no constructor matches %s", this.prettyPrint()); 068 } else if (decls().size() > 1 && validArgs()) { 069 errorf("several most specific constructors for %s", this.prettyPrint()); 070 for (Iterator iter = decls().iterator(); iter.hasNext(); ) { 071 errorf(" %s", ((ConstructorDecl) iter.next()).signature()); 072 } 073 } 074 } 075 } 076 /** 077 * @aspect Java4PrettyPrint 078 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:481 079 */ 080 public void prettyPrint(PrettyPrinter out) { 081 out.print(getID()); 082 out.print("("); 083 out.join(getArgList(), new PrettyPrinter.Joiner() { 084 @Override 085 public void printSeparator(PrettyPrinter out) { 086 out.print(", "); 087 } 088 }); 089 out.print(")"); 090 } 091 /** 092 * @aspect CreateBCode 093 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:689 094 */ 095 public void createBCode(CodeGeneration gen) { 096 ConstructorDecl c = decl(); 097 int index = 0; 098 // this 099 gen.emitLoadReference(index++); 100 // this$0 101 if (c.needsEnclosing()) { 102 gen.emitLoadReference(index++); 103 } 104 if (c.needsSuperEnclosing()) { 105 gen.emitLoadReference(index++); 106 } 107 108 // args 109 for (int i = 0; i < getNumArg(); ++i) { 110 getArg(i).createBCode(gen); 111 getArg(i).type().emitCastTo(gen, decl().getParameter(i).type()); // MethodInvocationConversion 112 } 113 if (decl().isPrivate() && decl().hostType() != hostType()) { 114 gen.emit(Bytecode.ACONST_NULL); 115 decl().createAccessor().emitInvokeConstructor(gen); 116 } else { 117 decl().emitInvokeConstructor(gen); 118 } 119 } 120 /** 121 * @aspect InnerClasses 122 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:540 123 */ 124 protected boolean addEnclosingVariables = true; 125 /** 126 * @aspect InnerClasses 127 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:541 128 */ 129 public void addEnclosingVariables() { 130 if (!addEnclosingVariables) { 131 return; 132 } 133 addEnclosingVariables = false; 134 decl().addEnclosingVariables(); 135 for (Iterator iter = decl().hostType().enclosingVariables().iterator(); iter.hasNext(); ) { 136 Variable v = (Variable) iter.next(); 137 getArgList().add(new VarAccess("val$" + v.name())); 138 } 139 } 140 /** 141 * @aspect Transformations 142 * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:132 143 */ 144 public void refined_Transformations_ConstructorAccess_transformation() { 145 // this$val 146 addEnclosingVariables(); 147 // touch accessorIndex go force creation of private constructorAccessor 148 if (decl().isPrivate() && decl().hostType() != hostType()) { 149 decl().createAccessor(); 150 } 151 super.transformation(); 152 } 153 /** 154 * @aspect Annotations 155 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:431 156 */ 157 public void checkModifiers() { 158 if (decl().isDeprecated() && 159 !withinDeprecatedAnnotation() && 160 hostType().topLevelType() != decl().hostType().topLevelType() && 161 !withinSuppressWarnings("deprecation")) 162 warning(decl().signature() + " in " + decl().hostType().typeName() + " has been deprecated"); 163 } 164 /** 165 * @declaredat ASTNode:1 166 */ 167 public ConstructorAccess() { 168 super(); 169 } 170 /** 171 * Initializes the child array to the correct size. 172 * Initializes List and Opt nta children. 173 * @apilevel internal 174 * @ast method 175 * @declaredat ASTNode:10 176 */ 177 public void init$Children() { 178 children = new ASTNode[1]; 179 setChild(new List(), 0); 180 } 181 /** 182 * @declaredat ASTNode:14 183 */ 184 public ConstructorAccess(String p0, List<Expr> p1) { 185 setID(p0); 186 setChild(p1, 0); 187 } 188 /** 189 * @declaredat ASTNode:18 190 */ 191 public ConstructorAccess(beaver.Symbol p0, List<Expr> p1) { 192 setID(p0); 193 setChild(p1, 0); 194 } 195 /** 196 * @apilevel low-level 197 * @declaredat ASTNode:25 198 */ 199 protected int numChildren() { 200 return 1; 201 } 202 /** 203 * @apilevel internal 204 * @declaredat ASTNode:31 205 */ 206 public boolean mayHaveRewrite() { 207 return false; 208 } 209 /** 210 * @apilevel internal 211 * @declaredat ASTNode:37 212 */ 213 public void flushAttrCache() { 214 super.flushAttrCache(); 215 decls_reset(); 216 decl_reset(); 217 type_reset(); 218 stmtCompatible_reset(); 219 } 220 /** 221 * @apilevel internal 222 * @declaredat ASTNode:47 223 */ 224 public void flushCollectionCache() { 225 super.flushCollectionCache(); 226 } 227 /** 228 * @apilevel internal 229 * @declaredat ASTNode:53 230 */ 231 public void flushRewriteCache() { 232 super.flushRewriteCache(); 233 } 234 /** 235 * @apilevel internal 236 * @declaredat ASTNode:59 237 */ 238 public ConstructorAccess clone() throws CloneNotSupportedException { 239 ConstructorAccess node = (ConstructorAccess) super.clone(); 240 return node; 241 } 242 /** 243 * @apilevel internal 244 * @declaredat ASTNode:66 245 */ 246 public ConstructorAccess copy() { 247 try { 248 ConstructorAccess node = (ConstructorAccess) clone(); 249 node.parent = null; 250 if (children != null) { 251 node.children = (ASTNode[]) children.clone(); 252 } 253 return node; 254 } catch (CloneNotSupportedException e) { 255 throw new Error("Error: clone not supported for " + getClass().getName()); 256 } 257 } 258 /** 259 * Create a deep copy of the AST subtree at this node. 260 * The copy is dangling, i.e. has no parent. 261 * @return dangling copy of the subtree at this node 262 * @apilevel low-level 263 * @deprecated Please use treeCopy or treeCopyNoTransform instead 264 * @declaredat ASTNode:85 265 */ 266 @Deprecated 267 public ConstructorAccess fullCopy() { 268 return treeCopyNoTransform(); 269 } 270 /** 271 * Create a deep copy of the AST subtree at this node. 272 * The copy is dangling, i.e. has no parent. 273 * @return dangling copy of the subtree at this node 274 * @apilevel low-level 275 * @declaredat ASTNode:95 276 */ 277 public ConstructorAccess treeCopyNoTransform() { 278 ConstructorAccess tree = (ConstructorAccess) copy(); 279 if (children != null) { 280 for (int i = 0; i < children.length; ++i) { 281 ASTNode child = (ASTNode) children[i]; 282 if (child != null) { 283 child = child.treeCopyNoTransform(); 284 tree.setChild(child, i); 285 } 286 } 287 } 288 return tree; 289 } 290 /** 291 * Create a deep copy of the AST subtree at this node. 292 * The subtree of this node is traversed to trigger rewrites before copy. 293 * The copy is dangling, i.e. has no parent. 294 * @return dangling copy of the subtree at this node 295 * @apilevel low-level 296 * @declaredat ASTNode:115 297 */ 298 public ConstructorAccess treeCopy() { 299 doFullTraversal(); 300 return treeCopyNoTransform(); 301 } 302 /** 303 * @apilevel internal 304 * @declaredat ASTNode:122 305 */ 306 protected boolean is$Equal(ASTNode node) { 307 return super.is$Equal(node) && (tokenString_ID == ((ConstructorAccess)node).tokenString_ID); 308 } 309 /** 310 * Replaces the lexeme ID. 311 * @param value The new value for the lexeme ID. 312 * @apilevel high-level 313 */ 314 public void setID(String value) { 315 tokenString_ID = value; 316 } 317 /** 318 * @apilevel internal 319 */ 320 protected String tokenString_ID; 321 /** 322 */ 323 public int IDstart; 324 /** 325 */ 326 public int IDend; 327 /** 328 * JastAdd-internal setter for lexeme ID using the Beaver parser. 329 * @param symbol Symbol containing the new value for the lexeme ID 330 * @apilevel internal 331 */ 332 public void setID(beaver.Symbol symbol) { 333 if (symbol.value != null && !(symbol.value instanceof String)) 334 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 335 tokenString_ID = (String)symbol.value; 336 IDstart = symbol.getStart(); 337 IDend = symbol.getEnd(); 338 } 339 /** 340 * Retrieves the value for the lexeme ID. 341 * @return The value for the lexeme ID. 342 * @apilevel high-level 343 */ 344 @ASTNodeAnnotation.Token(name="ID") 345 public String getID() { 346 return tokenString_ID != null ? tokenString_ID : ""; 347 } 348 /** 349 * Replaces the Arg list. 350 * @param list The new list node to be used as the Arg list. 351 * @apilevel high-level 352 */ 353 public void setArgList(List<Expr> list) { 354 setChild(list, 0); 355 } 356 /** 357 * Retrieves the number of children in the Arg list. 358 * @return Number of children in the Arg list. 359 * @apilevel high-level 360 */ 361 public int getNumArg() { 362 return getArgList().getNumChild(); 363 } 364 /** 365 * Retrieves the number of children in the Arg list. 366 * Calling this method will not trigger rewrites. 367 * @return Number of children in the Arg list. 368 * @apilevel low-level 369 */ 370 public int getNumArgNoTransform() { 371 return getArgListNoTransform().getNumChildNoTransform(); 372 } 373 /** 374 * Retrieves the element at index {@code i} in the Arg list. 375 * @param i Index of the element to return. 376 * @return The element at position {@code i} in the Arg list. 377 * @apilevel high-level 378 */ 379 public Expr getArg(int i) { 380 return (Expr) getArgList().getChild(i); 381 } 382 /** 383 * Check whether the Arg list has any children. 384 * @return {@code true} if it has at least one child, {@code false} otherwise. 385 * @apilevel high-level 386 */ 387 public boolean hasArg() { 388 return getArgList().getNumChild() != 0; 389 } 390 /** 391 * Append an element to the Arg list. 392 * @param node The element to append to the Arg list. 393 * @apilevel high-level 394 */ 395 public void addArg(Expr node) { 396 List<Expr> list = (parent == null) ? getArgListNoTransform() : getArgList(); 397 list.addChild(node); 398 } 399 /** 400 * @apilevel low-level 401 */ 402 public void addArgNoTransform(Expr node) { 403 List<Expr> list = getArgListNoTransform(); 404 list.addChild(node); 405 } 406 /** 407 * Replaces the Arg list element at index {@code i} with the new node {@code node}. 408 * @param node The new node to replace the old list element. 409 * @param i The list index of the node to be replaced. 410 * @apilevel high-level 411 */ 412 public void setArg(Expr node, int i) { 413 List<Expr> list = getArgList(); 414 list.setChild(node, i); 415 } 416 /** 417 * Retrieves the Arg list. 418 * @return The node representing the Arg list. 419 * @apilevel high-level 420 */ 421 @ASTNodeAnnotation.ListChild(name="Arg") 422 public List<Expr> getArgList() { 423 List<Expr> list = (List<Expr>) getChild(0); 424 return list; 425 } 426 /** 427 * Retrieves the Arg list. 428 * <p><em>This method does not invoke AST transformations.</em></p> 429 * @return The node representing the Arg list. 430 * @apilevel low-level 431 */ 432 public List<Expr> getArgListNoTransform() { 433 return (List<Expr>) getChildNoTransform(0); 434 } 435 /** 436 * Retrieves the Arg list. 437 * @return The node representing the Arg list. 438 * @apilevel high-level 439 */ 440 public List<Expr> getArgs() { 441 return getArgList(); 442 } 443 /** 444 * Retrieves the Arg list. 445 * <p><em>This method does not invoke AST transformations.</em></p> 446 * @return The node representing the Arg list. 447 * @apilevel low-level 448 */ 449 public List<Expr> getArgsNoTransform() { 450 return getArgListNoTransform(); 451 } 452 /** 453 * @aspect VariableArityParametersCodegen 454 * @declaredat /home/jesper/git/extendj/java5/backend/VariableArityParametersCodegen.jrag:85 455 */ 456 public void transformation() { 457 if (decl().isVariableArity() && !invokesVariableArityAsArray()) { 458 // arguments to normal parameters 459 List list = new List(); 460 for (int i = 0; i < decl().getNumParameter() - 1; i++) { 461 list.add(getArg(i).treeCopyNoTransform()); 462 } 463 // arguments to variable arity parameters 464 List last = new List(); 465 for (int i = decl().getNumParameter() - 1; i < getNumArg(); i++) { 466 last.add(getArg(i).treeCopyNoTransform()); 467 } 468 // build an array holding arguments 469 Access typeAccess = decl().lastParameter().type().elementType().createQualifiedAccess(); 470 for (int i = 0; i < decl().lastParameter().type().dimension(); i++) { 471 typeAccess = new ArrayTypeAccess(typeAccess); 472 } 473 list.add(new ArrayCreationExpr(typeAccess, new Opt(new ArrayInit(last)))); 474 // replace argument list with augemented argument list 475 setArgList(list); 476 } 477 refined_Transformations_ConstructorAccess_transformation(); 478 } 479 /** 480 * @attribute syn 481 * @aspect DA 482 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259 483 */ 484 @ASTNodeAnnotation.Attribute 485 public boolean isDAafter(Variable v) { 486 boolean isDAafter_Variable_value = decl().isDAafter(v); 487 488 return isDAafter_Variable_value; 489 } 490 /** 491 * @attribute syn 492 * @aspect DU 493 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783 494 */ 495 @ASTNodeAnnotation.Attribute 496 public boolean isDUafter(Variable v) { 497 boolean isDUafter_Variable_value = decl().isDUafter(v); 498 499 return isDUafter_Variable_value; 500 } 501 /** 502 * @attribute syn 503 * @aspect ConstructScope 504 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:75 505 */ 506 @ASTNodeAnnotation.Attribute 507 public boolean applicableAndAccessible(ConstructorDecl decl) { 508 boolean applicableAndAccessible_ConstructorDecl_value = decl.applicable(getArgList()) && decl.accessibleFrom(hostType()); 509 510 return applicableAndAccessible_ConstructorDecl_value; 511 } 512 /** 513 * @apilevel internal 514 */ 515 protected boolean decls_computed = false; 516 /** 517 * @apilevel internal 518 */ 519 protected SimpleSet decls_value; 520 /** 521 * @apilevel internal 522 */ 523 private void decls_reset() { 524 decls_computed = false; 525 decls_value = null; 526 } 527 /** 528 * @attribute syn 529 * @aspect ConstructScope 530 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:82 531 */ 532 @ASTNodeAnnotation.Attribute 533 public SimpleSet decls() { 534 ASTNode$State state = state(); 535 if (decls_computed) { 536 return decls_value; 537 } 538 boolean intermediate = state.INTERMEDIATE_VALUE; 539 state.INTERMEDIATE_VALUE = false; 540 int num = state.boundariesCrossed; 541 boolean isFinal = this.is$Final(); 542 decls_value = chooseConstructor(lookupConstructor(), getArgList()); 543 if (isFinal && num == state().boundariesCrossed) { 544 decls_computed = true; 545 } else { 546 } 547 state.INTERMEDIATE_VALUE |= intermediate; 548 549 return decls_value; 550 } 551 /** 552 * @apilevel internal 553 */ 554 protected boolean decl_computed = false; 555 /** 556 * @apilevel internal 557 */ 558 protected ConstructorDecl decl_value; 559 /** 560 * @apilevel internal 561 */ 562 private void decl_reset() { 563 decl_computed = false; 564 decl_value = null; 565 } 566 /** 567 * @attribute syn 568 * @aspect ConstructScope 569 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:89 570 */ 571 @ASTNodeAnnotation.Attribute 572 public ConstructorDecl decl() { 573 ASTNode$State state = state(); 574 if (decl_computed) { 575 return decl_value; 576 } 577 boolean intermediate = state.INTERMEDIATE_VALUE; 578 state.INTERMEDIATE_VALUE = false; 579 int num = state.boundariesCrossed; 580 boolean isFinal = this.is$Final(); 581 decl_value = decl_compute(); 582 if (isFinal && num == state().boundariesCrossed) { 583 decl_computed = true; 584 } else { 585 } 586 state.INTERMEDIATE_VALUE |= intermediate; 587 588 return decl_value; 589 } 590 /** 591 * @apilevel internal 592 */ 593 private ConstructorDecl decl_compute() { 594 SimpleSet decls = decls(); 595 if (decls.size() == 1) { 596 return (ConstructorDecl) decls.iterator().next(); 597 } 598 return unknownConstructor(); 599 } 600 /** 601 * @attribute syn 602 * @aspect NameCheck 603 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:168 604 */ 605 @ASTNodeAnnotation.Attribute 606 public boolean validArgs() { 607 { 608 for (int i = 0; i < getNumArg(); i++) { 609 if (!getArg(i).isPolyExpression() && getArg(i).type().isUnknown()) { 610 return false; 611 } 612 } 613 return true; 614 } 615 } 616 /** 617 * @attribute syn 618 * @aspect Names 619 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:38 620 */ 621 @ASTNodeAnnotation.Attribute 622 public String name() { 623 String name_value = "this"; 624 625 return name_value; 626 } 627 /** 628 * Defines the expected kind of name for the left hand side in a qualified 629 * expression. 630 * @attribute syn 631 * @aspect SyntacticClassification 632 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:58 633 */ 634 @ASTNodeAnnotation.Attribute 635 public NameType predNameType() { 636 NameType predNameType_value = NameType.AMBIGUOUS_NAME; 637 638 return predNameType_value; 639 } 640 /** 641 * @apilevel internal 642 */ 643 protected boolean type_computed = false; 644 /** 645 * @apilevel internal 646 */ 647 protected TypeDecl type_value; 648 /** 649 * @apilevel internal 650 */ 651 private void type_reset() { 652 type_computed = false; 653 type_value = null; 654 } 655 /** 656 * @attribute syn 657 * @aspect TypeAnalysis 658 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302 659 */ 660 @ASTNodeAnnotation.Attribute 661 public TypeDecl type() { 662 ASTNode$State state = state(); 663 if (type_computed) { 664 return type_value; 665 } 666 boolean intermediate = state.INTERMEDIATE_VALUE; 667 state.INTERMEDIATE_VALUE = false; 668 int num = state.boundariesCrossed; 669 boolean isFinal = this.is$Final(); 670 type_value = decl().type(); 671 if (isFinal && num == state().boundariesCrossed) { 672 type_computed = true; 673 } else { 674 } 675 state.INTERMEDIATE_VALUE |= intermediate; 676 677 return type_value; 678 } 679 /** 680 * @attribute syn 681 * @aspect CreateBCode 682 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:251 683 */ 684 @ASTNodeAnnotation.Attribute 685 public boolean needsPop() { 686 boolean needsPop_value = false; 687 688 return needsPop_value; 689 } 690 /** 691 * @attribute syn 692 * @aspect MethodSignature15 693 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:546 694 */ 695 @ASTNodeAnnotation.Attribute 696 public int arity() { 697 int arity_value = getNumArg(); 698 699 return arity_value; 700 } 701 /** 702 * @attribute syn 703 * @aspect VariableArityParameters 704 * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:70 705 */ 706 @ASTNodeAnnotation.Attribute 707 public boolean invokesVariableArityAsArray() { 708 { 709 if (!decl().isVariableArity()) { 710 return false; 711 } 712 if (arity() != decl().arity()) { 713 return false; 714 } 715 return getArg(getNumArg()-1).type().methodInvocationConversionTo(decl().lastParameter().type()); 716 } 717 } 718 /** 719 * @attribute syn 720 * @aspect PreciseRethrow 721 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149 722 */ 723 @ASTNodeAnnotation.Attribute 724 public boolean modifiedInScope(Variable var) { 725 { 726 for (int i = 0; i < getNumArg(); ++i) { 727 if (getArg(i).modifiedInScope(var)) { 728 return true; 729 } 730 } 731 return false; 732 } 733 } 734 /** 735 * @apilevel internal 736 */ 737 protected boolean stmtCompatible_computed = false; 738 /** 739 * @apilevel internal 740 */ 741 protected boolean stmtCompatible_value; 742 /** 743 * @apilevel internal 744 */ 745 private void stmtCompatible_reset() { 746 stmtCompatible_computed = false; 747 } 748 /** 749 * @attribute syn 750 * @aspect StmtCompatible 751 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:138 752 */ 753 @ASTNodeAnnotation.Attribute 754 public boolean stmtCompatible() { 755 ASTNode$State state = state(); 756 if (stmtCompatible_computed) { 757 return stmtCompatible_value; 758 } 759 boolean intermediate = state.INTERMEDIATE_VALUE; 760 state.INTERMEDIATE_VALUE = false; 761 int num = state.boundariesCrossed; 762 boolean isFinal = this.is$Final(); 763 stmtCompatible_value = true; 764 if (isFinal && num == state().boundariesCrossed) { 765 stmtCompatible_computed = true; 766 } else { 767 } 768 state.INTERMEDIATE_VALUE |= intermediate; 769 770 return stmtCompatible_value; 771 } 772 /** 773 * @attribute inh 774 * @aspect ExceptionHandling 775 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:77 776 */ 777 /** 778 * @attribute inh 779 * @aspect ExceptionHandling 780 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:77 781 */ 782 @ASTNodeAnnotation.Attribute 783 public boolean handlesException(TypeDecl exceptionType) { 784 boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType); 785 786 return handlesException_TypeDecl_value; 787 } 788 /** 789 * @attribute inh 790 * @aspect ConstructScope 791 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:35 792 */ 793 /** 794 * @attribute inh 795 * @aspect ConstructScope 796 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:35 797 */ 798 @ASTNodeAnnotation.Attribute 799 public Collection lookupConstructor() { 800 Collection lookupConstructor_value = getParent().Define_lookupConstructor(this, null); 801 802 return lookupConstructor_value; 803 } 804 /** 805 * @attribute inh 806 * @aspect ConstructScope 807 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:97 808 */ 809 /** 810 * @attribute inh 811 * @aspect ConstructScope 812 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:97 813 */ 814 @ASTNodeAnnotation.Attribute 815 public ConstructorDecl unknownConstructor() { 816 ConstructorDecl unknownConstructor_value = getParent().Define_unknownConstructor(this, null); 817 818 return unknownConstructor_value; 819 } 820 /** 821 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46 822 * @apilevel internal 823 */ 824 public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) { 825 if (caller == getArgListNoTransform()) { 826 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:51 827 int childIndex = caller.getIndexOfChild(child); 828 return unqualifiedScope().lookupMethod(name); 829 } 830 else { 831 return getParent().Define_lookupMethod(this, caller, name); 832 } 833 } 834 protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) { 835 return true; 836 } 837 /** 838 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115 839 * @apilevel internal 840 */ 841 public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) { 842 if (caller == getArgListNoTransform()) { 843 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:118 844 int childIndex = caller.getIndexOfChild(child); 845 return unqualifiedScope().hasPackage(packageName); 846 } 847 else { 848 return getParent().Define_hasPackage(this, caller, packageName); 849 } 850 } 851 protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) { 852 return true; 853 } 854 /** 855 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197 856 * @apilevel internal 857 */ 858 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 859 if (caller == getArgListNoTransform()) { 860 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:331 861 int childIndex = caller.getIndexOfChild(child); 862 return unqualifiedScope().lookupType(name); 863 } 864 else { 865 return getParent().Define_lookupType(this, caller, name); 866 } 867 } 868 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 869 return true; 870 } 871 /** 872 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 873 * @apilevel internal 874 */ 875 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 876 if (caller == getArgListNoTransform()) { 877 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:219 878 int childIndex = caller.getIndexOfChild(child); 879 return unqualifiedScope().lookupVariable(name); 880 } 881 else { 882 return getParent().Define_lookupVariable(this, caller, name); 883 } 884 } 885 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 886 return true; 887 } 888 /** 889 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 890 * @apilevel internal 891 */ 892 public NameType Define_nameType(ASTNode caller, ASTNode child) { 893 if (caller == getArgListNoTransform()) { 894 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:144 895 int childIndex = caller.getIndexOfChild(child); 896 return NameType.EXPRESSION_NAME; 897 } 898 else { 899 return getParent().Define_nameType(this, caller); 900 } 901 } 902 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 903 return true; 904 } 905 /** 906 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:32 907 * @apilevel internal 908 */ 909 public String Define_methodHost(ASTNode caller, ASTNode child) { 910 int childIndex = this.getIndexOfChild(caller); 911 return unqualifiedScope().methodHost(); 912 } 913 protected boolean canDefine_methodHost(ASTNode caller, ASTNode child) { 914 return true; 915 } 916 /** 917 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:165 918 * @apilevel internal 919 */ 920 public boolean Define_inExplicitConstructorInvocation(ASTNode caller, ASTNode child) { 921 if (caller == getArgListNoTransform()) { 922 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:168 923 int childIndex = caller.getIndexOfChild(child); 924 return true; 925 } 926 else { 927 return getParent().Define_inExplicitConstructorInvocation(this, caller); 928 } 929 } 930 protected boolean canDefine_inExplicitConstructorInvocation(ASTNode caller, ASTNode child) { 931 return true; 932 } 933 /** 934 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:173 935 * @apilevel internal 936 */ 937 public TypeDecl Define_enclosingExplicitConstructorHostType(ASTNode caller, ASTNode child) { 938 if (caller == getArgListNoTransform()) { 939 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:177 940 int childIndex = caller.getIndexOfChild(child); 941 return hostType(); 942 } 943 else { 944 return getParent().Define_enclosingExplicitConstructorHostType(this, caller); 945 } 946 } 947 protected boolean canDefine_enclosingExplicitConstructorHostType(ASTNode caller, ASTNode child) { 948 return true; 949 } 950 /** 951 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30 952 * @apilevel internal 953 */ 954 public TypeDecl Define_targetType(ASTNode caller, ASTNode child) { 955 if (caller == getArgListNoTransform()) { 956 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:100 957 int i = caller.getIndexOfChild(child); 958 { 959 ConstructorDecl decl = decl(); 960 if (unknownConstructor() == decl) { 961 return decl.type().unknownType(); 962 } 963 964 if (decl.isVariableArity() && i >= decl.arity() - 1) { 965 return decl.getParameter(decl.arity() - 1).type().componentType(); 966 } else { 967 return decl.getParameter(i).type(); 968 } 969 } 970 } 971 else { 972 return getParent().Define_targetType(this, caller); 973 } 974 } 975 protected boolean canDefine_targetType(ASTNode caller, ASTNode child) { 976 return true; 977 } 978 /** 979 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 980 * @apilevel internal 981 */ 982 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 983 if (caller == getArgListNoTransform()) { 984 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:337 985 int childIndex = caller.getIndexOfChild(child); 986 return false; 987 } 988 else { 989 return getParent().Define_assignmentContext(this, caller); 990 } 991 } 992 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 993 return true; 994 } 995 /** 996 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 997 * @apilevel internal 998 */ 999 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 1000 if (caller == getArgListNoTransform()) { 1001 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:338 1002 int childIndex = caller.getIndexOfChild(child); 1003 return true; 1004 } 1005 else { 1006 return getParent().Define_invocationContext(this, caller); 1007 } 1008 } 1009 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 1010 return true; 1011 } 1012 /** 1013 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 1014 * @apilevel internal 1015 */ 1016 public boolean Define_castContext(ASTNode caller, ASTNode child) { 1017 if (caller == getArgListNoTransform()) { 1018 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:339 1019 int childIndex = caller.getIndexOfChild(child); 1020 return false; 1021 } 1022 else { 1023 return getParent().Define_castContext(this, caller); 1024 } 1025 } 1026 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 1027 return true; 1028 } 1029 /** 1030 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 1031 * @apilevel internal 1032 */ 1033 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 1034 if (caller == getArgListNoTransform()) { 1035 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:340 1036 int childIndex = caller.getIndexOfChild(child); 1037 return false; 1038 } 1039 else { 1040 return getParent().Define_stringContext(this, caller); 1041 } 1042 } 1043 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 1044 return true; 1045 } 1046 /** 1047 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 1048 * @apilevel internal 1049 */ 1050 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 1051 if (caller == getArgListNoTransform()) { 1052 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:341 1053 int childIndex = caller.getIndexOfChild(child); 1054 return false; 1055 } 1056 else { 1057 return getParent().Define_numericContext(this, caller); 1058 } 1059 } 1060 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 1061 return true; 1062 } 1063 /** 1064 * @apilevel internal 1065 */ 1066 public ASTNode rewriteTo() { 1067 return super.rewriteTo(); 1068 } 1069 }