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:77 027 * @production FieldDeclaration : {@link MemberDecl} ::= <span class="component">{@link Modifiers}</span> <span class="component">TypeAccess:{@link Access}</span> <span class="component"><ID:String></span> <span class="component">[Init:{@link Expr}]</span>; 028 029 */ 030 public class FieldDeclaration extends MemberDecl implements Cloneable, SimpleSet, Iterator, Variable { 031 /** 032 * @aspect BoundNames 033 * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:32 034 */ 035 public Access createQualifiedBoundAccess() { 036 if (isStatic()) { 037 return hostType().createQualifiedAccess().qualifiesAccess(new BoundFieldAccess(this)); 038 } else 039 return new ThisAccess("this").qualifiesAccess( 040 new BoundFieldAccess(this)); 041 } 042 /** 043 * @aspect BoundNames 044 * @declaredat /home/jesper/git/extendj/java4/frontend/BoundNames.jrag:106 045 */ 046 public Access createBoundFieldAccess() { 047 return createQualifiedBoundAccess(); 048 } 049 /** 050 * @aspect DataStructures 051 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:105 052 */ 053 public SimpleSet add(Object o) { 054 return new SimpleSetImpl().add(this).add(o); 055 } 056 /** 057 * @aspect DataStructures 058 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:109 059 */ 060 public boolean isSingleton() { return true; } 061 /** 062 * @aspect DataStructures 063 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:110 064 */ 065 public boolean isSingleton(Object o) { return contains(o); } 066 /** 067 * @aspect DataStructures 068 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:113 069 */ 070 private FieldDeclaration iterElem; 071 /** 072 * @aspect DataStructures 073 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:114 074 */ 075 public Iterator iterator() { iterElem = this; return this; } 076 /** 077 * @aspect DataStructures 078 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:115 079 */ 080 public boolean hasNext() { return iterElem != null; } 081 /** 082 * @aspect DataStructures 083 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:116 084 */ 085 public Object next() { Object o = iterElem; iterElem = null; return o; } 086 /** 087 * @aspect DataStructures 088 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:117 089 */ 090 public void remove() { throw new UnsupportedOperationException(); } 091 /** 092 * @aspect DefiniteAssignment 093 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:194 094 */ 095 public void definiteAssignment() { 096 super.definiteAssignment(); 097 if (isBlank() && isFinal() && isClassVariable()) { 098 boolean found = false; 099 TypeDecl typeDecl = hostType(); 100 for (int i = 0; i < typeDecl.getNumBodyDecl(); i++) { 101 if (typeDecl.getBodyDecl(i) instanceof StaticInitializer) { 102 StaticInitializer s = (StaticInitializer) typeDecl.getBodyDecl(i); 103 if (s.isDAafter(this)) { 104 found = true; 105 } 106 } 107 108 else if (typeDecl.getBodyDecl(i) instanceof FieldDeclaration) { 109 FieldDeclaration f = (FieldDeclaration) typeDecl.getBodyDecl(i); 110 if (f.isStatic() && f.isDAafter(this)) { 111 found = true; 112 } 113 } 114 115 } 116 if (!found) { 117 errorf("blank final class variable %s in %s is not definitely assigned in static initializer", 118 name(), hostType().typeName()); 119 } 120 121 } 122 if (isBlank() && isFinal() && isInstanceVariable()) { 123 TypeDecl typeDecl = hostType(); 124 boolean found = false; 125 for (int i = 0; !found && i < typeDecl.getNumBodyDecl(); i++) { 126 if (typeDecl.getBodyDecl(i) instanceof FieldDeclaration) { 127 FieldDeclaration f = (FieldDeclaration) typeDecl.getBodyDecl(i); 128 if (!f.isStatic() && f.isDAafter(this)) { 129 found = true; 130 } 131 } else if (typeDecl.getBodyDecl(i) instanceof InstanceInitializer) { 132 InstanceInitializer ii = (InstanceInitializer) typeDecl.getBodyDecl(i); 133 if (ii.getBlock().isDAafter(this)) { 134 found = true; 135 } 136 } 137 } 138 for (Iterator iter = typeDecl.constructors().iterator(); !found && iter.hasNext(); ) { 139 ConstructorDecl c = (ConstructorDecl) iter.next(); 140 if (!c.isDAafter(this)) { 141 errorf("blank final instance variable %s in %s is not definitely assigned after %s", 142 name(), hostType().typeName(), c.signature()); 143 } 144 } 145 } 146 if (isBlank() && hostType().isInterfaceDecl()) { 147 errorf("variable %s in %s which is an interface must have an initializer", 148 name(), hostType().typeName()); 149 } 150 } 151 /** 152 * @aspect Modifiers 153 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:140 154 */ 155 public void checkModifiers() { 156 super.checkModifiers(); 157 if (hostType().isInterfaceDecl()) { 158 if (isProtected()) { 159 error("an interface field may not be protected"); 160 } 161 if (isPrivate()) { 162 error("an interface field may not be private"); 163 } 164 if (isTransient()) { 165 error("an interface field may not be transient"); 166 } 167 if (isVolatile()) { 168 error("an interface field may not be volatile"); 169 } 170 } 171 } 172 /** 173 * @aspect NameCheck 174 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:352 175 */ 176 public void nameCheck() { 177 super.nameCheck(); 178 // 8.3 179 for (Iterator iter = hostType().memberFields(name()).iterator(); iter.hasNext(); ) { 180 Variable v = (Variable) iter.next(); 181 if (v != this && v.hostType() == hostType()) { 182 errorf("field named %s is multiply declared in type %s", name(), hostType().typeName()); 183 } 184 } 185 186 } 187 /** 188 * @aspect NodeConstructors 189 * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:97 190 */ 191 public FieldDeclaration(Modifiers m, Access type, String name) { 192 this(m, type, name, new Opt()); 193 } 194 /** 195 * @aspect NodeConstructors 196 * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:101 197 */ 198 public FieldDeclaration(Modifiers m, Access type, String name, Expr init) { 199 this(m, type, name, new Opt(init)); 200 } 201 /** 202 * @aspect Java4PrettyPrint 203 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:41 204 */ 205 public void prettyPrint(PrettyPrinter out) { 206 if (hasDocComment()) { 207 out.print(docComment()); 208 } 209 if (!out.isNewLine()) { 210 out.println(); 211 } 212 out.print(getModifiers()); 213 out.print(getTypeAccess()); 214 out.print(" "); 215 out.print(getID()); 216 if (hasInit()) { 217 out.print(" = "); 218 out.print(getInit()); 219 } 220 out.print(";"); 221 } 222 /** 223 * @aspect TypeCheck 224 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:55 225 */ 226 public void typeCheck() { 227 if (hasInit()) { 228 TypeDecl source = getInit().type(); 229 TypeDecl dest = type(); 230 if (!source.assignConversionTo(dest, getInit())) { 231 errorf("can not assign field %s of type %s a value of type %s", 232 name(), dest.typeName(), source.typeName()); 233 } 234 } 235 } 236 /** 237 * @aspect VariableDeclarationTransformation 238 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:112 239 */ 240 private FieldDecl fieldDecl = null; 241 /** 242 * @aspect VariableDeclarationTransformation 243 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:113 244 */ 245 public FieldDecl getFieldDecl() { 246 return fieldDecl; 247 } 248 /** 249 * @aspect VariableDeclarationTransformation 250 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:116 251 */ 252 public void setFieldDecl(FieldDecl fieldDecl) { 253 this.fieldDecl = fieldDecl; 254 } 255 /** 256 * @aspect CodeGeneration 257 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:334 258 */ 259 public void emitLoadField(CodeGeneration gen, TypeDecl typeDecl) { 260 if (hostType().isArrayDecl() && name().equals("length")) { 261 gen.emit(Bytecode.ARRAYLENGTH); 262 return; 263 } 264 String classname = typeDecl.constantPoolName(); 265 String desc = type().typeDescriptor(); 266 String name = name(); 267 int index = gen.constantPool().addFieldref(classname, name, desc); 268 if (isStatic()) { 269 gen.emit(Bytecode.GETSTATIC, type().variableSize()).add2(index); 270 } else { 271 gen.emit(Bytecode.GETFIELD, type().variableSize() - 1).add2(index); 272 } 273 } 274 /** 275 * @aspect CodeGeneration 276 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:393 277 */ 278 public void emitStoreField(CodeGeneration gen, TypeDecl typeDecl) { 279 String classname = typeDecl.constantPoolName(); 280 String desc = type().typeDescriptor(); 281 String name = name(); 282 int index = gen.constantPool().addFieldref(classname, name, desc); 283 if (isStatic()) { 284 gen.emit(Bytecode.PUTSTATIC, -type().variableSize()).add2(index); 285 } else { 286 gen.emit(Bytecode.PUTFIELD, -type().variableSize() - 1).add2(index); 287 } 288 } 289 /** 290 * Generate static initialization code for the field. 291 * @aspect CreateBCode 292 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:295 293 */ 294 public void emitStaticInitializer(CodeGeneration gen, TypeDecl hostType) { 295 if (isStatic() && hasInit()) { 296 emitInitializerBCode(gen); 297 emitStoreField(gen, hostType); 298 } 299 } 300 /** 301 * Generate instance initialization code for the field. 302 * @aspect CreateBCode 303 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:305 304 */ 305 public void emitInstanceInitializer(CodeGeneration gen, TypeDecl hostType) { 306 if (!isStatic() && hasInit()) { 307 gen.emit(Bytecode.ALOAD_0); 308 emitInitializerBCode(gen); 309 emitStoreField(gen, hostType); 310 } 311 } 312 /** 313 * Generate field initialization bytecode. 314 * @aspect CreateBCode 315 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:316 316 */ 317 protected void emitInitializerBCode(CodeGeneration gen) { 318 getInit().createBCode(gen); 319 getInit().type().emitAssignConvTo(gen, type()); 320 } 321 /** 322 * @aspect GenerateClassfile 323 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:429 324 */ 325 public boolean clear() { 326 return false; 327 } 328 /** 329 * @aspect InnerClasses 330 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:341 331 */ 332 public MethodDecl createAccessor(TypeDecl fieldQualifier) { 333 MethodDecl m = (MethodDecl) fieldQualifier.getAccessor(this, "field_read"); 334 if (m != null) { 335 return m; 336 } 337 338 int accessorIndex = fieldQualifier.accessorCounter++; 339 Modifiers modifiers = new Modifiers(new List()); 340 modifiers.addModifier(new Modifier("static")); 341 modifiers.addModifier(new Modifier("synthetic")); 342 modifiers.addModifier(new Modifier("public")); 343 344 List parameters = new List(); 345 if (!isStatic()) { 346 parameters.add(new ParameterDeclaration(fieldQualifier.createQualifiedAccess(), "that")); 347 } 348 349 m = new MethodDecl( 350 modifiers, 351 type().createQualifiedAccess(), 352 "get$" + name() + "$access$" + accessorIndex, 353 parameters, 354 new List(), 355 new Opt( 356 new Block( 357 new List().add( 358 new ReturnStmt(createAccess()) 359 ) 360 ) 361 ) 362 ); 363 m = fieldQualifier.addMemberMethod(m); 364 fieldQualifier.addAccessor(this, "field_read", m); 365 return m; 366 } 367 /** 368 * @aspect InnerClasses 369 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:377 370 */ 371 public MethodDecl createAccessorWrite(TypeDecl fieldQualifier) { 372 MethodDecl m = (MethodDecl) fieldQualifier.getAccessor(this, "field_write"); 373 if (m != null) { 374 return m; 375 } 376 377 int accessorIndex = fieldQualifier.accessorCounter++; 378 Modifiers modifiers = new Modifiers(new List()); 379 modifiers.addModifier(new Modifier("static")); 380 modifiers.addModifier(new Modifier("synthetic")); 381 modifiers.addModifier(new Modifier("public")); 382 383 List parameters = new List(); 384 if (!isStatic()) { 385 parameters.add(new ParameterDeclaration(fieldQualifier.createQualifiedAccess(), "that")); 386 } 387 parameters.add(new ParameterDeclaration(type().createQualifiedAccess(), "value")); 388 389 m = new MethodDecl( 390 modifiers, 391 type().createQualifiedAccess(), 392 "set$" + name() + "$access$" + accessorIndex, 393 parameters, 394 new List(), 395 new Opt( 396 new Block( 397 new List().add( 398 new ExprStmt( 399 new AssignSimpleExpr( 400 createAccess(), 401 new VarAccess("value") 402 ) 403 ) 404 ).add( 405 new ReturnStmt( 406 new Opt( 407 new VarAccess("value") 408 ) 409 ) 410 ) 411 ) 412 ) 413 ); 414 m = fieldQualifier.addMemberMethod(m); 415 fieldQualifier.addAccessor(this, "field_write", m); 416 return m; 417 } 418 /** 419 * @aspect InnerClasses 420 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:425 421 */ 422 private Access createAccess() { 423 Access fieldAccess = new BoundFieldAccess(this); 424 return isStatic() ? fieldAccess : new VarAccess("that").qualifiesAccess(fieldAccess); 425 } 426 /** 427 * @aspect LookupParTypeDecl 428 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1400 429 */ 430 public BodyDecl substitutedBodyDecl(Parameterization parTypeDecl) { 431 return new FieldDeclarationSubstituted( 432 (Modifiers) getModifiers().treeCopyNoTransform(), 433 getTypeAccess().type().substituteReturnType(parTypeDecl), 434 getID(), 435 new Opt(), 436 this 437 ); 438 } 439 /** 440 * @aspect UncheckedConversion 441 * @declaredat /home/jesper/git/extendj/java7/frontend/UncheckedConversion.jrag:47 442 */ 443 public void checkWarnings() { 444 if (hasInit() && !suppressWarnings("unchecked")) { 445 checkUncheckedConversion(getInit().type(), type()); 446 } 447 } 448 /** 449 * @declaredat ASTNode:1 450 */ 451 public FieldDeclaration() { 452 super(); 453 } 454 /** 455 * Initializes the child array to the correct size. 456 * Initializes List and Opt nta children. 457 * @apilevel internal 458 * @ast method 459 * @declaredat ASTNode:10 460 */ 461 public void init$Children() { 462 children = new ASTNode[3]; 463 setChild(new Opt(), 2); 464 } 465 /** 466 * @declaredat ASTNode:14 467 */ 468 public FieldDeclaration(Modifiers p0, Access p1, String p2, Opt<Expr> p3) { 469 setChild(p0, 0); 470 setChild(p1, 1); 471 setID(p2); 472 setChild(p3, 2); 473 } 474 /** 475 * @declaredat ASTNode:20 476 */ 477 public FieldDeclaration(Modifiers p0, Access p1, beaver.Symbol p2, Opt<Expr> p3) { 478 setChild(p0, 0); 479 setChild(p1, 1); 480 setID(p2); 481 setChild(p3, 2); 482 } 483 /** 484 * @apilevel low-level 485 * @declaredat ASTNode:29 486 */ 487 protected int numChildren() { 488 return 3; 489 } 490 /** 491 * @apilevel internal 492 * @declaredat ASTNode:35 493 */ 494 public boolean mayHaveRewrite() { 495 return false; 496 } 497 /** 498 * @apilevel internal 499 * @declaredat ASTNode:41 500 */ 501 public void flushAttrCache() { 502 super.flushAttrCache(); 503 accessibleFrom_TypeDecl_reset(); 504 exceptions_reset(); 505 isDAafter_Variable_reset(); 506 isDUafter_Variable_reset(); 507 constant_reset(); 508 attributes_reset(); 509 flags_reset(); 510 usesTypeVariable_reset(); 511 sourceVariableDecl_reset(); 512 throwTypes_reset(); 513 isEffectivelyFinal_reset(); 514 } 515 /** 516 * @apilevel internal 517 * @declaredat ASTNode:58 518 */ 519 public void flushCollectionCache() { 520 super.flushCollectionCache(); 521 } 522 /** 523 * @apilevel internal 524 * @declaredat ASTNode:64 525 */ 526 public void flushRewriteCache() { 527 super.flushRewriteCache(); 528 } 529 /** 530 * @apilevel internal 531 * @declaredat ASTNode:70 532 */ 533 public FieldDeclaration clone() throws CloneNotSupportedException { 534 FieldDeclaration node = (FieldDeclaration) super.clone(); 535 return node; 536 } 537 /** 538 * @apilevel internal 539 * @declaredat ASTNode:77 540 */ 541 public FieldDeclaration copy() { 542 try { 543 FieldDeclaration node = (FieldDeclaration) clone(); 544 node.parent = null; 545 if (children != null) { 546 node.children = (ASTNode[]) children.clone(); 547 } 548 return node; 549 } catch (CloneNotSupportedException e) { 550 throw new Error("Error: clone not supported for " + getClass().getName()); 551 } 552 } 553 /** 554 * Create a deep copy of the AST subtree at this node. 555 * The copy is dangling, i.e. has no parent. 556 * @return dangling copy of the subtree at this node 557 * @apilevel low-level 558 * @deprecated Please use treeCopy or treeCopyNoTransform instead 559 * @declaredat ASTNode:96 560 */ 561 @Deprecated 562 public FieldDeclaration fullCopy() { 563 return treeCopyNoTransform(); 564 } 565 /** 566 * Create a deep copy of the AST subtree at this node. 567 * The copy is dangling, i.e. has no parent. 568 * @return dangling copy of the subtree at this node 569 * @apilevel low-level 570 * @declaredat ASTNode:106 571 */ 572 public FieldDeclaration treeCopyNoTransform() { 573 FieldDeclaration tree = (FieldDeclaration) copy(); 574 if (children != null) { 575 for (int i = 0; i < children.length; ++i) { 576 ASTNode child = (ASTNode) children[i]; 577 if (child != null) { 578 child = child.treeCopyNoTransform(); 579 tree.setChild(child, i); 580 } 581 } 582 } 583 return tree; 584 } 585 /** 586 * Create a deep copy of the AST subtree at this node. 587 * The subtree of this node is traversed to trigger rewrites before copy. 588 * The copy is dangling, i.e. has no parent. 589 * @return dangling copy of the subtree at this node 590 * @apilevel low-level 591 * @declaredat ASTNode:126 592 */ 593 public FieldDeclaration treeCopy() { 594 doFullTraversal(); 595 return treeCopyNoTransform(); 596 } 597 /** 598 * @apilevel internal 599 * @declaredat ASTNode:133 600 */ 601 protected boolean is$Equal(ASTNode node) { 602 return super.is$Equal(node) && (tokenString_ID == ((FieldDeclaration)node).tokenString_ID); 603 } 604 /** 605 * Replaces the Modifiers child. 606 * @param node The new node to replace the Modifiers child. 607 * @apilevel high-level 608 */ 609 public void setModifiers(Modifiers node) { 610 setChild(node, 0); 611 } 612 /** 613 * Retrieves the Modifiers child. 614 * @return The current node used as the Modifiers child. 615 * @apilevel high-level 616 */ 617 @ASTNodeAnnotation.Child(name="Modifiers") 618 public Modifiers getModifiers() { 619 return (Modifiers) getChild(0); 620 } 621 /** 622 * Retrieves the Modifiers child. 623 * <p><em>This method does not invoke AST transformations.</em></p> 624 * @return The current node used as the Modifiers child. 625 * @apilevel low-level 626 */ 627 public Modifiers getModifiersNoTransform() { 628 return (Modifiers) getChildNoTransform(0); 629 } 630 /** 631 * Replaces the TypeAccess child. 632 * @param node The new node to replace the TypeAccess child. 633 * @apilevel high-level 634 */ 635 public void setTypeAccess(Access node) { 636 setChild(node, 1); 637 } 638 /** 639 * Retrieves the TypeAccess child. 640 * @return The current node used as the TypeAccess child. 641 * @apilevel high-level 642 */ 643 @ASTNodeAnnotation.Child(name="TypeAccess") 644 public Access getTypeAccess() { 645 return (Access) getChild(1); 646 } 647 /** 648 * Retrieves the TypeAccess child. 649 * <p><em>This method does not invoke AST transformations.</em></p> 650 * @return The current node used as the TypeAccess child. 651 * @apilevel low-level 652 */ 653 public Access getTypeAccessNoTransform() { 654 return (Access) getChildNoTransform(1); 655 } 656 /** 657 * Replaces the lexeme ID. 658 * @param value The new value for the lexeme ID. 659 * @apilevel high-level 660 */ 661 public void setID(String value) { 662 tokenString_ID = value; 663 } 664 /** 665 * @apilevel internal 666 */ 667 protected String tokenString_ID; 668 /** 669 */ 670 public int IDstart; 671 /** 672 */ 673 public int IDend; 674 /** 675 * JastAdd-internal setter for lexeme ID using the Beaver parser. 676 * @param symbol Symbol containing the new value for the lexeme ID 677 * @apilevel internal 678 */ 679 public void setID(beaver.Symbol symbol) { 680 if (symbol.value != null && !(symbol.value instanceof String)) 681 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 682 tokenString_ID = (String)symbol.value; 683 IDstart = symbol.getStart(); 684 IDend = symbol.getEnd(); 685 } 686 /** 687 * Retrieves the value for the lexeme ID. 688 * @return The value for the lexeme ID. 689 * @apilevel high-level 690 */ 691 @ASTNodeAnnotation.Token(name="ID") 692 public String getID() { 693 return tokenString_ID != null ? tokenString_ID : ""; 694 } 695 /** 696 * Replaces the optional node for the Init child. This is the <code>Opt</code> 697 * node containing the child Init, not the actual child! 698 * @param opt The new node to be used as the optional node for the Init child. 699 * @apilevel low-level 700 */ 701 public void setInitOpt(Opt<Expr> opt) { 702 setChild(opt, 2); 703 } 704 /** 705 * Replaces the (optional) Init child. 706 * @param node The new node to be used as the Init child. 707 * @apilevel high-level 708 */ 709 public void setInit(Expr node) { 710 getInitOpt().setChild(node, 0); 711 } 712 /** 713 * Check whether the optional Init child exists. 714 * @return {@code true} if the optional Init child exists, {@code false} if it does not. 715 * @apilevel high-level 716 */ 717 public boolean hasInit() { 718 return getInitOpt().getNumChild() != 0; 719 } 720 /** 721 * Retrieves the (optional) Init child. 722 * @return The Init child, if it exists. Returns {@code null} otherwise. 723 * @apilevel low-level 724 */ 725 public Expr getInit() { 726 return (Expr) getInitOpt().getChild(0); 727 } 728 /** 729 * Retrieves the optional node for the Init child. This is the <code>Opt</code> node containing the child Init, not the actual child! 730 * @return The optional node for child the Init child. 731 * @apilevel low-level 732 */ 733 @ASTNodeAnnotation.OptChild(name="Init") 734 public Opt<Expr> getInitOpt() { 735 return (Opt<Expr>) getChild(2); 736 } 737 /** 738 * Retrieves the optional node for child Init. This is the <code>Opt</code> node containing the child Init, not the actual child! 739 * <p><em>This method does not invoke AST transformations.</em></p> 740 * @return The optional node for child Init. 741 * @apilevel low-level 742 */ 743 public Opt<Expr> getInitOptNoTransform() { 744 return (Opt<Expr>) getChildNoTransform(2); 745 } 746 /** 747 * @aspect Attributes 748 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:213 749 */ 750 private Collection refined_Attributes_FieldDeclaration_attributes() 751 { 752 ArrayList l = new ArrayList(); 753 if (isFinal() && isConstant() && (type().isPrimitive() || type().isString())) { 754 l.add(new ConstantValueAttribute(hostType().constantPool(), this)); 755 } 756 return l; 757 } 758 /** 759 * @aspect AnnotationsCodegen 760 * @declaredat /home/jesper/git/extendj/java5/backend/AnnotationsCodegen.jrag:38 761 */ 762 private Collection refined_AnnotationsCodegen_FieldDeclaration_attributes() 763 { 764 Collection c = refined_Attributes_FieldDeclaration_attributes(); 765 getModifiers().addRuntimeVisibleAnnotationsAttribute(c); 766 getModifiers().addRuntimeInvisibleAnnotationsAttribute(c); 767 return c; 768 } 769 /** 770 * @apilevel internal 771 */ 772 protected java.util.Map accessibleFrom_TypeDecl_values; 773 /** 774 * @apilevel internal 775 */ 776 private void accessibleFrom_TypeDecl_reset() { 777 accessibleFrom_TypeDecl_values = null; 778 } 779 /** 780 * @attribute syn 781 * @aspect AccessControl 782 * @declaredat /home/jesper/git/extendj/java4/frontend/AccessControl.jrag:132 783 */ 784 @ASTNodeAnnotation.Attribute 785 public boolean accessibleFrom(TypeDecl type) { 786 Object _parameters = type; 787 if (accessibleFrom_TypeDecl_values == null) accessibleFrom_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 788 ASTNode$State state = state(); 789 if (accessibleFrom_TypeDecl_values.containsKey(_parameters)) { 790 return (Boolean) accessibleFrom_TypeDecl_values.get(_parameters); 791 } 792 boolean intermediate = state.INTERMEDIATE_VALUE; 793 state.INTERMEDIATE_VALUE = false; 794 int num = state.boundariesCrossed; 795 boolean isFinal = this.is$Final(); 796 boolean accessibleFrom_TypeDecl_value = accessibleFrom_compute(type); 797 if (isFinal && num == state().boundariesCrossed) { 798 accessibleFrom_TypeDecl_values.put(_parameters, accessibleFrom_TypeDecl_value); 799 } else { 800 } 801 state.INTERMEDIATE_VALUE |= intermediate; 802 803 return accessibleFrom_TypeDecl_value; 804 } 805 /** 806 * @apilevel internal 807 */ 808 private boolean accessibleFrom_compute(TypeDecl type) { 809 if (isPublic()) { 810 return true; 811 } else if (isProtected()) { 812 if (hostPackage().equals(type.hostPackage())) { 813 return true; 814 } 815 if (type.withinBodyThatSubclasses(hostType()) != null) { 816 return true; 817 } 818 return false; 819 } else if (isPrivate()) { 820 return hostType().topLevelType() == type.topLevelType(); 821 } else { 822 return hostPackage().equals(type.hostPackage()); 823 } 824 } 825 /** 826 * @apilevel internal 827 */ 828 protected boolean exceptions_computed = false; 829 /** 830 * @apilevel internal 831 */ 832 protected Collection exceptions_value; 833 /** 834 * @apilevel internal 835 */ 836 private void exceptions_reset() { 837 exceptions_computed = false; 838 exceptions_value = null; 839 } 840 /** 841 * @attribute syn 842 * @aspect AnonymousClasses 843 * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:97 844 */ 845 @ASTNodeAnnotation.Attribute 846 public Collection exceptions() { 847 ASTNode$State state = state(); 848 if (exceptions_computed) { 849 return exceptions_value; 850 } 851 boolean intermediate = state.INTERMEDIATE_VALUE; 852 state.INTERMEDIATE_VALUE = false; 853 int num = state.boundariesCrossed; 854 boolean isFinal = this.is$Final(); 855 exceptions_value = exceptions_compute(); 856 if (isFinal && num == state().boundariesCrossed) { 857 exceptions_computed = true; 858 } else { 859 } 860 state.INTERMEDIATE_VALUE |= intermediate; 861 862 return exceptions_value; 863 } 864 /** 865 * @apilevel internal 866 */ 867 private Collection exceptions_compute() { 868 HashSet set = new HashSet(); 869 if (isInstanceVariable() && hasInit()) { 870 collectExceptions(set, this); 871 for (Iterator iter = set.iterator(); iter.hasNext(); ) { 872 TypeDecl typeDecl = (TypeDecl) iter.next(); 873 if (!getInit().reachedException(typeDecl)) { 874 iter.remove(); 875 } 876 } 877 } 878 return set; 879 } 880 /** 881 * @attribute syn 882 * @aspect ConstantExpression 883 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:250 884 */ 885 @ASTNodeAnnotation.Attribute 886 public boolean isConstant() { 887 boolean isConstant_value = isFinal() && hasInit() && getInit().isConstant() && (type() instanceof PrimitiveType || type().isString()); 888 889 return isConstant_value; 890 } 891 /** 892 * @attribute syn 893 * @aspect DataStructures 894 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:103 895 */ 896 @ASTNodeAnnotation.Attribute 897 public int size() { 898 int size_value = 1; 899 900 return size_value; 901 } 902 /** 903 * @attribute syn 904 * @aspect DataStructures 905 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:104 906 */ 907 @ASTNodeAnnotation.Attribute 908 public boolean isEmpty() { 909 boolean isEmpty_value = false; 910 911 return isEmpty_value; 912 } 913 /** 914 * @attribute syn 915 * @aspect DataStructures 916 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:108 917 */ 918 @ASTNodeAnnotation.Attribute 919 public boolean contains(Object o) { 920 boolean contains_Object_value = this == o; 921 922 return contains_Object_value; 923 } 924 /** 925 * @apilevel internal 926 */ 927 protected java.util.Map isDAafter_Variable_values; 928 /** 929 * @apilevel internal 930 */ 931 private void isDAafter_Variable_reset() { 932 isDAafter_Variable_values = null; 933 } 934 /** 935 * @attribute syn 936 * @aspect DA 937 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:266 938 */ 939 @ASTNodeAnnotation.Attribute 940 public boolean isDAafter(Variable v) { 941 Object _parameters = v; 942 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 943 ASTNode$State state = state(); 944 if (isDAafter_Variable_values.containsKey(_parameters)) { 945 return (Boolean) isDAafter_Variable_values.get(_parameters); 946 } 947 boolean intermediate = state.INTERMEDIATE_VALUE; 948 state.INTERMEDIATE_VALUE = false; 949 int num = state.boundariesCrossed; 950 boolean isFinal = this.is$Final(); 951 boolean isDAafter_Variable_value = isDAafter_compute(v); 952 if (isFinal && num == state().boundariesCrossed) { 953 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 954 } else { 955 } 956 state.INTERMEDIATE_VALUE |= intermediate; 957 958 return isDAafter_Variable_value; 959 } 960 /** 961 * @apilevel internal 962 */ 963 private boolean isDAafter_compute(Variable v) { 964 if (v == this) { 965 return hasInit(); 966 } 967 return hasInit() ? getInit().isDAafter(v) : isDAbefore(v); 968 } 969 /** 970 * @apilevel internal 971 */ 972 protected java.util.Map isDUafter_Variable_values; 973 /** 974 * @apilevel internal 975 */ 976 private void isDUafter_Variable_reset() { 977 isDUafter_Variable_values = null; 978 } 979 /** 980 * @attribute syn 981 * @aspect DU 982 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:796 983 */ 984 @ASTNodeAnnotation.Attribute 985 public boolean isDUafter(Variable v) { 986 Object _parameters = v; 987 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 988 ASTNode$State state = state(); 989 if (isDUafter_Variable_values.containsKey(_parameters)) { 990 return (Boolean) isDUafter_Variable_values.get(_parameters); 991 } 992 boolean intermediate = state.INTERMEDIATE_VALUE; 993 state.INTERMEDIATE_VALUE = false; 994 int num = state.boundariesCrossed; 995 boolean isFinal = this.is$Final(); 996 boolean isDUafter_Variable_value = isDUafter_compute(v); 997 if (isFinal && num == state().boundariesCrossed) { 998 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 999 } else { 1000 } 1001 state.INTERMEDIATE_VALUE |= intermediate; 1002 1003 return isDUafter_Variable_value; 1004 } 1005 /** 1006 * @apilevel internal 1007 */ 1008 private boolean isDUafter_compute(Variable v) { 1009 if (v == this) { 1010 return !hasInit(); 1011 } 1012 return hasInit() ? getInit().isDUafter(v) : isDUbefore(v); 1013 } 1014 /** 1015 * @attribute syn 1016 * @aspect Modifiers 1017 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:255 1018 */ 1019 @ASTNodeAnnotation.Attribute 1020 public boolean isSynthetic() { 1021 boolean isSynthetic_value = getModifiers().isSynthetic(); 1022 1023 return isSynthetic_value; 1024 } 1025 /** 1026 * @attribute syn 1027 * @aspect Modifiers 1028 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:280 1029 */ 1030 @ASTNodeAnnotation.Attribute 1031 public boolean isPublic() { 1032 boolean isPublic_value = getModifiers().isPublic() || hostType().isInterfaceDecl(); 1033 1034 return isPublic_value; 1035 } 1036 /** 1037 * @attribute syn 1038 * @aspect Modifiers 1039 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:281 1040 */ 1041 @ASTNodeAnnotation.Attribute 1042 public boolean isPrivate() { 1043 boolean isPrivate_value = getModifiers().isPrivate(); 1044 1045 return isPrivate_value; 1046 } 1047 /** 1048 * @attribute syn 1049 * @aspect Modifiers 1050 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:282 1051 */ 1052 @ASTNodeAnnotation.Attribute 1053 public boolean isProtected() { 1054 boolean isProtected_value = getModifiers().isProtected(); 1055 1056 return isProtected_value; 1057 } 1058 /** 1059 * @attribute syn 1060 * @aspect Modifiers 1061 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:283 1062 */ 1063 @ASTNodeAnnotation.Attribute 1064 public boolean isStatic() { 1065 boolean isStatic_value = getModifiers().isStatic() || hostType().isInterfaceDecl(); 1066 1067 return isStatic_value; 1068 } 1069 /** 1070 * @attribute syn 1071 * @aspect Modifiers 1072 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:285 1073 */ 1074 @ASTNodeAnnotation.Attribute 1075 public boolean isFinal() { 1076 boolean isFinal_value = getModifiers().isFinal() || hostType().isInterfaceDecl(); 1077 1078 return isFinal_value; 1079 } 1080 /** 1081 * @attribute syn 1082 * @aspect Modifiers 1083 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:286 1084 */ 1085 @ASTNodeAnnotation.Attribute 1086 public boolean isTransient() { 1087 boolean isTransient_value = getModifiers().isTransient(); 1088 1089 return isTransient_value; 1090 } 1091 /** 1092 * @attribute syn 1093 * @aspect Modifiers 1094 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:287 1095 */ 1096 @ASTNodeAnnotation.Attribute 1097 public boolean isVolatile() { 1098 boolean isVolatile_value = getModifiers().isVolatile(); 1099 1100 return isVolatile_value; 1101 } 1102 /** 1103 * @attribute syn 1104 * @aspect PrettyPrintUtil 1105 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:249 1106 */ 1107 @ASTNodeAnnotation.Attribute 1108 public boolean hasModifiers() { 1109 boolean hasModifiers_value = getModifiers().getNumModifier() > 0; 1110 1111 return hasModifiers_value; 1112 } 1113 /** 1114 * @attribute syn 1115 * @aspect TypeAnalysis 1116 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:275 1117 */ 1118 @ASTNodeAnnotation.Attribute 1119 public TypeDecl type() { 1120 TypeDecl type_value = getTypeAccess().type(); 1121 1122 return type_value; 1123 } 1124 /** 1125 * @attribute syn 1126 * @aspect TypeAnalysis 1127 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:297 1128 */ 1129 @ASTNodeAnnotation.Attribute 1130 public boolean isVoid() { 1131 boolean isVoid_value = type().isVoid(); 1132 1133 return isVoid_value; 1134 } 1135 /** 1136 * @attribute syn 1137 * @aspect Variables 1138 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:53 1139 */ 1140 @ASTNodeAnnotation.Attribute 1141 public boolean isParameter() { 1142 boolean isParameter_value = false; 1143 1144 return isParameter_value; 1145 } 1146 /** 1147 * @attribute syn 1148 * @aspect Variables 1149 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:55 1150 */ 1151 @ASTNodeAnnotation.Attribute 1152 public boolean isClassVariable() { 1153 boolean isClassVariable_value = isStatic() || hostType().isInterfaceDecl(); 1154 1155 return isClassVariable_value; 1156 } 1157 /** 1158 * @attribute syn 1159 * @aspect Variables 1160 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:56 1161 */ 1162 @ASTNodeAnnotation.Attribute 1163 public boolean isInstanceVariable() { 1164 boolean isInstanceVariable_value = (hostType().isClassDecl() || hostType().isAnonymous() )&& !isStatic(); 1165 1166 return isInstanceVariable_value; 1167 } 1168 /** 1169 * @attribute syn 1170 * @aspect Variables 1171 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:57 1172 */ 1173 @ASTNodeAnnotation.Attribute 1174 public boolean isMethodParameter() { 1175 boolean isMethodParameter_value = false; 1176 1177 return isMethodParameter_value; 1178 } 1179 /** 1180 * @attribute syn 1181 * @aspect Variables 1182 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:58 1183 */ 1184 @ASTNodeAnnotation.Attribute 1185 public boolean isConstructorParameter() { 1186 boolean isConstructorParameter_value = false; 1187 1188 return isConstructorParameter_value; 1189 } 1190 /** 1191 * @attribute syn 1192 * @aspect Variables 1193 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:59 1194 */ 1195 @ASTNodeAnnotation.Attribute 1196 public boolean isExceptionHandlerParameter() { 1197 boolean isExceptionHandlerParameter_value = false; 1198 1199 return isExceptionHandlerParameter_value; 1200 } 1201 /** 1202 * @attribute syn 1203 * @aspect Variables 1204 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:60 1205 */ 1206 @ASTNodeAnnotation.Attribute 1207 public boolean isLocalVariable() { 1208 boolean isLocalVariable_value = false; 1209 1210 return isLocalVariable_value; 1211 } 1212 /** 1213 * @attribute syn 1214 * @aspect Variables 1215 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:62 1216 */ 1217 @ASTNodeAnnotation.Attribute 1218 public boolean isBlank() { 1219 boolean isBlank_value = !hasInit(); 1220 1221 return isBlank_value; 1222 } 1223 /** 1224 * @attribute syn 1225 * @aspect Variables 1226 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:64 1227 */ 1228 @ASTNodeAnnotation.Attribute 1229 public String name() { 1230 String name_value = getID(); 1231 1232 return name_value; 1233 } 1234 /** 1235 * @apilevel internal 1236 */ 1237 protected boolean constant_computed = false; 1238 /** 1239 * @apilevel internal 1240 */ 1241 protected Constant constant_value; 1242 /** 1243 * @apilevel internal 1244 */ 1245 private void constant_reset() { 1246 constant_computed = false; 1247 constant_value = null; 1248 } 1249 /** 1250 * @attribute syn 1251 * @aspect Variables 1252 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:65 1253 */ 1254 @ASTNodeAnnotation.Attribute 1255 public Constant constant() { 1256 ASTNode$State state = state(); 1257 if (constant_computed) { 1258 return constant_value; 1259 } 1260 boolean intermediate = state.INTERMEDIATE_VALUE; 1261 state.INTERMEDIATE_VALUE = false; 1262 int num = state.boundariesCrossed; 1263 boolean isFinal = this.is$Final(); 1264 constant_value = type().cast(getInit().constant()); 1265 if (isFinal && num == state().boundariesCrossed) { 1266 constant_computed = true; 1267 } else { 1268 } 1269 state.INTERMEDIATE_VALUE |= intermediate; 1270 1271 return constant_value; 1272 } 1273 /** 1274 * @apilevel internal 1275 */ 1276 protected boolean attributes_computed = false; 1277 /** 1278 * @apilevel internal 1279 */ 1280 protected Collection attributes_value; 1281 /** 1282 * @apilevel internal 1283 */ 1284 private void attributes_reset() { 1285 attributes_computed = false; 1286 attributes_value = null; 1287 } 1288 /** 1289 * @attribute syn 1290 * @aspect Attributes 1291 * @declaredat /home/jesper/git/extendj/java4/backend/Attributes.jrag:212 1292 */ 1293 @ASTNodeAnnotation.Attribute 1294 public Collection attributes() { 1295 ASTNode$State state = state(); 1296 if (attributes_computed) { 1297 return attributes_value; 1298 } 1299 boolean intermediate = state.INTERMEDIATE_VALUE; 1300 state.INTERMEDIATE_VALUE = false; 1301 int num = state.boundariesCrossed; 1302 boolean isFinal = this.is$Final(); 1303 attributes_value = attributes_compute(); 1304 if (isFinal && num == state().boundariesCrossed) { 1305 attributes_computed = true; 1306 } else { 1307 } 1308 state.INTERMEDIATE_VALUE |= intermediate; 1309 1310 return attributes_value; 1311 } 1312 /** 1313 * @apilevel internal 1314 */ 1315 private Collection attributes_compute() { 1316 Collection c = refined_AnnotationsCodegen_FieldDeclaration_attributes(); 1317 if (needsSignatureAttribute()) { 1318 c.add(new SignatureAttribute(hostType().constantPool(), type().fieldTypeSignature())); 1319 } 1320 return c; 1321 } 1322 /** 1323 * @apilevel internal 1324 */ 1325 protected boolean flags_computed = false; 1326 /** 1327 * @apilevel internal 1328 */ 1329 protected int flags_value; 1330 /** 1331 * @apilevel internal 1332 */ 1333 private void flags_reset() { 1334 flags_computed = false; 1335 } 1336 /** 1337 * @attribute syn 1338 * @aspect Flags 1339 * @declaredat /home/jesper/git/extendj/java4/backend/Flags.jrag:134 1340 */ 1341 @ASTNodeAnnotation.Attribute 1342 public int flags() { 1343 ASTNode$State state = state(); 1344 if (flags_computed) { 1345 return flags_value; 1346 } 1347 boolean intermediate = state.INTERMEDIATE_VALUE; 1348 state.INTERMEDIATE_VALUE = false; 1349 int num = state.boundariesCrossed; 1350 boolean isFinal = this.is$Final(); 1351 flags_value = flags_compute(); 1352 if (isFinal && num == state().boundariesCrossed) { 1353 flags_computed = true; 1354 } else { 1355 } 1356 state.INTERMEDIATE_VALUE |= intermediate; 1357 1358 return flags_value; 1359 } 1360 /** 1361 * @apilevel internal 1362 */ 1363 private int flags_compute() { 1364 int res = 0; 1365 if (isPublic()) { 1366 res |= Modifiers.ACC_PUBLIC; 1367 } 1368 if (isPrivate()) { 1369 res |= Modifiers.ACC_PRIVATE; 1370 } 1371 if (isProtected()) { 1372 res |= Modifiers.ACC_PROTECTED; 1373 } 1374 if (isStatic()) { 1375 res |= Modifiers.ACC_STATIC; 1376 } 1377 if (isFinal()) { 1378 res |= Modifiers.ACC_FINAL; 1379 } 1380 if (isVolatile()) { 1381 res |= Modifiers.ACC_VOLATILE; 1382 } 1383 if (isTransient()) { 1384 res |= Modifiers.ACC_TRANSIENT; 1385 } 1386 return res; 1387 } 1388 /** 1389 * @attribute syn 1390 * @aspect GenerateClassfile 1391 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:347 1392 */ 1393 @ASTNodeAnnotation.Attribute 1394 public boolean isBytecodeField() { 1395 boolean isBytecodeField_value = true; 1396 1397 return isBytecodeField_value; 1398 } 1399 /** 1400 * @attribute syn 1401 * @aspect GenerateClassfile 1402 * @declaredat /home/jesper/git/extendj/java4/backend/GenerateClassfile.jrag:379 1403 */ 1404 @ASTNodeAnnotation.Attribute 1405 public boolean flush() { 1406 boolean flush_value = false; 1407 1408 return flush_value; 1409 } 1410 /** 1411 * @attribute syn 1412 * @aspect Annotations 1413 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:356 1414 */ 1415 @ASTNodeAnnotation.Attribute 1416 public boolean hasAnnotationSuppressWarnings(String annot) { 1417 boolean hasAnnotationSuppressWarnings_String_value = getModifiers().hasAnnotationSuppressWarnings(annot); 1418 1419 return hasAnnotationSuppressWarnings_String_value; 1420 } 1421 /** 1422 * @attribute syn 1423 * @aspect Annotations 1424 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:401 1425 */ 1426 @ASTNodeAnnotation.Attribute 1427 public boolean isDeprecated() { 1428 boolean isDeprecated_value = getModifiers().hasDeprecatedAnnotation(); 1429 1430 return isDeprecated_value; 1431 } 1432 /** 1433 * @apilevel internal 1434 */ 1435 protected boolean usesTypeVariable_computed = false; 1436 /** 1437 * @apilevel internal 1438 */ 1439 protected boolean usesTypeVariable_value; 1440 /** 1441 * @apilevel internal 1442 */ 1443 private void usesTypeVariable_reset() { 1444 usesTypeVariable_computed = false; 1445 } 1446 /** 1447 * @attribute syn 1448 * @aspect LookupParTypeDecl 1449 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1253 1450 */ 1451 @ASTNodeAnnotation.Attribute 1452 public boolean usesTypeVariable() { 1453 ASTNode$State state = state(); 1454 if (usesTypeVariable_computed) { 1455 return usesTypeVariable_value; 1456 } 1457 boolean intermediate = state.INTERMEDIATE_VALUE; 1458 state.INTERMEDIATE_VALUE = false; 1459 int num = state.boundariesCrossed; 1460 boolean isFinal = this.is$Final(); 1461 usesTypeVariable_value = getTypeAccess().usesTypeVariable(); 1462 if (isFinal && num == state().boundariesCrossed) { 1463 usesTypeVariable_computed = true; 1464 } else { 1465 } 1466 state.INTERMEDIATE_VALUE |= intermediate; 1467 1468 return usesTypeVariable_value; 1469 } 1470 /** 1471 * @attribute syn 1472 * @aspect LookupParTypeDecl 1473 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1410 1474 */ 1475 @ASTNodeAnnotation.Attribute 1476 public FieldDeclaration erasedField() { 1477 FieldDeclaration erasedField_value = this; 1478 1479 return erasedField_value; 1480 } 1481 /** 1482 * @apilevel internal 1483 */ 1484 protected boolean sourceVariableDecl_computed = false; 1485 /** 1486 * @apilevel internal 1487 */ 1488 protected Variable sourceVariableDecl_value; 1489 /** 1490 * @apilevel internal 1491 */ 1492 private void sourceVariableDecl_reset() { 1493 sourceVariableDecl_computed = false; 1494 sourceVariableDecl_value = null; 1495 } 1496 /** 1497 * @attribute syn 1498 * @aspect SourceDeclarations 1499 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1637 1500 */ 1501 @ASTNodeAnnotation.Attribute 1502 public Variable sourceVariableDecl() { 1503 ASTNode$State state = state(); 1504 if (sourceVariableDecl_computed) { 1505 return sourceVariableDecl_value; 1506 } 1507 boolean intermediate = state.INTERMEDIATE_VALUE; 1508 state.INTERMEDIATE_VALUE = false; 1509 int num = state.boundariesCrossed; 1510 boolean isFinal = this.is$Final(); 1511 sourceVariableDecl_value = this; 1512 if (isFinal && num == state().boundariesCrossed) { 1513 sourceVariableDecl_computed = true; 1514 } else { 1515 } 1516 state.INTERMEDIATE_VALUE |= intermediate; 1517 1518 return sourceVariableDecl_value; 1519 } 1520 /** 1521 * @attribute syn 1522 * @aspect GenericsParTypeDecl 1523 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:90 1524 */ 1525 @ASTNodeAnnotation.Attribute 1526 public boolean visibleTypeParameters() { 1527 boolean visibleTypeParameters_value = !isStatic(); 1528 1529 return visibleTypeParameters_value; 1530 } 1531 /** 1532 * @attribute syn 1533 * @aspect GenericsCodegen 1534 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:374 1535 */ 1536 @ASTNodeAnnotation.Attribute 1537 public boolean needsSignatureAttribute() { 1538 boolean needsSignatureAttribute_value = type().needsSignatureAttribute(); 1539 1540 return needsSignatureAttribute_value; 1541 } 1542 /** 1543 * @apilevel internal 1544 */ 1545 protected boolean throwTypes_computed = false; 1546 /** 1547 * @apilevel internal 1548 */ 1549 protected Collection<TypeDecl> throwTypes_value; 1550 /** 1551 * @apilevel internal 1552 */ 1553 private void throwTypes_reset() { 1554 throwTypes_computed = false; 1555 throwTypes_value = null; 1556 } 1557 /** 1558 * @attribute syn 1559 * @aspect PreciseRethrow 1560 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:47 1561 */ 1562 @ASTNodeAnnotation.Attribute 1563 public Collection<TypeDecl> throwTypes() { 1564 ASTNode$State state = state(); 1565 if (throwTypes_computed) { 1566 return throwTypes_value; 1567 } 1568 boolean intermediate = state.INTERMEDIATE_VALUE; 1569 state.INTERMEDIATE_VALUE = false; 1570 int num = state.boundariesCrossed; 1571 boolean isFinal = this.is$Final(); 1572 throwTypes_value = throwTypes_compute(); 1573 if (isFinal && num == state().boundariesCrossed) { 1574 throwTypes_computed = true; 1575 } else { 1576 } 1577 state.INTERMEDIATE_VALUE |= intermediate; 1578 1579 return throwTypes_value; 1580 } 1581 /** 1582 * @apilevel internal 1583 */ 1584 private Collection<TypeDecl> throwTypes_compute() { 1585 Collection<TypeDecl> tts = new LinkedList<TypeDecl>(); 1586 tts.add(type()); 1587 return tts; 1588 } 1589 /** 1590 * @return true if the modifier list includes the SafeVarargs annotation 1591 * @attribute syn 1592 * @aspect SafeVarargs 1593 * @declaredat /home/jesper/git/extendj/java7/frontend/SafeVarargs.jrag:42 1594 */ 1595 @ASTNodeAnnotation.Attribute 1596 public boolean hasAnnotationSafeVarargs() { 1597 boolean hasAnnotationSafeVarargs_value = getModifiers().hasAnnotationSafeVarargs(); 1598 1599 return hasAnnotationSafeVarargs_value; 1600 } 1601 /** 1602 * @attribute syn 1603 * @aspect SuppressWarnings 1604 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:44 1605 */ 1606 @ASTNodeAnnotation.Attribute 1607 public boolean suppressWarnings(String type) { 1608 boolean suppressWarnings_String_value = hasAnnotationSuppressWarnings(type) || withinSuppressWarnings(type); 1609 1610 return suppressWarnings_String_value; 1611 } 1612 /** 1613 * @apilevel internal 1614 */ 1615 protected boolean isEffectivelyFinal_computed = false; 1616 /** 1617 * @apilevel internal 1618 */ 1619 protected boolean isEffectivelyFinal_value; 1620 /** 1621 * @apilevel internal 1622 */ 1623 private void isEffectivelyFinal_reset() { 1624 isEffectivelyFinal_computed = false; 1625 } 1626 /** 1627 * @attribute syn 1628 * @aspect EffectivelyFinal 1629 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:138 1630 */ 1631 @ASTNodeAnnotation.Attribute 1632 public boolean isEffectivelyFinal() { 1633 ASTNode$State state = state(); 1634 if (isEffectivelyFinal_computed) { 1635 return isEffectivelyFinal_value; 1636 } 1637 boolean intermediate = state.INTERMEDIATE_VALUE; 1638 state.INTERMEDIATE_VALUE = false; 1639 int num = state.boundariesCrossed; 1640 boolean isFinal = this.is$Final(); 1641 isEffectivelyFinal_value = isFinal(); 1642 if (isFinal && num == state().boundariesCrossed) { 1643 isEffectivelyFinal_computed = true; 1644 } else { 1645 } 1646 state.INTERMEDIATE_VALUE |= intermediate; 1647 1648 return isEffectivelyFinal_value; 1649 } 1650 /** 1651 * @attribute inh 1652 * @aspect ExceptionHandling 1653 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:81 1654 */ 1655 /** 1656 * @attribute inh 1657 * @aspect ExceptionHandling 1658 * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:81 1659 */ 1660 @ASTNodeAnnotation.Attribute 1661 public boolean handlesException(TypeDecl exceptionType) { 1662 boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType); 1663 1664 return handlesException_TypeDecl_value; 1665 } 1666 /** 1667 * @attribute inh 1668 * @aspect SuppressWarnings 1669 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:36 1670 */ 1671 /** 1672 * @attribute inh 1673 * @aspect SuppressWarnings 1674 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:36 1675 */ 1676 @ASTNodeAnnotation.Attribute 1677 public boolean withinSuppressWarnings(String annot) { 1678 boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot); 1679 1680 return withinSuppressWarnings_String_value; 1681 } 1682 /** 1683 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47 1684 * @apilevel internal 1685 */ 1686 public boolean Define_isSource(ASTNode caller, ASTNode child) { 1687 if (caller == getInitOptNoTransform()) { 1688 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:61 1689 return true; 1690 } 1691 else { 1692 return getParent().Define_isSource(this, caller); 1693 } 1694 } 1695 protected boolean canDefine_isSource(ASTNode caller, ASTNode child) { 1696 return true; 1697 } 1698 /** 1699 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 1700 * @apilevel internal 1701 */ 1702 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1703 if (caller == getInitOptNoTransform()) { 1704 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:361 1705 { 1706 return isDAbefore(v); 1707 } 1708 } 1709 else { 1710 return super.Define_isDAbefore(caller, child, v); 1711 } 1712 } 1713 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1714 return true; 1715 } 1716 /** 1717 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:113 1718 * @apilevel internal 1719 */ 1720 public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 1721 if (caller == getInitOptNoTransform()) { 1722 // @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:209 1723 { 1724 if (hostType().isAnonymous()) { 1725 return true; 1726 } 1727 for (Iterator iter = hostType().constructors().iterator(); iter.hasNext(); ) { 1728 ConstructorDecl decl = (ConstructorDecl) iter.next(); 1729 if (!decl.throwsException(exceptionType)) { 1730 return false; 1731 } 1732 } 1733 return true; 1734 } 1735 } 1736 else { 1737 return getParent().Define_handlesException(this, caller, exceptionType); 1738 } 1739 } 1740 protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 1741 return true; 1742 } 1743 /** 1744 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:419 1745 * @apilevel internal 1746 */ 1747 public boolean Define_mayBePublic(ASTNode caller, ASTNode child) { 1748 if (caller == getModifiersNoTransform()) { 1749 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:303 1750 return true; 1751 } 1752 else { 1753 return getParent().Define_mayBePublic(this, caller); 1754 } 1755 } 1756 protected boolean canDefine_mayBePublic(ASTNode caller, ASTNode child) { 1757 return true; 1758 } 1759 /** 1760 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:421 1761 * @apilevel internal 1762 */ 1763 public boolean Define_mayBeProtected(ASTNode caller, ASTNode child) { 1764 if (caller == getModifiersNoTransform()) { 1765 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:304 1766 return true; 1767 } 1768 else { 1769 return getParent().Define_mayBeProtected(this, caller); 1770 } 1771 } 1772 protected boolean canDefine_mayBeProtected(ASTNode caller, ASTNode child) { 1773 return true; 1774 } 1775 /** 1776 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:420 1777 * @apilevel internal 1778 */ 1779 public boolean Define_mayBePrivate(ASTNode caller, ASTNode child) { 1780 if (caller == getModifiersNoTransform()) { 1781 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:305 1782 return true; 1783 } 1784 else { 1785 return getParent().Define_mayBePrivate(this, caller); 1786 } 1787 } 1788 protected boolean canDefine_mayBePrivate(ASTNode caller, ASTNode child) { 1789 return true; 1790 } 1791 /** 1792 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:422 1793 * @apilevel internal 1794 */ 1795 public boolean Define_mayBeStatic(ASTNode caller, ASTNode child) { 1796 if (caller == getModifiersNoTransform()) { 1797 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:306 1798 return true; 1799 } 1800 else { 1801 return getParent().Define_mayBeStatic(this, caller); 1802 } 1803 } 1804 protected boolean canDefine_mayBeStatic(ASTNode caller, ASTNode child) { 1805 return true; 1806 } 1807 /** 1808 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423 1809 * @apilevel internal 1810 */ 1811 public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) { 1812 if (caller == getModifiersNoTransform()) { 1813 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:307 1814 return true; 1815 } 1816 else { 1817 return getParent().Define_mayBeFinal(this, caller); 1818 } 1819 } 1820 protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) { 1821 return true; 1822 } 1823 /** 1824 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:426 1825 * @apilevel internal 1826 */ 1827 public boolean Define_mayBeTransient(ASTNode caller, ASTNode child) { 1828 if (caller == getModifiersNoTransform()) { 1829 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:308 1830 return true; 1831 } 1832 else { 1833 return getParent().Define_mayBeTransient(this, caller); 1834 } 1835 } 1836 protected boolean canDefine_mayBeTransient(ASTNode caller, ASTNode child) { 1837 return true; 1838 } 1839 /** 1840 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:425 1841 * @apilevel internal 1842 */ 1843 public boolean Define_mayBeVolatile(ASTNode caller, ASTNode child) { 1844 if (caller == getModifiersNoTransform()) { 1845 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:309 1846 return true; 1847 } 1848 else { 1849 return getParent().Define_mayBeVolatile(this, caller); 1850 } 1851 } 1852 protected boolean canDefine_mayBeVolatile(ASTNode caller, ASTNode child) { 1853 return true; 1854 } 1855 /** 1856 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 1857 * @apilevel internal 1858 */ 1859 public NameType Define_nameType(ASTNode caller, ASTNode child) { 1860 if (caller == getTypeAccessNoTransform()) { 1861 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:105 1862 return NameType.TYPE_NAME; 1863 } 1864 else { 1865 return getParent().Define_nameType(this, caller); 1866 } 1867 } 1868 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 1869 return true; 1870 } 1871 /** 1872 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:601 1873 * @apilevel internal 1874 */ 1875 public TypeDecl Define_declType(ASTNode caller, ASTNode child) { 1876 if (caller == getInitOptNoTransform()) { 1877 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:286 1878 return type(); 1879 } 1880 else { 1881 return getParent().Define_declType(this, caller); 1882 } 1883 } 1884 protected boolean canDefine_declType(ASTNode caller, ASTNode child) { 1885 return true; 1886 } 1887 /** 1888 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182 1889 * @apilevel internal 1890 */ 1891 public boolean Define_inStaticContext(ASTNode caller, ASTNode child) { 1892 if (caller == getInitOptNoTransform()) { 1893 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:189 1894 return isStatic(); 1895 } 1896 else { 1897 return getParent().Define_inStaticContext(this, caller); 1898 } 1899 } 1900 protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) { 1901 return true; 1902 } 1903 /** 1904 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:93 1905 * @apilevel internal 1906 */ 1907 public TypeDecl Define_expectedType(ASTNode caller, ASTNode child) { 1908 if (caller == getInitOptNoTransform()) { 1909 // @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:98 1910 return type().componentType(); 1911 } 1912 else { 1913 return getParent().Define_expectedType(this, caller); 1914 } 1915 } 1916 protected boolean canDefine_expectedType(ASTNode caller, ASTNode child) { 1917 return true; 1918 } 1919 /** 1920 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:96 1921 * @apilevel internal 1922 */ 1923 public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 1924 if (caller == getModifiersNoTransform()) { 1925 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:107 1926 return name.equals("FIELD"); 1927 } 1928 else { 1929 return getParent().Define_mayUseAnnotationTarget(this, caller, name); 1930 } 1931 } 1932 protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 1933 return true; 1934 } 1935 /** 1936 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:58 1937 * @apilevel internal 1938 */ 1939 public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) { 1940 if (caller == getInitOptNoTransform()) { 1941 // @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:60 1942 return type(); 1943 } 1944 else { 1945 return getParent().Define_assignConvertedType(this, caller); 1946 } 1947 } 1948 protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) { 1949 return true; 1950 } 1951 /** 1952 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30 1953 * @apilevel internal 1954 */ 1955 public TypeDecl Define_targetType(ASTNode caller, ASTNode child) { 1956 if (caller == getInitOptNoTransform()) { 1957 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:40 1958 return getTypeAccess().type(); 1959 } 1960 else { 1961 return getParent().Define_targetType(this, caller); 1962 } 1963 } 1964 protected boolean canDefine_targetType(ASTNode caller, ASTNode child) { 1965 return true; 1966 } 1967 /** 1968 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 1969 * @apilevel internal 1970 */ 1971 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 1972 if (caller == getInitOptNoTransform()) { 1973 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:373 1974 return true; 1975 } 1976 else { 1977 return getParent().Define_assignmentContext(this, caller); 1978 } 1979 } 1980 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 1981 return true; 1982 } 1983 /** 1984 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 1985 * @apilevel internal 1986 */ 1987 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 1988 if (caller == getInitOptNoTransform()) { 1989 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:374 1990 return false; 1991 } 1992 else { 1993 return getParent().Define_invocationContext(this, caller); 1994 } 1995 } 1996 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 1997 return true; 1998 } 1999 /** 2000 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 2001 * @apilevel internal 2002 */ 2003 public boolean Define_castContext(ASTNode caller, ASTNode child) { 2004 if (caller == getInitOptNoTransform()) { 2005 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:375 2006 return false; 2007 } 2008 else { 2009 return getParent().Define_castContext(this, caller); 2010 } 2011 } 2012 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 2013 return true; 2014 } 2015 /** 2016 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 2017 * @apilevel internal 2018 */ 2019 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 2020 if (caller == getInitOptNoTransform()) { 2021 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:376 2022 return false; 2023 } 2024 else { 2025 return getParent().Define_stringContext(this, caller); 2026 } 2027 } 2028 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 2029 return true; 2030 } 2031 /** 2032 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 2033 * @apilevel internal 2034 */ 2035 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 2036 if (caller == getInitOptNoTransform()) { 2037 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:377 2038 return false; 2039 } 2040 else { 2041 return getParent().Define_numericContext(this, caller); 2042 } 2043 } 2044 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 2045 return true; 2046 } 2047 /** 2048 * @apilevel internal 2049 */ 2050 public ASTNode rewriteTo() { 2051 return super.rewriteTo(); 2052 } 2053 }