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