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:19 027 * @production MethodAccess : {@link Access} ::= <span class="component"><ID:String></span> <span class="component">Arg:{@link Expr}*</span>; 028 029 */ 030 public class MethodAccess extends Access implements Cloneable { 031 /** 032 * @aspect AnonymousClasses 033 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:138 034 */ 035 protected void collectExceptions(Collection c, ASTNode target) { 036 super.collectExceptions(c, target); 037 for (int i = 0; i < decl().getNumException(); i++) { 038 c.add(decl().getException(i).type()); 039 } 040 } 041 /** 042 * @aspect ExceptionHandling 043 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:90 044 */ 045 public void exceptionHandling() { 046 for (Iterator iter = exceptionCollection().iterator(); iter.hasNext(); ) { 047 TypeDecl exceptionType = (TypeDecl) iter.next(); 048 if (exceptionType.isCheckedException() && !handlesException(exceptionType)) { 049 errorf("%s.%s invoked in %s may throw uncaught exception %s", 050 decl().hostType().fullName(), this.name(), 051 hostType().fullName(), exceptionType.fullName()); 052 } 053 } 054 } 055 /** 056 * @aspect ExceptionHandling 057 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:308 058 */ 059 protected boolean reachedException(TypeDecl catchType) { 060 for (Iterator iter = exceptionCollection().iterator(); iter.hasNext(); ) { 061 TypeDecl exceptionType = (TypeDecl) iter.next(); 062 if (catchType.mayCatch(exceptionType)) { 063 return true; 064 } 065 } 066 return super.reachedException(catchType); 067 } 068 /** 069 * @aspect LookupMethod 070 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:165 071 */ 072 private static SimpleSet removeInstanceMethods(SimpleSet c) { 073 SimpleSet set = SimpleSet.emptySet; 074 for (Iterator iter = c.iterator(); iter.hasNext(); ) { 075 MethodDecl m = (MethodDecl) iter.next(); 076 if (m.isStatic()) { 077 set = set.add(m); 078 } 079 } 080 return set; 081 } 082 /** 083 * @aspect MethodDecl 084 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:247 085 */ 086 public boolean applicable(MethodDecl decl) { 087 if (getNumArg() != decl.getNumParameter()) { 088 return false; 089 } 090 if (!name().equals(decl.name())) { 091 return false; 092 } 093 for (int i = 0; i < getNumArg(); i++) { 094 if (!getArg(i).type().instanceOf(decl.getParameter(i).type())) { 095 return false; 096 } 097 } 098 return true; 099 } 100 /** 101 * @aspect NodeConstructors 102 * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:67 103 */ 104 public MethodAccess(String name, List args, int start, int end) { 105 this(name, args); 106 setStart(start); 107 setEnd(end); 108 } 109 /** 110 * @aspect Java4PrettyPrint 111 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:626 112 */ 113 public void prettyPrint(PrettyPrinter out) { 114 out.print(getID()); 115 out.print("("); 116 out.join(getArgList(), new PrettyPrinter.Joiner() { 117 @Override 118 public void printSeparator(PrettyPrinter out) { 119 out.print(", "); 120 } 121 }); 122 out.print(")"); 123 } 124 /** 125 * @aspect TypeHierarchyCheck 126 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:44 127 */ 128 public void nameCheck() { 129 if (isQualified() && qualifier().isPackageAccess() && !qualifier().isUnknown()) { 130 errorf("The method %s can not be qualified by a package name.", decl().fullSignature()); 131 } 132 if (isQualified() && decl().isAbstract() && qualifier().isSuperAccess()) { 133 error("may not access abstract methods in superclass"); 134 } 135 if (decls().isEmpty() && (!isQualified() || !qualifier().isUnknown())) { 136 StringBuilder sb = new StringBuilder(); 137 sb.append("no method named " + name()); 138 sb.append("("); 139 for (int i = 0; i < getNumArg(); i++) { 140 TypeDecl argType = getArg(i).type(); 141 if (argType.isVoid()) { 142 // error will be reported for the void argument in typeCheck 143 // so we return now to avoid confusing double errors 144 return; 145 } 146 if (i != 0) { 147 sb.append(", "); 148 } 149 sb.append(argType.typeName()); 150 } 151 sb.append(")" + " in " + methodHost() + " matches."); 152 if (singleCandidateDecl() != null) { 153 sb.append(" However, there is a method " + singleCandidateDecl().fullSignature()); 154 } 155 error(sb.toString()); 156 } 157 if (decls().size() > 1) { 158 boolean allAbstract = true; 159 for (Iterator iter = decls().iterator(); iter.hasNext() && allAbstract; ) { 160 MethodDecl m = (MethodDecl) iter.next(); 161 if (!m.isAbstract() && !m.hostType().isObject()) { 162 allAbstract = false; 163 } 164 } 165 if (!allAbstract && validArgs()) { 166 StringBuilder sb = new StringBuilder(); 167 sb.append("several most specific methods for " + this.prettyPrint() + "\n"); 168 for (Iterator iter = decls().iterator(); iter.hasNext(); ) { 169 MethodDecl m = (MethodDecl) iter.next(); 170 sb.append(" " + m.fullSignature() + " in " + m.hostType().typeName() + "\n"); 171 } 172 error(sb.toString()); 173 } 174 175 } 176 } 177 /** 178 * @aspect CreateBCode 179 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:636 180 */ 181 protected void createLoadQualifier(CodeGeneration gen) { 182 MethodDecl m = decl(); 183 if (hasPrevExpr()) { 184 // load explicit qualifier 185 prevExpr().createBCode(gen); 186 // pop qualifier stack element for class variables 187 // this qualifier must be computed to ensure side effects 188 if (m.isStatic() && !prevExpr().isTypeAccess()) { 189 prevExpr().type().emitPop(gen); 190 } 191 } else if (!m.isStatic()) { 192 // load implicit this qualifier 193 emitThis(gen, methodQualifierType()); 194 } 195 } 196 /** 197 * @aspect InnerClasses 198 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:77 199 */ 200 private TypeDecl refined_InnerClasses_MethodAccess_methodQualifierType() { 201 if (hasPrevExpr()) { 202 return prevExpr().type(); 203 } 204 TypeDecl typeDecl = hostType(); 205 while (typeDecl != null && !typeDecl.hasMethod(name())) { 206 typeDecl = typeDecl.enclosingType(); 207 } 208 if (typeDecl != null) { 209 return typeDecl; 210 } 211 return decl().hostType(); 212 } 213 /** 214 * @aspect InnerClasses 215 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:147 216 */ 217 public TypeDecl superAccessorTarget() { 218 TypeDecl targetDecl = prevExpr().type(); 219 TypeDecl enclosing = hostType(); 220 do { 221 enclosing = enclosing.enclosingType(); 222 } while (!enclosing.instanceOf(targetDecl)); 223 return enclosing; 224 } 225 /** 226 * @aspect Transformations 227 * @declaredat /home/jesper/git/extendj/java4/backend/Transformations.jrag:72 228 */ 229 public void refined_Transformations_MethodAccess_transformation() { 230 MethodDecl m = decl(); 231 232 if (requiresAccessor()) { 233 /* Access to private methods in enclosing types: 234 The original MethodAccess is replaced with an access to an accessor method 235 built by createAccessor(). This method is built lazily and differs from 236 normal MethodDeclarations in the following ways: 237 1) The method in the class file should always be static and the signature 238 is thus changed to include a possible this reference as the first argument. 239 2) The method is always invoked using INVOKESTATIC 240 3) The flags must indicate that the method is static and package private 241 */ 242 super.transformation(); 243 this.replaceWith(decl().createAccessor(methodQualifierType()).createBoundAccess(getArgList())); 244 return; 245 } else if (!m.isStatic() && isQualified() && prevExpr().isSuperAccess() && !hostType().instanceOf(prevExpr().type())) { 246 decl().createSuperAccessor(superAccessorTarget()); 247 } 248 super.transformation(); 249 } 250 /** 251 * @aspect Annotations 252 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:412 253 */ 254 public void checkModifiers() { 255 if (decl().isDeprecated() && 256 !withinDeprecatedAnnotation() && 257 hostType().topLevelType() != decl().hostType().topLevelType() && 258 !withinSuppressWarnings("deprecation")) 259 warning(decl().signature() + " in " + decl().hostType().typeName() + " has been deprecated"); 260 } 261 /** 262 * @aspect MethodSignature15 263 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:44 264 */ 265 protected SimpleSet potentiallyApplicable(Collection candidates) { 266 SimpleSet potentiallyApplicable = SimpleSet.emptySet; 267 // select potentially applicable methods 268 for (Iterator iter = candidates.iterator(); iter.hasNext(); ) { 269 MethodDecl decl = (MethodDecl) iter.next(); 270 if (potentiallyApplicable(decl) && accessible(decl)) { 271 if (decl.isGeneric()) { 272 GenericMethodDecl gm = decl.genericDecl(); 273 decl = gm.lookupParMethodDecl( 274 inferTypeArguments( 275 gm.type(), 276 gm.getParameterList(), 277 getArgList(), 278 gm.getTypeParameterList())); 279 } 280 potentiallyApplicable = potentiallyApplicable.add(decl); 281 } 282 } 283 return potentiallyApplicable; 284 } 285 /** 286 * @aspect MethodSignature15 287 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:65 288 */ 289 protected SimpleSet applicableBySubtyping(SimpleSet potentiallyApplicable) { 290 SimpleSet maxSpecific = SimpleSet.emptySet; 291 for (Iterator iter = potentiallyApplicable.iterator(); iter.hasNext(); ) { 292 MethodDecl decl = (MethodDecl) iter.next(); 293 if (applicableBySubtyping(decl)) { 294 maxSpecific = mostSpecific(maxSpecific, decl); 295 } 296 } 297 return maxSpecific; 298 } 299 /** 300 * @aspect MethodSignature15 301 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:76 302 */ 303 protected SimpleSet applicableByMethodInvocationConversion( 304 SimpleSet potentiallyApplicable, SimpleSet maxSpecific) { 305 if (maxSpecific.isEmpty()) { 306 for (Iterator iter = potentiallyApplicable.iterator(); iter.hasNext(); ) { 307 MethodDecl decl = (MethodDecl) iter.next(); 308 if (applicableByMethodInvocationConversion(decl)) { 309 maxSpecific = mostSpecific(maxSpecific, decl); 310 } 311 } 312 } 313 return maxSpecific; 314 } 315 /** 316 * @aspect MethodSignature15 317 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:89 318 */ 319 protected SimpleSet applicableVariableArity(SimpleSet potentiallyApplicable, 320 SimpleSet maxSpecific) { 321 if (maxSpecific.isEmpty()) { 322 for (Iterator iter = potentiallyApplicable.iterator(); iter.hasNext(); ) { 323 MethodDecl decl = (MethodDecl) iter.next(); 324 if (decl.isVariableArity() && applicableVariableArity(decl)) { 325 maxSpecific = mostSpecific(maxSpecific, decl); 326 } 327 } 328 } 329 return maxSpecific; 330 } 331 /** 332 * @aspect SafeVarargs 333 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:88 334 */ 335 public void checkWarnings() { 336 337 MethodDecl decl = decl(); 338 if (decl.getNumParameter() == 0 || decl.getNumParameter() > getNumArg()) { 339 return; 340 } 341 342 ParameterDeclaration param = decl.getParameter(decl.getNumParameter()-1); 343 if (!withinSuppressWarnings("unchecked") 344 && !decl.hasAnnotationSafeVarargs() 345 && param.isVariableArity() 346 && !param.type().isReifiable()) { 347 warning("unchecked array creation for variable " + "arity parameter of " + decl().name()); 348 } 349 } 350 /** 351 * @aspect MethodSignature18 352 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:702 353 */ 354 protected boolean moreSpecificThan(MethodDecl m1, MethodDecl m2) { 355 if (m1 instanceof ParMethodDecl) { 356 return m1.moreSpecificThan(m2); 357 } 358 if (m1.getNumParameter() == 0) { 359 return false; 360 } 361 if (!m1.isVariableArity() && !m2.isVariableArity()) { 362 for (int i = 0; i < m1.getNumParameter(); i++) { 363 if (!getArg(i).moreSpecificThan(m1.getParameter(i).type(), m2.getParameter(i).type())) { 364 return false; 365 } 366 } 367 return true; 368 } 369 370 int num = getNumArg(); 371 for (int i = 0; i < num; i++) { 372 TypeDecl t1 = i < m1.getNumParameter() - 1 373 ? m1.getParameter(i).type() 374 : m1.getParameter(m1.getNumParameter()-1).type().componentType(); 375 TypeDecl t2 = i < m2.getNumParameter() - 1 376 ? m2.getParameter(i).type() 377 : m2.getParameter(m2.getNumParameter()-1).type().componentType(); 378 if (!getArg(i).moreSpecificThan(t1, t2)) { 379 return false; 380 } 381 382 } 383 num++; 384 if (m2.getNumParameter() == num) { 385 TypeDecl t1 = num < m1.getNumParameter() - 1 386 ? m1.getParameter(num).type() 387 : m1.getParameter(m1.getNumParameter()-1).type().componentType(); 388 TypeDecl t2 = num < m2.getNumParameter() - 1 389 ? m2.getParameter(num).type() 390 : m2.getParameter(m2.getNumParameter()-1).type().componentType(); 391 if (!t1.instanceOf(t2) && !t1.withinBounds(t2, Parameterization.RAW)) { 392 return false; 393 } 394 } 395 return true; 396 } 397 /** 398 * @declaredat ASTNode:1 399 */ 400 public MethodAccess() { 401 super(); 402 } 403 /** 404 * Initializes the child array to the correct size. 405 * Initializes List and Opt nta children. 406 * @apilevel internal 407 * @ast method 408 * @declaredat ASTNode:10 409 */ 410 public void init$Children() { 411 children = new ASTNode[1]; 412 setChild(new List(), 0); 413 } 414 /** 415 * @declaredat ASTNode:14 416 */ 417 public MethodAccess(String p0, List<Expr> p1) { 418 setID(p0); 419 setChild(p1, 0); 420 } 421 /** 422 * @declaredat ASTNode:18 423 */ 424 public MethodAccess(beaver.Symbol p0, List<Expr> p1) { 425 setID(p0); 426 setChild(p1, 0); 427 } 428 /** 429 * @apilevel low-level 430 * @declaredat ASTNode:25 431 */ 432 protected int numChildren() { 433 return 1; 434 } 435 /** 436 * @apilevel internal 437 * @declaredat ASTNode:31 438 */ 439 public boolean mayHaveRewrite() { 440 return false; 441 } 442 /** 443 * @apilevel internal 444 * @declaredat ASTNode:37 445 */ 446 public void flushAttrCache() { 447 super.flushAttrCache(); 448 computeDAbefore_int_Variable_reset(); 449 computeDUbefore_int_Variable_reset(); 450 exceptionCollection_reset(); 451 decls_reset(); 452 decl_reset(); 453 type_reset(); 454 stmtCompatible_reset(); 455 isBooleanExpression_reset(); 456 isNumericExpression_reset(); 457 isPolyExpression_reset(); 458 } 459 /** 460 * @apilevel internal 461 * @declaredat ASTNode:53 462 */ 463 public void flushCollectionCache() { 464 super.flushCollectionCache(); 465 } 466 /** 467 * @apilevel internal 468 * @declaredat ASTNode:59 469 */ 470 public void flushRewriteCache() { 471 super.flushRewriteCache(); 472 } 473 /** 474 * @apilevel internal 475 * @declaredat ASTNode:65 476 */ 477 public MethodAccess clone() throws CloneNotSupportedException { 478 MethodAccess node = (MethodAccess) super.clone(); 479 return node; 480 } 481 /** 482 * @apilevel internal 483 * @declaredat ASTNode:72 484 */ 485 public MethodAccess copy() { 486 try { 487 MethodAccess node = (MethodAccess) clone(); 488 node.parent = null; 489 if (children != null) { 490 node.children = (ASTNode[]) children.clone(); 491 } 492 return node; 493 } catch (CloneNotSupportedException e) { 494 throw new Error("Error: clone not supported for " + getClass().getName()); 495 } 496 } 497 /** 498 * Create a deep copy of the AST subtree at this node. 499 * The copy is dangling, i.e. has no parent. 500 * @return dangling copy of the subtree at this node 501 * @apilevel low-level 502 * @deprecated Please use treeCopy or treeCopyNoTransform instead 503 * @declaredat ASTNode:91 504 */ 505 @Deprecated 506 public MethodAccess fullCopy() { 507 return treeCopyNoTransform(); 508 } 509 /** 510 * Create a deep copy of the AST subtree at this node. 511 * The copy is dangling, i.e. has no parent. 512 * @return dangling copy of the subtree at this node 513 * @apilevel low-level 514 * @declaredat ASTNode:101 515 */ 516 public MethodAccess treeCopyNoTransform() { 517 MethodAccess tree = (MethodAccess) copy(); 518 if (children != null) { 519 for (int i = 0; i < children.length; ++i) { 520 ASTNode child = (ASTNode) children[i]; 521 if (child != null) { 522 child = child.treeCopyNoTransform(); 523 tree.setChild(child, i); 524 } 525 } 526 } 527 return tree; 528 } 529 /** 530 * Create a deep copy of the AST subtree at this node. 531 * The subtree of this node is traversed to trigger rewrites before copy. 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:121 536 */ 537 public MethodAccess treeCopy() { 538 doFullTraversal(); 539 return treeCopyNoTransform(); 540 } 541 /** 542 * @apilevel internal 543 * @declaredat ASTNode:128 544 */ 545 protected boolean is$Equal(ASTNode node) { 546 return super.is$Equal(node) && (tokenString_ID == ((MethodAccess)node).tokenString_ID); 547 } 548 /** 549 * Replaces the lexeme ID. 550 * @param value The new value for the lexeme ID. 551 * @apilevel high-level 552 */ 553 public void setID(String value) { 554 tokenString_ID = value; 555 } 556 /** 557 * @apilevel internal 558 */ 559 protected String tokenString_ID; 560 /** 561 */ 562 public int IDstart; 563 /** 564 */ 565 public int IDend; 566 /** 567 * JastAdd-internal setter for lexeme ID using the Beaver parser. 568 * @param symbol Symbol containing the new value for the lexeme ID 569 * @apilevel internal 570 */ 571 public void setID(beaver.Symbol symbol) { 572 if (symbol.value != null && !(symbol.value instanceof String)) 573 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 574 tokenString_ID = (String)symbol.value; 575 IDstart = symbol.getStart(); 576 IDend = symbol.getEnd(); 577 } 578 /** 579 * Retrieves the value for the lexeme ID. 580 * @return The value for the lexeme ID. 581 * @apilevel high-level 582 */ 583 @ASTNodeAnnotation.Token(name="ID") 584 public String getID() { 585 return tokenString_ID != null ? tokenString_ID : ""; 586 } 587 /** 588 * Replaces the Arg list. 589 * @param list The new list node to be used as the Arg list. 590 * @apilevel high-level 591 */ 592 public void setArgList(List<Expr> list) { 593 setChild(list, 0); 594 } 595 /** 596 * Retrieves the number of children in the Arg list. 597 * @return Number of children in the Arg list. 598 * @apilevel high-level 599 */ 600 public int getNumArg() { 601 return getArgList().getNumChild(); 602 } 603 /** 604 * Retrieves the number of children in the Arg list. 605 * Calling this method will not trigger rewrites. 606 * @return Number of children in the Arg list. 607 * @apilevel low-level 608 */ 609 public int getNumArgNoTransform() { 610 return getArgListNoTransform().getNumChildNoTransform(); 611 } 612 /** 613 * Retrieves the element at index {@code i} in the Arg list. 614 * @param i Index of the element to return. 615 * @return The element at position {@code i} in the Arg list. 616 * @apilevel high-level 617 */ 618 public Expr getArg(int i) { 619 return (Expr) getArgList().getChild(i); 620 } 621 /** 622 * Check whether the Arg list has any children. 623 * @return {@code true} if it has at least one child, {@code false} otherwise. 624 * @apilevel high-level 625 */ 626 public boolean hasArg() { 627 return getArgList().getNumChild() != 0; 628 } 629 /** 630 * Append an element to the Arg list. 631 * @param node The element to append to the Arg list. 632 * @apilevel high-level 633 */ 634 public void addArg(Expr node) { 635 List<Expr> list = (parent == null) ? getArgListNoTransform() : getArgList(); 636 list.addChild(node); 637 } 638 /** 639 * @apilevel low-level 640 */ 641 public void addArgNoTransform(Expr node) { 642 List<Expr> list = getArgListNoTransform(); 643 list.addChild(node); 644 } 645 /** 646 * Replaces the Arg list element at index {@code i} with the new node {@code node}. 647 * @param node The new node to replace the old list element. 648 * @param i The list index of the node to be replaced. 649 * @apilevel high-level 650 */ 651 public void setArg(Expr node, int i) { 652 List<Expr> list = getArgList(); 653 list.setChild(node, i); 654 } 655 /** 656 * Retrieves the Arg list. 657 * @return The node representing the Arg list. 658 * @apilevel high-level 659 */ 660 @ASTNodeAnnotation.ListChild(name="Arg") 661 public List<Expr> getArgList() { 662 List<Expr> list = (List<Expr>) getChild(0); 663 return list; 664 } 665 /** 666 * Retrieves the Arg list. 667 * <p><em>This method does not invoke AST transformations.</em></p> 668 * @return The node representing the Arg list. 669 * @apilevel low-level 670 */ 671 public List<Expr> getArgListNoTransform() { 672 return (List<Expr>) getChildNoTransform(0); 673 } 674 /** 675 * Retrieves the Arg list. 676 * @return The node representing the Arg list. 677 * @apilevel high-level 678 */ 679 public List<Expr> getArgs() { 680 return getArgList(); 681 } 682 /** 683 * Retrieves the Arg list. 684 * <p><em>This method does not invoke AST transformations.</em></p> 685 * @return The node representing the Arg list. 686 * @apilevel low-level 687 */ 688 public List<Expr> getArgsNoTransform() { 689 return getArgListNoTransform(); 690 } 691 /** 692 * @aspect MethodSignature15 693 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:33 694 */ 695 protected SimpleSet maxSpecific(Collection candidates) { 696 SimpleSet potentiallyApplicable = potentiallyApplicable(candidates); 697 // first phase 698 SimpleSet maxSpecific = applicableBySubtyping(potentiallyApplicable); 699 // second phase 700 maxSpecific = applicableByMethodInvocationConversion(potentiallyApplicable, maxSpecific); 701 // third phase 702 maxSpecific = applicableVariableArity(potentiallyApplicable, maxSpecific); 703 return maxSpecific; 704 } 705 /** 706 * @aspect MethodSignature15 707 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:551 708 */ 709 public void typeCheck() { 710 for (int i = 0; i < getNumArg(); ++i) { 711 if (getArg(i).type().isVoid()) { 712 errorf("expression '%s' has type void and is not a valid method argument", 713 getArg(i).prettyPrint()); 714 } 715 } 716 if (isQualified() && decl().isAbstract() && qualifier().isSuperAccess()) { 717 error("may not access abstract methods in superclass"); 718 } 719 if (!decl().isVariableArity() || invokesVariableArityAsArray()) { 720 for (int i = 0; i < decl().getNumParameter(); i++) { 721 TypeDecl exprType = getArg(i).type(); 722 TypeDecl parmType = decl().getParameter(i).type(); 723 if (!exprType.methodInvocationConversionTo(parmType) && 724 !exprType.isUnknown() && !parmType.isUnknown()) { 725 errorf("argument '%s' of type %s is not compatible with the method parameter type %s", 726 getArg(i).prettyPrint(), exprType.typeName(), parmType.typeName()); 727 } 728 } 729 } 730 } 731 /** 732 * @aspect GenericsCodegen 733 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:180 734 */ 735 protected TypeDecl refined_GenericsCodegen_MethodAccess_methodQualifierType() { 736 TypeDecl typeDecl = refined_InnerClasses_MethodAccess_methodQualifierType(); 737 if (typeDecl == null) { 738 return null; 739 } 740 typeDecl = typeDecl.erasure(); 741 MethodDecl m = decl().sourceMethodDecl(); 742 Collection methods = typeDecl.memberMethods(m.name()); 743 if (!methods.contains(decl()) && !methods.contains(m)) { 744 return m.hostType(); 745 } 746 return typeDecl.erasure(); 747 } 748 /** 749 * @aspect MethodSignature18 750 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:746 751 */ 752 753 private SimpleSet mostSpecific(SimpleSet maxSpecific, MethodDecl decl) { 754 SimpleSet newMax; 755 if (maxSpecific.isEmpty()) { 756 newMax = maxSpecific.add(decl); 757 } else { 758 boolean foundStricter = false; 759 newMax = SimpleSet.emptySet; 760 Iterator<MethodDecl> iter = maxSpecific.iterator(); 761 while (iter.hasNext()) { 762 MethodDecl toCompare = iter.next(); 763 if (!(moreSpecificThan(decl, toCompare) && !moreSpecificThan(toCompare, decl))) { 764 newMax = newMax.add(toCompare); 765 } 766 767 if (!moreSpecificThan(decl, toCompare) && moreSpecificThan(toCompare, decl)) { 768 foundStricter = true; 769 } 770 771 } 772 773 if (!foundStricter) { 774 newMax = newMax.add(decl); 775 } 776 } 777 return newMax; 778 } 779 /** 780 * @aspect GenericsCodegen 781 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:131 782 */ 783 public void refined_GenericsCodegen_MethodAccess_createBCode(CodeGeneration gen) { 784 MethodDecl decl = decl().erasedMethod(); 785 createLoadQualifier(gen); 786 787 if (program().options().hasOption("-debug")) { 788 if (decl.type().isUnknown()) { 789 System.err.println("Could not bind " + this); 790 for (int i = 0; i < getNumArg(); ++i) { 791 System.err.println("Argument " + getArg(i) 792 + " is of type " + getArg(i).type().typeName()); 793 if (getArg(i).varDecl() != null) { 794 System.err.println(getArg(i).varDecl() + " in " 795 + getArg(i).varDecl().hostType().typeName()); 796 } 797 } 798 if (isQualified()) { 799 System.err.println("Qualifier " + qualifier() 800 + " is of type " + qualifier().type().typeName()); 801 } 802 throw new Error("Could not bind " + this); 803 } 804 if (decl.getNumParameter() != getNumArg()) { 805 System.out.println(this 806 + " does not have the same number of arguments as " + decl); 807 } 808 } 809 810 for (int i = 0; i < getNumArg(); ++i) { 811 getArg(i).createBCode(gen); 812 // The cast or boxing/unboxing operation must know the bound rather than the erased type. 813 getArg(i).type().emitCastTo(gen, decl().getParameter(i).type()); // MethodInvocationConversion 814 } 815 816 if (!decl.isStatic() && isQualified() && prevExpr().isSuperAccess()) { 817 if (!hostType().instanceOf(prevExpr().type())) { 818 /* Should this be decl instead? possible copy/paste error? */ 819 decl().createSuperAccessor(superAccessorTarget()).emitInvokeMethod(gen, superAccessorTarget()); 820 } else { 821 decl.emitInvokeSpecialMethod(gen, methodQualifierType()); 822 } 823 } else { 824 decl.emitInvokeMethod(gen, methodQualifierType()); 825 } 826 827 if (decl.type() != decl().type()) { 828 gen.emitCheckCast(decl().type()); 829 } 830 } 831 /** 832 * @aspect VariableArityParametersCodegen 833 * @declaredat /home/jesper/git/extendj/java5/backend/VariableArityParametersCodegen.jrag:37 834 */ 835 public void refined_VariableArityParametersCodegen_MethodAccess_transformation() { 836 if (decl().isVariableArity() && !invokesVariableArityAsArray()) { 837 // arguments to normal parameters 838 List list = new List(); 839 for (int i = 0; i < decl().getNumParameter() - 1; i++) { 840 list.add(getArg(i).treeCopyNoTransform()); 841 } 842 // arguments to variable arity parameters 843 List last = new List(); 844 for (int i = decl().getNumParameter() - 1; i < getNumArg(); i++) { 845 last.add(getArg(i).treeCopyNoTransform()); 846 } 847 // build an array holding arguments 848 Access typeAccess = decl().lastParameter().type().elementType().createQualifiedAccess(); 849 for (int i = 0; i < decl().lastParameter().type().dimension(); i++) { 850 typeAccess = new ArrayTypeAccess(typeAccess); 851 } 852 list.add(new ArrayCreationExpr(typeAccess, new Opt(new ArrayInit(last)))); 853 // replace argument list with augemented argument list 854 setArgList(list); 855 } 856 refined_Transformations_MethodAccess_transformation(); 857 } 858 /** 859 * @aspect Java8CreateBCode 860 * @declaredat /home/jesper/git/extendj/java8/backend/CreateBCode.jrag:55 861 */ 862 863 public void createBCode(CodeGeneration gen) { 864 MethodDecl decl = decl().erasedMethod(); 865 createLoadQualifier(gen); 866 867 if (program().options().hasOption("-debug")) { 868 if (decl.type().isUnknown()) { 869 System.err.println("Could not bind " + this); 870 for (int i = 0; i < getNumArg(); ++i) { 871 System.err.println("Argument " + getArg(i) 872 + " is of type " + getArg(i).type().typeName()); 873 if (getArg(i).varDecl() != null) { 874 System.err.println(getArg(i).varDecl() + " in " 875 + getArg(i).varDecl().hostType().typeName()); 876 } 877 } 878 if (isQualified()) { 879 System.err.println("Qualifier " + qualifier() 880 + " is of type " + qualifier().type().typeName()); 881 } 882 throw new Error("Could not bind " + this); 883 } 884 if (decl.getNumParameter() != getNumArg()) { 885 System.out.println(this 886 + " does not have the same number of arguments as " + decl); 887 } 888 } 889 890 for (int i = 0; i < getNumArg(); ++i) { 891 getArg(i).createBCode(gen); 892 // the cast or boxing/unboxing operation must know the bound rather than the erased type 893 getArg(i).type().emitCastTo(gen, decl().getParameter(i).type()); // MethodInvocationConversion 894 } 895 896 if (!decl.isStatic() && isQualified() && prevExpr().isSuperAccess()) { 897 if (!hostType().instanceOf(prevExpr().type()) && !prevExpr().type().isInterfaceDecl()) { 898 /* should this be decl instead? possible copy/paste error? */ 899 decl().createSuperAccessor(superAccessorTarget()).emitInvokeMethod(gen, superAccessorTarget()); 900 } else { 901 decl.emitInvokeSpecialMethod(gen, methodQualifierType()); 902 } 903 } else { 904 decl.emitInvokeMethod(gen, methodQualifierType()); 905 } 906 907 if (decl.type() != decl().type()) { 908 gen.emitCheckCast(decl().type()); 909 } 910 } 911 /** 912 * @aspect StaticImportsCodegen 913 * @declaredat /home/jesper/git/extendj/java5/backend/StaticImportsCodegen.jrag:40 914 */ 915 protected TypeDecl methodQualifierType() { 916 TypeDecl typeDecl = refined_GenericsCodegen_MethodAccess_methodQualifierType(); 917 if (typeDecl != null) { 918 return typeDecl; 919 } 920 return decl().hostType(); 921 } 922 /** 923 * @aspect Transformations 924 * @declaredat /home/jesper/git/extendj/java8/backend/Transformations.jrag:46 925 */ 926 927 public void transformation() { 928 if (decl().isVariableArity() && !invokesVariableArityAsArray()) { 929 // arguments to normal parameters 930 List list = new List(); 931 for (int i = 0; i < decl().getNumParameter() - 1; i++) 932 list.add(getArg(i).treeCopyNoTransform()); 933 // arguments to variable arity parameters 934 List last = new List(); 935 for (int i = decl().getNumParameter() - 1; i < getNumArg(); i++) 936 last.add(getArg(i).treeCopyNoTransform()); 937 // build an array holding arguments 938 Access typeAccess = decl().lastParameter().type().elementType().createQualifiedAccess(); 939 for (int i = 0; i < decl().lastParameter().type().dimension(); i++) 940 typeAccess = new ArrayTypeAccess(typeAccess); 941 list.add(new ArrayCreationExpr(typeAccess, new Opt(new ArrayInit(last)))); 942 // replace argument list with augemented argument list 943 setArgList(list); 944 } 945 MethodDecl m = decl(); 946 947 948 /*if (!isQualified() && !m.isStatic()) { 949 TypeDecl typeDecl = hostType(); 950 while (typeDecl != null && !typeDecl.hasMethod(name())) { 951 typeDecl = typeDecl.enclosingType(); 952 } 953 ASTNode result = this.replaceWith(typeDecl.createQualifiedAccess().qualifiesAccess(new ThisAccess("this")).qualifiesAccess(new MethodAccess(name(), getArgList()))); 954 result.transformation(); 955 return; 956 }*/ 957 958 if (requiresAccessor()) { 959 /* Access to private methods in enclosing types: 960 The original MethodAccess is replaced with an access to an accessor method 961 built by createAccessor(). This method is built lazily and differs from 962 normal MethodDeclarations in the following ways: 963 1) The method in the class file should always be static and the signature 964 is thus changed to include a possible this reference as the first argument. 965 2) The method is always invoked using INVOKESTATIC 966 3) The flags must indicate that the method is static and package private 967 */ 968 super.transformation(); 969 this.replaceWith(decl().createAccessor(methodQualifierType()).createBoundAccess(getArgList())); 970 return; 971 } else if (!m.isStatic() && isQualified() 972 && prevExpr().isSuperAccess() 973 && !hostType().instanceOf(prevExpr().type()) 974 && !prevExpr().type().isInterfaceDecl()) { 975 decl().createSuperAccessor(superAccessorTarget()); 976 } 977 super.transformation(); 978 } 979 /** 980 * @aspect TypeAnalysis 981 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:310 982 */ 983 private TypeDecl refined_TypeAnalysis_MethodAccess_type() 984 { return decl().type(); } 985 /** 986 * @apilevel internal 987 */ 988 protected java.util.Map computeDAbefore_int_Variable_values; 989 /** 990 * @apilevel internal 991 */ 992 private void computeDAbefore_int_Variable_reset() { 993 computeDAbefore_int_Variable_values = null; 994 } 995 /** 996 * @attribute syn 997 * @aspect DA 998 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:451 999 */ 1000 @ASTNodeAnnotation.Attribute 1001 public boolean computeDAbefore(int i, Variable v) { 1002 java.util.List _parameters = new java.util.ArrayList(2); 1003 _parameters.add(i); 1004 _parameters.add(v); 1005 if (computeDAbefore_int_Variable_values == null) computeDAbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1006 ASTNode$State state = state(); 1007 if (computeDAbefore_int_Variable_values.containsKey(_parameters)) { 1008 return (Boolean) computeDAbefore_int_Variable_values.get(_parameters); 1009 } 1010 boolean intermediate = state.INTERMEDIATE_VALUE; 1011 state.INTERMEDIATE_VALUE = false; 1012 int num = state.boundariesCrossed; 1013 boolean isFinal = this.is$Final(); 1014 boolean computeDAbefore_int_Variable_value = i == 0 ? isDAbefore(v) : getArg(i-1).isDAafter(v); 1015 if (isFinal && num == state().boundariesCrossed) { 1016 computeDAbefore_int_Variable_values.put(_parameters, computeDAbefore_int_Variable_value); 1017 } else { 1018 } 1019 state.INTERMEDIATE_VALUE |= intermediate; 1020 1021 return computeDAbefore_int_Variable_value; 1022 } 1023 /** 1024 * @attribute syn 1025 * @aspect DA 1026 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259 1027 */ 1028 @ASTNodeAnnotation.Attribute 1029 public boolean isDAafter(Variable v) { 1030 boolean isDAafter_Variable_value = getNumArg() == 0 ? isDAbefore(v) : getArg(getNumArg()-1).isDAafter(v); 1031 1032 return isDAafter_Variable_value; 1033 } 1034 /** 1035 * @attribute syn 1036 * @aspect DA 1037 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:374 1038 */ 1039 @ASTNodeAnnotation.Attribute 1040 public boolean isDAafterTrue(Variable v) { 1041 boolean isDAafterTrue_Variable_value = isFalse() || (getNumArg() == 0 ? isDAbefore(v) : getArg(getNumArg()-1).isDAafter(v)); 1042 1043 return isDAafterTrue_Variable_value; 1044 } 1045 /** 1046 * @attribute syn 1047 * @aspect DA 1048 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:375 1049 */ 1050 @ASTNodeAnnotation.Attribute 1051 public boolean isDAafterFalse(Variable v) { 1052 boolean isDAafterFalse_Variable_value = isTrue() || (getNumArg() == 0 ? isDAbefore(v) : getArg(getNumArg()-1).isDAafter(v)); 1053 1054 return isDAafterFalse_Variable_value; 1055 } 1056 /** 1057 * @apilevel internal 1058 */ 1059 protected java.util.Map computeDUbefore_int_Variable_values; 1060 /** 1061 * @apilevel internal 1062 */ 1063 private void computeDUbefore_int_Variable_reset() { 1064 computeDUbefore_int_Variable_values = null; 1065 } 1066 /** 1067 * @attribute syn 1068 * @aspect DU 1069 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:959 1070 */ 1071 @ASTNodeAnnotation.Attribute 1072 public boolean computeDUbefore(int i, Variable v) { 1073 java.util.List _parameters = new java.util.ArrayList(2); 1074 _parameters.add(i); 1075 _parameters.add(v); 1076 if (computeDUbefore_int_Variable_values == null) computeDUbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1077 ASTNode$State state = state(); 1078 if (computeDUbefore_int_Variable_values.containsKey(_parameters)) { 1079 return (Boolean) computeDUbefore_int_Variable_values.get(_parameters); 1080 } 1081 boolean intermediate = state.INTERMEDIATE_VALUE; 1082 state.INTERMEDIATE_VALUE = false; 1083 int num = state.boundariesCrossed; 1084 boolean isFinal = this.is$Final(); 1085 boolean computeDUbefore_int_Variable_value = i == 0 ? isDUbefore(v) : getArg(i-1).isDUafter(v); 1086 if (isFinal && num == state().boundariesCrossed) { 1087 computeDUbefore_int_Variable_values.put(_parameters, computeDUbefore_int_Variable_value); 1088 } else { 1089 } 1090 state.INTERMEDIATE_VALUE |= intermediate; 1091 1092 return computeDUbefore_int_Variable_value; 1093 } 1094 /** 1095 * @attribute syn 1096 * @aspect DU 1097 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783 1098 */ 1099 @ASTNodeAnnotation.Attribute 1100 public boolean isDUafter(Variable v) { 1101 boolean isDUafter_Variable_value = getNumArg() == 0 ? isDUbefore(v) : getArg(getNumArg()-1).isDUafter(v); 1102 1103 return isDUafter_Variable_value; 1104 } 1105 /** 1106 * @attribute syn 1107 * @aspect DU 1108 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:791 1109 */ 1110 @ASTNodeAnnotation.Attribute 1111 public boolean isDUafterTrue(Variable v) { 1112 boolean isDUafterTrue_Variable_value = isFalse() || (getNumArg() == 0 ? isDUbefore(v) : getArg(getNumArg()-1).isDUafter(v)); 1113 1114 return isDUafterTrue_Variable_value; 1115 } 1116 /** 1117 * @attribute syn 1118 * @aspect DU 1119 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:792 1120 */ 1121 @ASTNodeAnnotation.Attribute 1122 public boolean isDUafterFalse(Variable v) { 1123 boolean isDUafterFalse_Variable_value = isTrue() || (getNumArg() == 0 ? isDUbefore(v) : getArg(getNumArg()-1).isDUafter(v)); 1124 1125 return isDUafterFalse_Variable_value; 1126 } 1127 /** 1128 * @apilevel internal 1129 */ 1130 protected boolean exceptionCollection_computed = false; 1131 /** 1132 * @apilevel internal 1133 */ 1134 protected Collection exceptionCollection_value; 1135 /** 1136 * @apilevel internal 1137 */ 1138 private void exceptionCollection_reset() { 1139 exceptionCollection_computed = false; 1140 exceptionCollection_value = null; 1141 } 1142 /** 1143 * @attribute syn 1144 * @aspect ExceptionHandling 1145 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:101 1146 */ 1147 @ASTNodeAnnotation.Attribute 1148 public Collection exceptionCollection() { 1149 ASTNode$State state = state(); 1150 if (exceptionCollection_computed) { 1151 return exceptionCollection_value; 1152 } 1153 boolean intermediate = state.INTERMEDIATE_VALUE; 1154 state.INTERMEDIATE_VALUE = false; 1155 int num = state.boundariesCrossed; 1156 boolean isFinal = this.is$Final(); 1157 exceptionCollection_value = exceptionCollection_compute(); 1158 if (isFinal && num == state().boundariesCrossed) { 1159 exceptionCollection_computed = true; 1160 } else { 1161 } 1162 state.INTERMEDIATE_VALUE |= intermediate; 1163 1164 return exceptionCollection_value; 1165 } 1166 /** 1167 * @apilevel internal 1168 */ 1169 private Collection exceptionCollection_compute() { 1170 //System.out.println("Computing exceptionCollection for " + name()); 1171 HashSet set = new HashSet(); 1172 Iterator iter = decls().iterator(); 1173 if (!iter.hasNext()) { 1174 return set; 1175 } 1176 1177 MethodDecl m = (MethodDecl) iter.next(); 1178 //System.out.println("Processing first found method " + m.signature() + " in " + m.hostType().fullName()); 1179 1180 for (int i = 0; i < m.getNumException(); i++) { 1181 TypeDecl exceptionType = m.getException(i).type(); 1182 set.add(exceptionType); 1183 } 1184 while (iter.hasNext()) { 1185 HashSet first = new HashSet(); 1186 first.addAll(set); 1187 HashSet second = new HashSet(); 1188 m = (MethodDecl) iter.next(); 1189 //System.out.println("Processing the next method " + m.signature() + " in " + m.hostType().fullName()); 1190 for (int i = 0; i < m.getNumException(); i++) { 1191 TypeDecl exceptionType = m.getException(i).type(); 1192 second.add(exceptionType); 1193 } 1194 set = new HashSet(); 1195 for (Iterator i1 = first.iterator(); i1.hasNext(); ) { 1196 TypeDecl firstType = (TypeDecl) i1.next(); 1197 for (Iterator i2 = second.iterator(); i2.hasNext(); ) { 1198 TypeDecl secondType = (TypeDecl) i2.next(); 1199 if (firstType.instanceOf(secondType)) { 1200 set.add(firstType); 1201 } else if (secondType.instanceOf(firstType)) { 1202 set.add(secondType); 1203 } 1204 } 1205 } 1206 } 1207 return set; 1208 } 1209 /** 1210 * @attribute syn 1211 * @aspect LookupMethod 1212 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:105 1213 */ 1214 @ASTNodeAnnotation.Attribute 1215 public MethodDecl singleCandidateDecl() { 1216 { 1217 MethodDecl result = null; 1218 for (Iterator iter = lookupMethod(name()).iterator(); iter.hasNext(); ) { 1219 MethodDecl m = (MethodDecl) iter.next(); 1220 if (result == null) { 1221 result = m; 1222 } else if (m.getNumParameter() == getNumArg() && result.getNumParameter() != getNumArg()) { 1223 result = m; 1224 } 1225 } 1226 return result; 1227 } 1228 } 1229 /** 1230 * @apilevel internal 1231 */ 1232 protected boolean decls_computed = false; 1233 /** 1234 * @apilevel internal 1235 */ 1236 protected SimpleSet decls_value; 1237 /** 1238 * @apilevel internal 1239 */ 1240 private void decls_reset() { 1241 decls_computed = false; 1242 decls_value = null; 1243 } 1244 /** 1245 * @attribute syn 1246 * @aspect LookupMethod 1247 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:138 1248 */ 1249 @ASTNodeAnnotation.Attribute 1250 public SimpleSet decls() { 1251 ASTNode$State state = state(); 1252 if (decls_computed) { 1253 return decls_value; 1254 } 1255 boolean intermediate = state.INTERMEDIATE_VALUE; 1256 state.INTERMEDIATE_VALUE = false; 1257 int num = state.boundariesCrossed; 1258 boolean isFinal = this.is$Final(); 1259 decls_value = decls_compute(); 1260 if (isFinal && num == state().boundariesCrossed) { 1261 decls_computed = true; 1262 } else { 1263 } 1264 state.INTERMEDIATE_VALUE |= intermediate; 1265 1266 return decls_value; 1267 } 1268 /** 1269 * @apilevel internal 1270 */ 1271 private SimpleSet decls_compute() { 1272 SimpleSet maxSpecific = maxSpecific(lookupMethod(name())); 1273 if (isQualified() ? qualifier().staticContextQualifier() : inStaticContext()) { 1274 maxSpecific = removeInstanceMethods(maxSpecific); 1275 } 1276 return maxSpecific; 1277 } 1278 /** 1279 * @apilevel internal 1280 */ 1281 protected boolean decl_computed = false; 1282 /** 1283 * @apilevel internal 1284 */ 1285 protected MethodDecl decl_value; 1286 /** 1287 * @apilevel internal 1288 */ 1289 private void decl_reset() { 1290 decl_computed = false; 1291 decl_value = null; 1292 } 1293 /** 1294 * @attribute syn 1295 * @aspect LookupMethod 1296 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:146 1297 */ 1298 @ASTNodeAnnotation.Attribute 1299 public MethodDecl decl() { 1300 ASTNode$State state = state(); 1301 if (decl_computed) { 1302 return decl_value; 1303 } 1304 boolean intermediate = state.INTERMEDIATE_VALUE; 1305 state.INTERMEDIATE_VALUE = false; 1306 int num = state.boundariesCrossed; 1307 boolean isFinal = this.is$Final(); 1308 decl_value = decl_compute(); 1309 if (isFinal && num == state().boundariesCrossed) { 1310 decl_computed = true; 1311 } else { 1312 } 1313 state.INTERMEDIATE_VALUE |= intermediate; 1314 1315 return decl_value; 1316 } 1317 /** 1318 * @apilevel internal 1319 */ 1320 private MethodDecl decl_compute() { 1321 SimpleSet decls = decls(); 1322 if (decls.size() == 1) { 1323 return (MethodDecl) decls.iterator().next(); 1324 } 1325 1326 // 8.4.6.4 - only return the first method in case of multply inherited abstract methods 1327 boolean allAbstract = true; 1328 for (Iterator iter = decls.iterator(); iter.hasNext() && allAbstract; ) { 1329 MethodDecl m = (MethodDecl) iter.next(); 1330 if (!m.isAbstract() && !m.hostType().isObject()) { 1331 allAbstract = false; 1332 } 1333 } 1334 if (decls.size() > 1 && allAbstract) { 1335 return (MethodDecl) decls.iterator().next(); 1336 } 1337 return unknownMethod(); 1338 } 1339 /** 1340 * @attribute syn 1341 * @aspect MethodDecl 1342 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:262 1343 */ 1344 @ASTNodeAnnotation.Attribute 1345 public boolean accessible(MethodDecl m) { 1346 { 1347 if (!isQualified()) { 1348 return true; 1349 } 1350 if (!m.accessibleFrom(hostType())) { 1351 return false; 1352 } 1353 // the method is not accessible if the type is not accessible 1354 if (!qualifier().type().accessibleFrom(hostType())) { 1355 return false; 1356 } 1357 // 6.6.2.1 - include qualifier type for protected access 1358 if (m.isProtected() && !m.hostPackage().equals(hostPackage()) 1359 && !m.isStatic() && !qualifier().isSuperAccess()) { 1360 return hostType().mayAccess(this, m); 1361 } 1362 return true; 1363 } 1364 } 1365 /** 1366 * @attribute syn 1367 * @aspect NameCheck 1368 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:88 1369 */ 1370 @ASTNodeAnnotation.Attribute 1371 public boolean validArgs() { 1372 { 1373 for (int i = 0; i < getNumArg(); i++) { 1374 if (!getArg(i).isPolyExpression() && getArg(i).type().isUnknown()) { 1375 return false; 1376 } 1377 } 1378 return true; 1379 } 1380 } 1381 /** 1382 * @attribute syn 1383 * @aspect Names 1384 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:37 1385 */ 1386 @ASTNodeAnnotation.Attribute 1387 public String name() { 1388 String name_value = getID(); 1389 1390 return name_value; 1391 } 1392 /** 1393 * @attribute syn 1394 * @aspect AccessTypes 1395 * @declaredat /home/jesper/git/extendj/java4/frontend/ResolveAmbiguousNames.jrag:39 1396 */ 1397 @ASTNodeAnnotation.Attribute 1398 public boolean isMethodAccess() { 1399 boolean isMethodAccess_value = true; 1400 1401 return isMethodAccess_value; 1402 } 1403 /** 1404 * Defines the expected kind of name for the left hand side in a qualified 1405 * expression. 1406 * @attribute syn 1407 * @aspect SyntacticClassification 1408 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:58 1409 */ 1410 @ASTNodeAnnotation.Attribute 1411 public NameType predNameType() { 1412 NameType predNameType_value = NameType.AMBIGUOUS_NAME; 1413 1414 return predNameType_value; 1415 } 1416 /** 1417 * @apilevel internal 1418 */ 1419 protected boolean type_computed = false; 1420 /** 1421 * @apilevel internal 1422 */ 1423 protected TypeDecl type_value; 1424 /** 1425 * @apilevel internal 1426 */ 1427 private void type_reset() { 1428 type_computed = false; 1429 type_value = null; 1430 } 1431 /** 1432 * @attribute syn 1433 * @aspect TypeAnalysis 1434 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302 1435 */ 1436 @ASTNodeAnnotation.Attribute 1437 public TypeDecl type() { 1438 ASTNode$State state = state(); 1439 if (type_computed) { 1440 return type_value; 1441 } 1442 boolean intermediate = state.INTERMEDIATE_VALUE; 1443 state.INTERMEDIATE_VALUE = false; 1444 int num = state.boundariesCrossed; 1445 boolean isFinal = this.is$Final(); 1446 type_value = type_compute(); 1447 if (isFinal && num == state().boundariesCrossed) { 1448 type_computed = true; 1449 } else { 1450 } 1451 state.INTERMEDIATE_VALUE |= intermediate; 1452 1453 return type_value; 1454 } 1455 /** 1456 * @apilevel internal 1457 */ 1458 private TypeDecl type_compute() { 1459 if (getNumArg() == 0 && name().equals("getClass") && decl().hostType().isObject()) { 1460 TypeDecl typeClass = lookupType("java.lang", "Class"); 1461 if (typeClass instanceof GenericClassDecl) { 1462 TypeDecl bound = isQualified() ? qualifier().type() : hostType(); 1463 ArrayList<TypeDecl> args = new ArrayList<TypeDecl>(); 1464 args.add(bound.erasure().asWildcardExtends()); 1465 return ((GenericClassDecl) typeClass).lookupParTypeDecl(args); 1466 } 1467 } 1468 // Legacy getClass access using non-generic java.lang.Class. 1469 return refined_TypeAnalysis_MethodAccess_type(); 1470 } 1471 /** 1472 * @attribute syn 1473 * @aspect InnerClasses 1474 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:445 1475 */ 1476 @ASTNodeAnnotation.Attribute 1477 public boolean requiresAccessor() { 1478 { 1479 MethodDecl m = decl(); 1480 if (m.isPrivate() && m.hostType() != hostType()) { 1481 return true; 1482 } 1483 if (m.isProtected() && !m.hostPackage().equals(hostPackage()) && !hostType().hasMethod(m.name())) { 1484 return true; 1485 } 1486 return false; 1487 } 1488 } 1489 /** 1490 * @attribute syn 1491 * @aspect MethodSignature15 1492 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:279 1493 */ 1494 @ASTNodeAnnotation.Attribute 1495 public boolean applicableBySubtyping(MethodDecl m) { 1496 { 1497 if (m.getNumParameter() != getNumArg()) { 1498 return false; 1499 } 1500 for (int i = 0; i < m.getNumParameter(); i++) { 1501 if (!getArg(i).pertinentToApplicability(this, m, i)) { 1502 continue; 1503 } else if (!getArg(i).compatibleStrictContext(m.getParameter(i).type())) { 1504 return false; 1505 } 1506 } 1507 return true; 1508 } 1509 } 1510 /** 1511 * @attribute syn 1512 * @aspect MethodSignature15 1513 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:319 1514 */ 1515 @ASTNodeAnnotation.Attribute 1516 public boolean applicableByMethodInvocationConversion(MethodDecl m) { 1517 { 1518 if (m.getNumParameter() != getNumArg()) { 1519 return false; 1520 } 1521 for (int i = 0; i < m.getNumParameter(); i++) { 1522 if (!getArg(i).pertinentToApplicability(this, m, i)) { 1523 continue; 1524 } else if (!getArg(i).compatibleLooseContext(m.getParameter(i).type())) { 1525 return false; 1526 } 1527 } 1528 return true; 1529 } 1530 } 1531 /** 1532 * @attribute syn 1533 * @aspect MethodSignature15 1534 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:343 1535 */ 1536 @ASTNodeAnnotation.Attribute 1537 public boolean applicableVariableArity(MethodDecl m) { 1538 { 1539 for (int i = 0; i < m.getNumParameter() - 1; i++) { 1540 if (!getArg(i).pertinentToApplicability(this, m, i)) { 1541 continue; 1542 } 1543 if (!getArg(i).compatibleLooseContext(m.getParameter(i).type())) { 1544 return false; 1545 } 1546 } 1547 for (int i = m.getNumParameter() - 1; i < getNumArg(); i++) { 1548 if (!getArg(i).pertinentToApplicability(this, m, i)) { 1549 continue; 1550 } 1551 if (!getArg(i).compatibleLooseContext(m.lastParameter().type().componentType())) { 1552 return false; 1553 } 1554 } 1555 return true; 1556 } 1557 } 1558 /** 1559 * A member method is potentially applicable to a method invocation if and 1560 * only if all of the following are true: 1561 * <ul> 1562 * <li>The name of the member is identical to the name of the method in the 1563 * method invocation. 1564 * <li>The member is accessible (\ufffd6.6) to the class or interface in which 1565 * the method invocation appears. 1566 * <li>The arity of the member is lesser or equal to the arity of the 1567 * method invocation. 1568 * <li>If the member is a variable arity method with arity n, the arity of 1569 * the method invocation is greater or equal to n-1. 1570 * <li>If the member is a fixed arity method with arity n, the arity of the 1571 * method invocation is equal to n. 1572 * <li>If the method invocation includes explicit type parameters, and the 1573 * member is a generic method, then the number of actual type parameters is 1574 * equal to the number of formal type parameters. 1575 * </ul> 1576 * @attribute syn 1577 * @aspect MethodSignature15 1578 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:438 1579 */ 1580 @ASTNodeAnnotation.Attribute 1581 public boolean potentiallyApplicable(MethodDecl m) { 1582 { 1583 if (!m.name().equals(name())) { 1584 return false; 1585 } 1586 if (!m.accessibleFrom(hostType())) { 1587 return false; 1588 } 1589 if (!m.isVariableArity()) { 1590 if (arity() != m.arity()) { 1591 return false; 1592 } 1593 for (int i = 0; i < getNumArg(); i++) { 1594 if (!getArg(i).potentiallyCompatible(m.getParameter(i).type(), m)) { 1595 return false; 1596 } 1597 } 1598 } 1599 if (m.isVariableArity()) { 1600 if (!(arity() >= m.arity()-1)) { 1601 return false; 1602 } 1603 for (int i = 0; i < m.arity() - 2; i++) { 1604 if (!getArg(i).potentiallyCompatible(m.getParameter(i).type(), m)) { 1605 return false; 1606 } 1607 } 1608 TypeDecl varArgType = m.getParameter(m.arity()-1).type(); 1609 if (arity() == m.arity()) { 1610 if (!getArg(arity()-1).potentiallyCompatible(varArgType, m) 1611 && !getArg(arity()-1).potentiallyCompatible(varArgType.componentType(), m)) { 1612 return false; 1613 } 1614 } else if (arity() > m.arity()) { 1615 for (int i = m.arity()-1; i < arity(); i++) { 1616 if (!getArg(i).potentiallyCompatible(varArgType.componentType(), m)) { 1617 return false; 1618 } 1619 } 1620 } 1621 } 1622 1623 if (m.isGeneric()) { 1624 GenericMethodDecl gm = m.genericDecl(); 1625 ArrayList<TypeDecl> typeArguments = inferTypeArguments( 1626 gm.type(), 1627 gm.getParameterList(), 1628 getArgList(), 1629 gm.getTypeParameterList()); 1630 if (!typeArguments.isEmpty()) { 1631 if (gm.getNumTypeParameter() != typeArguments.size()) { 1632 return false; 1633 } 1634 Parameterization par = new SimpleParameterization(gm.getTypeParameterList(), typeArguments); 1635 for (int i = 0; i < gm.getNumTypeParameter(); i++) { 1636 if (!((TypeDecl) typeArguments.get(i)).withinBounds(gm.original().getTypeParameter(i), par)) { 1637 return false; 1638 } 1639 } 1640 } 1641 } 1642 1643 return true; 1644 } 1645 } 1646 /** 1647 * @attribute syn 1648 * @aspect MethodSignature15 1649 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:474 1650 */ 1651 @ASTNodeAnnotation.Attribute 1652 public int arity() { 1653 int arity_value = getNumArg(); 1654 1655 return arity_value; 1656 } 1657 /** 1658 * @attribute syn 1659 * @aspect VariableArityParameters 1660 * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:61 1661 */ 1662 @ASTNodeAnnotation.Attribute 1663 public boolean invokesVariableArityAsArray() { 1664 { 1665 if (!decl().isVariableArity()) { 1666 return false; 1667 } 1668 if (arity() != decl().arity()) { 1669 return false; 1670 } 1671 return getArg(getNumArg()-1).type().methodInvocationConversionTo(decl().lastParameter().type()); 1672 } 1673 } 1674 /** 1675 * @attribute syn 1676 * @aspect PreciseRethrow 1677 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149 1678 */ 1679 @ASTNodeAnnotation.Attribute 1680 public boolean modifiedInScope(Variable var) { 1681 { 1682 for (int i = 0; i < getNumArg(); ++i) { 1683 if (getArg(i).modifiedInScope(var)) { 1684 return true; 1685 } 1686 } 1687 return false; 1688 } 1689 } 1690 /** 1691 * @apilevel internal 1692 */ 1693 protected boolean stmtCompatible_computed = false; 1694 /** 1695 * @apilevel internal 1696 */ 1697 protected boolean stmtCompatible_value; 1698 /** 1699 * @apilevel internal 1700 */ 1701 private void stmtCompatible_reset() { 1702 stmtCompatible_computed = false; 1703 } 1704 /** 1705 * @attribute syn 1706 * @aspect StmtCompatible 1707 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:145 1708 */ 1709 @ASTNodeAnnotation.Attribute 1710 public boolean stmtCompatible() { 1711 ASTNode$State state = state(); 1712 if (stmtCompatible_computed) { 1713 return stmtCompatible_value; 1714 } 1715 boolean intermediate = state.INTERMEDIATE_VALUE; 1716 state.INTERMEDIATE_VALUE = false; 1717 int num = state.boundariesCrossed; 1718 boolean isFinal = this.is$Final(); 1719 stmtCompatible_value = true; 1720 if (isFinal && num == state().boundariesCrossed) { 1721 stmtCompatible_computed = true; 1722 } else { 1723 } 1724 state.INTERMEDIATE_VALUE |= intermediate; 1725 1726 return stmtCompatible_value; 1727 } 1728 /** 1729 * @apilevel internal 1730 */ 1731 protected boolean isBooleanExpression_computed = false; 1732 /** 1733 * @apilevel internal 1734 */ 1735 protected boolean isBooleanExpression_value; 1736 /** 1737 * @apilevel internal 1738 */ 1739 private void isBooleanExpression_reset() { 1740 isBooleanExpression_computed = false; 1741 } 1742 /** 1743 * @attribute syn 1744 * @aspect PolyExpressions 1745 * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:29 1746 */ 1747 @ASTNodeAnnotation.Attribute 1748 public boolean isBooleanExpression() { 1749 ASTNode$State state = state(); 1750 if (isBooleanExpression_computed) { 1751 return isBooleanExpression_value; 1752 } 1753 boolean intermediate = state.INTERMEDIATE_VALUE; 1754 state.INTERMEDIATE_VALUE = false; 1755 int num = state.boundariesCrossed; 1756 boolean isFinal = this.is$Final(); 1757 isBooleanExpression_value = isBooleanExpression_compute(); 1758 if (isFinal && num == state().boundariesCrossed) { 1759 isBooleanExpression_computed = true; 1760 } else { 1761 } 1762 state.INTERMEDIATE_VALUE |= intermediate; 1763 1764 return isBooleanExpression_value; 1765 } 1766 /** 1767 * @apilevel internal 1768 */ 1769 private boolean isBooleanExpression_compute() { 1770 MethodDecl decl = decl(); 1771 if (decl instanceof ParMethodDecl) { 1772 return ((ParMethodDecl) decl).genericMethodDecl().type().isBoolean(); 1773 } else { 1774 return decl.type().isBoolean(); 1775 } 1776 } 1777 /** 1778 * @apilevel internal 1779 */ 1780 protected boolean isNumericExpression_computed = false; 1781 /** 1782 * @apilevel internal 1783 */ 1784 protected boolean isNumericExpression_value; 1785 /** 1786 * @apilevel internal 1787 */ 1788 private void isNumericExpression_reset() { 1789 isNumericExpression_computed = false; 1790 } 1791 /** 1792 * @attribute syn 1793 * @aspect PolyExpressions 1794 * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:59 1795 */ 1796 @ASTNodeAnnotation.Attribute 1797 public boolean isNumericExpression() { 1798 ASTNode$State state = state(); 1799 if (isNumericExpression_computed) { 1800 return isNumericExpression_value; 1801 } 1802 boolean intermediate = state.INTERMEDIATE_VALUE; 1803 state.INTERMEDIATE_VALUE = false; 1804 int num = state.boundariesCrossed; 1805 boolean isFinal = this.is$Final(); 1806 isNumericExpression_value = isNumericExpression_compute(); 1807 if (isFinal && num == state().boundariesCrossed) { 1808 isNumericExpression_computed = true; 1809 } else { 1810 } 1811 state.INTERMEDIATE_VALUE |= intermediate; 1812 1813 return isNumericExpression_value; 1814 } 1815 /** 1816 * @apilevel internal 1817 */ 1818 private boolean isNumericExpression_compute() { 1819 MethodDecl decl = decl(); 1820 if (decl instanceof ParMethodDecl) { 1821 return ((ParMethodDecl) decl).genericMethodDecl().type().isNumericType(); 1822 } else { 1823 return decl.type().isNumericType(); 1824 } 1825 } 1826 /** 1827 * @apilevel internal 1828 */ 1829 protected boolean isPolyExpression_computed = false; 1830 /** 1831 * @apilevel internal 1832 */ 1833 protected boolean isPolyExpression_value; 1834 /** 1835 * @apilevel internal 1836 */ 1837 private void isPolyExpression_reset() { 1838 isPolyExpression_computed = false; 1839 } 1840 /** 1841 * @attribute syn 1842 * @aspect PolyExpressions 1843 * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:80 1844 */ 1845 @ASTNodeAnnotation.Attribute 1846 public boolean isPolyExpression() { 1847 ASTNode$State state = state(); 1848 if (isPolyExpression_computed) { 1849 return isPolyExpression_value; 1850 } 1851 boolean intermediate = state.INTERMEDIATE_VALUE; 1852 state.INTERMEDIATE_VALUE = false; 1853 int num = state.boundariesCrossed; 1854 boolean isFinal = this.is$Final(); 1855 isPolyExpression_value = isPolyExpression_compute(); 1856 if (isFinal && num == state().boundariesCrossed) { 1857 isPolyExpression_computed = true; 1858 } else { 1859 } 1860 state.INTERMEDIATE_VALUE |= intermediate; 1861 1862 return isPolyExpression_value; 1863 } 1864 /** 1865 * @apilevel internal 1866 */ 1867 private boolean isPolyExpression_compute() { 1868 if (!assignmentContext() && !invocationContext()) { 1869 return false; 1870 } 1871 if (!decl().isGeneric()) { 1872 return false; 1873 } 1874 GenericMethodDecl genericDecl = decl().genericDecl(); 1875 return genericDecl.typeVariableInReturn(); 1876 } 1877 /** 1878 * @attribute inh 1879 * @aspect ExceptionHandling 1880 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:76 1881 */ 1882 /** 1883 * @attribute inh 1884 * @aspect ExceptionHandling 1885 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:76 1886 */ 1887 @ASTNodeAnnotation.Attribute 1888 public boolean handlesException(TypeDecl exceptionType) { 1889 boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType); 1890 1891 return handlesException_TypeDecl_value; 1892 } 1893 /** 1894 * @attribute inh 1895 * @aspect LookupMethod 1896 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:37 1897 */ 1898 /** 1899 * @attribute inh 1900 * @aspect LookupMethod 1901 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:37 1902 */ 1903 @ASTNodeAnnotation.Attribute 1904 public MethodDecl unknownMethod() { 1905 MethodDecl unknownMethod_value = getParent().Define_unknownMethod(this, null); 1906 1907 return unknownMethod_value; 1908 } 1909 /** 1910 * @attribute inh 1911 * @aspect TypeHierarchyCheck 1912 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:161 1913 */ 1914 /** 1915 * @attribute inh 1916 * @aspect TypeHierarchyCheck 1917 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:161 1918 */ 1919 @ASTNodeAnnotation.Attribute 1920 public boolean inExplicitConstructorInvocation() { 1921 boolean inExplicitConstructorInvocation_value = getParent().Define_inExplicitConstructorInvocation(this, null); 1922 1923 return inExplicitConstructorInvocation_value; 1924 } 1925 /** 1926 * @attribute inh 1927 * @aspect SuppressWarnings 1928 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:40 1929 */ 1930 /** 1931 * @attribute inh 1932 * @aspect SuppressWarnings 1933 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:40 1934 */ 1935 @ASTNodeAnnotation.Attribute 1936 public boolean withinSuppressWarnings(String annot) { 1937 boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot); 1938 1939 return withinSuppressWarnings_String_value; 1940 } 1941 /** 1942 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 1943 * @apilevel internal 1944 */ 1945 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1946 if (caller == getArgListNoTransform()) { 1947 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:450 1948 int i = caller.getIndexOfChild(child); 1949 return computeDAbefore(i, v); 1950 } 1951 else { 1952 return getParent().Define_isDAbefore(this, caller, v); 1953 } 1954 } 1955 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1956 return true; 1957 } 1958 /** 1959 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 1960 * @apilevel internal 1961 */ 1962 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 1963 if (caller == getArgListNoTransform()) { 1964 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:958 1965 int i = caller.getIndexOfChild(child); 1966 return computeDUbefore(i, v); 1967 } 1968 else { 1969 return getParent().Define_isDUbefore(this, caller, v); 1970 } 1971 } 1972 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 1973 return true; 1974 } 1975 /** 1976 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46 1977 * @apilevel internal 1978 */ 1979 public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) { 1980 if (caller == getArgListNoTransform()) { 1981 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:50 1982 int childIndex = caller.getIndexOfChild(child); 1983 return unqualifiedScope().lookupMethod(name); 1984 } 1985 else { 1986 return getParent().Define_lookupMethod(this, caller, name); 1987 } 1988 } 1989 protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) { 1990 return true; 1991 } 1992 /** 1993 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115 1994 * @apilevel internal 1995 */ 1996 public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) { 1997 if (caller == getArgListNoTransform()) { 1998 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:116 1999 int childIndex = caller.getIndexOfChild(child); 2000 return unqualifiedScope().hasPackage(packageName); 2001 } 2002 else { 2003 return getParent().Define_hasPackage(this, caller, packageName); 2004 } 2005 } 2006 protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) { 2007 return true; 2008 } 2009 /** 2010 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197 2011 * @apilevel internal 2012 */ 2013 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 2014 if (caller == getArgListNoTransform()) { 2015 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:330 2016 int childIndex = caller.getIndexOfChild(child); 2017 return unqualifiedScope().lookupType(name); 2018 } 2019 else { 2020 return getParent().Define_lookupType(this, caller, name); 2021 } 2022 } 2023 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 2024 return true; 2025 } 2026 /** 2027 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 2028 * @apilevel internal 2029 */ 2030 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 2031 if (caller == getArgListNoTransform()) { 2032 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:218 2033 int childIndex = caller.getIndexOfChild(child); 2034 return unqualifiedScope().lookupVariable(name); 2035 } 2036 else { 2037 return getParent().Define_lookupVariable(this, caller, name); 2038 } 2039 } 2040 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 2041 return true; 2042 } 2043 /** 2044 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 2045 * @apilevel internal 2046 */ 2047 public NameType Define_nameType(ASTNode caller, ASTNode child) { 2048 if (caller == getArgListNoTransform()) { 2049 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:143 2050 int childIndex = caller.getIndexOfChild(child); 2051 return NameType.EXPRESSION_NAME; 2052 } 2053 else { 2054 return getParent().Define_nameType(this, caller); 2055 } 2056 } 2057 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 2058 return true; 2059 } 2060 /** 2061 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:32 2062 * @apilevel internal 2063 */ 2064 public String Define_methodHost(ASTNode caller, ASTNode child) { 2065 int childIndex = this.getIndexOfChild(caller); 2066 return unqualifiedScope().methodHost(); 2067 } 2068 protected boolean canDefine_methodHost(ASTNode caller, ASTNode child) { 2069 return true; 2070 } 2071 /** 2072 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:58 2073 * @apilevel internal 2074 */ 2075 public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) { 2076 if (caller == getArgListNoTransform()) { 2077 // @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:66 2078 int childIndex = caller.getIndexOfChild(child); 2079 return typeObject(); 2080 } 2081 else { 2082 return getParent().Define_assignConvertedType(this, caller); 2083 } 2084 } 2085 protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) { 2086 return true; 2087 } 2088 /** 2089 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30 2090 * @apilevel internal 2091 */ 2092 public TypeDecl Define_targetType(ASTNode caller, ASTNode child) { 2093 if (caller == getArgListNoTransform()) { 2094 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:87 2095 int i = caller.getIndexOfChild(child); 2096 { 2097 MethodDecl decl = decl(); 2098 if (decl.unknownMethod() == decl) { 2099 return decl.type().unknownType(); 2100 } 2101 2102 if (decl.isVariableArity() && i >= decl.arity() - 1) { 2103 return decl.getParameter(decl.arity() - 1).type().componentType(); 2104 } else { 2105 return decl.getParameter(i).type(); 2106 } 2107 } 2108 } 2109 else { 2110 return getParent().Define_targetType(this, caller); 2111 } 2112 } 2113 protected boolean canDefine_targetType(ASTNode caller, ASTNode child) { 2114 return true; 2115 } 2116 /** 2117 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 2118 * @apilevel internal 2119 */ 2120 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 2121 if (caller == getArgListNoTransform()) { 2122 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:331 2123 int childIndex = caller.getIndexOfChild(child); 2124 return false; 2125 } 2126 else { 2127 return getParent().Define_assignmentContext(this, caller); 2128 } 2129 } 2130 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 2131 return true; 2132 } 2133 /** 2134 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 2135 * @apilevel internal 2136 */ 2137 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 2138 if (caller == getArgListNoTransform()) { 2139 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:332 2140 int childIndex = caller.getIndexOfChild(child); 2141 return true; 2142 } 2143 else { 2144 return getParent().Define_invocationContext(this, caller); 2145 } 2146 } 2147 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 2148 return true; 2149 } 2150 /** 2151 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 2152 * @apilevel internal 2153 */ 2154 public boolean Define_castContext(ASTNode caller, ASTNode child) { 2155 if (caller == getArgListNoTransform()) { 2156 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:333 2157 int childIndex = caller.getIndexOfChild(child); 2158 return false; 2159 } 2160 else { 2161 return getParent().Define_castContext(this, caller); 2162 } 2163 } 2164 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 2165 return true; 2166 } 2167 /** 2168 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 2169 * @apilevel internal 2170 */ 2171 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 2172 if (caller == getArgListNoTransform()) { 2173 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:334 2174 int childIndex = caller.getIndexOfChild(child); 2175 return false; 2176 } 2177 else { 2178 return getParent().Define_stringContext(this, caller); 2179 } 2180 } 2181 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 2182 return true; 2183 } 2184 /** 2185 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 2186 * @apilevel internal 2187 */ 2188 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 2189 if (caller == getArgListNoTransform()) { 2190 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:335 2191 int childIndex = caller.getIndexOfChild(child); 2192 return false; 2193 } 2194 else { 2195 return getParent().Define_numericContext(this, caller); 2196 } 2197 } 2198 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 2199 return true; 2200 } 2201 /** 2202 * @apilevel internal 2203 */ 2204 public ASTNode rewriteTo() { 2205 return super.rewriteTo(); 2206 } 2207 }