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:92 027 * @production MethodDecl : {@link MemberDecl} ::= <span class="component">{@link Modifiers}</span> <span class="component">TypeAccess:{@link Access}</span> <span class="component"><ID:String></span> <span class="component">Parameter:{@link ParameterDeclaration}*</span> <span class="component">Exception:{@link Access}*</span> <span class="component">[{@link Block}]</span>; 028 029 */ 030 public class MethodDecl extends MemberDecl implements Cloneable, SimpleSet, Iterator, ExceptionHolder { 031 /** 032 * @aspect BoundNames 033 * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:97 034 */ 035 public Access createBoundAccess(List args) { 036 if (isStatic()) { 037 return hostType().createQualifiedAccess().qualifiesAccess( 038 new BoundMethodAccess(name(), args, this) 039 ); 040 } 041 return new BoundMethodAccess(name(), args, this); 042 } 043 /** 044 * @aspect DataStructures 045 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:177 046 */ 047 public SimpleSet add(Object o) { 048 return new SimpleSetImpl().add(this).add(o); 049 } 050 /** 051 * @aspect DataStructures 052 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:181 053 */ 054 public boolean isSingleton() { return true; } 055 /** 056 * @aspect DataStructures 057 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:182 058 */ 059 public boolean isSingleton(Object o) { return contains(o); } 060 /** 061 * @aspect DataStructures 062 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:185 063 */ 064 private MethodDecl iterElem; 065 /** 066 * @aspect DataStructures 067 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:186 068 */ 069 public Iterator iterator() { iterElem = this; return this; } 070 /** 071 * @aspect DataStructures 072 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:187 073 */ 074 public boolean hasNext() { return iterElem != null; } 075 /** 076 * @aspect DataStructures 077 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:188 078 */ 079 public Object next() { Object o = iterElem; iterElem = null; return o; } 080 /** 081 * @aspect DataStructures 082 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:189 083 */ 084 public void remove() { throw new UnsupportedOperationException(); } 085 /** 086 * @aspect NameCheck 087 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:131 088 */ 089 public void nameCheck() { 090 // 8.4 091 // 8.4.2 092 if (hostType().methodsSignature(signature()).size() > 1) { 093 errorf("method with signature %s is multiply declared in type %s", signature(), 094 hostType().typeName()); 095 } 096 // 8.4.3.4 097 if (isNative() && hasBlock()) { 098 error("native methods must have an empty semicolon body"); 099 } 100 // 8.4.5 101 if (isAbstract() && hasBlock()) { 102 error("abstract methods must have an empty semicolon body"); 103 } 104 // 8.4.5 105 if (!hasBlock() && !(isNative() || isAbstract())) { 106 error("only abstract and native methods may have an empty semicolon body"); 107 } 108 } 109 /** 110 * @aspect Java4PrettyPrint 111 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:66 112 */ 113 public void prettyPrint(PrettyPrinter out) { 114 if (hasDocComment()) { 115 out.print(docComment()); 116 } 117 if (!out.isNewLine()) { 118 out.println(); 119 } 120 out.print(getModifiers()); 121 out.print(getTypeAccess()); 122 out.print(" "); 123 out.print(getID()); 124 out.print("("); 125 out.join(getParameterList(), new PrettyPrinter.Joiner() { 126 @Override 127 public void printSeparator(PrettyPrinter out) { 128 out.print(", "); 129 } 130 }); 131 out.print(")"); 132 if (hasExceptions()) { 133 out.print(" throws "); 134 out.join(getExceptionList(), new PrettyPrinter.Joiner() { 135 @Override 136 public void printSeparator(PrettyPrinter out) { 137 out.print(", "); 138 } 139 }); 140 } 141 if (hasBlock()) { 142 out.print(" "); 143 out.print(getBlock()); 144 } else { 145 out.print(";"); 146 } 147 } 148 /** 149 * @aspect TypeCheck 150 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:453 151 */ 152 public void typeCheck() { 153 // Thrown vs super class method see MethodDecl.nameCheck 154 // 8.4.4 155 TypeDecl exceptionType = typeThrowable(); 156 for (int i = 0; i < getNumException(); i++) { 157 TypeDecl typeDecl = getException(i).type(); 158 if (!typeDecl.instanceOf(exceptionType)) { 159 errorf("%s throws non throwable type %s", signature(), typeDecl.fullName()); 160 } 161 } 162 163 // check returns 164 if (!isVoid() && hasBlock() && getBlock().canCompleteNormally()) { 165 error("the body of a non void method may not complete normally"); 166 } 167 168 } 169 /** 170 * @aspect CodeGeneration 171 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:504 172 */ 173 public void emitInvokeMethod(CodeGeneration gen, TypeDecl hostType) { 174 if (hostType.isInterfaceDecl()) { 175 String classname = hostType.constantPoolName(); 176 String desc = descName(); 177 String name = name(); 178 int index = gen.constantPool().addInterfaceMethodref(classname, name, desc); 179 int numArg = 1; // instance 180 for (int i = 0; i < getNumParameter(); i++) { 181 numArg += getParameter(i).type().variableSize(); 182 } 183 int stackChange = type().variableSize() - numArg; 184 gen.emit(Bytecode.INVOKEINTERFACE, stackChange) 185 .add2(index).add(numArg).add(0); 186 } else { 187 String classname = hostType.constantPoolName(); 188 String desc = descName(); 189 String name = name(); 190 int index = gen.constantPool().addMethodref(classname, name, desc); 191 int stackChange = type().variableSize(); 192 for (int i = 0; i < getNumParameter(); i++) { 193 stackChange -= getParameter(i).type().variableSize(); 194 } 195 if (isStatic()) { 196 gen.emit(Bytecode.INVOKESTATIC, stackChange).add2(index); 197 } else { 198 stackChange -= 1; 199 gen.emit(Bytecode.INVOKEVIRTUAL, stackChange).add2(index); 200 } 201 } 202 } 203 /** 204 * @aspect CodeGeneration 205 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:535 206 */ 207 public void emitInvokeSpecialMethod(CodeGeneration gen, TypeDecl hostType) { 208 String classname = hostType.constantPoolName(); 209 String desc = descName(); 210 String name = name(); 211 int index = gen.constantPool().addMethodref(classname, name, desc); 212 int stackChange = type().variableSize() - 1; 213 for (int i = 0; i < getNumParameter(); i++) { 214 stackChange -= getParameter(i).type().variableSize(); 215 } 216 gen.emit(Bytecode.INVOKESPECIAL, stackChange).add2(index); 217 } 218 /** 219 * @aspect CreateBCode 220 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:106 221 */ 222 private void generateBytecodes(CodeGeneration gen) { 223 int label = gen.variableScopeLabel(); 224 int paramLength = 0; 225 if (!isStatic()) { 226 paramLength += 1; 227 gen.addLocalVariableEntryAtCurrentPC("this", hostType().typeDescriptor(), 0, label); 228 } 229 for (ParameterDeclaration p: getParameterList()) { 230 paramLength += p.type().variableSize(); 231 if (paramLength > 255) { 232 throw new Error("parameter list too large"); 233 } 234 gen.addLocalVariableEntryAtCurrentPC( 235 p.name(), p.type().typeDescriptor(), p.localNum(), label 236 ); 237 } 238 createBCode(gen); 239 if (type() instanceof VoidType) // TODO: canCompleteNormally check as well 240 gen.emitReturn(); 241 gen.addVariableScopeLabel(label); 242 } 243 /** 244 * @aspect CreateBCode 245 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:160 246 */ 247 public void createBCode(CodeGeneration gen) { 248 try { 249 if (hasBlock()) { 250 gen.maxLocals = Math.max(gen.maxLocals, getBlock().localNum()); 251 getBlock().createBCode(gen); 252 } 253 } catch (Error e) { 254 System.err.println(hostType().typeName() + ": " + this); 255 throw e; 256 } 257 } 258 /** 259 * @aspect GenerateClassfile 260 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:283 261 */ 262 public void generateMethod(DataOutputStream out, ConstantPool cp) throws IOException { 263 out.writeChar(flags()); 264 out.writeChar(cp.addUtf8(name())); 265 out.writeChar(cp.addUtf8(descName())); 266 out.writeChar(attributes().size()); 267 for (Iterator itera = attributes().iterator(); itera.hasNext();) { 268 ((Attribute) itera.next()).emit(out); 269 } 270 } 271 /** 272 * @aspect GenerateClassfile 273 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:305 274 */ 275 public void touchMethod(ConstantPool cp) { 276 cp.addUtf8(name()); 277 cp.addUtf8(descName()); 278 attributes(); 279 } 280 /** 281 * @aspect GenerateClassfile 282 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:420 283 */ 284 public boolean clear() { 285 if (hasBlock()) { 286 getBlock().clear(); 287 setBlock(new Block(new List())); 288 } 289 bytecodes_ConstantPool_values = null; 290 return false; 291 } 292 /** 293 * @aspect InnerClasses 294 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:240 295 */ 296 public MethodDecl createAccessor(TypeDecl methodQualifier) { 297 MethodDecl m = (MethodDecl) methodQualifier.getAccessor(this, "method"); 298 if (m != null) { 299 return m; 300 } 301 302 int accessorIndex = methodQualifier.accessorCounter++; 303 304 List parameterList = new List(); 305 for (int i = 0; i < getNumParameter(); i++) { 306 parameterList.add(new ParameterDeclaration( 307 // We don't need to create a qualified access to the type here 308 // since there can be no ambiguity concerning unqualified 309 // type names in an inner/enclosing class 310 // Jesper 2012-05-04 311 // FALSE! We need to create a qualified access in case the 312 // method we are generating an access for is not declared 313 // in the methodQualifier type 314 getParameter(i).type().createQualifiedAccess(), 315 getParameter(i).name())); 316 } 317 List exceptionList = new List(); 318 for (int i = 0; i < getNumException(); i++) { 319 exceptionList.add((Access) getException(i).treeCopyNoTransform()); 320 } 321 322 // add synthetic flag to modifiers 323 Modifiers modifiers = new Modifiers(new List()); 324 if (getModifiers().isStatic()) { 325 modifiers.addModifier(new Modifier("static")); 326 } 327 modifiers.addModifier(new Modifier("synthetic")); 328 modifiers.addModifier(new Modifier("public")); 329 // build accessor declaration 330 m = new MethodDecl( 331 modifiers, 332 getTypeAccess().type().createQualifiedAccess(), 333 name() + "$access$" + accessorIndex, 334 parameterList, 335 exceptionList, 336 new Opt( 337 new Block( 338 new List().add( 339 createAccessorStmt() 340 ) 341 ) 342 ) 343 ); 344 m = methodQualifier.addMemberMethod(m); 345 methodQualifier.addAccessor(this, "method", m); 346 return m; 347 } 348 /** 349 * @aspect InnerClasses 350 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:293 351 */ 352 private Stmt createAccessorStmt() { 353 List argumentList = new List(); 354 for (int i = 0; i < getNumParameter(); i++) { 355 argumentList.add(new VarAccess(getParameter(i).name())); 356 } 357 Access access = new BoundMethodAccess(name(), argumentList, this); 358 if (!isStatic()) { 359 access = new ThisAccess("this").qualifiesAccess(access); 360 } 361 return isVoid() ? (Stmt) new ExprStmt(access) : new ReturnStmt(new Opt(access)); 362 } 363 /** 364 * @aspect InnerClasses 365 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:305 366 */ 367 public MethodDecl createSuperAccessor(TypeDecl methodQualifier) { 368 MethodDecl m = (MethodDecl) methodQualifier.getAccessor(this, "method_super"); 369 if (m != null) { 370 return m; 371 } 372 373 int accessorIndex = methodQualifier.accessorCounter++; 374 List parameters = new List(); 375 List args = new List(); 376 for (int i = 0; i < getNumParameter(); i++) { 377 parameters.add(new ParameterDeclaration(getParameter(i).type(), getParameter(i).name())); 378 args.add(new VarAccess(getParameter(i).name())); 379 } 380 Stmt stmt; 381 if (type().isVoid()) { 382 stmt = new ExprStmt(new SuperAccess("super").qualifiesAccess(new MethodAccess(name(), args))); 383 } else { 384 stmt = new ReturnStmt(new Opt(new SuperAccess("super").qualifiesAccess(new MethodAccess(name(), args)))); 385 } 386 m = new MethodDecl( 387 new Modifiers(new List().add(new Modifier("synthetic"))), 388 type().createQualifiedAccess(), 389 name() + "$access$" + accessorIndex, 390 parameters, 391 new List(), 392 new Opt( 393 new Block( 394 new List().add(stmt) 395 ) 396 ) 397 ); 398 m = methodQualifier.addMemberMethod(m); 399 methodQualifier.addAccessor(this, "method_super", m); 400 return m; 401 } 402 /** 403 * @aspect LookupParTypeDecl 404 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1365 405 */ 406 public BodyDecl substitutedBodyDecl(Parameterization parTypeDecl) { 407 MethodDecl m = new MethodDeclSubstituted( 408 (Modifiers) getModifiers().treeCopyNoTransform(), 409 getTypeAccess().type().substituteReturnType(parTypeDecl), 410 getID(), 411 getParameterList().substitute(parTypeDecl), 412 getExceptionList().substitute(parTypeDecl), 413 substituteBody(parTypeDecl), 414 this 415 ); 416 return m; 417 } 418 /** 419 * @aspect LookupParTypeDecl 420 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1378 421 */ 422 public Opt substituteBody(Parameterization parTypeDecl) { 423 return new Opt(); 424 } 425 /** 426 * @aspect AnnotationsCodegen 427 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:110 428 */ 429 public void addRuntimeVisibleParameterAnnotationsAttribute(Collection c) { 430 boolean foundVisibleAnnotations = false; 431 Collection annotations = new ArrayList(getNumParameter()); 432 for (int i = 0; i < getNumParameter(); i++) { 433 Collection a = getParameter(i).getModifiers().runtimeVisibleAnnotations(); 434 if (!a.isEmpty()) { 435 foundVisibleAnnotations = true; 436 } 437 annotations.add(a); 438 } 439 if (foundVisibleAnnotations) { 440 c.add(new ParameterAnnotationsAttribute(hostType().constantPool(), annotations, "RuntimeVisibleParameterAnnotations")); 441 } 442 } 443 /** 444 * @aspect AnnotationsCodegen 445 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:136 446 */ 447 public void addRuntimeInvisibleParameterAnnotationsAttribute(Collection c) { 448 boolean foundInvisibleAnnotations = false; 449 Collection annotations = new ArrayList(getNumParameter()); 450 for (int i = 0; i < getNumParameter(); i++) { 451 Collection a = getParameter(i).getModifiers().runtimeInvisibleAnnotations(); 452 if (!a.isEmpty()) { 453 foundInvisibleAnnotations = true; 454 } 455 annotations.add(a); 456 } 457 if (foundInvisibleAnnotations) { 458 c.add(new ParameterAnnotationsAttribute(hostType().constantPool(), annotations, "RuntimeInvisibleParameterAnnotations")); 459 } 460 } 461 /** 462 * @aspect GenericsCodegen 463 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:238 464 */ 465 public void transformation() { 466 super.transformation(); 467 HashSet processed = new HashSet(); 468 for (Iterator iter = hostType().bridgeCandidates(signature()).iterator(); iter.hasNext(); ) { 469 MethodDecl m = (MethodDecl) iter.next(); 470 if (this.overrides(m)) { 471 MethodDecl erased = m.erasedMethod(); 472 if (!erased.signature().equals(signature()) || erased.type().erasure() != type().erasure()) { 473 StringBuilder keyBuffer = new StringBuilder(); 474 for (int i = 0; i < getNumParameter(); i++) { 475 keyBuffer.append(erased.getParameter(i).type().erasure().fullName()); 476 } 477 keyBuffer.append(erased.type().erasure().fullName()); 478 String key = keyBuffer.toString(); 479 if (!processed.contains(key)) { 480 processed.add(key); 481 482 List args = new List(); 483 List parameters = new List(); 484 for (int i = 0; i < getNumParameter(); i++) { 485 args.add(new CastExpr(getParameter(i).type().erasure().createBoundAccess(), new VarAccess("p" + i))); 486 parameters.add(new ParameterDeclaration(erased.getParameter(i).type().erasure(), "p" + i)); 487 } 488 Stmt stmt; 489 if (type().isVoid()) { 490 stmt = new ExprStmt( 491 createBoundAccess( 492 args 493 ) 494 ); 495 } else { 496 stmt = new ReturnStmt( 497 createBoundAccess( 498 args 499 ) 500 ); 501 } 502 List modifiersList = new List(); 503 if (isPublic()) { 504 modifiersList.add(new Modifier("public")); 505 } else if (isProtected()) { 506 modifiersList.add(new Modifier("protected")); 507 } else if (isPrivate()) { 508 modifiersList.add(new Modifier("private")); 509 } 510 MethodDecl bridge = new BridgeMethodDecl( 511 new Modifiers(modifiersList), 512 erased.type().erasure().createBoundAccess(), 513 erased.name(), 514 parameters, 515 (List) getExceptionList().treeCopyNoTransform(), 516 new Opt( 517 new Block( 518 new List().add(stmt) 519 ) 520 ) 521 ); 522 hostType().addBodyDecl(bridge); 523 } 524 } 525 } 526 } 527 } 528 /** 529 * Check if the method is missing a SafeVarargs annotation. 530 * @aspect SafeVarargs 531 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:117 532 */ 533 public void checkWarnings() { 534 // Check for illegal use of @SafeVarargs. 535 super.checkWarnings(); 536 537 if (!suppressWarnings("unchecked") 538 && !hasAnnotationSafeVarargs() 539 && isVariableArity() 540 && !getParameter(getNumParameter()-1).type().isReifiable()) { 541 warning("possible heap pollution for " 542 + "variable arity parameter"); 543 } 544 } 545 /** 546 * Checks that the argument exception is a subtype to all exceptions 547 * in the methods throws-clause. This takes the position of the type 548 * parameters into account. 549 * @aspect FunctionDescriptor 550 * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionDescriptor.jrag:209 551 */ 552 public boolean subtypeThrowsClause(Access exception) { 553 boolean foundCompatible = false; 554 for (Access throwsException : getExceptionList()) { 555 if (exception.type().strictSubtype(throwsException.type())) { 556 foundCompatible = true; 557 break; 558 } 559 } 560 return foundCompatible; 561 } 562 /** 563 * Checks that the argument exception is a subtype to all exceptions 564 * in the methods throws-clause. Performs erasure on all types before 565 * comparing them. 566 * @aspect FunctionDescriptor 567 * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionDescriptor.jrag:225 568 */ 569 public boolean subtypeThrowsClauseErased(Access exception) { 570 boolean foundCompatible = false; 571 for (Access throwsException : getExceptionList()) { 572 if (exception.type().erasure().strictSubtype(throwsException.type().erasure())) { 573 foundCompatible = true; 574 break; 575 } 576 } 577 return foundCompatible; 578 } 579 /** 580 * @declaredat ASTNode:1 581 */ 582 public MethodDecl() { 583 super(); 584 } 585 /** 586 * Initializes the child array to the correct size. 587 * Initializes List and Opt nta children. 588 * @apilevel internal 589 * @ast method 590 * @declaredat ASTNode:10 591 */ 592 public void init$Children() { 593 children = new ASTNode[5]; 594 setChild(new List(), 2); 595 setChild(new List(), 3); 596 setChild(new Opt(), 4); 597 } 598 /** 599 * @declaredat ASTNode:16 600 */ 601 public MethodDecl(Modifiers p0, Access p1, String p2, List<ParameterDeclaration> p3, List<Access> p4, Opt<Block> p5) { 602 setChild(p0, 0); 603 setChild(p1, 1); 604 setID(p2); 605 setChild(p3, 2); 606 setChild(p4, 3); 607 setChild(p5, 4); 608 } 609 /** 610 * @declaredat ASTNode:24 611 */ 612 public MethodDecl(Modifiers p0, Access p1, beaver.Symbol p2, List<ParameterDeclaration> p3, List<Access> p4, Opt<Block> p5) { 613 setChild(p0, 0); 614 setChild(p1, 1); 615 setID(p2); 616 setChild(p3, 2); 617 setChild(p4, 3); 618 setChild(p5, 4); 619 } 620 /** 621 * @apilevel low-level 622 * @declaredat ASTNode:35 623 */ 624 protected int numChildren() { 625 return 5; 626 } 627 /** 628 * @apilevel internal 629 * @declaredat ASTNode:41 630 */ 631 public boolean mayHaveRewrite() { 632 return false; 633 } 634 /** 635 * @apilevel internal 636 * @declaredat ASTNode:47 637 */ 638 public void flushAttrCache() { 639 super.flushAttrCache(); 640 accessibleFrom_TypeDecl_reset(); 641 throwsException_TypeDecl_reset(); 642 signature_reset(); 643 lessSpecificThan_MethodDecl_reset(); 644 overrideCandidate_MethodDecl_reset(); 645 overrides_MethodDecl_reset(); 646 hides_MethodDecl_reset(); 647 parameterDeclaration_String_reset(); 648 type_reset(); 649 attributes_reset(); 650 descName_reset(); 651 bytecodes_ConstantPool_reset(); 652 flags_reset(); 653 offsetBeforeParameters_reset(); 654 offsetAfterParameters_reset(); 655 resultOffset_reset(); 656 usesTypeVariable_reset(); 657 sourceMethodDecl_reset(); 658 subsignatureTo_MethodDecl_reset(); 659 returnTypeSubstitutableFor_MethodDecl_reset(); 660 isDefault_reset(); 661 handlesException_TypeDecl_reset(); 662 } 663 /** 664 * @apilevel internal 665 * @declaredat ASTNode:75 666 */ 667 public void flushCollectionCache() { 668 super.flushCollectionCache(); 669 } 670 /** 671 * @apilevel internal 672 * @declaredat ASTNode:81 673 */ 674 public void flushRewriteCache() { 675 super.flushRewriteCache(); 676 } 677 /** 678 * @apilevel internal 679 * @declaredat ASTNode:87 680 */ 681 public MethodDecl clone() throws CloneNotSupportedException { 682 MethodDecl node = (MethodDecl) super.clone(); 683 return node; 684 } 685 /** 686 * @apilevel internal 687 * @declaredat ASTNode:94 688 */ 689 public MethodDecl copy() { 690 try { 691 MethodDecl node = (MethodDecl) clone(); 692 node.parent = null; 693 if (children != null) { 694 node.children = (ASTNode[]) children.clone(); 695 } 696 return node; 697 } catch (CloneNotSupportedException e) { 698 throw new Error("Error: clone not supported for " + getClass().getName()); 699 } 700 } 701 /** 702 * Create a deep copy of the AST subtree at this node. 703 * The copy is dangling, i.e. has no parent. 704 * @return dangling copy of the subtree at this node 705 * @apilevel low-level 706 * @deprecated Please use treeCopy or treeCopyNoTransform instead 707 * @declaredat ASTNode:113 708 */ 709 @Deprecated 710 public MethodDecl fullCopy() { 711 return treeCopyNoTransform(); 712 } 713 /** 714 * Create a deep copy of the AST subtree at this node. 715 * The copy is dangling, i.e. has no parent. 716 * @return dangling copy of the subtree at this node 717 * @apilevel low-level 718 * @declaredat ASTNode:123 719 */ 720 public MethodDecl treeCopyNoTransform() { 721 MethodDecl tree = (MethodDecl) copy(); 722 if (children != null) { 723 for (int i = 0; i < children.length; ++i) { 724 ASTNode child = (ASTNode) children[i]; 725 if (child != null) { 726 child = child.treeCopyNoTransform(); 727 tree.setChild(child, i); 728 } 729 } 730 } 731 return tree; 732 } 733 /** 734 * Create a deep copy of the AST subtree at this node. 735 * The subtree of this node is traversed to trigger rewrites before copy. 736 * The copy is dangling, i.e. has no parent. 737 * @return dangling copy of the subtree at this node 738 * @apilevel low-level 739 * @declaredat ASTNode:143 740 */ 741 public MethodDecl treeCopy() { 742 doFullTraversal(); 743 return treeCopyNoTransform(); 744 } 745 /** 746 * @apilevel internal 747 * @declaredat ASTNode:150 748 */ 749 protected boolean is$Equal(ASTNode node) { 750 return super.is$Equal(node) && (tokenString_ID == ((MethodDecl)node).tokenString_ID); 751 } 752 /** 753 * Replaces the Modifiers child. 754 * @param node The new node to replace the Modifiers child. 755 * @apilevel high-level 756 */ 757 public void setModifiers(Modifiers node) { 758 setChild(node, 0); 759 } 760 /** 761 * Retrieves the Modifiers child. 762 * @return The current node used as the Modifiers child. 763 * @apilevel high-level 764 */ 765 @ASTNodeAnnotation.Child(name="Modifiers") 766 public Modifiers getModifiers() { 767 return (Modifiers) getChild(0); 768 } 769 /** 770 * Retrieves the Modifiers child. 771 * <p><em>This method does not invoke AST transformations.</em></p> 772 * @return The current node used as the Modifiers child. 773 * @apilevel low-level 774 */ 775 public Modifiers getModifiersNoTransform() { 776 return (Modifiers) getChildNoTransform(0); 777 } 778 /** 779 * Replaces the TypeAccess child. 780 * @param node The new node to replace the TypeAccess child. 781 * @apilevel high-level 782 */ 783 public void setTypeAccess(Access node) { 784 setChild(node, 1); 785 } 786 /** 787 * Retrieves the TypeAccess child. 788 * @return The current node used as the TypeAccess child. 789 * @apilevel high-level 790 */ 791 @ASTNodeAnnotation.Child(name="TypeAccess") 792 public Access getTypeAccess() { 793 return (Access) getChild(1); 794 } 795 /** 796 * Retrieves the TypeAccess child. 797 * <p><em>This method does not invoke AST transformations.</em></p> 798 * @return The current node used as the TypeAccess child. 799 * @apilevel low-level 800 */ 801 public Access getTypeAccessNoTransform() { 802 return (Access) getChildNoTransform(1); 803 } 804 /** 805 * Replaces the lexeme ID. 806 * @param value The new value for the lexeme ID. 807 * @apilevel high-level 808 */ 809 public void setID(String value) { 810 tokenString_ID = value; 811 } 812 /** 813 * @apilevel internal 814 */ 815 protected String tokenString_ID; 816 /** 817 */ 818 public int IDstart; 819 /** 820 */ 821 public int IDend; 822 /** 823 * JastAdd-internal setter for lexeme ID using the Beaver parser. 824 * @param symbol Symbol containing the new value for the lexeme ID 825 * @apilevel internal 826 */ 827 public void setID(beaver.Symbol symbol) { 828 if (symbol.value != null && !(symbol.value instanceof String)) 829 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 830 tokenString_ID = (String)symbol.value; 831 IDstart = symbol.getStart(); 832 IDend = symbol.getEnd(); 833 } 834 /** 835 * Retrieves the value for the lexeme ID. 836 * @return The value for the lexeme ID. 837 * @apilevel high-level 838 */ 839 @ASTNodeAnnotation.Token(name="ID") 840 public String getID() { 841 return tokenString_ID != null ? tokenString_ID : ""; 842 } 843 /** 844 * Replaces the Parameter list. 845 * @param list The new list node to be used as the Parameter list. 846 * @apilevel high-level 847 */ 848 public void setParameterList(List<ParameterDeclaration> list) { 849 setChild(list, 2); 850 } 851 /** 852 * Retrieves the number of children in the Parameter list. 853 * @return Number of children in the Parameter list. 854 * @apilevel high-level 855 */ 856 public int getNumParameter() { 857 return getParameterList().getNumChild(); 858 } 859 /** 860 * Retrieves the number of children in the Parameter list. 861 * Calling this method will not trigger rewrites. 862 * @return Number of children in the Parameter list. 863 * @apilevel low-level 864 */ 865 public int getNumParameterNoTransform() { 866 return getParameterListNoTransform().getNumChildNoTransform(); 867 } 868 /** 869 * Retrieves the element at index {@code i} in the Parameter list. 870 * @param i Index of the element to return. 871 * @return The element at position {@code i} in the Parameter list. 872 * @apilevel high-level 873 */ 874 public ParameterDeclaration getParameter(int i) { 875 return (ParameterDeclaration) getParameterList().getChild(i); 876 } 877 /** 878 * Check whether the Parameter list has any children. 879 * @return {@code true} if it has at least one child, {@code false} otherwise. 880 * @apilevel high-level 881 */ 882 public boolean hasParameter() { 883 return getParameterList().getNumChild() != 0; 884 } 885 /** 886 * Append an element to the Parameter list. 887 * @param node The element to append to the Parameter list. 888 * @apilevel high-level 889 */ 890 public void addParameter(ParameterDeclaration node) { 891 List<ParameterDeclaration> list = (parent == null) ? getParameterListNoTransform() : getParameterList(); 892 list.addChild(node); 893 } 894 /** 895 * @apilevel low-level 896 */ 897 public void addParameterNoTransform(ParameterDeclaration node) { 898 List<ParameterDeclaration> list = getParameterListNoTransform(); 899 list.addChild(node); 900 } 901 /** 902 * Replaces the Parameter list element at index {@code i} with the new node {@code node}. 903 * @param node The new node to replace the old list element. 904 * @param i The list index of the node to be replaced. 905 * @apilevel high-level 906 */ 907 public void setParameter(ParameterDeclaration node, int i) { 908 List<ParameterDeclaration> list = getParameterList(); 909 list.setChild(node, i); 910 } 911 /** 912 * Retrieves the Parameter list. 913 * @return The node representing the Parameter list. 914 * @apilevel high-level 915 */ 916 @ASTNodeAnnotation.ListChild(name="Parameter") 917 public List<ParameterDeclaration> getParameterList() { 918 List<ParameterDeclaration> list = (List<ParameterDeclaration>) getChild(2); 919 return list; 920 } 921 /** 922 * Retrieves the Parameter list. 923 * <p><em>This method does not invoke AST transformations.</em></p> 924 * @return The node representing the Parameter list. 925 * @apilevel low-level 926 */ 927 public List<ParameterDeclaration> getParameterListNoTransform() { 928 return (List<ParameterDeclaration>) getChildNoTransform(2); 929 } 930 /** 931 * Retrieves the Parameter list. 932 * @return The node representing the Parameter list. 933 * @apilevel high-level 934 */ 935 public List<ParameterDeclaration> getParameters() { 936 return getParameterList(); 937 } 938 /** 939 * Retrieves the Parameter list. 940 * <p><em>This method does not invoke AST transformations.</em></p> 941 * @return The node representing the Parameter list. 942 * @apilevel low-level 943 */ 944 public List<ParameterDeclaration> getParametersNoTransform() { 945 return getParameterListNoTransform(); 946 } 947 /** 948 * Replaces the Exception list. 949 * @param list The new list node to be used as the Exception list. 950 * @apilevel high-level 951 */ 952 public void setExceptionList(List<Access> list) { 953 setChild(list, 3); 954 } 955 /** 956 * Retrieves the number of children in the Exception list. 957 * @return Number of children in the Exception list. 958 * @apilevel high-level 959 */ 960 public int getNumException() { 961 return getExceptionList().getNumChild(); 962 } 963 /** 964 * Retrieves the number of children in the Exception list. 965 * Calling this method will not trigger rewrites. 966 * @return Number of children in the Exception list. 967 * @apilevel low-level 968 */ 969 public int getNumExceptionNoTransform() { 970 return getExceptionListNoTransform().getNumChildNoTransform(); 971 } 972 /** 973 * Retrieves the element at index {@code i} in the Exception list. 974 * @param i Index of the element to return. 975 * @return The element at position {@code i} in the Exception list. 976 * @apilevel high-level 977 */ 978 public Access getException(int i) { 979 return (Access) getExceptionList().getChild(i); 980 } 981 /** 982 * Check whether the Exception list has any children. 983 * @return {@code true} if it has at least one child, {@code false} otherwise. 984 * @apilevel high-level 985 */ 986 public boolean hasException() { 987 return getExceptionList().getNumChild() != 0; 988 } 989 /** 990 * Append an element to the Exception list. 991 * @param node The element to append to the Exception list. 992 * @apilevel high-level 993 */ 994 public void addException(Access node) { 995 List<Access> list = (parent == null) ? getExceptionListNoTransform() : getExceptionList(); 996 list.addChild(node); 997 } 998 /** 999 * @apilevel low-level 1000 */ 1001 public void addExceptionNoTransform(Access node) { 1002 List<Access> list = getExceptionListNoTransform(); 1003 list.addChild(node); 1004 } 1005 /** 1006 * Replaces the Exception list element at index {@code i} with the new node {@code node}. 1007 * @param node The new node to replace the old list element. 1008 * @param i The list index of the node to be replaced. 1009 * @apilevel high-level 1010 */ 1011 public void setException(Access node, int i) { 1012 List<Access> list = getExceptionList(); 1013 list.setChild(node, i); 1014 } 1015 /** 1016 * Retrieves the Exception list. 1017 * @return The node representing the Exception list. 1018 * @apilevel high-level 1019 */ 1020 @ASTNodeAnnotation.ListChild(name="Exception") 1021 public List<Access> getExceptionList() { 1022 List<Access> list = (List<Access>) getChild(3); 1023 return list; 1024 } 1025 /** 1026 * Retrieves the Exception list. 1027 * <p><em>This method does not invoke AST transformations.</em></p> 1028 * @return The node representing the Exception list. 1029 * @apilevel low-level 1030 */ 1031 public List<Access> getExceptionListNoTransform() { 1032 return (List<Access>) getChildNoTransform(3); 1033 } 1034 /** 1035 * Retrieves the Exception list. 1036 * @return The node representing the Exception list. 1037 * @apilevel high-level 1038 */ 1039 public List<Access> getExceptions() { 1040 return getExceptionList(); 1041 } 1042 /** 1043 * Retrieves the Exception list. 1044 * <p><em>This method does not invoke AST transformations.</em></p> 1045 * @return The node representing the Exception list. 1046 * @apilevel low-level 1047 */ 1048 public List<Access> getExceptionsNoTransform() { 1049 return getExceptionListNoTransform(); 1050 } 1051 /** 1052 * Replaces the optional node for the Block child. This is the <code>Opt</code> 1053 * node containing the child Block, not the actual child! 1054 * @param opt The new node to be used as the optional node for the Block child. 1055 * @apilevel low-level 1056 */ 1057 public void setBlockOpt(Opt<Block> opt) { 1058 setChild(opt, 4); 1059 } 1060 /** 1061 * Replaces the (optional) Block child. 1062 * @param node The new node to be used as the Block child. 1063 * @apilevel high-level 1064 */ 1065 public void setBlock(Block node) { 1066 getBlockOpt().setChild(node, 0); 1067 } 1068 /** 1069 * Check whether the optional Block child exists. 1070 * @return {@code true} if the optional Block child exists, {@code false} if it does not. 1071 * @apilevel high-level 1072 */ 1073 public boolean hasBlock() { 1074 return getBlockOpt().getNumChild() != 0; 1075 } 1076 /** 1077 * Retrieves the (optional) Block child. 1078 * @return The Block child, if it exists. Returns {@code null} otherwise. 1079 * @apilevel low-level 1080 */ 1081 public Block getBlock() { 1082 return (Block) getBlockOpt().getChild(0); 1083 } 1084 /** 1085 * Retrieves the optional node for the Block child. This is the <code>Opt</code> node containing the child Block, not the actual child! 1086 * @return The optional node for child the Block child. 1087 * @apilevel low-level 1088 */ 1089 @ASTNodeAnnotation.OptChild(name="Block") 1090 public Opt<Block> getBlockOpt() { 1091 return (Opt<Block>) getChild(4); 1092 } 1093 /** 1094 * Retrieves the optional node for child Block. This is the <code>Opt</code> node containing the child Block, not the actual child! 1095 * <p><em>This method does not invoke AST transformations.</em></p> 1096 * @return The optional node for child Block. 1097 * @apilevel low-level 1098 */ 1099 public Opt<Block> getBlockOptNoTransform() { 1100 return (Opt<Block>) getChildNoTransform(4); 1101 } 1102 /** 1103 * @aspect Enums 1104 * @declaredat /home/jesper/git/extendj/java5/frontend/Enums.jrag:768 1105 */ 1106 1107 public void refined_Enums_MethodDecl_checkModifiers() { 1108 super.checkModifiers(); 1109 if (hostType().isClassDecl()) { 1110 // 8.4.3.1 1111 if (!hostType().isEnumDecl() && isAbstract() && !hostType().isAbstract()) { 1112 error("class must be abstract to include abstract methods"); 1113 } 1114 // 8.4.3.1 1115 if (isAbstract() && isPrivate()) { 1116 error("method may not be abstract and private"); 1117 } 1118 // 8.4.3.1 1119 // 8.4.3.2 1120 if (isAbstract() && isStatic()) { 1121 error("method may not be abstract and static"); 1122 } 1123 if (isAbstract() && isSynchronized()) { 1124 error("method may not be abstract and synchronized"); 1125 } 1126 // 8.4.3.4 1127 if (isAbstract() && isNative()) { 1128 error("method may not be abstract and native"); 1129 } 1130 if (isAbstract() && isStrictfp()) { 1131 error("method may not be abstract and strictfp"); 1132 } 1133 if (isNative() && isStrictfp()) { 1134 error("method may not be native and strictfp"); 1135 } 1136 } 1137 if (hostType().isInterfaceDecl()) { 1138 // 9.4 1139 if (isStatic()) { 1140 errorf("interface method %s in %s may not be static", signature(), hostType().typeName()); 1141 } 1142 if (isStrictfp()) { 1143 errorf("interface method %s in %s may not be strictfp", signature(), hostType().typeName()); 1144 } 1145 if (isNative()) { 1146 errorf("interface method %s in %s may not be native", signature(), hostType().typeName()); 1147 } 1148 if (isSynchronized()) { 1149 errorf("interface method %s in %s may not be synchronized", signature(), 1150 hostType().typeName()); 1151 } 1152 if (isProtected()) { 1153 errorf("interface method %s in %s may not be protected", signature(), 1154 hostType().typeName()); 1155 } 1156 if (isPrivate()) { 1157 errorf("interface method %s in %s may not be private", signature(), hostType().typeName()); 1158 } else if (isFinal()) { 1159 errorf("interface method %s in %s may not be final", signature(), hostType().typeName()); 1160 } 1161 } 1162 } 1163 /** 1164 * @aspect Modifiers 1165 * @declaredat /home/jesper/git/extendj/java8/frontend/Modifiers.jrag:40 1166 */ 1167 1168 public void checkModifiers() { 1169 super.checkModifiers(); 1170 if (hostType().isClassDecl()) { 1171 // 8.4.3.1 1172 if (!hostType().isEnumDecl() && isAbstract() && !hostType().isAbstract()) { 1173 error("class must be abstract to include abstract methods"); 1174 } 1175 // 8.4.3.1 1176 if (isAbstract() && isPrivate()) { 1177 error("method may not be abstract and private"); 1178 } 1179 // 8.4.3.1 1180 // 8.4.3.2 1181 if (isAbstract() && isStatic()) { 1182 error("method may not be abstract and static"); 1183 } 1184 if (isAbstract() && isSynchronized()) { 1185 error("method may not be abstract and synchronized"); 1186 } 1187 // 8.4.3.4 1188 if (isAbstract() && isNative()) { 1189 error("method may not be abstract and native"); 1190 } 1191 if (isAbstract() && isStrictfp()) { 1192 error("method may not be abstract and strictfp"); 1193 } 1194 if (isNative() && isStrictfp()) { 1195 error("method may not be native and strictfp"); 1196 } 1197 if (isDefault()) { 1198 error("non-interface methods may not use the default modifier"); 1199 } 1200 } 1201 if (hostType().isInterfaceDecl()) { 1202 // 9.4 1203 if (isAbstract()) { 1204 if (isStatic()) { 1205 errorf("interface method %s in %s can not be both abstract and static", 1206 signature(), hostType().typeName()); 1207 } 1208 if (isDefault()) { 1209 errorf("interface method %s in %s can not be both abstract and default", 1210 signature(), hostType().typeName()); 1211 } 1212 if (isStrictfp()) { 1213 errorf("interface method %s in %s can not be both abstract and strictfp", 1214 signature(), hostType().typeName()); 1215 } 1216 } 1217 if (isStatic() && isDefault()) { 1218 errorf("interface method %s in %s can not be both static and default", 1219 signature(), hostType().typeName()); 1220 } 1221 if (isNative()) { 1222 errorf("interface method %s in %s may not be native", signature(), hostType().typeName()); 1223 } 1224 if (isSynchronized()) { 1225 errorf("interface method %s in %s may not be synchronized", 1226 signature(), hostType().typeName()); 1227 } 1228 if (isProtected()) { 1229 errorf("interface method %s in %s may not be protected", 1230 signature(), hostType().typeName()); 1231 } 1232 if (isPrivate()) { 1233 errorf("interface method %s in %s may not be private", signature(), hostType().typeName()); 1234 } else if (isFinal()) { 1235 errorf("interface method %s in %s may not be final", signature(), hostType().typeName()); 1236 } 1237 } 1238 } 1239 /** 1240 * @aspect MethodDecl 1241 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:217 1242 */ 1243 private boolean refined_MethodDecl_MethodDecl_sameSignature_MethodDecl(MethodDecl other) 1244 { return signature().equals(other.signature()); } 1245 /** 1246 * @aspect Attributes 1247 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:221 1248 */ 1249 private Collection refined_Attributes_MethodDecl_attributes() 1250 { 1251 ArrayList l = new ArrayList(); 1252 CodeGeneration bytecodes = bytecodes(hostType().constantPool()); 1253 l.add(new ExceptionsAttribute(bytecodes, this)); 1254 if (isAbstract() || isNative()) { 1255 return l; 1256 } else { 1257 l.add(new CodeAttribute(bytecodes, this)); 1258 if (getModifiers().isSynthetic()) { 1259 l.add(new SyntheticAttribute(hostType().constantPool())); 1260 } 1261 return l; 1262 } 1263 } 1264 /** 1265 * @aspect Flags 1266 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:62 1267 */ 1268 private int refined_Flags_MethodDecl_flags() 1269 { 1270 int res = 0; 1271 if (isPublic()) { 1272 res |= Modifiers.ACC_PUBLIC; 1273 } 1274 if (isPrivate()) { 1275 res |= Modifiers.ACC_PRIVATE; 1276 } 1277 if (isProtected()) { 1278 res |= Modifiers.ACC_PROTECTED; 1279 } 1280 if (isStatic()) { 1281 res |= Modifiers.ACC_STATIC; 1282 } 1283 if (isFinal()) { 1284 res |= Modifiers.ACC_FINAL; 1285 } 1286 if (isSynchronized()) { 1287 res |= Modifiers.ACC_SYNCHRONIZED; 1288 } 1289 if (isNative()) { 1290 res |= Modifiers.ACC_NATIVE; 1291 } 1292 if (isAbstract()) { 1293 res |= Modifiers.ACC_ABSTRACT; 1294 } 1295 if (isStrictfp() || (hostType().isStrictfp() && !hostType().isInterfaceDecl())) { 1296 res |= Modifiers.ACC_STRICT; 1297 } 1298 return res; 1299 } 1300 /** 1301 * @aspect AnnotationsCodegen 1302 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:44 1303 */ 1304 private Collection refined_AnnotationsCodegen_MethodDecl_attributes() 1305 { 1306 Collection c = refined_Attributes_MethodDecl_attributes(); 1307 getModifiers().addRuntimeVisibleAnnotationsAttribute(c); 1308 getModifiers().addRuntimeInvisibleAnnotationsAttribute(c); 1309 addRuntimeVisibleParameterAnnotationsAttribute(c); 1310 addRuntimeInvisibleParameterAnnotationsAttribute(c); 1311 return c; 1312 } 1313 /** 1314 * @apilevel internal 1315 */ 1316 protected java.util.Map accessibleFrom_TypeDecl_values; 1317 /** 1318 * @apilevel internal 1319 */ 1320 private void accessibleFrom_TypeDecl_reset() { 1321 accessibleFrom_TypeDecl_values = null; 1322 } 1323 /** 1324 * @attribute syn 1325 * @aspect AccessControl 1326 * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:100 1327 */ 1328 @ASTNodeAnnotation.Attribute 1329 public boolean accessibleFrom(TypeDecl type) { 1330 Object _parameters = type; 1331 if (accessibleFrom_TypeDecl_values == null) accessibleFrom_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1332 ASTNode$State state = state(); 1333 if (accessibleFrom_TypeDecl_values.containsKey(_parameters)) { 1334 return (Boolean) accessibleFrom_TypeDecl_values.get(_parameters); 1335 } 1336 boolean intermediate = state.INTERMEDIATE_VALUE; 1337 state.INTERMEDIATE_VALUE = false; 1338 int num = state.boundariesCrossed; 1339 boolean isFinal = this.is$Final(); 1340 boolean accessibleFrom_TypeDecl_value = accessibleFrom_compute(type); 1341 if (isFinal && num == state().boundariesCrossed) { 1342 accessibleFrom_TypeDecl_values.put(_parameters, accessibleFrom_TypeDecl_value); 1343 } else { 1344 } 1345 state.INTERMEDIATE_VALUE |= intermediate; 1346 1347 return accessibleFrom_TypeDecl_value; 1348 } 1349 /** 1350 * @apilevel internal 1351 */ 1352 private boolean accessibleFrom_compute(TypeDecl type) { 1353 if (isPublic()) { 1354 return true; 1355 } else if (isProtected()) { 1356 if (hostPackage().equals(type.hostPackage())) { 1357 return true; 1358 } 1359 if (type.withinBodyThatSubclasses(hostType()) != null) { 1360 return true; 1361 } 1362 return false; 1363 } else if (isPrivate()) { 1364 return hostType().topLevelType() == type.topLevelType(); 1365 } else { 1366 return hostPackage().equals(type.hostPackage()); 1367 } 1368 } 1369 /** 1370 * @attribute syn 1371 * @aspect DataStructures 1372 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:175 1373 */ 1374 @ASTNodeAnnotation.Attribute 1375 public int size() { 1376 int size_value = 1; 1377 1378 return size_value; 1379 } 1380 /** 1381 * @attribute syn 1382 * @aspect DataStructures 1383 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:176 1384 */ 1385 @ASTNodeAnnotation.Attribute 1386 public boolean isEmpty() { 1387 boolean isEmpty_value = false; 1388 1389 return isEmpty_value; 1390 } 1391 /** 1392 * @attribute syn 1393 * @aspect DataStructures 1394 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:180 1395 */ 1396 @ASTNodeAnnotation.Attribute 1397 public boolean contains(Object o) { 1398 boolean contains_Object_value = this == o; 1399 1400 return contains_Object_value; 1401 } 1402 /** 1403 * @attribute syn 1404 * @aspect ErrorCheck 1405 * @declaredat /home/jesper/git/extendj/java4/frontend/ErrorCheck.jrag:45 1406 */ 1407 @ASTNodeAnnotation.Attribute 1408 public int lineNumber() { 1409 int lineNumber_value = getLine(IDstart); 1410 1411 return lineNumber_value; 1412 } 1413 /** 1414 * @apilevel internal 1415 */ 1416 protected java.util.Map throwsException_TypeDecl_values; 1417 /** 1418 * @apilevel internal 1419 */ 1420 private void throwsException_TypeDecl_reset() { 1421 throwsException_TypeDecl_values = null; 1422 } 1423 /** 1424 * @attribute syn 1425 * @aspect ExceptionHandling 1426 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:182 1427 */ 1428 @ASTNodeAnnotation.Attribute 1429 public boolean throwsException(TypeDecl exceptionType) { 1430 Object _parameters = exceptionType; 1431 if (throwsException_TypeDecl_values == null) throwsException_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1432 ASTNode$State state = state(); 1433 if (throwsException_TypeDecl_values.containsKey(_parameters)) { 1434 return (Boolean) throwsException_TypeDecl_values.get(_parameters); 1435 } 1436 boolean intermediate = state.INTERMEDIATE_VALUE; 1437 state.INTERMEDIATE_VALUE = false; 1438 int num = state.boundariesCrossed; 1439 boolean isFinal = this.is$Final(); 1440 boolean throwsException_TypeDecl_value = throwsException_compute(exceptionType); 1441 if (isFinal && num == state().boundariesCrossed) { 1442 throwsException_TypeDecl_values.put(_parameters, throwsException_TypeDecl_value); 1443 } else { 1444 } 1445 state.INTERMEDIATE_VALUE |= intermediate; 1446 1447 return throwsException_TypeDecl_value; 1448 } 1449 /** 1450 * @apilevel internal 1451 */ 1452 private boolean throwsException_compute(TypeDecl exceptionType) { 1453 for (Access exception : getExceptionList()) { 1454 if (exceptionType.instanceOf(exception.type())) { 1455 return true; 1456 } 1457 } 1458 return false; 1459 } 1460 /** 1461 * @attribute syn 1462 * @aspect MethodDecl 1463 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:178 1464 */ 1465 @ASTNodeAnnotation.Attribute 1466 public String name() { 1467 String name_value = getID(); 1468 1469 return name_value; 1470 } 1471 /** 1472 * @apilevel internal 1473 */ 1474 protected boolean signature_computed = false; 1475 /** 1476 * @apilevel internal 1477 */ 1478 protected String signature_value; 1479 /** 1480 * @apilevel internal 1481 */ 1482 private void signature_reset() { 1483 signature_computed = false; 1484 signature_value = null; 1485 } 1486 /** 1487 * @attribute syn 1488 * @aspect MethodDecl 1489 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:181 1490 */ 1491 @ASTNodeAnnotation.Attribute 1492 public String signature() { 1493 ASTNode$State state = state(); 1494 if (signature_computed) { 1495 return signature_value; 1496 } 1497 boolean intermediate = state.INTERMEDIATE_VALUE; 1498 state.INTERMEDIATE_VALUE = false; 1499 int num = state.boundariesCrossed; 1500 boolean isFinal = this.is$Final(); 1501 signature_value = signature_compute(); 1502 if (isFinal && num == state().boundariesCrossed) { 1503 signature_computed = true; 1504 } else { 1505 } 1506 state.INTERMEDIATE_VALUE |= intermediate; 1507 1508 return signature_value; 1509 } 1510 /** 1511 * @apilevel internal 1512 */ 1513 private String signature_compute() { 1514 StringBuilder sb = new StringBuilder(); 1515 sb.append(name() + "("); 1516 for (int i = 0; i < getNumParameter(); i++) { 1517 if (i != 0) { 1518 sb.append(", "); 1519 } 1520 sb.append(getParameter(i).type().erasure().typeName()); 1521 } 1522 sb.append(")"); 1523 return sb.toString(); 1524 } 1525 /** 1526 * @return Method signature, including generic parameters. 1527 * @attribute syn 1528 * @aspect MethodDecl 1529 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:197 1530 */ 1531 @ASTNodeAnnotation.Attribute 1532 public String fullSignature() { 1533 { 1534 StringBuilder sb = new StringBuilder(); 1535 sb.append(name() + "("); 1536 for (int i = 0; i < getNumParameter(); i++) { 1537 if (i != 0) { 1538 sb.append(", "); 1539 } 1540 if (getParameter(i).type() instanceof PrimitiveType) { 1541 sb.append(getParameter(i).type().typeName()); 1542 } else { 1543 sb.append(getParameter(i).type().fullName()); 1544 } 1545 } 1546 sb.append(")"); 1547 return sb.toString(); 1548 } 1549 } 1550 /** 1551 * 8.4.2 Method Signature 1552 * @param other 1553 * @return {@code true} if the signature of this method is same as the 1554 * the signature of the argument method 1555 * @attribute syn 1556 * @aspect MethodDecl 1557 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:217 1558 */ 1559 @ASTNodeAnnotation.Attribute 1560 public boolean sameSignature(MethodDecl other) { 1561 { 1562 if (!refined_MethodDecl_MethodDecl_sameSignature_MethodDecl(other)) { 1563 return false; 1564 } 1565 for (int i = 0; i < getNumParameter(); ++i) { 1566 TypeDecl p1 = getParameter(i).type(); 1567 TypeDecl p2 = other.getParameter(i).type(); 1568 // JLSv7 $8.4.8.1 exception: if one parameter type is raw, then don't check type bounds 1569 if (p1 != p2 && !p1.isRawType() && !p2.isRawType()) { 1570 return false; 1571 } 1572 } 1573 return true; 1574 } 1575 } 1576 /** 1577 * @param m argument method to compare to 1578 * @return {@code true} if this the argument method is less specific than this 1579 * and this is not less specific than the argument 1580 * @attribute syn 1581 * @aspect MethodDecl 1582 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:225 1583 */ 1584 @ASTNodeAnnotation.Attribute 1585 public boolean moreSpecificThan(MethodDecl m) { 1586 boolean moreSpecificThan_MethodDecl_value = m.lessSpecificThan(this) && !this.lessSpecificThan(m); 1587 1588 return moreSpecificThan_MethodDecl_value; 1589 } 1590 /** 1591 * @apilevel internal 1592 */ 1593 protected java.util.Map lessSpecificThan_MethodDecl_values; 1594 /** 1595 * @apilevel internal 1596 */ 1597 private void lessSpecificThan_MethodDecl_reset() { 1598 lessSpecificThan_MethodDecl_values = null; 1599 } 1600 /** 1601 * Caution: a less specific than b does not mean b is not less specific than a! 1602 * @param m argument method to compare to 1603 * @return {@code true} if any parameter of this method decl is not a 1604 * subtype (non-proper subtype) of the corresponding parameter of the 1605 * argument method 1606 * @attribute syn 1607 * @aspect MethodDecl 1608 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:235 1609 */ 1610 @ASTNodeAnnotation.Attribute 1611 public boolean lessSpecificThan(MethodDecl m) { 1612 Object _parameters = m; 1613 if (lessSpecificThan_MethodDecl_values == null) lessSpecificThan_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1614 ASTNode$State state = state(); 1615 if (lessSpecificThan_MethodDecl_values.containsKey(_parameters)) { 1616 return (Boolean) lessSpecificThan_MethodDecl_values.get(_parameters); 1617 } 1618 boolean intermediate = state.INTERMEDIATE_VALUE; 1619 state.INTERMEDIATE_VALUE = false; 1620 int num = state.boundariesCrossed; 1621 boolean isFinal = this.is$Final(); 1622 boolean lessSpecificThan_MethodDecl_value = lessSpecificThan_compute(m); 1623 if (isFinal && num == state().boundariesCrossed) { 1624 lessSpecificThan_MethodDecl_values.put(_parameters, lessSpecificThan_MethodDecl_value); 1625 } else { 1626 } 1627 state.INTERMEDIATE_VALUE |= intermediate; 1628 1629 return lessSpecificThan_MethodDecl_value; 1630 } 1631 /** 1632 * @apilevel internal 1633 */ 1634 private boolean lessSpecificThan_compute(MethodDecl m) { 1635 int numA = getNumParameter(); 1636 int numB = m.getNumParameter(); 1637 int num = Math.max(numA, numB); 1638 for (int i = 0; i < num; i++) { 1639 TypeDecl t1 = getParameter(Math.min(i, numA-1)).type(); 1640 TypeDecl t2 = m.getParameter(Math.min(i, numB-1)).type(); 1641 if (!t1.instanceOf(t2) && !t1.withinBounds(t2, Parameterization.RAW)) { 1642 return true; 1643 } 1644 } 1645 return false; 1646 } 1647 /** 1648 * @apilevel internal 1649 */ 1650 protected java.util.Map overrideCandidate_MethodDecl_values; 1651 /** 1652 * @apilevel internal 1653 */ 1654 private void overrideCandidate_MethodDecl_reset() { 1655 overrideCandidate_MethodDecl_values = null; 1656 } 1657 /** 1658 * Only check if this method would be able to override other method, 1659 * not if this method is declared in a subtype of the hostType of 1660 * other method. NB: does not check for equal signature! 1661 * @param m other method 1662 * @return {@code true} of the method could potentially override 1663 * @attribute syn 1664 * @aspect MethodDecl 1665 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:304 1666 */ 1667 @ASTNodeAnnotation.Attribute 1668 public boolean overrideCandidate(MethodDecl m) { 1669 Object _parameters = m; 1670 if (overrideCandidate_MethodDecl_values == null) overrideCandidate_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1671 ASTNode$State state = state(); 1672 if (overrideCandidate_MethodDecl_values.containsKey(_parameters)) { 1673 return (Boolean) overrideCandidate_MethodDecl_values.get(_parameters); 1674 } 1675 boolean intermediate = state.INTERMEDIATE_VALUE; 1676 state.INTERMEDIATE_VALUE = false; 1677 int num = state.boundariesCrossed; 1678 boolean isFinal = this.is$Final(); 1679 boolean overrideCandidate_MethodDecl_value = !isStatic() && !m.isPrivate() && m.accessibleFrom(hostType()); 1680 if (isFinal && num == state().boundariesCrossed) { 1681 overrideCandidate_MethodDecl_values.put(_parameters, overrideCandidate_MethodDecl_value); 1682 } else { 1683 } 1684 state.INTERMEDIATE_VALUE |= intermediate; 1685 1686 return overrideCandidate_MethodDecl_value; 1687 } 1688 /** 1689 * @apilevel internal 1690 */ 1691 protected java.util.Map overrides_MethodDecl_values; 1692 /** 1693 * @apilevel internal 1694 */ 1695 private void overrides_MethodDecl_reset() { 1696 overrides_MethodDecl_values = null; 1697 } 1698 /** 1699 * @attribute syn 1700 * @aspect MethodDecl 1701 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:307 1702 */ 1703 @ASTNodeAnnotation.Attribute 1704 public boolean overrides(MethodDecl m) { 1705 Object _parameters = m; 1706 if (overrides_MethodDecl_values == null) overrides_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1707 ASTNode$State state = state(); 1708 if (overrides_MethodDecl_values.containsKey(_parameters)) { 1709 return (Boolean) overrides_MethodDecl_values.get(_parameters); 1710 } 1711 boolean intermediate = state.INTERMEDIATE_VALUE; 1712 state.INTERMEDIATE_VALUE = false; 1713 int num = state.boundariesCrossed; 1714 boolean isFinal = this.is$Final(); 1715 boolean overrides_MethodDecl_value = !isStatic() && !m.isPrivate() && m.accessibleFrom(hostType()) 1716 && hostType().instanceOf(m.hostType()) && m.signature().equals(signature()); 1717 if (isFinal && num == state().boundariesCrossed) { 1718 overrides_MethodDecl_values.put(_parameters, overrides_MethodDecl_value); 1719 } else { 1720 } 1721 state.INTERMEDIATE_VALUE |= intermediate; 1722 1723 return overrides_MethodDecl_value; 1724 } 1725 /** 1726 * @apilevel internal 1727 */ 1728 protected java.util.Map hides_MethodDecl_values; 1729 /** 1730 * @apilevel internal 1731 */ 1732 private void hides_MethodDecl_reset() { 1733 hides_MethodDecl_values = null; 1734 } 1735 /** 1736 * @attribute syn 1737 * @aspect MethodDecl 1738 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:311 1739 */ 1740 @ASTNodeAnnotation.Attribute 1741 public boolean hides(MethodDecl m) { 1742 Object _parameters = m; 1743 if (hides_MethodDecl_values == null) hides_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1744 ASTNode$State state = state(); 1745 if (hides_MethodDecl_values.containsKey(_parameters)) { 1746 return (Boolean) hides_MethodDecl_values.get(_parameters); 1747 } 1748 boolean intermediate = state.INTERMEDIATE_VALUE; 1749 state.INTERMEDIATE_VALUE = false; 1750 int num = state.boundariesCrossed; 1751 boolean isFinal = this.is$Final(); 1752 boolean hides_MethodDecl_value = isStatic() && !m.isPrivate() && m.accessibleFrom(hostType()) 1753 && hostType().instanceOf(m.hostType()) && m.signature().equals(signature()); 1754 if (isFinal && num == state().boundariesCrossed) { 1755 hides_MethodDecl_values.put(_parameters, hides_MethodDecl_value); 1756 } else { 1757 } 1758 state.INTERMEDIATE_VALUE |= intermediate; 1759 1760 return hides_MethodDecl_value; 1761 } 1762 /** 1763 * @apilevel internal 1764 */ 1765 protected java.util.Map parameterDeclaration_String_values; 1766 /** 1767 * @apilevel internal 1768 */ 1769 private void parameterDeclaration_String_reset() { 1770 parameterDeclaration_String_values = null; 1771 } 1772 /** 1773 * @attribute syn 1774 * @aspect VariableScope 1775 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:161 1776 */ 1777 @ASTNodeAnnotation.Attribute 1778 public SimpleSet parameterDeclaration(String name) { 1779 Object _parameters = name; 1780 if (parameterDeclaration_String_values == null) parameterDeclaration_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1781 ASTNode$State state = state(); 1782 if (parameterDeclaration_String_values.containsKey(_parameters)) { 1783 return (SimpleSet) parameterDeclaration_String_values.get(_parameters); 1784 } 1785 boolean intermediate = state.INTERMEDIATE_VALUE; 1786 state.INTERMEDIATE_VALUE = false; 1787 int num = state.boundariesCrossed; 1788 boolean isFinal = this.is$Final(); 1789 SimpleSet parameterDeclaration_String_value = parameterDeclaration_compute(name); 1790 if (isFinal && num == state().boundariesCrossed) { 1791 parameterDeclaration_String_values.put(_parameters, parameterDeclaration_String_value); 1792 } else { 1793 } 1794 state.INTERMEDIATE_VALUE |= intermediate; 1795 1796 return parameterDeclaration_String_value; 1797 } 1798 /** 1799 * @apilevel internal 1800 */ 1801 private SimpleSet parameterDeclaration_compute(String name) { 1802 for (int i = 0; i < getNumParameter(); i++) { 1803 if (getParameter(i).name().equals(name)) { 1804 return (ParameterDeclaration) getParameter(i); 1805 } 1806 } 1807 return SimpleSet.emptySet; 1808 } 1809 /** 1810 * @attribute syn 1811 * @aspect Modifiers 1812 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:255 1813 */ 1814 @ASTNodeAnnotation.Attribute 1815 public boolean isSynthetic() { 1816 boolean isSynthetic_value = getModifiers().isSynthetic(); 1817 1818 return isSynthetic_value; 1819 } 1820 /** 1821 * @attribute syn 1822 * @aspect Modifiers 1823 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:265 1824 */ 1825 @ASTNodeAnnotation.Attribute 1826 public boolean isPublic() { 1827 boolean isPublic_value = getModifiers().isPublic() || hostType().isInterfaceDecl(); 1828 1829 return isPublic_value; 1830 } 1831 /** 1832 * @attribute syn 1833 * @aspect Modifiers 1834 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:266 1835 */ 1836 @ASTNodeAnnotation.Attribute 1837 public boolean isPrivate() { 1838 boolean isPrivate_value = getModifiers().isPrivate(); 1839 1840 return isPrivate_value; 1841 } 1842 /** 1843 * @attribute syn 1844 * @aspect Modifiers 1845 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:267 1846 */ 1847 @ASTNodeAnnotation.Attribute 1848 public boolean isProtected() { 1849 boolean isProtected_value = getModifiers().isProtected(); 1850 1851 return isProtected_value; 1852 } 1853 /** 1854 * @attribute syn 1855 * @aspect Modifiers 1856 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:268 1857 */ 1858 @ASTNodeAnnotation.Attribute 1859 public boolean isAbstract() { 1860 { 1861 return getModifiers().isAbstract() || (hostType().isInterfaceDecl() && !isStatic() && !isDefault()); 1862 } 1863 } 1864 /** 1865 * @attribute syn 1866 * @aspect Modifiers 1867 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:269 1868 */ 1869 @ASTNodeAnnotation.Attribute 1870 public boolean isStatic() { 1871 boolean isStatic_value = getModifiers().isStatic(); 1872 1873 return isStatic_value; 1874 } 1875 /** 1876 * @attribute syn 1877 * @aspect Modifiers 1878 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:271 1879 */ 1880 @ASTNodeAnnotation.Attribute 1881 public boolean isFinal() { 1882 boolean isFinal_value = getModifiers().isFinal() || hostType().isFinal() || isPrivate(); 1883 1884 return isFinal_value; 1885 } 1886 /** 1887 * @attribute syn 1888 * @aspect Modifiers 1889 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:272 1890 */ 1891 @ASTNodeAnnotation.Attribute 1892 public boolean isSynchronized() { 1893 boolean isSynchronized_value = getModifiers().isSynchronized(); 1894 1895 return isSynchronized_value; 1896 } 1897 /** 1898 * @attribute syn 1899 * @aspect Modifiers 1900 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:273 1901 */ 1902 @ASTNodeAnnotation.Attribute 1903 public boolean isNative() { 1904 boolean isNative_value = getModifiers().isNative(); 1905 1906 return isNative_value; 1907 } 1908 /** 1909 * @attribute syn 1910 * @aspect Modifiers 1911 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:274 1912 */ 1913 @ASTNodeAnnotation.Attribute 1914 public boolean isStrictfp() { 1915 boolean isStrictfp_value = getModifiers().isStrictfp(); 1916 1917 return isStrictfp_value; 1918 } 1919 /** 1920 * @attribute syn 1921 * @aspect PrettyPrintUtil 1922 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:247 1923 */ 1924 @ASTNodeAnnotation.Attribute 1925 public boolean hasModifiers() { 1926 boolean hasModifiers_value = getModifiers().getNumModifier() > 0; 1927 1928 return hasModifiers_value; 1929 } 1930 /** 1931 * @attribute syn 1932 * @aspect PrettyPrintUtil 1933 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:259 1934 */ 1935 @ASTNodeAnnotation.Attribute 1936 public boolean hasExceptions() { 1937 boolean hasExceptions_value = getNumException() > 0; 1938 1939 return hasExceptions_value; 1940 } 1941 /** 1942 * @apilevel internal 1943 */ 1944 protected boolean type_computed = false; 1945 /** 1946 * @apilevel internal 1947 */ 1948 protected TypeDecl type_value; 1949 /** 1950 * @apilevel internal 1951 */ 1952 private void type_reset() { 1953 type_computed = false; 1954 type_value = null; 1955 } 1956 /** 1957 * @attribute syn 1958 * @aspect TypeAnalysis 1959 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:295 1960 */ 1961 @ASTNodeAnnotation.Attribute 1962 public TypeDecl type() { 1963 ASTNode$State state = state(); 1964 if (type_computed) { 1965 return type_value; 1966 } 1967 boolean intermediate = state.INTERMEDIATE_VALUE; 1968 state.INTERMEDIATE_VALUE = false; 1969 int num = state.boundariesCrossed; 1970 boolean isFinal = this.is$Final(); 1971 type_value = getTypeAccess().type(); 1972 if (isFinal && num == state().boundariesCrossed) { 1973 type_computed = true; 1974 } else { 1975 } 1976 state.INTERMEDIATE_VALUE |= intermediate; 1977 1978 return type_value; 1979 } 1980 /** 1981 * @attribute syn 1982 * @aspect TypeAnalysis 1983 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:297 1984 */ 1985 @ASTNodeAnnotation.Attribute 1986 public boolean isVoid() { 1987 boolean isVoid_value = type().isVoid(); 1988 1989 return isVoid_value; 1990 } 1991 /** 1992 * @attribute syn 1993 * @aspect TypeHierarchyCheck 1994 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:360 1995 */ 1996 @ASTNodeAnnotation.Attribute 1997 public boolean mayOverride(MethodDecl m) { 1998 { 1999 // 9.4.3 2000 if (isDefault() && m.hostType() == type().typeObject() && !m.isPrivate()) { 2001 return false; 2002 } else { 2003 return returnTypeSubstitutableFor(m); 2004 } 2005 } 2006 } 2007 /** 2008 * @apilevel internal 2009 */ 2010 protected boolean attributes_computed = false; 2011 /** 2012 * @apilevel internal 2013 */ 2014 protected Collection attributes_value; 2015 /** 2016 * @apilevel internal 2017 */ 2018 private void attributes_reset() { 2019 attributes_computed = false; 2020 attributes_value = null; 2021 } 2022 /** 2023 * @attribute syn 2024 * @aspect Attributes 2025 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:212 2026 */ 2027 @ASTNodeAnnotation.Attribute 2028 public Collection attributes() { 2029 ASTNode$State state = state(); 2030 if (attributes_computed) { 2031 return attributes_value; 2032 } 2033 boolean intermediate = state.INTERMEDIATE_VALUE; 2034 state.INTERMEDIATE_VALUE = false; 2035 int num = state.boundariesCrossed; 2036 boolean isFinal = this.is$Final(); 2037 attributes_value = attributes_compute(); 2038 if (isFinal && num == state().boundariesCrossed) { 2039 attributes_computed = true; 2040 } else { 2041 } 2042 state.INTERMEDIATE_VALUE |= intermediate; 2043 2044 return attributes_value; 2045 } 2046 /** 2047 * @apilevel internal 2048 */ 2049 private Collection attributes_compute() { 2050 Collection c = refined_AnnotationsCodegen_MethodDecl_attributes(); 2051 if (needsSignatureAttribute()) { 2052 c.add(new SignatureAttribute(hostType().constantPool(), methodTypeSignature())); 2053 } 2054 return c; 2055 } 2056 /** 2057 * @apilevel internal 2058 */ 2059 protected boolean descName_computed = false; 2060 /** 2061 * @apilevel internal 2062 */ 2063 protected String descName_value; 2064 /** 2065 * @apilevel internal 2066 */ 2067 private void descName_reset() { 2068 descName_computed = false; 2069 descName_value = null; 2070 } 2071 /** 2072 * @attribute syn 2073 * @aspect ConstantPoolNames 2074 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:103 2075 */ 2076 @ASTNodeAnnotation.Attribute 2077 public String descName() { 2078 ASTNode$State state = state(); 2079 if (descName_computed) { 2080 return descName_value; 2081 } 2082 boolean intermediate = state.INTERMEDIATE_VALUE; 2083 state.INTERMEDIATE_VALUE = false; 2084 int num = state.boundariesCrossed; 2085 boolean isFinal = this.is$Final(); 2086 descName_value = descName_compute(); 2087 if (isFinal && num == state().boundariesCrossed) { 2088 descName_computed = true; 2089 } else { 2090 } 2091 state.INTERMEDIATE_VALUE |= intermediate; 2092 2093 return descName_value; 2094 } 2095 /** 2096 * @apilevel internal 2097 */ 2098 private String descName_compute() { 2099 StringBuilder b = new StringBuilder(); 2100 b.append("("); 2101 for (int i=0; i<getNumParameter(); i++) { 2102 b.append(getParameter(i).type().typeDescriptor()); 2103 } 2104 b.append(")"); 2105 if (type().elementType().isUnknown()) { 2106 System.err.println(getTypeAccess().dumpTree()); 2107 throw new Error("Error generating descName for " + signature() + ", did not expect unknown return type"); 2108 } 2109 b.append(type().typeDescriptor()); 2110 return b.toString(); 2111 } 2112 /** 2113 * @apilevel internal 2114 */ 2115 protected java.util.Map bytecodes_ConstantPool_values; 2116 /** 2117 * @apilevel internal 2118 */ 2119 private void bytecodes_ConstantPool_reset() { 2120 bytecodes_ConstantPool_values = null; 2121 } 2122 /** 2123 * @attribute syn 2124 * @aspect CreateBCode 2125 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:92 2126 */ 2127 @ASTNodeAnnotation.Attribute 2128 public CodeGeneration bytecodes(ConstantPool constantPool) { 2129 Object _parameters = constantPool; 2130 if (bytecodes_ConstantPool_values == null) bytecodes_ConstantPool_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2131 ASTNode$State state = state(); 2132 if (bytecodes_ConstantPool_values.containsKey(_parameters)) { 2133 return (CodeGeneration) bytecodes_ConstantPool_values.get(_parameters); 2134 } 2135 boolean intermediate = state.INTERMEDIATE_VALUE; 2136 state.INTERMEDIATE_VALUE = false; 2137 int num = state.boundariesCrossed; 2138 boolean isFinal = this.is$Final(); 2139 CodeGeneration bytecodes_ConstantPool_value = bytecodes_compute(constantPool); 2140 if (isFinal && num == state().boundariesCrossed) { 2141 bytecodes_ConstantPool_values.put(_parameters, bytecodes_ConstantPool_value); 2142 } else { 2143 } 2144 state.INTERMEDIATE_VALUE |= intermediate; 2145 2146 return bytecodes_ConstantPool_value; 2147 } 2148 /** 2149 * @apilevel internal 2150 */ 2151 private CodeGeneration bytecodes_compute(ConstantPool constantPool) { 2152 CodeGeneration gen = new CodeGeneration(constantPool); 2153 generateBytecodes(gen); 2154 if (!gen.numberFormatError()) { 2155 return gen; 2156 } 2157 gen = new CodeGeneration(constantPool, true); 2158 generateBytecodes(gen); 2159 if (!gen.numberFormatError()) { 2160 return gen; 2161 } 2162 throw new Error("Could not generate code for " + signature() + " in " + hostType().typeName()); 2163 } 2164 /** 2165 * @apilevel internal 2166 */ 2167 protected boolean flags_computed = false; 2168 /** 2169 * @apilevel internal 2170 */ 2171 protected int flags_value; 2172 /** 2173 * @apilevel internal 2174 */ 2175 private void flags_reset() { 2176 flags_computed = false; 2177 } 2178 /** 2179 * @attribute syn 2180 * @aspect Flags 2181 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:62 2182 */ 2183 @ASTNodeAnnotation.Attribute 2184 public int flags() { 2185 ASTNode$State state = state(); 2186 if (flags_computed) { 2187 return flags_value; 2188 } 2189 boolean intermediate = state.INTERMEDIATE_VALUE; 2190 state.INTERMEDIATE_VALUE = false; 2191 int num = state.boundariesCrossed; 2192 boolean isFinal = this.is$Final(); 2193 flags_value = flags_compute(); 2194 if (isFinal && num == state().boundariesCrossed) { 2195 flags_computed = true; 2196 } else { 2197 } 2198 state.INTERMEDIATE_VALUE |= intermediate; 2199 2200 return flags_value; 2201 } 2202 /** 2203 * @apilevel internal 2204 */ 2205 private int flags_compute() { 2206 int res = refined_Flags_MethodDecl_flags(); 2207 if (isVariableArity()) { 2208 res |= Modifiers.ACC_VARARGS; 2209 } 2210 return res; 2211 } 2212 /** 2213 * @attribute syn 2214 * @aspect GenerateClassfile 2215 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:350 2216 */ 2217 @ASTNodeAnnotation.Attribute 2218 public boolean isBytecodeMethod() { 2219 boolean isBytecodeMethod_value = true; 2220 2221 return isBytecodeMethod_value; 2222 } 2223 /** 2224 * @attribute syn 2225 * @aspect GenerateClassfile 2226 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:379 2227 */ 2228 @ASTNodeAnnotation.Attribute 2229 public boolean flush() { 2230 boolean flush_value = false; 2231 2232 return flush_value; 2233 } 2234 /** 2235 * @apilevel internal 2236 */ 2237 protected boolean offsetBeforeParameters_computed = false; 2238 /** 2239 * @apilevel internal 2240 */ 2241 protected int offsetBeforeParameters_value; 2242 /** 2243 * @apilevel internal 2244 */ 2245 private void offsetBeforeParameters_reset() { 2246 offsetBeforeParameters_computed = false; 2247 } 2248 /** 2249 * @attribute syn 2250 * @aspect LocalNum 2251 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:69 2252 */ 2253 @ASTNodeAnnotation.Attribute 2254 public int offsetBeforeParameters() { 2255 ASTNode$State state = state(); 2256 if (offsetBeforeParameters_computed) { 2257 return offsetBeforeParameters_value; 2258 } 2259 boolean intermediate = state.INTERMEDIATE_VALUE; 2260 state.INTERMEDIATE_VALUE = false; 2261 int num = state.boundariesCrossed; 2262 boolean isFinal = this.is$Final(); 2263 offsetBeforeParameters_value = isStatic() ? 0 : 1; 2264 if (isFinal && num == state().boundariesCrossed) { 2265 offsetBeforeParameters_computed = true; 2266 } else { 2267 } 2268 state.INTERMEDIATE_VALUE |= intermediate; 2269 2270 return offsetBeforeParameters_value; 2271 } 2272 /** 2273 * @apilevel internal 2274 */ 2275 protected boolean offsetAfterParameters_computed = false; 2276 /** 2277 * @apilevel internal 2278 */ 2279 protected int offsetAfterParameters_value; 2280 /** 2281 * @apilevel internal 2282 */ 2283 private void offsetAfterParameters_reset() { 2284 offsetAfterParameters_computed = false; 2285 } 2286 /** 2287 * @attribute syn 2288 * @aspect LocalNum 2289 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:71 2290 */ 2291 @ASTNodeAnnotation.Attribute 2292 public int offsetAfterParameters() { 2293 ASTNode$State state = state(); 2294 if (offsetAfterParameters_computed) { 2295 return offsetAfterParameters_value; 2296 } 2297 boolean intermediate = state.INTERMEDIATE_VALUE; 2298 state.INTERMEDIATE_VALUE = false; 2299 int num = state.boundariesCrossed; 2300 boolean isFinal = this.is$Final(); 2301 offsetAfterParameters_value = offsetAfterParameters_compute(); 2302 if (isFinal && num == state().boundariesCrossed) { 2303 offsetAfterParameters_computed = true; 2304 } else { 2305 } 2306 state.INTERMEDIATE_VALUE |= intermediate; 2307 2308 return offsetAfterParameters_value; 2309 } 2310 /** 2311 * @apilevel internal 2312 */ 2313 private int offsetAfterParameters_compute() { 2314 if (getNumParameter() == 0) { 2315 return offsetBeforeParameters(); 2316 } else { 2317 ParameterDeclaration last = getParameter(getNumParameter()-1); 2318 return last.localNum() + last.type().variableSize(); 2319 } 2320 } 2321 /** 2322 * @apilevel internal 2323 */ 2324 protected boolean resultOffset_computed = false; 2325 /** 2326 * @apilevel internal 2327 */ 2328 protected int resultOffset_value; 2329 /** 2330 * @apilevel internal 2331 */ 2332 private void resultOffset_reset() { 2333 resultOffset_computed = false; 2334 } 2335 /** 2336 * @attribute syn 2337 * @aspect LocalNum 2338 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:107 2339 */ 2340 @ASTNodeAnnotation.Attribute 2341 public int resultOffset() { 2342 ASTNode$State state = state(); 2343 if (resultOffset_computed) { 2344 return resultOffset_value; 2345 } 2346 boolean intermediate = state.INTERMEDIATE_VALUE; 2347 state.INTERMEDIATE_VALUE = false; 2348 int num = state.boundariesCrossed; 2349 boolean isFinal = this.is$Final(); 2350 resultOffset_value = type().isVoid() ? 0 : type().variableSize(); 2351 if (isFinal && num == state().boundariesCrossed) { 2352 resultOffset_computed = true; 2353 } else { 2354 } 2355 state.INTERMEDIATE_VALUE |= intermediate; 2356 2357 return resultOffset_value; 2358 } 2359 /** 2360 * @attribute syn 2361 * @aspect Annotations 2362 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:180 2363 */ 2364 @ASTNodeAnnotation.Attribute 2365 public boolean annotationMethodOverride() { 2366 boolean annotationMethodOverride_value = !hostType().ancestorMethods(signature()).isEmpty(); 2367 2368 return annotationMethodOverride_value; 2369 } 2370 /** 2371 * @attribute syn 2372 * @aspect Annotations 2373 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:356 2374 */ 2375 @ASTNodeAnnotation.Attribute 2376 public boolean hasAnnotationSuppressWarnings(String annot) { 2377 boolean hasAnnotationSuppressWarnings_String_value = getModifiers().hasAnnotationSuppressWarnings(annot); 2378 2379 return hasAnnotationSuppressWarnings_String_value; 2380 } 2381 /** 2382 * @attribute syn 2383 * @aspect Annotations 2384 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:399 2385 */ 2386 @ASTNodeAnnotation.Attribute 2387 public boolean isDeprecated() { 2388 boolean isDeprecated_value = getModifiers().hasDeprecatedAnnotation(); 2389 2390 return isDeprecated_value; 2391 } 2392 /** 2393 * @apilevel internal 2394 */ 2395 protected boolean usesTypeVariable_computed = false; 2396 /** 2397 * @apilevel internal 2398 */ 2399 protected boolean usesTypeVariable_value; 2400 /** 2401 * @apilevel internal 2402 */ 2403 private void usesTypeVariable_reset() { 2404 usesTypeVariable_computed = false; 2405 } 2406 /** 2407 * @attribute syn 2408 * @aspect LookupParTypeDecl 2409 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1249 2410 */ 2411 @ASTNodeAnnotation.Attribute 2412 public boolean usesTypeVariable() { 2413 ASTNode$State state = state(); 2414 if (usesTypeVariable_computed) { 2415 return usesTypeVariable_value; 2416 } 2417 boolean intermediate = state.INTERMEDIATE_VALUE; 2418 state.INTERMEDIATE_VALUE = false; 2419 int num = state.boundariesCrossed; 2420 boolean isFinal = this.is$Final(); 2421 usesTypeVariable_value = getModifiers().usesTypeVariable() || getTypeAccess().usesTypeVariable() 2422 || getParameterList().usesTypeVariable() || getExceptionList().usesTypeVariable(); 2423 if (isFinal && num == state().boundariesCrossed) { 2424 usesTypeVariable_computed = true; 2425 } else { 2426 } 2427 state.INTERMEDIATE_VALUE |= intermediate; 2428 2429 return usesTypeVariable_value; 2430 } 2431 /** 2432 * @attribute syn 2433 * @aspect LookupParTypeDecl 2434 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1413 2435 */ 2436 @ASTNodeAnnotation.Attribute 2437 public MethodDecl erasedMethod() { 2438 MethodDecl erasedMethod_value = this; 2439 2440 return erasedMethod_value; 2441 } 2442 /** 2443 * @apilevel internal 2444 */ 2445 protected boolean sourceMethodDecl_computed = false; 2446 /** 2447 * @apilevel internal 2448 */ 2449 protected MethodDecl sourceMethodDecl_value; 2450 /** 2451 * @apilevel internal 2452 */ 2453 private void sourceMethodDecl_reset() { 2454 sourceMethodDecl_computed = false; 2455 sourceMethodDecl_value = null; 2456 } 2457 /** 2458 * @attribute syn 2459 * @aspect SourceDeclarations 2460 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1625 2461 */ 2462 @ASTNodeAnnotation.Attribute 2463 public MethodDecl sourceMethodDecl() { 2464 ASTNode$State state = state(); 2465 if (sourceMethodDecl_computed) { 2466 return sourceMethodDecl_value; 2467 } 2468 boolean intermediate = state.INTERMEDIATE_VALUE; 2469 state.INTERMEDIATE_VALUE = false; 2470 int num = state.boundariesCrossed; 2471 boolean isFinal = this.is$Final(); 2472 sourceMethodDecl_value = this; 2473 if (isFinal && num == state().boundariesCrossed) { 2474 sourceMethodDecl_computed = true; 2475 } else { 2476 } 2477 state.INTERMEDIATE_VALUE |= intermediate; 2478 2479 return sourceMethodDecl_value; 2480 } 2481 /** 2482 * @attribute syn 2483 * @aspect GenericsParTypeDecl 2484 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:90 2485 */ 2486 @ASTNodeAnnotation.Attribute 2487 public boolean visibleTypeParameters() { 2488 boolean visibleTypeParameters_value = !isStatic(); 2489 2490 return visibleTypeParameters_value; 2491 } 2492 /** 2493 * Note: isGeneric must be called first to check if this declaration is generic. 2494 * Otherwise this attribute will throw an error! 2495 * @return the original generic declaration of this method. 2496 * @attribute syn 2497 * @aspect MethodSignature15 2498 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:386 2499 */ 2500 @ASTNodeAnnotation.Attribute 2501 public GenericMethodDecl genericDecl() { 2502 { 2503 throw new Error("can not evaulate generic declaration of non-generic method"); 2504 } 2505 } 2506 /** 2507 * @attribute syn 2508 * @aspect MethodSignature15 2509 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:473 2510 */ 2511 @ASTNodeAnnotation.Attribute 2512 public int arity() { 2513 int arity_value = getNumParameter(); 2514 2515 return arity_value; 2516 } 2517 /** 2518 * @attribute syn 2519 * @aspect VariableArityParameters 2520 * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:55 2521 */ 2522 @ASTNodeAnnotation.Attribute 2523 public boolean isVariableArity() { 2524 boolean isVariableArity_value = getNumParameter() == 0 ? false : getParameter(getNumParameter()-1).isVariableArity(); 2525 2526 return isVariableArity_value; 2527 } 2528 /** 2529 * @attribute syn 2530 * @aspect VariableArityParameters 2531 * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:60 2532 */ 2533 @ASTNodeAnnotation.Attribute 2534 public ParameterDeclaration lastParameter() { 2535 ParameterDeclaration lastParameter_value = getParameter(getNumParameter() - 1); 2536 2537 return lastParameter_value; 2538 } 2539 /** 2540 * @attribute syn 2541 * @aspect GenericsCodegen 2542 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:375 2543 */ 2544 @ASTNodeAnnotation.Attribute 2545 public boolean needsSignatureAttribute() { 2546 { 2547 if (type().needsSignatureAttribute()) { 2548 return true; 2549 } 2550 for (int i = 0; i < getNumParameter(); i++) { 2551 if (getParameter(i).type().needsSignatureAttribute()) { 2552 return true; 2553 } 2554 } 2555 return false; 2556 } 2557 } 2558 /** 2559 * @attribute syn 2560 * @aspect GenericsCodegen 2561 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:508 2562 */ 2563 @ASTNodeAnnotation.Attribute 2564 public String methodTypeSignature() { 2565 { 2566 StringBuilder buf = new StringBuilder(); 2567 buf.append("("); 2568 for (int i = 0; i < getNumParameter(); i++) { 2569 buf.append(getParameter(i).type().classTypeSignature()); 2570 } 2571 buf.append(")"); 2572 buf.append(type().classTypeSignature()); 2573 for (int i = 0; i < getNumException(); i++) { 2574 buf.append("^" + getException(i).type().classTypeSignature()); 2575 } 2576 return buf.toString(); 2577 } 2578 } 2579 /** 2580 * @return true if the modifier list includes the SafeVarargs annotation 2581 * @attribute syn 2582 * @aspect SafeVarargs 2583 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:42 2584 */ 2585 @ASTNodeAnnotation.Attribute 2586 public boolean hasAnnotationSafeVarargs() { 2587 boolean hasAnnotationSafeVarargs_value = getModifiers().hasAnnotationSafeVarargs(); 2588 2589 return hasAnnotationSafeVarargs_value; 2590 } 2591 /** 2592 * It is an error if the SafeVarargs annotation is used on something 2593 * that is not a variable arity method or constructor. 2594 * @attribute syn 2595 * @aspect SafeVarargs 2596 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:73 2597 */ 2598 @ASTNodeAnnotation.Attribute 2599 public boolean hasIllegalAnnotationSafeVarargs() { 2600 boolean hasIllegalAnnotationSafeVarargs_value = hasAnnotationSafeVarargs() && (!isVariableArity() || (!isFinal() && !isStatic())); 2601 2602 return hasIllegalAnnotationSafeVarargs_value; 2603 } 2604 /** 2605 * @attribute syn 2606 * @aspect SuppressWarnings 2607 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:46 2608 */ 2609 @ASTNodeAnnotation.Attribute 2610 public boolean suppressWarnings(String type) { 2611 boolean suppressWarnings_String_value = hasAnnotationSuppressWarnings(type) || withinSuppressWarnings(type); 2612 2613 return suppressWarnings_String_value; 2614 } 2615 /** 2616 * @attribute syn 2617 * @aspect PreciseRethrow 2618 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:40 2619 */ 2620 @ASTNodeAnnotation.Attribute 2621 public boolean modifiedInScope(Variable var) { 2622 boolean modifiedInScope_Variable_value = hasBlock() && getBlock().modifiedInScope(var); 2623 2624 return modifiedInScope_Variable_value; 2625 } 2626 /** 2627 * @apilevel internal 2628 */ 2629 protected java.util.Map subsignatureTo_MethodDecl_values; 2630 /** 2631 * @apilevel internal 2632 */ 2633 private void subsignatureTo_MethodDecl_reset() { 2634 subsignatureTo_MethodDecl_values = null; 2635 } 2636 /** 2637 * @attribute syn 2638 * @aspect FunctionalInterface 2639 * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionalInterface.jrag:62 2640 */ 2641 @ASTNodeAnnotation.Attribute 2642 public boolean subsignatureTo(MethodDecl m) { 2643 Object _parameters = m; 2644 if (subsignatureTo_MethodDecl_values == null) subsignatureTo_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2645 ASTNode$State state = state(); 2646 if (subsignatureTo_MethodDecl_values.containsKey(_parameters)) { 2647 return (Boolean) subsignatureTo_MethodDecl_values.get(_parameters); 2648 } 2649 boolean intermediate = state.INTERMEDIATE_VALUE; 2650 state.INTERMEDIATE_VALUE = false; 2651 int num = state.boundariesCrossed; 2652 boolean isFinal = this.is$Final(); 2653 boolean subsignatureTo_MethodDecl_value = subsignatureTo_compute(m); 2654 if (isFinal && num == state().boundariesCrossed) { 2655 subsignatureTo_MethodDecl_values.put(_parameters, subsignatureTo_MethodDecl_value); 2656 } else { 2657 } 2658 state.INTERMEDIATE_VALUE |= intermediate; 2659 2660 return subsignatureTo_MethodDecl_value; 2661 } 2662 /** 2663 * @apilevel internal 2664 */ 2665 private boolean subsignatureTo_compute(MethodDecl m) { 2666 if (fullSignature().equals(m.fullSignature())) { 2667 return true; 2668 } else if (fullSignature().equals(m.signature())) { 2669 return true; 2670 } else { 2671 return false; 2672 } 2673 } 2674 /** 2675 * @apilevel internal 2676 */ 2677 protected java.util.Map returnTypeSubstitutableFor_MethodDecl_values; 2678 /** 2679 * @apilevel internal 2680 */ 2681 private void returnTypeSubstitutableFor_MethodDecl_reset() { 2682 returnTypeSubstitutableFor_MethodDecl_values = null; 2683 } 2684 /** 2685 * @attribute syn 2686 * @aspect FunctionalInterface 2687 * @declaredat /home/jesper/git/extendj/java8/frontend/FunctionalInterface.jrag:86 2688 */ 2689 @ASTNodeAnnotation.Attribute 2690 public boolean returnTypeSubstitutableFor(MethodDecl m) { 2691 Object _parameters = m; 2692 if (returnTypeSubstitutableFor_MethodDecl_values == null) returnTypeSubstitutableFor_MethodDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2693 ASTNode$State state = state(); 2694 if (returnTypeSubstitutableFor_MethodDecl_values.containsKey(_parameters)) { 2695 return (Boolean) returnTypeSubstitutableFor_MethodDecl_values.get(_parameters); 2696 } 2697 boolean intermediate = state.INTERMEDIATE_VALUE; 2698 state.INTERMEDIATE_VALUE = false; 2699 int num = state.boundariesCrossed; 2700 boolean isFinal = this.is$Final(); 2701 boolean returnTypeSubstitutableFor_MethodDecl_value = returnTypeSubstitutableFor_compute(m); 2702 if (isFinal && num == state().boundariesCrossed) { 2703 returnTypeSubstitutableFor_MethodDecl_values.put(_parameters, returnTypeSubstitutableFor_MethodDecl_value); 2704 } else { 2705 } 2706 state.INTERMEDIATE_VALUE |= intermediate; 2707 2708 return returnTypeSubstitutableFor_MethodDecl_value; 2709 } 2710 /** 2711 * @apilevel internal 2712 */ 2713 private boolean returnTypeSubstitutableFor_compute(MethodDecl m) { 2714 TypeDecl t1 = type(); 2715 TypeDecl t2 = m.type(); 2716 if (t1 instanceof VoidType && t2 instanceof VoidType) { 2717 return true; 2718 } else if (t1 instanceof PrimitiveType && t2 instanceof PrimitiveType) { 2719 PrimitiveType p1 = (PrimitiveType)t1; 2720 PrimitiveType p2 = (PrimitiveType)t2; 2721 return p1 == p2; 2722 } else if (t1.isReferenceType() && t2.isReferenceType()) { 2723 if (t1.strictSubtype(t2)) { 2724 return true; 2725 } else { 2726 return t1 == t2.erasure(); 2727 } 2728 } else { 2729 return false; 2730 } 2731 } 2732 /** 2733 * @apilevel internal 2734 */ 2735 protected boolean isDefault_computed = false; 2736 /** 2737 * @apilevel internal 2738 */ 2739 protected boolean isDefault_value; 2740 /** 2741 * @apilevel internal 2742 */ 2743 private void isDefault_reset() { 2744 isDefault_computed = false; 2745 } 2746 /** 2747 * @attribute syn 2748 * @aspect Modifiers 2749 * @declaredat /home/jesper/git/extendj/java8/frontend/Modifiers.jrag:31 2750 */ 2751 @ASTNodeAnnotation.Attribute 2752 public boolean isDefault() { 2753 ASTNode$State state = state(); 2754 if (isDefault_computed) { 2755 return isDefault_value; 2756 } 2757 boolean intermediate = state.INTERMEDIATE_VALUE; 2758 state.INTERMEDIATE_VALUE = false; 2759 int num = state.boundariesCrossed; 2760 boolean isFinal = this.is$Final(); 2761 isDefault_value = getModifiers().isDefault(); 2762 if (isFinal && num == state().boundariesCrossed) { 2763 isDefault_computed = true; 2764 } else { 2765 } 2766 state.INTERMEDIATE_VALUE |= intermediate; 2767 2768 return isDefault_value; 2769 } 2770 /** 2771 * @attribute inh 2772 * @aspect ExceptionHandling 2773 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:84 2774 */ 2775 /** 2776 * @attribute inh 2777 * @aspect ExceptionHandling 2778 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:84 2779 */ 2780 @ASTNodeAnnotation.Attribute 2781 public boolean handlesException(TypeDecl exceptionType) { 2782 Object _parameters = exceptionType; 2783 if (handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2784 ASTNode$State state = state(); 2785 if (handlesException_TypeDecl_values.containsKey(_parameters)) { 2786 return (Boolean) handlesException_TypeDecl_values.get(_parameters); 2787 } 2788 boolean intermediate = state.INTERMEDIATE_VALUE; 2789 state.INTERMEDIATE_VALUE = false; 2790 int num = state.boundariesCrossed; 2791 boolean isFinal = this.is$Final(); 2792 boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType); 2793 if (isFinal && num == state().boundariesCrossed) { 2794 handlesException_TypeDecl_values.put(_parameters, handlesException_TypeDecl_value); 2795 } else { 2796 } 2797 state.INTERMEDIATE_VALUE |= intermediate; 2798 2799 return handlesException_TypeDecl_value; 2800 } 2801 /** 2802 * @apilevel internal 2803 */ 2804 protected java.util.Map handlesException_TypeDecl_values; 2805 /** 2806 * @apilevel internal 2807 */ 2808 private void handlesException_TypeDecl_reset() { 2809 handlesException_TypeDecl_values = null; 2810 } 2811 /** 2812 * @attribute inh 2813 * @aspect LookupMethod 2814 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:36 2815 */ 2816 /** 2817 * @attribute inh 2818 * @aspect LookupMethod 2819 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:36 2820 */ 2821 @ASTNodeAnnotation.Attribute 2822 public MethodDecl unknownMethod() { 2823 MethodDecl unknownMethod_value = getParent().Define_unknownMethod(this, null); 2824 2825 return unknownMethod_value; 2826 } 2827 /** 2828 * @attribute inh 2829 * @aspect SuppressWarnings 2830 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:39 2831 */ 2832 /** 2833 * @attribute inh 2834 * @aspect SuppressWarnings 2835 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:39 2836 */ 2837 @ASTNodeAnnotation.Attribute 2838 public boolean withinSuppressWarnings(String annot) { 2839 boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot); 2840 2841 return withinSuppressWarnings_String_value; 2842 } 2843 /** 2844 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 2845 * @apilevel internal 2846 */ 2847 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 2848 if (caller == getBlockOptNoTransform()) { 2849 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:479 2850 return v.isFinal() && (v.isClassVariable() || v.isInstanceVariable()) ? true : isDAbefore(v); 2851 } 2852 else { 2853 return super.Define_isDAbefore(caller, child, v); 2854 } 2855 } 2856 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 2857 return true; 2858 } 2859 /** 2860 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 2861 * @apilevel internal 2862 */ 2863 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 2864 if (caller == getBlockOptNoTransform()) { 2865 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:983 2866 return v.isFinal() && (v.isClassVariable() || v.isInstanceVariable()) ? false : true; 2867 } 2868 else { 2869 return super.Define_isDUbefore(caller, child, v); 2870 } 2871 } 2872 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 2873 return true; 2874 } 2875 /** 2876 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:113 2877 * @apilevel internal 2878 */ 2879 public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 2880 if (caller == getBlockOptNoTransform()) { 2881 // @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:179 2882 return throwsException(exceptionType); 2883 } 2884 else { 2885 return getParent().Define_handlesException(this, caller, exceptionType); 2886 } 2887 } 2888 protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 2889 return true; 2890 } 2891 /** 2892 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 2893 * @apilevel internal 2894 */ 2895 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 2896 if (caller == getParameterListNoTransform()) { 2897 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:72 2898 int childIndex = caller.getIndexOfChild(child); 2899 return parameterDeclaration(name); 2900 } 2901 else if (caller == getBlockOptNoTransform()) { 2902 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:61 2903 { 2904 SimpleSet set = parameterDeclaration(name); 2905 // A declaration of a method parameter name shadows any other variable declarations 2906 if (!set.isEmpty()) { 2907 return set; 2908 } 2909 // Delegate to other declarations in scope 2910 return lookupVariable(name); 2911 } 2912 } 2913 else { 2914 return getParent().Define_lookupVariable(this, caller, name); 2915 } 2916 } 2917 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 2918 return true; 2919 } 2920 /** 2921 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:419 2922 * @apilevel internal 2923 */ 2924 public boolean Define_mayBePublic(ASTNode caller, ASTNode child) { 2925 if (caller == getModifiersNoTransform()) { 2926 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:312 2927 return true; 2928 } 2929 else { 2930 return getParent().Define_mayBePublic(this, caller); 2931 } 2932 } 2933 protected boolean canDefine_mayBePublic(ASTNode caller, ASTNode child) { 2934 return true; 2935 } 2936 /** 2937 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:421 2938 * @apilevel internal 2939 */ 2940 public boolean Define_mayBeProtected(ASTNode caller, ASTNode child) { 2941 if (caller == getModifiersNoTransform()) { 2942 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:313 2943 return true; 2944 } 2945 else { 2946 return getParent().Define_mayBeProtected(this, caller); 2947 } 2948 } 2949 protected boolean canDefine_mayBeProtected(ASTNode caller, ASTNode child) { 2950 return true; 2951 } 2952 /** 2953 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:420 2954 * @apilevel internal 2955 */ 2956 public boolean Define_mayBePrivate(ASTNode caller, ASTNode child) { 2957 if (caller == getModifiersNoTransform()) { 2958 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:314 2959 return true; 2960 } 2961 else { 2962 return getParent().Define_mayBePrivate(this, caller); 2963 } 2964 } 2965 protected boolean canDefine_mayBePrivate(ASTNode caller, ASTNode child) { 2966 return true; 2967 } 2968 /** 2969 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:424 2970 * @apilevel internal 2971 */ 2972 public boolean Define_mayBeAbstract(ASTNode caller, ASTNode child) { 2973 if (caller == getModifiersNoTransform()) { 2974 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:315 2975 return true; 2976 } 2977 else { 2978 return getParent().Define_mayBeAbstract(this, caller); 2979 } 2980 } 2981 protected boolean canDefine_mayBeAbstract(ASTNode caller, ASTNode child) { 2982 return true; 2983 } 2984 /** 2985 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:422 2986 * @apilevel internal 2987 */ 2988 public boolean Define_mayBeStatic(ASTNode caller, ASTNode child) { 2989 if (caller == getModifiersNoTransform()) { 2990 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:316 2991 return true; 2992 } 2993 else { 2994 return getParent().Define_mayBeStatic(this, caller); 2995 } 2996 } 2997 protected boolean canDefine_mayBeStatic(ASTNode caller, ASTNode child) { 2998 return true; 2999 } 3000 /** 3001 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423 3002 * @apilevel internal 3003 */ 3004 public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) { 3005 if (caller == getModifiersNoTransform()) { 3006 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:317 3007 return true; 3008 } 3009 else { 3010 return getParent().Define_mayBeFinal(this, caller); 3011 } 3012 } 3013 protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) { 3014 return true; 3015 } 3016 /** 3017 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:428 3018 * @apilevel internal 3019 */ 3020 public boolean Define_mayBeSynchronized(ASTNode caller, ASTNode child) { 3021 if (caller == getModifiersNoTransform()) { 3022 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:318 3023 return true; 3024 } 3025 else { 3026 return getParent().Define_mayBeSynchronized(this, caller); 3027 } 3028 } 3029 protected boolean canDefine_mayBeSynchronized(ASTNode caller, ASTNode child) { 3030 return true; 3031 } 3032 /** 3033 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:429 3034 * @apilevel internal 3035 */ 3036 public boolean Define_mayBeNative(ASTNode caller, ASTNode child) { 3037 if (caller == getModifiersNoTransform()) { 3038 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:319 3039 return true; 3040 } 3041 else { 3042 return getParent().Define_mayBeNative(this, caller); 3043 } 3044 } 3045 protected boolean canDefine_mayBeNative(ASTNode caller, ASTNode child) { 3046 return true; 3047 } 3048 /** 3049 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:427 3050 * @apilevel internal 3051 */ 3052 public boolean Define_mayBeStrictfp(ASTNode caller, ASTNode child) { 3053 if (caller == getModifiersNoTransform()) { 3054 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:320 3055 return true; 3056 } 3057 else { 3058 return getParent().Define_mayBeStrictfp(this, caller); 3059 } 3060 } 3061 protected boolean canDefine_mayBeStrictfp(ASTNode caller, ASTNode child) { 3062 return true; 3063 } 3064 /** 3065 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:310 3066 * @apilevel internal 3067 */ 3068 public ASTNode Define_enclosingBlock(ASTNode caller, ASTNode child) { 3069 if (caller == getBlockOptNoTransform()) { 3070 // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:311 3071 return this; 3072 } 3073 else { 3074 return getParent().Define_enclosingBlock(this, caller); 3075 } 3076 } 3077 protected boolean canDefine_enclosingBlock(ASTNode caller, ASTNode child) { 3078 return true; 3079 } 3080 /** 3081 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 3082 * @apilevel internal 3083 */ 3084 public NameType Define_nameType(ASTNode caller, ASTNode child) { 3085 if (caller == getExceptionListNoTransform()) { 3086 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:108 3087 int childIndex = caller.getIndexOfChild(child); 3088 return NameType.TYPE_NAME; 3089 } 3090 else if (caller == getParameterListNoTransform()) { 3091 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:107 3092 int childIndex = caller.getIndexOfChild(child); 3093 return NameType.TYPE_NAME; 3094 } 3095 else if (caller == getTypeAccessNoTransform()) { 3096 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:106 3097 return NameType.TYPE_NAME; 3098 } 3099 else { 3100 return getParent().Define_nameType(this, caller); 3101 } 3102 } 3103 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 3104 return true; 3105 } 3106 /** 3107 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:472 3108 * @apilevel internal 3109 */ 3110 public TypeDecl Define_returnType(ASTNode caller, ASTNode child) { 3111 if (caller == getBlockOptNoTransform()) { 3112 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:474 3113 return type(); 3114 } 3115 else { 3116 return getParent().Define_returnType(this, caller); 3117 } 3118 } 3119 protected boolean canDefine_returnType(ASTNode caller, ASTNode child) { 3120 return true; 3121 } 3122 /** 3123 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182 3124 * @apilevel internal 3125 */ 3126 public boolean Define_inStaticContext(ASTNode caller, ASTNode child) { 3127 if (caller == getBlockOptNoTransform()) { 3128 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:190 3129 return isStatic(); 3130 } 3131 else { 3132 return getParent().Define_inStaticContext(this, caller); 3133 } 3134 } 3135 protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) { 3136 return true; 3137 } 3138 /** 3139 * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52 3140 * @apilevel internal 3141 */ 3142 public boolean Define_reachable(ASTNode caller, ASTNode child) { 3143 if (caller == getBlockOptNoTransform()) { 3144 // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:64 3145 return true; 3146 } 3147 else { 3148 return getParent().Define_reachable(this, caller); 3149 } 3150 } 3151 protected boolean canDefine_reachable(ASTNode caller, ASTNode child) { 3152 return true; 3153 } 3154 /** 3155 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:44 3156 * @apilevel internal 3157 */ 3158 public boolean Define_isMethodParameter(ASTNode caller, ASTNode child) { 3159 if (caller == getParameterListNoTransform()) { 3160 // @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:82 3161 int childIndex = caller.getIndexOfChild(child); 3162 return true; 3163 } 3164 else { 3165 return getParent().Define_isMethodParameter(this, caller); 3166 } 3167 } 3168 protected boolean canDefine_isMethodParameter(ASTNode caller, ASTNode child) { 3169 return true; 3170 } 3171 /** 3172 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:45 3173 * @apilevel internal 3174 */ 3175 public boolean Define_isConstructorParameter(ASTNode caller, ASTNode child) { 3176 if (caller == getParameterListNoTransform()) { 3177 // @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:83 3178 int childIndex = caller.getIndexOfChild(child); 3179 return false; 3180 } 3181 else { 3182 return getParent().Define_isConstructorParameter(this, caller); 3183 } 3184 } 3185 protected boolean canDefine_isConstructorParameter(ASTNode caller, ASTNode child) { 3186 return true; 3187 } 3188 /** 3189 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:46 3190 * @apilevel internal 3191 */ 3192 public boolean Define_isExceptionHandlerParameter(ASTNode caller, ASTNode child) { 3193 if (caller == getParameterListNoTransform()) { 3194 // @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:84 3195 int childIndex = caller.getIndexOfChild(child); 3196 return false; 3197 } 3198 else { 3199 return getParent().Define_isExceptionHandlerParameter(this, caller); 3200 } 3201 } 3202 protected boolean canDefine_isExceptionHandlerParameter(ASTNode caller, ASTNode child) { 3203 return true; 3204 } 3205 /** 3206 * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64 3207 * @apilevel internal 3208 */ 3209 public int Define_localNum(ASTNode caller, ASTNode child) { 3210 if (caller == getBlockOptNoTransform()) { 3211 // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:109 3212 return offsetAfterParameters() + resultOffset(); 3213 } 3214 else if (caller == getParameterListNoTransform()) { 3215 // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:80 3216 int index = caller.getIndexOfChild(child); 3217 { 3218 if (index == 0) { 3219 return offsetBeforeParameters(); 3220 } else { 3221 ParameterDeclaration last = getParameter(index-1); 3222 return last.localNum() + last.type().variableSize(); 3223 } 3224 } 3225 } 3226 else { 3227 return getParent().Define_localNum(this, caller); 3228 } 3229 } 3230 protected boolean canDefine_localNum(ASTNode caller, ASTNode child) { 3231 return true; 3232 } 3233 /** 3234 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:101 3235 * @apilevel internal 3236 */ 3237 public int Define_resultSaveLocalNum(ASTNode caller, ASTNode child) { 3238 if (caller == getBlockOptNoTransform()) { 3239 // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:102 3240 return offsetAfterParameters(); 3241 } 3242 else { 3243 return getParent().Define_resultSaveLocalNum(this, caller); 3244 } 3245 } 3246 protected boolean canDefine_resultSaveLocalNum(ASTNode caller, ASTNode child) { 3247 return true; 3248 } 3249 /** 3250 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:96 3251 * @apilevel internal 3252 */ 3253 public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 3254 if (caller == getModifiersNoTransform()) { 3255 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:113 3256 return name.equals("METHOD"); 3257 } 3258 else { 3259 return getParent().Define_mayUseAnnotationTarget(this, caller, name); 3260 } 3261 } 3262 protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 3263 return true; 3264 } 3265 /** 3266 * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:48 3267 * @apilevel internal 3268 */ 3269 public boolean Define_variableArityValid(ASTNode caller, ASTNode child) { 3270 if (caller == getParameterListNoTransform()) { 3271 // @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:44 3272 int i = caller.getIndexOfChild(child); 3273 return i == getNumParameter() - 1; 3274 } 3275 else { 3276 return getParent().Define_variableArityValid(this, caller); 3277 } 3278 } 3279 protected boolean canDefine_variableArityValid(ASTNode caller, ASTNode child) { 3280 return true; 3281 } 3282 /** 3283 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30 3284 * @apilevel internal 3285 */ 3286 public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 3287 if (caller == getParameterListNoTransform()) { 3288 // @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:79 3289 int childIndex = caller.getIndexOfChild(child); 3290 return hasBlock() && getBlock().modifiedInScope(var); 3291 } 3292 else { 3293 return getParent().Define_inhModifiedInScope(this, caller, var); 3294 } 3295 } 3296 protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 3297 return true; 3298 } 3299 /** 3300 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:206 3301 * @apilevel internal 3302 */ 3303 public boolean Define_isCatchParam(ASTNode caller, ASTNode child) { 3304 if (caller == getParameterListNoTransform()) { 3305 // @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:209 3306 int childIndex = caller.getIndexOfChild(child); 3307 return false; 3308 } 3309 else { 3310 return getParent().Define_isCatchParam(this, caller); 3311 } 3312 } 3313 protected boolean canDefine_isCatchParam(ASTNode caller, ASTNode child) { 3314 return true; 3315 } 3316 /** 3317 * @apilevel internal 3318 */ 3319 public ASTNode rewriteTo() { 3320 return super.rewriteTo(); 3321 } 3322 }