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:34 027 * @production ClassInstanceExpr : {@link Access} ::= <span class="component">{@link Access}</span> <span class="component">Arg:{@link Expr}*</span> <span class="component">[{@link TypeDecl}]</span>; 028 029 */ 030 public class ClassInstanceExpr extends Access implements Cloneable { 031 /** 032 * @aspect AccessControl 033 * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:165 034 */ 035 public void accessControl() { 036 super.accessControl(); 037 if (type().isAbstract()) { 038 errorf("Can not instantiate abstract class %s", type().fullName()); 039 } 040 if (!decl().accessibleFrom(hostType())) { 041 errorf("constructor %s is not accessible", decl().signature()); 042 } 043 } 044 /** 045 * @aspect ExceptionHandling 046 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:152 047 */ 048 public void exceptionHandling() { 049 for (Access exception : decl().getExceptionList()) { 050 TypeDecl exceptionType = exception.type(); 051 if (exceptionType.isCheckedException() && !handlesException(exceptionType)) { 052 errorf("%s may throw uncaught exception %s; it must be caught or declared as being thrown", 053 this.prettyPrint(), exceptionType.fullName()); 054 } 055 } 056 } 057 /** 058 * @aspect ExceptionHandling 059 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:340 060 */ 061 protected boolean reachedException(TypeDecl catchType) { 062 ConstructorDecl decl = decl(); 063 for (Access exception : decl().getExceptionList()) { 064 TypeDecl exceptionType = exception.type(); 065 if (catchType.mayCatch(exceptionType)) { 066 return true; 067 } 068 } 069 for (int i = 0; i < getNumArg(); i++) { 070 if (getArg(i).reachedException(catchType)) { 071 return true; 072 } 073 } 074 return false; 075 } 076 /** 077 * @aspect TypeScopePropagation 078 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:538 079 */ 080 public SimpleSet keepInnerClasses(SimpleSet c) { 081 SimpleSet newSet = SimpleSet.emptySet; 082 for (Iterator iter = c.iterator(); iter.hasNext(); ) { 083 TypeDecl t = (TypeDecl) iter.next(); 084 if (t.isInnerType() && t.isClassDecl()) { 085 newSet = newSet.add(c); 086 } 087 } 088 return newSet; 089 } 090 /** 091 * @aspect NameCheck 092 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:186 093 */ 094 public void refined_NameCheck_ClassInstanceExpr_nameCheck() { 095 super.nameCheck(); 096 if (decls().isEmpty()) { 097 errorf("can not instantiate %s no matching constructor found in %s", type().typeName(), 098 type().typeName()); 099 } else if (decls().size() > 1 && validArgs()) { 100 error("several most specific constructors found"); 101 for (Iterator iter = decls().iterator(); iter.hasNext(); ) { 102 errorf(" %s", ((ConstructorDecl) iter.next()).signature()); 103 } 104 } else if (!hasTypeDecl()) { 105 // check if the constructor is accessible (stricter when not in a class instance expression) 106 // if constructor is private it can not be accessed outside the host class or a subtype of it 107 ConstructorDecl decl = decl(); 108 if (decl.isProtected() && !hostPackage().equals(decl.hostPackage()) && 109 !hostType().instanceOf(decl.hostType())) { 110 errorf("can not access the constructor %s", this.prettyPrint()); 111 } 112 } 113 } 114 /** 115 * @aspect NodeConstructors 116 * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:93 117 */ 118 public ClassInstanceExpr(Access type, List args) { 119 this(type, args, new Opt()); 120 } 121 /** 122 * @aspect Java4PrettyPrint 123 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:561 124 */ 125 public void prettyPrint(PrettyPrinter out) { 126 out.print("new "); 127 out.print(getAccess()); 128 out.print("("); 129 out.join(getArgList(), new PrettyPrinter.Joiner() { 130 @Override 131 public void printSeparator(PrettyPrinter out) { 132 out.print(", "); 133 } 134 }); 135 out.print(")"); 136 if (hasTypeDecl()) { 137 if (hasPrintableBodyDecl()) { 138 out.print(" {"); 139 out.println(); 140 out.indent(1); 141 out.join(bodyDecls(), new PrettyPrinter.Joiner() { 142 @Override 143 public void printSeparator(PrettyPrinter out) { 144 out.println(); 145 } 146 }); 147 out.print("}"); 148 } else { 149 out.print(" { }"); 150 } 151 } 152 } 153 /** 154 * @aspect TypeCheck 155 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:509 156 */ 157 public void typeCheck() { 158 if (isQualified() && qualifier().isTypeAccess() && !qualifier().type().isUnknown()) { 159 error("*** The expression in a qualified class instance expr must not be a type name"); 160 } 161 // 15.9 162 if (isQualified() && !type().isInnerClass() && !((ClassDecl) type()).superclass().isInnerClass() && !type().isUnknown()) { 163 error("*** Qualified class instance creation can only instantiate inner classes and their anonymous subclasses"); 164 } 165 if (!type().isClassDecl()) { 166 errorf("*** Can only instantiate classes, which %s is not", type().typeName()); 167 } 168 typeCheckEnclosingInstance(); 169 typeCheckAnonymousSuperclassEnclosingInstance(); 170 } 171 /** 172 * @aspect TypeCheck 173 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:524 174 */ 175 public void typeCheckEnclosingInstance() { 176 TypeDecl C = type(); 177 if (!C.isInnerClass()) { 178 return; 179 } 180 181 TypeDecl enclosing = null; 182 if (C.isAnonymous()) { 183 if (noEnclosingInstance()) { 184 enclosing = null; 185 } else { 186 enclosing = hostType(); 187 } 188 } else if (C.isLocalClass()) { 189 if (C.inStaticContext()) { 190 enclosing = null; 191 } else if (noEnclosingInstance()) { 192 enclosing = unknownType(); 193 } else { 194 TypeDecl nest = hostType(); 195 while (nest != null && !nest.instanceOf(C.enclosingType())) { 196 nest = nest.enclosingType(); 197 } 198 enclosing = nest; 199 } 200 } else if (C.isMemberType()) { 201 if (!isQualified()) { 202 if (noEnclosingInstance()) { 203 errorf("No enclosing instance to initialize %s with", C.typeName()); 204 //System.err.println("ClassInstanceExpr: Non qualified MemberType " + C.typeName() + " is in a static context when instantiated in " + this); 205 enclosing = unknownType(); 206 } else { 207 TypeDecl nest = hostType(); 208 while (nest != null && !nest.instanceOf(C.enclosingType())) { 209 if (nest.isStatic()) { 210 errorf("No enclosing instance to initialize %s with", C.typeName()); 211 nest = unknownType(); 212 break; 213 } 214 nest = nest.enclosingType(); 215 } 216 enclosing = nest == null ? unknownType() : nest; 217 } 218 } else { 219 enclosing = enclosingInstance(); 220 } 221 } 222 if (enclosing != null) { 223 if (enclosing.isUnknown()) { 224 errorf("No enclosing instance to initialize %s with", C.typeName()); 225 } else if (!enclosing.instanceOf(C.enclosingType())) { 226 errorf("*** Can not instantiate %s with the enclosing instance %s due to incorrect enclosing instance", 227 C.typeName(), enclosing.typeName()); 228 } else if (!isQualified() && C.isMemberType() && inExplicitConstructorInvocation() && enclosing == hostType()) { 229 errorf("*** The innermost enclosing instance of type %s is this which is not yet initialized here.", 230 enclosing.typeName()); 231 } 232 } 233 } 234 /** 235 * @aspect TypeCheck 236 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:606 237 */ 238 public void typeCheckAnonymousSuperclassEnclosingInstance() { 239 if (type().isAnonymous() && ((ClassDecl) type()).superclass().isInnerType()) { 240 TypeDecl S = ((ClassDecl) type()).superclass(); 241 if (S.isLocalClass()) { 242 if (S.inStaticContext()) { 243 } else if (noEnclosingInstance()) { 244 errorf("*** No enclosing instance to class %s due to static context", type().typeName()); 245 } else if (inExplicitConstructorInvocation()) { 246 errorf("*** No enclosing instance to superclass %s of %s since this is not initialized yet", 247 S.typeName(), type().typeName()); 248 } 249 } else if (S.isMemberType()) { 250 if (!isQualified()) { 251 // 15.9.2 2nd paragraph 252 if (noEnclosingInstance()) { 253 errorf("*** No enclosing instance to class %s due to static context", type().typeName()); 254 } else { 255 TypeDecl nest = hostType(); 256 while (nest != null && !nest.instanceOf(S.enclosingType())) { 257 nest = nest.enclosingType(); 258 } 259 if (nest == null) { 260 errorf("*** No enclosing instance to superclass %s of %s", 261 S.typeName(), type().typeName()); 262 } else if (inExplicitConstructorInvocation()) { 263 errorf("*** No enclosing instance to superclass %s of %s since this is not initialized yet", 264 S.typeName(), type().typeName()); 265 } 266 } 267 } 268 } 269 } 270 } 271 /** 272 * @aspect CreateBCode 273 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:755 274 */ 275 private void emitLocalEnclosing(CodeGeneration gen, TypeDecl localClass) { 276 if (!localClass.inStaticContext()) { 277 emitThis(gen, localClass.enclosingType()); 278 } 279 } 280 /** 281 * @aspect CreateBCode 282 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:760 283 */ 284 private void emitInnerMemberEnclosing(CodeGeneration gen, TypeDecl innerClass) { 285 if (hasPrevExpr()) { 286 prevExpr().createBCode(gen); 287 gen.emitDup(); 288 int index = gen.constantPool().addMethodref("java/lang/Object", "getClass", "()Ljava/lang/Class;"); 289 gen.emit(Bytecode.INVOKEVIRTUAL, 0).add2(index); 290 gen.emitPop(); 291 } else { 292 TypeDecl enclosing = hostType(); 293 while (enclosing != null && !enclosing.hasType(innerClass.name())) { 294 enclosing = enclosing.enclosingType(); 295 } 296 if (enclosing == null) { 297 throw new Error(errorPrefix() + "Could not find enclosing for " + this); 298 } else { 299 emitThis(gen, enclosing); 300 } 301 } 302 } 303 /** 304 * @aspect CreateBCode 305 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:779 306 */ 307 public void createBCode(CodeGeneration gen) { 308 type().emitNew(gen); 309 type().emitDup(gen); 310 311 // 15.9.2 first part 312 if (type().isAnonymous()) { 313 if (type().isAnonymousInNonStaticContext()) { 314 if (type().inExplicitConstructorInvocation()) { 315 gen.emit(Bytecode.ALOAD_1); 316 } else { 317 gen.emit(Bytecode.ALOAD_0); 318 } 319 } 320 // 15.9.2 second part 321 ClassDecl C = (ClassDecl) type(); 322 TypeDecl S = C.superclass(); 323 if (S.isLocalClass()) { 324 if (!type().inStaticContext()) { 325 emitLocalEnclosing(gen, S); 326 } 327 } else if (S.isInnerType()) { 328 emitInnerMemberEnclosing(gen, S); 329 } 330 } else if (type().isLocalClass()) { 331 if (!type().inStaticContext()) { 332 emitLocalEnclosing(gen, type()); 333 } 334 } else if (type().isInnerType()) { 335 emitInnerMemberEnclosing(gen, type()); 336 } 337 /* 338 // 15.9.2 first part 339 if (type().isAnonymous()) { 340 if (type().isAnonymousInNonStaticContext()) { 341 if (type().inExplicitConstructorInvocation()) { 342 gen.emit(Bytecode.ALOAD_1); 343 } else { 344 gen.emit(Bytecode.ALOAD_0); 345 } 346 } 347 if (type().needsSuperEnclosing()) { 348 // 15.9.2 second part 349 ClassDecl C = (ClassDecl) type(); 350 TypeDecl S = C.superclass(); 351 if (S.isLocalClass()) { 352 emitLocalEnclosing(gen, S); 353 } else if (S.isInnerType()) { 354 emitInnerMemberEnclosing(gen, S); 355 } 356 } 357 } else if (type().isLocalClass()) { 358 emitLocalEnclosing(gen, type()); 359 } else if (type().isInnerType()) { 360 emitInnerMemberEnclosing(gen, type()); 361 } 362 */ 363 364 for (int i = 0; i < getNumArg(); ++i) { 365 getArg(i).createBCode(gen); 366 getArg(i).type().emitCastTo(gen, decl().getParameter(i).type()); // MethodInvocationConversion 367 } 368 369 if (decl().isPrivate() && type() != hostType()) { 370 gen.emit(Bytecode.ACONST_NULL); 371 decl().createAccessor().emitInvokeConstructor(gen); 372 } else { 373 decl().emitInvokeConstructor(gen); 374 } 375 } 376 /** 377 * @aspect InnerClasses 378 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:554 379 */ 380 protected boolean addEnclosingVariables = true; 381 /** 382 * @aspect InnerClasses 383 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:555 384 */ 385 public void addEnclosingVariables() { 386 if (!addEnclosingVariables) { 387 return; 388 } 389 addEnclosingVariables = false; 390 decl().addEnclosingVariables(); 391 for (Iterator iter = decl().hostType().enclosingVariables().iterator(); iter.hasNext(); ) { 392 Variable v = (Variable) iter.next(); 393 getArgList().add(new VarAccess(v.name())); 394 } 395 } 396 /** 397 * @aspect Transformations 398 * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:121 399 */ 400 public void refined_Transformations_ClassInstanceExpr_transformation() { 401 // this$val 402 addEnclosingVariables(); 403 // touch accessorIndex go force creation of private constructorAccessor 404 if (decl().isPrivate() && type() != hostType()) { 405 decl().createAccessor(); 406 } 407 super.transformation(); 408 } 409 /** 410 * @aspect Annotations 411 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:439 412 */ 413 public void checkModifiers() { 414 if (decl().isDeprecated() && 415 !withinDeprecatedAnnotation() && 416 hostType().topLevelType() != decl().hostType().topLevelType() && 417 !withinSuppressWarnings("deprecation")) 418 warning(decl().signature() + " in " + decl().hostType().typeName() + " has been deprecated"); 419 } 420 /** 421 * @declaredat ASTNode:1 422 */ 423 public ClassInstanceExpr() { 424 super(); 425 } 426 /** 427 * Initializes the child array to the correct size. 428 * Initializes List and Opt nta children. 429 * @apilevel internal 430 * @ast method 431 * @declaredat ASTNode:10 432 */ 433 public void init$Children() { 434 children = new ASTNode[3]; 435 setChild(new List(), 1); 436 setChild(new Opt(), 2); 437 } 438 /** 439 * @declaredat ASTNode:15 440 */ 441 public ClassInstanceExpr(Access p0, List<Expr> p1, Opt<TypeDecl> p2) { 442 setChild(p0, 0); 443 setChild(p1, 1); 444 setChild(p2, 2); 445 } 446 /** 447 * @apilevel low-level 448 * @declaredat ASTNode:23 449 */ 450 protected int numChildren() { 451 return 3; 452 } 453 /** 454 * @apilevel internal 455 * @declaredat ASTNode:29 456 */ 457 public boolean mayHaveRewrite() { 458 return false; 459 } 460 /** 461 * @apilevel internal 462 * @declaredat ASTNode:35 463 */ 464 public void flushAttrCache() { 465 super.flushAttrCache(); 466 isDAafterInstance_Variable_reset(); 467 computeDAbefore_int_Variable_reset(); 468 computeDUbefore_int_Variable_reset(); 469 decls_reset(); 470 decl_reset(); 471 localLookupType_String_reset(); 472 type_reset(); 473 stmtCompatible_reset(); 474 compatibleStrictContext_TypeDecl_reset(); 475 compatibleLooseContext_TypeDecl_reset(); 476 isBooleanExpression_reset(); 477 isPolyExpression_reset(); 478 assignConversionTo_TypeDecl_reset(); 479 } 480 /** 481 * @apilevel internal 482 * @declaredat ASTNode:54 483 */ 484 public void flushCollectionCache() { 485 super.flushCollectionCache(); 486 } 487 /** 488 * @apilevel internal 489 * @declaredat ASTNode:60 490 */ 491 public void flushRewriteCache() { 492 super.flushRewriteCache(); 493 } 494 /** 495 * @apilevel internal 496 * @declaredat ASTNode:66 497 */ 498 public ClassInstanceExpr clone() throws CloneNotSupportedException { 499 ClassInstanceExpr node = (ClassInstanceExpr) super.clone(); 500 return node; 501 } 502 /** 503 * @apilevel internal 504 * @declaredat ASTNode:73 505 */ 506 public ClassInstanceExpr copy() { 507 try { 508 ClassInstanceExpr node = (ClassInstanceExpr) clone(); 509 node.parent = null; 510 if (children != null) { 511 node.children = (ASTNode[]) children.clone(); 512 } 513 return node; 514 } catch (CloneNotSupportedException e) { 515 throw new Error("Error: clone not supported for " + getClass().getName()); 516 } 517 } 518 /** 519 * Create a deep copy of the AST subtree at this node. 520 * The copy is dangling, i.e. has no parent. 521 * @return dangling copy of the subtree at this node 522 * @apilevel low-level 523 * @deprecated Please use treeCopy or treeCopyNoTransform instead 524 * @declaredat ASTNode:92 525 */ 526 @Deprecated 527 public ClassInstanceExpr fullCopy() { 528 return treeCopyNoTransform(); 529 } 530 /** 531 * Create a deep copy of the AST subtree at this node. 532 * The copy is dangling, i.e. has no parent. 533 * @return dangling copy of the subtree at this node 534 * @apilevel low-level 535 * @declaredat ASTNode:102 536 */ 537 public ClassInstanceExpr treeCopyNoTransform() { 538 ClassInstanceExpr tree = (ClassInstanceExpr) copy(); 539 if (children != null) { 540 for (int i = 0; i < children.length; ++i) { 541 ASTNode child = (ASTNode) children[i]; 542 if (child != null) { 543 child = child.treeCopyNoTransform(); 544 tree.setChild(child, i); 545 } 546 } 547 } 548 return tree; 549 } 550 /** 551 * Create a deep copy of the AST subtree at this node. 552 * The subtree of this node is traversed to trigger rewrites before copy. 553 * The copy is dangling, i.e. has no parent. 554 * @return dangling copy of the subtree at this node 555 * @apilevel low-level 556 * @declaredat ASTNode:122 557 */ 558 public ClassInstanceExpr treeCopy() { 559 doFullTraversal(); 560 return treeCopyNoTransform(); 561 } 562 /** 563 * @apilevel internal 564 * @declaredat ASTNode:129 565 */ 566 protected boolean is$Equal(ASTNode node) { 567 return super.is$Equal(node); 568 } 569 /** 570 * Replaces the Access child. 571 * @param node The new node to replace the Access child. 572 * @apilevel high-level 573 */ 574 public void setAccess(Access node) { 575 setChild(node, 0); 576 } 577 /** 578 * Retrieves the Access child. 579 * @return The current node used as the Access child. 580 * @apilevel high-level 581 */ 582 @ASTNodeAnnotation.Child(name="Access") 583 public Access getAccess() { 584 return (Access) getChild(0); 585 } 586 /** 587 * Retrieves the Access child. 588 * <p><em>This method does not invoke AST transformations.</em></p> 589 * @return The current node used as the Access child. 590 * @apilevel low-level 591 */ 592 public Access getAccessNoTransform() { 593 return (Access) getChildNoTransform(0); 594 } 595 /** 596 * Replaces the Arg list. 597 * @param list The new list node to be used as the Arg list. 598 * @apilevel high-level 599 */ 600 public void setArgList(List<Expr> list) { 601 setChild(list, 1); 602 } 603 /** 604 * Retrieves the number of children in the Arg list. 605 * @return Number of children in the Arg list. 606 * @apilevel high-level 607 */ 608 public int getNumArg() { 609 return getArgList().getNumChild(); 610 } 611 /** 612 * Retrieves the number of children in the Arg list. 613 * Calling this method will not trigger rewrites. 614 * @return Number of children in the Arg list. 615 * @apilevel low-level 616 */ 617 public int getNumArgNoTransform() { 618 return getArgListNoTransform().getNumChildNoTransform(); 619 } 620 /** 621 * Retrieves the element at index {@code i} in the Arg list. 622 * @param i Index of the element to return. 623 * @return The element at position {@code i} in the Arg list. 624 * @apilevel high-level 625 */ 626 public Expr getArg(int i) { 627 return (Expr) getArgList().getChild(i); 628 } 629 /** 630 * Check whether the Arg list has any children. 631 * @return {@code true} if it has at least one child, {@code false} otherwise. 632 * @apilevel high-level 633 */ 634 public boolean hasArg() { 635 return getArgList().getNumChild() != 0; 636 } 637 /** 638 * Append an element to the Arg list. 639 * @param node The element to append to the Arg list. 640 * @apilevel high-level 641 */ 642 public void addArg(Expr node) { 643 List<Expr> list = (parent == null) ? getArgListNoTransform() : getArgList(); 644 list.addChild(node); 645 } 646 /** 647 * @apilevel low-level 648 */ 649 public void addArgNoTransform(Expr node) { 650 List<Expr> list = getArgListNoTransform(); 651 list.addChild(node); 652 } 653 /** 654 * Replaces the Arg list element at index {@code i} with the new node {@code node}. 655 * @param node The new node to replace the old list element. 656 * @param i The list index of the node to be replaced. 657 * @apilevel high-level 658 */ 659 public void setArg(Expr node, int i) { 660 List<Expr> list = getArgList(); 661 list.setChild(node, i); 662 } 663 /** 664 * Retrieves the Arg list. 665 * @return The node representing the Arg list. 666 * @apilevel high-level 667 */ 668 @ASTNodeAnnotation.ListChild(name="Arg") 669 public List<Expr> getArgList() { 670 List<Expr> list = (List<Expr>) getChild(1); 671 return list; 672 } 673 /** 674 * Retrieves the Arg list. 675 * <p><em>This method does not invoke AST transformations.</em></p> 676 * @return The node representing the Arg list. 677 * @apilevel low-level 678 */ 679 public List<Expr> getArgListNoTransform() { 680 return (List<Expr>) getChildNoTransform(1); 681 } 682 /** 683 * Retrieves the Arg list. 684 * @return The node representing the Arg list. 685 * @apilevel high-level 686 */ 687 public List<Expr> getArgs() { 688 return getArgList(); 689 } 690 /** 691 * Retrieves the Arg list. 692 * <p><em>This method does not invoke AST transformations.</em></p> 693 * @return The node representing the Arg list. 694 * @apilevel low-level 695 */ 696 public List<Expr> getArgsNoTransform() { 697 return getArgListNoTransform(); 698 } 699 /** 700 * Replaces the optional node for the TypeDecl child. This is the <code>Opt</code> 701 * node containing the child TypeDecl, not the actual child! 702 * @param opt The new node to be used as the optional node for the TypeDecl child. 703 * @apilevel low-level 704 */ 705 public void setTypeDeclOpt(Opt<TypeDecl> opt) { 706 setChild(opt, 2); 707 } 708 /** 709 * Replaces the (optional) TypeDecl child. 710 * @param node The new node to be used as the TypeDecl child. 711 * @apilevel high-level 712 */ 713 public void setTypeDecl(TypeDecl node) { 714 getTypeDeclOpt().setChild(node, 0); 715 } 716 /** 717 * Check whether the optional TypeDecl child exists. 718 * @return {@code true} if the optional TypeDecl child exists, {@code false} if it does not. 719 * @apilevel high-level 720 */ 721 public boolean hasTypeDecl() { 722 return getTypeDeclOpt().getNumChild() != 0; 723 } 724 /** 725 * Retrieves the (optional) TypeDecl child. 726 * @return The TypeDecl child, if it exists. Returns {@code null} otherwise. 727 * @apilevel low-level 728 */ 729 public TypeDecl getTypeDecl() { 730 return (TypeDecl) getTypeDeclOpt().getChild(0); 731 } 732 /** 733 * Retrieves the optional node for the TypeDecl child. This is the <code>Opt</code> node containing the child TypeDecl, not the actual child! 734 * @return The optional node for child the TypeDecl child. 735 * @apilevel low-level 736 */ 737 @ASTNodeAnnotation.OptChild(name="TypeDecl") 738 public Opt<TypeDecl> getTypeDeclOpt() { 739 return (Opt<TypeDecl>) getChild(2); 740 } 741 /** 742 * Retrieves the optional node for child TypeDecl. This is the <code>Opt</code> node containing the child TypeDecl, not the actual child! 743 * <p><em>This method does not invoke AST transformations.</em></p> 744 * @return The optional node for child TypeDecl. 745 * @apilevel low-level 746 */ 747 public Opt<TypeDecl> getTypeDeclOptNoTransform() { 748 return (Opt<TypeDecl>) getChildNoTransform(2); 749 } 750 /** 751 * @aspect Enums 752 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:40 753 */ 754 public void nameCheck() { 755 if (getAccess().type().isEnumDecl() && !enclosingBodyDecl().isEnumConstant()) { 756 error("enum types may not be instantiated explicitly"); 757 } else { 758 refined_NameCheck_ClassInstanceExpr_nameCheck(); 759 } 760 } 761 /** 762 * @aspect VariableArityParametersCodegen 763 * @declaredat /home/jesper/git/extendj/java5/backend/VariableArityParametersCodegen.jrag:61 764 */ 765 public void transformation() { 766 if (decl().isVariableArity() && !invokesVariableArityAsArray()) { 767 // arguments to normal parameters 768 List list = new List(); 769 for (int i = 0; i < decl().getNumParameter() - 1; i++) { 770 list.add(getArg(i).treeCopyNoTransform()); 771 } 772 // arguments to variable arity parameters 773 List last = new List(); 774 for (int i = decl().getNumParameter() - 1; i < getNumArg(); i++) { 775 last.add(getArg(i).treeCopyNoTransform()); 776 } 777 // build an array holding arguments 778 Access typeAccess = decl().lastParameter().type().elementType().createQualifiedAccess(); 779 for (int i = 0; i < decl().lastParameter().type().dimension(); i++) { 780 typeAccess = new ArrayTypeAccess(typeAccess); 781 } 782 list.add(new ArrayCreationExpr(typeAccess, new Opt(new ArrayInit(last)))); 783 // replace argument list with augemented argument list 784 setArgList(list); 785 } 786 refined_Transformations_ClassInstanceExpr_transformation(); 787 } 788 /** 789 * @apilevel internal 790 */ 791 protected java.util.Map isDAafterInstance_Variable_values; 792 /** 793 * @apilevel internal 794 */ 795 private void isDAafterInstance_Variable_reset() { 796 isDAafterInstance_Variable_values = null; 797 } 798 /** 799 * @attribute syn 800 * @aspect DA 801 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:462 802 */ 803 @ASTNodeAnnotation.Attribute 804 public boolean isDAafterInstance(Variable v) { 805 Object _parameters = v; 806 if (isDAafterInstance_Variable_values == null) isDAafterInstance_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 807 ASTNode$State state = state(); 808 if (isDAafterInstance_Variable_values.containsKey(_parameters)) { 809 return (Boolean) isDAafterInstance_Variable_values.get(_parameters); 810 } 811 boolean intermediate = state.INTERMEDIATE_VALUE; 812 state.INTERMEDIATE_VALUE = false; 813 int num = state.boundariesCrossed; 814 boolean isFinal = this.is$Final(); 815 boolean isDAafterInstance_Variable_value = isDAafterInstance_compute(v); 816 if (isFinal && num == state().boundariesCrossed) { 817 isDAafterInstance_Variable_values.put(_parameters, isDAafterInstance_Variable_value); 818 } else { 819 } 820 state.INTERMEDIATE_VALUE |= intermediate; 821 822 return isDAafterInstance_Variable_value; 823 } 824 /** 825 * @apilevel internal 826 */ 827 private boolean isDAafterInstance_compute(Variable v) { 828 if (getNumArg() == 0) { 829 return isDAbefore(v); 830 } 831 return getArg(getNumArg()-1).isDAafter(v); 832 } 833 /** 834 * @attribute syn 835 * @aspect DA 836 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259 837 */ 838 @ASTNodeAnnotation.Attribute 839 public boolean isDAafter(Variable v) { 840 boolean isDAafter_Variable_value = isDAafterInstance(v); 841 842 return isDAafter_Variable_value; 843 } 844 /** 845 * @apilevel internal 846 */ 847 protected java.util.Map computeDAbefore_int_Variable_values; 848 /** 849 * @apilevel internal 850 */ 851 private void computeDAbefore_int_Variable_reset() { 852 computeDAbefore_int_Variable_values = null; 853 } 854 /** 855 * @attribute syn 856 * @aspect DA 857 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:470 858 */ 859 @ASTNodeAnnotation.Attribute 860 public boolean computeDAbefore(int i, Variable v) { 861 java.util.List _parameters = new java.util.ArrayList(2); 862 _parameters.add(i); 863 _parameters.add(v); 864 if (computeDAbefore_int_Variable_values == null) computeDAbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 865 ASTNode$State state = state(); 866 if (computeDAbefore_int_Variable_values.containsKey(_parameters)) { 867 return (Boolean) computeDAbefore_int_Variable_values.get(_parameters); 868 } 869 boolean intermediate = state.INTERMEDIATE_VALUE; 870 state.INTERMEDIATE_VALUE = false; 871 int num = state.boundariesCrossed; 872 boolean isFinal = this.is$Final(); 873 boolean computeDAbefore_int_Variable_value = i == 0 ? isDAbefore(v) : getArg(i-1).isDAafter(v); 874 if (isFinal && num == state().boundariesCrossed) { 875 computeDAbefore_int_Variable_values.put(_parameters, computeDAbefore_int_Variable_value); 876 } else { 877 } 878 state.INTERMEDIATE_VALUE |= intermediate; 879 880 return computeDAbefore_int_Variable_value; 881 } 882 /** 883 * @attribute syn 884 * @aspect DU 885 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:964 886 */ 887 @ASTNodeAnnotation.Attribute 888 public boolean isDUafterInstance(Variable v) { 889 { 890 if (getNumArg() == 0) { 891 return isDUbefore(v); 892 } 893 return getArg(getNumArg()-1).isDUafter(v); 894 } 895 } 896 /** 897 * @attribute syn 898 * @aspect DU 899 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783 900 */ 901 @ASTNodeAnnotation.Attribute 902 public boolean isDUafter(Variable v) { 903 boolean isDUafter_Variable_value = isDUafterInstance(v); 904 905 return isDUafter_Variable_value; 906 } 907 /** 908 * @apilevel internal 909 */ 910 protected java.util.Map computeDUbefore_int_Variable_values; 911 /** 912 * @apilevel internal 913 */ 914 private void computeDUbefore_int_Variable_reset() { 915 computeDUbefore_int_Variable_values = null; 916 } 917 /** 918 * @attribute syn 919 * @aspect DU 920 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:972 921 */ 922 @ASTNodeAnnotation.Attribute 923 public boolean computeDUbefore(int i, Variable v) { 924 java.util.List _parameters = new java.util.ArrayList(2); 925 _parameters.add(i); 926 _parameters.add(v); 927 if (computeDUbefore_int_Variable_values == null) computeDUbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 928 ASTNode$State state = state(); 929 if (computeDUbefore_int_Variable_values.containsKey(_parameters)) { 930 return (Boolean) computeDUbefore_int_Variable_values.get(_parameters); 931 } 932 boolean intermediate = state.INTERMEDIATE_VALUE; 933 state.INTERMEDIATE_VALUE = false; 934 int num = state.boundariesCrossed; 935 boolean isFinal = this.is$Final(); 936 boolean computeDUbefore_int_Variable_value = i == 0 ? isDUbefore(v) : getArg(i-1).isDUafter(v); 937 if (isFinal && num == state().boundariesCrossed) { 938 computeDUbefore_int_Variable_values.put(_parameters, computeDUbefore_int_Variable_value); 939 } else { 940 } 941 state.INTERMEDIATE_VALUE |= intermediate; 942 943 return computeDUbefore_int_Variable_value; 944 } 945 /** 946 * @attribute syn 947 * @aspect ConstructScope 948 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:75 949 */ 950 @ASTNodeAnnotation.Attribute 951 public boolean applicableAndAccessible(ConstructorDecl decl) { 952 boolean applicableAndAccessible_ConstructorDecl_value = decl.applicable(getArgList()) && decl.accessibleFrom(hostType()) 953 && (!decl.isProtected() || hasTypeDecl() || decl.hostPackage().equals(hostPackage())); 954 955 return applicableAndAccessible_ConstructorDecl_value; 956 } 957 /** 958 * @apilevel internal 959 */ 960 protected boolean decls_computed = false; 961 /** 962 * @apilevel internal 963 */ 964 protected SimpleSet decls_value; 965 /** 966 * @apilevel internal 967 */ 968 private void decls_reset() { 969 decls_computed = false; 970 decls_value = null; 971 } 972 /** 973 * @attribute syn 974 * @aspect ConstructScope 975 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:99 976 */ 977 @ASTNodeAnnotation.Attribute 978 public SimpleSet decls() { 979 ASTNode$State state = state(); 980 if (decls_computed) { 981 return decls_value; 982 } 983 boolean intermediate = state.INTERMEDIATE_VALUE; 984 state.INTERMEDIATE_VALUE = false; 985 int num = state.boundariesCrossed; 986 boolean isFinal = this.is$Final(); 987 decls_value = decls_compute(); 988 if (isFinal && num == state().boundariesCrossed) { 989 decls_computed = true; 990 } else { 991 } 992 state.INTERMEDIATE_VALUE |= intermediate; 993 994 return decls_value; 995 } 996 /** 997 * @apilevel internal 998 */ 999 private SimpleSet decls_compute() { 1000 TypeDecl typeDecl = hasTypeDecl() ? getTypeDecl() : getAccess().type(); 1001 return chooseConstructor(typeDecl.constructors(), getArgList()); 1002 } 1003 /** 1004 * @apilevel internal 1005 */ 1006 protected boolean decl_computed = false; 1007 /** 1008 * @apilevel internal 1009 */ 1010 protected ConstructorDecl decl_value; 1011 /** 1012 * @apilevel internal 1013 */ 1014 private void decl_reset() { 1015 decl_computed = false; 1016 decl_value = null; 1017 } 1018 /** 1019 * @attribute syn 1020 * @aspect ConstructScope 1021 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:104 1022 */ 1023 @ASTNodeAnnotation.Attribute 1024 public ConstructorDecl decl() { 1025 ASTNode$State state = state(); 1026 if (decl_computed) { 1027 return decl_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 decl_value = decl_compute(); 1034 if (isFinal && num == state().boundariesCrossed) { 1035 decl_computed = true; 1036 } else { 1037 } 1038 state.INTERMEDIATE_VALUE |= intermediate; 1039 1040 return decl_value; 1041 } 1042 /** 1043 * @apilevel internal 1044 */ 1045 private ConstructorDecl decl_compute() { 1046 SimpleSet decls = decls(); 1047 if (decls.size() == 1) { 1048 return (ConstructorDecl) decls.iterator().next(); 1049 } else { 1050 return unknownConstructor(); 1051 } 1052 } 1053 /** 1054 * @attribute syn 1055 * @aspect TypeScopePropagation 1056 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:553 1057 */ 1058 @ASTNodeAnnotation.Attribute 1059 public SimpleSet qualifiedLookupType(String name) { 1060 { 1061 SimpleSet c = keepAccessibleTypes(type().memberTypes(name)); 1062 if (!c.isEmpty()) { 1063 return c; 1064 } 1065 if (type().name().equals(name)) { 1066 return SimpleSet.emptySet.add(type()); 1067 } 1068 return SimpleSet.emptySet; 1069 } 1070 } 1071 /** 1072 * @apilevel internal 1073 */ 1074 protected java.util.Map localLookupType_String_values; 1075 /** 1076 * @apilevel internal 1077 */ 1078 private void localLookupType_String_reset() { 1079 localLookupType_String_values = null; 1080 } 1081 /** 1082 * @attribute syn 1083 * @aspect TypeScopePropagation 1084 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:593 1085 */ 1086 @ASTNodeAnnotation.Attribute 1087 public SimpleSet localLookupType(String name) { 1088 Object _parameters = name; 1089 if (localLookupType_String_values == null) localLookupType_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1090 ASTNode$State state = state(); 1091 if (localLookupType_String_values.containsKey(_parameters)) { 1092 return (SimpleSet) localLookupType_String_values.get(_parameters); 1093 } 1094 boolean intermediate = state.INTERMEDIATE_VALUE; 1095 state.INTERMEDIATE_VALUE = false; 1096 int num = state.boundariesCrossed; 1097 boolean isFinal = this.is$Final(); 1098 SimpleSet localLookupType_String_value = hasTypeDecl() && getTypeDecl().name().equals(name) 1099 ? SimpleSet.emptySet.add(getTypeDecl()) 1100 : SimpleSet.emptySet; 1101 if (isFinal && num == state().boundariesCrossed) { 1102 localLookupType_String_values.put(_parameters, localLookupType_String_value); 1103 } else { 1104 } 1105 state.INTERMEDIATE_VALUE |= intermediate; 1106 1107 return localLookupType_String_value; 1108 } 1109 /** 1110 * @attribute syn 1111 * @aspect NameCheck 1112 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:177 1113 */ 1114 @ASTNodeAnnotation.Attribute 1115 public boolean validArgs() { 1116 { 1117 for (int i = 0; i < getNumArg(); i++) { 1118 if (!getArg(i).isPolyExpression() && getArg(i).type().isUnknown()) { 1119 return false; 1120 } 1121 } 1122 return true; 1123 } 1124 } 1125 /** 1126 * @return <code>true</code> if there is any printable body decl 1127 * @attribute syn 1128 * @aspect PrettyPrintUtil 1129 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:224 1130 */ 1131 @ASTNodeAnnotation.Attribute 1132 public boolean hasPrintableBodyDecl() { 1133 { 1134 TypeDecl decl = getTypeDecl(); 1135 for (int i = 0; i < decl.getNumBodyDecl(); ++i) { 1136 if (decl.getBodyDecl(i) instanceof ConstructorDecl) { 1137 ConstructorDecl cd = (ConstructorDecl) decl.getBodyDecl(i); 1138 if (!cd.isImplicitConstructor()) { 1139 return true; 1140 } 1141 } else { 1142 return true; 1143 } 1144 } 1145 return false; 1146 } 1147 } 1148 /** 1149 * @attribute syn 1150 * @aspect PrettyPrintUtil 1151 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:239 1152 */ 1153 @ASTNodeAnnotation.Attribute 1154 public List<BodyDecl> bodyDecls() { 1155 List<BodyDecl> bodyDecls_value = getTypeDecl().getBodyDeclList(); 1156 1157 return bodyDecls_value; 1158 } 1159 /** 1160 * Defines the expected kind of name for the left hand side in a qualified 1161 * expression. 1162 * @attribute syn 1163 * @aspect SyntacticClassification 1164 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:58 1165 */ 1166 @ASTNodeAnnotation.Attribute 1167 public NameType predNameType() { 1168 NameType predNameType_value = NameType.EXPRESSION_NAME; 1169 1170 return predNameType_value; 1171 } 1172 /** 1173 * @apilevel internal 1174 */ 1175 protected boolean type_computed = false; 1176 /** 1177 * @apilevel internal 1178 */ 1179 protected TypeDecl type_value; 1180 /** 1181 * @apilevel internal 1182 */ 1183 private void type_reset() { 1184 type_computed = false; 1185 type_value = null; 1186 } 1187 /** 1188 * @attribute syn 1189 * @aspect TypeAnalysis 1190 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302 1191 */ 1192 @ASTNodeAnnotation.Attribute 1193 public TypeDecl type() { 1194 ASTNode$State state = state(); 1195 if (type_computed) { 1196 return type_value; 1197 } 1198 boolean intermediate = state.INTERMEDIATE_VALUE; 1199 state.INTERMEDIATE_VALUE = false; 1200 int num = state.boundariesCrossed; 1201 boolean isFinal = this.is$Final(); 1202 type_value = hasTypeDecl() ? getTypeDecl() : getAccess().type(); 1203 if (isFinal && num == state().boundariesCrossed) { 1204 type_computed = true; 1205 } else { 1206 } 1207 state.INTERMEDIATE_VALUE |= intermediate; 1208 1209 return type_value; 1210 } 1211 /** 1212 * @attribute syn 1213 * @aspect TypeCheck 1214 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:603 1215 */ 1216 @ASTNodeAnnotation.Attribute 1217 public boolean noEnclosingInstance() { 1218 boolean noEnclosingInstance_value = isQualified() ? qualifier().staticContextQualifier() : inStaticContext(); 1219 1220 return noEnclosingInstance_value; 1221 } 1222 /** 1223 * @attribute syn 1224 * @aspect MethodSignature15 1225 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:547 1226 */ 1227 @ASTNodeAnnotation.Attribute 1228 public int arity() { 1229 int arity_value = getNumArg(); 1230 1231 return arity_value; 1232 } 1233 /** 1234 * @attribute syn 1235 * @aspect VariableArityParameters 1236 * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:79 1237 */ 1238 @ASTNodeAnnotation.Attribute 1239 public boolean invokesVariableArityAsArray() { 1240 { 1241 if (!decl().isVariableArity()) { 1242 return false; 1243 } 1244 if (arity() != decl().arity()) { 1245 return false; 1246 } 1247 return getArg(getNumArg()-1).type().methodInvocationConversionTo(decl().lastParameter().type()); 1248 } 1249 } 1250 /** 1251 * @attribute syn 1252 * @aspect PreciseRethrow 1253 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149 1254 */ 1255 @ASTNodeAnnotation.Attribute 1256 public boolean modifiedInScope(Variable var) { 1257 { 1258 for (int i = 0; i < getNumArg(); ++i) { 1259 if (getArg(i).modifiedInScope(var)) { 1260 return true; 1261 } 1262 } 1263 if (hasTypeDecl()) { 1264 return getTypeDecl().modifiedInScope(var); 1265 } else { 1266 return false; 1267 } 1268 } 1269 } 1270 /** 1271 * @apilevel internal 1272 */ 1273 protected boolean stmtCompatible_computed = false; 1274 /** 1275 * @apilevel internal 1276 */ 1277 protected boolean stmtCompatible_value; 1278 /** 1279 * @apilevel internal 1280 */ 1281 private void stmtCompatible_reset() { 1282 stmtCompatible_computed = false; 1283 } 1284 /** 1285 * @attribute syn 1286 * @aspect StmtCompatible 1287 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:139 1288 */ 1289 @ASTNodeAnnotation.Attribute 1290 public boolean stmtCompatible() { 1291 ASTNode$State state = state(); 1292 if (stmtCompatible_computed) { 1293 return stmtCompatible_value; 1294 } 1295 boolean intermediate = state.INTERMEDIATE_VALUE; 1296 state.INTERMEDIATE_VALUE = false; 1297 int num = state.boundariesCrossed; 1298 boolean isFinal = this.is$Final(); 1299 stmtCompatible_value = true; 1300 if (isFinal && num == state().boundariesCrossed) { 1301 stmtCompatible_computed = true; 1302 } else { 1303 } 1304 state.INTERMEDIATE_VALUE |= intermediate; 1305 1306 return stmtCompatible_value; 1307 } 1308 /** 1309 * @apilevel internal 1310 */ 1311 protected java.util.Map compatibleStrictContext_TypeDecl_values; 1312 /** 1313 * @apilevel internal 1314 */ 1315 private void compatibleStrictContext_TypeDecl_reset() { 1316 compatibleStrictContext_TypeDecl_values = null; 1317 } 1318 /** 1319 * @attribute syn 1320 * @aspect MethodSignature18 1321 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:32 1322 */ 1323 @ASTNodeAnnotation.Attribute 1324 public boolean compatibleStrictContext(TypeDecl type) { 1325 Object _parameters = type; 1326 if (compatibleStrictContext_TypeDecl_values == null) compatibleStrictContext_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1327 ASTNode$State state = state(); 1328 if (compatibleStrictContext_TypeDecl_values.containsKey(_parameters)) { 1329 return (Boolean) compatibleStrictContext_TypeDecl_values.get(_parameters); 1330 } 1331 boolean intermediate = state.INTERMEDIATE_VALUE; 1332 state.INTERMEDIATE_VALUE = false; 1333 int num = state.boundariesCrossed; 1334 boolean isFinal = this.is$Final(); 1335 boolean compatibleStrictContext_TypeDecl_value = isPolyExpression() 1336 ? assignConversionTo(type) 1337 : super.compatibleStrictContext(type); 1338 if (isFinal && num == state().boundariesCrossed) { 1339 compatibleStrictContext_TypeDecl_values.put(_parameters, compatibleStrictContext_TypeDecl_value); 1340 } else { 1341 } 1342 state.INTERMEDIATE_VALUE |= intermediate; 1343 1344 return compatibleStrictContext_TypeDecl_value; 1345 } 1346 /** 1347 * @apilevel internal 1348 */ 1349 protected java.util.Map compatibleLooseContext_TypeDecl_values; 1350 /** 1351 * @apilevel internal 1352 */ 1353 private void compatibleLooseContext_TypeDecl_reset() { 1354 compatibleLooseContext_TypeDecl_values = null; 1355 } 1356 /** 1357 * @attribute syn 1358 * @aspect MethodSignature18 1359 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:79 1360 */ 1361 @ASTNodeAnnotation.Attribute 1362 public boolean compatibleLooseContext(TypeDecl type) { 1363 Object _parameters = type; 1364 if (compatibleLooseContext_TypeDecl_values == null) compatibleLooseContext_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1365 ASTNode$State state = state(); 1366 if (compatibleLooseContext_TypeDecl_values.containsKey(_parameters)) { 1367 return (Boolean) compatibleLooseContext_TypeDecl_values.get(_parameters); 1368 } 1369 boolean intermediate = state.INTERMEDIATE_VALUE; 1370 state.INTERMEDIATE_VALUE = false; 1371 int num = state.boundariesCrossed; 1372 boolean isFinal = this.is$Final(); 1373 boolean compatibleLooseContext_TypeDecl_value = isPolyExpression() 1374 ? assignConversionTo(type) 1375 : super.compatibleLooseContext(type); 1376 if (isFinal && num == state().boundariesCrossed) { 1377 compatibleLooseContext_TypeDecl_values.put(_parameters, compatibleLooseContext_TypeDecl_value); 1378 } else { 1379 } 1380 state.INTERMEDIATE_VALUE |= intermediate; 1381 1382 return compatibleLooseContext_TypeDecl_value; 1383 } 1384 /** 1385 * @apilevel internal 1386 */ 1387 protected boolean isBooleanExpression_computed = false; 1388 /** 1389 * @apilevel internal 1390 */ 1391 protected boolean isBooleanExpression_value; 1392 /** 1393 * @apilevel internal 1394 */ 1395 private void isBooleanExpression_reset() { 1396 isBooleanExpression_computed = false; 1397 } 1398 /** 1399 * @attribute syn 1400 * @aspect PolyExpressions 1401 * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:29 1402 */ 1403 @ASTNodeAnnotation.Attribute 1404 public boolean isBooleanExpression() { 1405 ASTNode$State state = state(); 1406 if (isBooleanExpression_computed) { 1407 return isBooleanExpression_value; 1408 } 1409 boolean intermediate = state.INTERMEDIATE_VALUE; 1410 state.INTERMEDIATE_VALUE = false; 1411 int num = state.boundariesCrossed; 1412 boolean isFinal = this.is$Final(); 1413 isBooleanExpression_value = isBooleanExpression_compute(); 1414 if (isFinal && num == state().boundariesCrossed) { 1415 isBooleanExpression_computed = true; 1416 } else { 1417 } 1418 state.INTERMEDIATE_VALUE |= intermediate; 1419 1420 return isBooleanExpression_value; 1421 } 1422 /** 1423 * @apilevel internal 1424 */ 1425 private boolean isBooleanExpression_compute() { 1426 if (getAccess() instanceof TypeAccess) { 1427 TypeAccess typeAccess = (TypeAccess) getAccess(); 1428 return typeAccess.name().equals("Boolean"); 1429 } 1430 return false; 1431 } 1432 /** 1433 * @apilevel internal 1434 */ 1435 protected boolean isPolyExpression_computed = false; 1436 /** 1437 * @apilevel internal 1438 */ 1439 protected boolean isPolyExpression_value; 1440 /** 1441 * @apilevel internal 1442 */ 1443 private void isPolyExpression_reset() { 1444 isPolyExpression_computed = false; 1445 } 1446 /** 1447 * @attribute syn 1448 * @aspect PolyExpressions 1449 * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:80 1450 */ 1451 @ASTNodeAnnotation.Attribute 1452 public boolean isPolyExpression() { 1453 ASTNode$State state = state(); 1454 if (isPolyExpression_computed) { 1455 return isPolyExpression_value; 1456 } 1457 boolean intermediate = state.INTERMEDIATE_VALUE; 1458 state.INTERMEDIATE_VALUE = false; 1459 int num = state.boundariesCrossed; 1460 boolean isFinal = this.is$Final(); 1461 isPolyExpression_value = (getAccess() instanceof DiamondAccess) && (assignmentContext() || invocationContext()); 1462 if (isFinal && num == state().boundariesCrossed) { 1463 isPolyExpression_computed = true; 1464 } else { 1465 } 1466 state.INTERMEDIATE_VALUE |= intermediate; 1467 1468 return isPolyExpression_value; 1469 } 1470 /** 1471 * @apilevel internal 1472 */ 1473 protected java.util.Map assignConversionTo_TypeDecl_values; 1474 /** 1475 * @apilevel internal 1476 */ 1477 private void assignConversionTo_TypeDecl_reset() { 1478 assignConversionTo_TypeDecl_values = null; 1479 } 1480 /** 1481 * @attribute syn 1482 * @aspect PolyExpressions 1483 * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:142 1484 */ 1485 @ASTNodeAnnotation.Attribute 1486 public boolean assignConversionTo(TypeDecl type) { 1487 Object _parameters = type; 1488 if (assignConversionTo_TypeDecl_values == null) assignConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1489 ASTNode$State state = state(); 1490 if (assignConversionTo_TypeDecl_values.containsKey(_parameters)) { 1491 return (Boolean) assignConversionTo_TypeDecl_values.get(_parameters); 1492 } 1493 boolean intermediate = state.INTERMEDIATE_VALUE; 1494 state.INTERMEDIATE_VALUE = false; 1495 int num = state.boundariesCrossed; 1496 boolean isFinal = this.is$Final(); 1497 boolean assignConversionTo_TypeDecl_value = assignConversionTo_compute(type); 1498 if (isFinal && num == state().boundariesCrossed) { 1499 assignConversionTo_TypeDecl_values.put(_parameters, assignConversionTo_TypeDecl_value); 1500 } else { 1501 } 1502 state.INTERMEDIATE_VALUE |= intermediate; 1503 1504 return assignConversionTo_TypeDecl_value; 1505 } 1506 /** 1507 * @apilevel internal 1508 */ 1509 private boolean assignConversionTo_compute(TypeDecl type) { 1510 if (!isPolyExpression()) { 1511 return super.assignConversionTo(type); 1512 } else { 1513 return ((DiamondAccess) getAccess()).getTypeAccess().type().assignConversionTo( 1514 type, ((DiamondAccess)getAccess()).getTypeAccess()); 1515 } 1516 } 1517 /** 1518 * @attribute inh 1519 * @aspect ExceptionHandling 1520 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:85 1521 */ 1522 /** 1523 * @attribute inh 1524 * @aspect ExceptionHandling 1525 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:85 1526 */ 1527 @ASTNodeAnnotation.Attribute 1528 public boolean handlesException(TypeDecl exceptionType) { 1529 boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType); 1530 1531 return handlesException_TypeDecl_value; 1532 } 1533 /** 1534 * @attribute inh 1535 * @aspect ConstructScope 1536 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:48 1537 */ 1538 /** 1539 * @attribute inh 1540 * @aspect ConstructScope 1541 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:48 1542 */ 1543 @ASTNodeAnnotation.Attribute 1544 public TypeDecl typeObject() { 1545 TypeDecl typeObject_value = getParent().Define_typeObject(this, null); 1546 1547 return typeObject_value; 1548 } 1549 /** 1550 * @attribute inh 1551 * @aspect ConstructScope 1552 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:113 1553 */ 1554 /** 1555 * @attribute inh 1556 * @aspect ConstructScope 1557 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupConstructor.jrag:113 1558 */ 1559 @ASTNodeAnnotation.Attribute 1560 public ConstructorDecl unknownConstructor() { 1561 ConstructorDecl unknownConstructor_value = getParent().Define_unknownConstructor(this, null); 1562 1563 return unknownConstructor_value; 1564 } 1565 /** 1566 * @attribute inh 1567 * @aspect TypeCheck 1568 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:585 1569 */ 1570 /** 1571 * @attribute inh 1572 * @aspect TypeCheck 1573 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:585 1574 */ 1575 @ASTNodeAnnotation.Attribute 1576 public TypeDecl enclosingInstance() { 1577 TypeDecl enclosingInstance_value = getParent().Define_enclosingInstance(this, null); 1578 1579 return enclosingInstance_value; 1580 } 1581 /** 1582 * @attribute inh 1583 * @aspect TypeHierarchyCheck 1584 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:164 1585 */ 1586 /** 1587 * @attribute inh 1588 * @aspect TypeHierarchyCheck 1589 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:164 1590 */ 1591 @ASTNodeAnnotation.Attribute 1592 public boolean inExplicitConstructorInvocation() { 1593 boolean inExplicitConstructorInvocation_value = getParent().Define_inExplicitConstructorInvocation(this, null); 1594 1595 return inExplicitConstructorInvocation_value; 1596 } 1597 /** 1598 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:33 1599 * @apilevel internal 1600 */ 1601 public TypeDecl Define_superType(ASTNode caller, ASTNode child) { 1602 if (caller == getTypeDeclOptNoTransform()) { 1603 // @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:34 1604 return getAccess().type(); 1605 } 1606 else { 1607 return getParent().Define_superType(this, caller); 1608 } 1609 } 1610 protected boolean canDefine_superType(ASTNode caller, ASTNode child) { 1611 return true; 1612 } 1613 /** 1614 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:37 1615 * @apilevel internal 1616 */ 1617 public ConstructorDecl Define_constructorDecl(ASTNode caller, ASTNode child) { 1618 if (caller == getTypeDeclOptNoTransform()) { 1619 // @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:117 1620 { 1621 Collection c = getAccess().type().constructors(); 1622 SimpleSet maxSpecific = chooseConstructor(c, getArgList()); 1623 if (maxSpecific.size() == 1) { 1624 return (ConstructorDecl) maxSpecific.iterator().next(); 1625 } 1626 return unknownConstructor(); 1627 } 1628 } 1629 else { 1630 return getParent().Define_constructorDecl(this, caller); 1631 } 1632 } 1633 protected boolean canDefine_constructorDecl(ASTNode caller, ASTNode child) { 1634 return true; 1635 } 1636 /** 1637 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 1638 * @apilevel internal 1639 */ 1640 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1641 if (caller == getTypeDeclOptNoTransform()) { 1642 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:472 1643 return isDAafterInstance(v); 1644 } 1645 else if (caller == getArgListNoTransform()) { 1646 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:469 1647 int i = caller.getIndexOfChild(child); 1648 return computeDAbefore(i, v); 1649 } 1650 else { 1651 return getParent().Define_isDAbefore(this, caller, v); 1652 } 1653 } 1654 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1655 return true; 1656 } 1657 /** 1658 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 1659 * @apilevel internal 1660 */ 1661 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 1662 if (caller == getArgListNoTransform()) { 1663 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:971 1664 int i = caller.getIndexOfChild(child); 1665 return computeDUbefore(i, v); 1666 } 1667 else { 1668 return getParent().Define_isDUbefore(this, caller, v); 1669 } 1670 } 1671 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 1672 return true; 1673 } 1674 /** 1675 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115 1676 * @apilevel internal 1677 */ 1678 public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) { 1679 if (caller == getArgListNoTransform()) { 1680 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:126 1681 int childIndex = caller.getIndexOfChild(child); 1682 return unqualifiedScope().hasPackage(packageName); 1683 } 1684 else { 1685 return getParent().Define_hasPackage(this, caller, packageName); 1686 } 1687 } 1688 protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) { 1689 return true; 1690 } 1691 /** 1692 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197 1693 * @apilevel internal 1694 */ 1695 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 1696 if (caller == getTypeDeclOptNoTransform()) { 1697 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:526 1698 { 1699 SimpleSet c = localLookupType(name); 1700 if (!c.isEmpty()) { 1701 return c; 1702 } 1703 c = lookupType(name); 1704 if (!c.isEmpty()) { 1705 return c; 1706 } 1707 return unqualifiedScope().lookupType(name); 1708 } 1709 } 1710 else if (caller == getAccessNoTransform()) { 1711 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:516 1712 { 1713 SimpleSet c = lookupType(name); 1714 if (c.size() == 1) { 1715 if (isQualified()) { 1716 c = keepInnerClasses(c); 1717 } 1718 } 1719 return c; 1720 } 1721 } 1722 else if (caller == getArgListNoTransform()) { 1723 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:334 1724 int childIndex = caller.getIndexOfChild(child); 1725 return unqualifiedScope().lookupType(name); 1726 } 1727 else { 1728 return getParent().Define_lookupType(this, caller, name); 1729 } 1730 } 1731 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 1732 return true; 1733 } 1734 /** 1735 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 1736 * @apilevel internal 1737 */ 1738 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 1739 if (caller == getArgListNoTransform()) { 1740 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:227 1741 int childIndex = caller.getIndexOfChild(child); 1742 return unqualifiedScope().lookupVariable(name); 1743 } 1744 else { 1745 return getParent().Define_lookupVariable(this, caller, name); 1746 } 1747 } 1748 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 1749 return true; 1750 } 1751 /** 1752 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 1753 * @apilevel internal 1754 */ 1755 public NameType Define_nameType(ASTNode caller, ASTNode child) { 1756 if (caller == getArgListNoTransform()) { 1757 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:150 1758 int childIndex = caller.getIndexOfChild(child); 1759 return NameType.EXPRESSION_NAME; 1760 } 1761 else if (caller == getTypeDeclOptNoTransform()) { 1762 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:149 1763 return NameType.TYPE_NAME; 1764 } 1765 else if (caller == getAccessNoTransform()) { 1766 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:148 1767 return NameType.TYPE_NAME; 1768 } 1769 else { 1770 return getParent().Define_nameType(this, caller); 1771 } 1772 } 1773 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 1774 return true; 1775 } 1776 /** 1777 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:240 1778 * @apilevel internal 1779 */ 1780 public boolean Define_isAnonymous(ASTNode caller, ASTNode child) { 1781 if (caller == getTypeDeclOptNoTransform()) { 1782 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:241 1783 return true; 1784 } 1785 else { 1786 return getParent().Define_isAnonymous(this, caller); 1787 } 1788 } 1789 protected boolean canDefine_isAnonymous(ASTNode caller, ASTNode child) { 1790 return true; 1791 } 1792 /** 1793 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:577 1794 * @apilevel internal 1795 */ 1796 public boolean Define_isMemberType(ASTNode caller, ASTNode child) { 1797 if (caller == getTypeDeclOptNoTransform()) { 1798 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:581 1799 return false; 1800 } 1801 else { 1802 return getParent().Define_isMemberType(this, caller); 1803 } 1804 } 1805 protected boolean canDefine_isMemberType(ASTNode caller, ASTNode child) { 1806 return true; 1807 } 1808 /** 1809 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:71 1810 * @apilevel internal 1811 */ 1812 public TypeDecl Define_hostType(ASTNode caller, ASTNode child) { 1813 if (caller == getTypeDeclOptNoTransform()) { 1814 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:628 1815 return hostType(); 1816 } 1817 else { 1818 return getParent().Define_hostType(this, caller); 1819 } 1820 } 1821 protected boolean canDefine_hostType(ASTNode caller, ASTNode child) { 1822 return true; 1823 } 1824 /** 1825 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182 1826 * @apilevel internal 1827 */ 1828 public boolean Define_inStaticContext(ASTNode caller, ASTNode child) { 1829 if (caller == getTypeDeclOptNoTransform()) { 1830 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:196 1831 return isQualified() ? 1832 qualifier().staticContextQualifier() : inStaticContext(); 1833 } 1834 else { 1835 return getParent().Define_inStaticContext(this, caller); 1836 } 1837 } 1838 protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) { 1839 return true; 1840 } 1841 /** 1842 * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:90 1843 * @apilevel internal 1844 */ 1845 public ClassInstanceExpr Define_getClassInstanceExpr(ASTNode caller, ASTNode child) { 1846 if (caller == getAccessNoTransform()) { 1847 // @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:91 1848 return this; 1849 } 1850 else { 1851 return getParent().Define_getClassInstanceExpr(this, caller); 1852 } 1853 } 1854 protected boolean canDefine_getClassInstanceExpr(ASTNode caller, ASTNode child) { 1855 return true; 1856 } 1857 /** 1858 * @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:401 1859 * @apilevel internal 1860 */ 1861 public boolean Define_isAnonymousDecl(ASTNode caller, ASTNode child) { 1862 if (caller == getAccessNoTransform()) { 1863 // @declaredat /home/jesper/git/extendj/java7/frontend/Diamond.jrag:406 1864 return hasTypeDecl(); 1865 } 1866 else { 1867 return getParent().Define_isAnonymousDecl(this, caller); 1868 } 1869 } 1870 protected boolean canDefine_isAnonymousDecl(ASTNode caller, ASTNode child) { 1871 return true; 1872 } 1873 /** 1874 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30 1875 * @apilevel internal 1876 */ 1877 public TypeDecl Define_targetType(ASTNode caller, ASTNode child) { 1878 if (caller == getArgListNoTransform()) { 1879 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:113 1880 int i = caller.getIndexOfChild(child); 1881 { 1882 ConstructorDecl decl = decl(); 1883 if (unknownConstructor() == decl) { 1884 return decl.type().unknownType(); 1885 } 1886 1887 if (decl.isVariableArity() && i >= decl.arity() - 1) { 1888 return decl.getParameter(decl.arity() - 1).type().componentType(); 1889 } else { 1890 return decl.getParameter(i).type(); 1891 } 1892 } 1893 } 1894 else { 1895 return getParent().Define_targetType(this, caller); 1896 } 1897 } 1898 protected boolean canDefine_targetType(ASTNode caller, ASTNode child) { 1899 return true; 1900 } 1901 /** 1902 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:58 1903 * @apilevel internal 1904 */ 1905 public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) { 1906 if (caller == getAccessNoTransform()) { 1907 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:181 1908 return targetType(); 1909 } 1910 else { 1911 return getParent().Define_assignConvertedType(this, caller); 1912 } 1913 } 1914 protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) { 1915 return true; 1916 } 1917 /** 1918 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 1919 * @apilevel internal 1920 */ 1921 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 1922 if (caller == getArgListNoTransform()) { 1923 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:325 1924 int childIndex = caller.getIndexOfChild(child); 1925 return false; 1926 } 1927 else { 1928 return getParent().Define_assignmentContext(this, caller); 1929 } 1930 } 1931 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 1932 return true; 1933 } 1934 /** 1935 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 1936 * @apilevel internal 1937 */ 1938 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 1939 if (caller == getArgListNoTransform()) { 1940 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:326 1941 int childIndex = caller.getIndexOfChild(child); 1942 return true; 1943 } 1944 else { 1945 return getParent().Define_invocationContext(this, caller); 1946 } 1947 } 1948 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 1949 return true; 1950 } 1951 /** 1952 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 1953 * @apilevel internal 1954 */ 1955 public boolean Define_castContext(ASTNode caller, ASTNode child) { 1956 if (caller == getArgListNoTransform()) { 1957 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:327 1958 int childIndex = caller.getIndexOfChild(child); 1959 return false; 1960 } 1961 else { 1962 return getParent().Define_castContext(this, caller); 1963 } 1964 } 1965 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 1966 return true; 1967 } 1968 /** 1969 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 1970 * @apilevel internal 1971 */ 1972 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 1973 if (caller == getArgListNoTransform()) { 1974 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:328 1975 int childIndex = caller.getIndexOfChild(child); 1976 return false; 1977 } 1978 else { 1979 return getParent().Define_stringContext(this, caller); 1980 } 1981 } 1982 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 1983 return true; 1984 } 1985 /** 1986 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 1987 * @apilevel internal 1988 */ 1989 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 1990 if (caller == getArgListNoTransform()) { 1991 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:329 1992 int childIndex = caller.getIndexOfChild(child); 1993 return false; 1994 } 1995 else { 1996 return getParent().Define_numericContext(this, caller); 1997 } 1998 } 1999 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 2000 return true; 2001 } 2002 /** 2003 * @apilevel internal 2004 */ 2005 public ASTNode rewriteTo() { 2006 return super.rewriteTo(); 2007 } 2008 }