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:80 027 * @production VariableDeclaration : {@link ASTNode} ::= <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 VariableDeclaration extends ASTNode<ASTNode> implements Cloneable, SimpleSet, Iterator, Variable { 031 /** 032 * @aspect DataStructures 033 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:123 034 */ 035 public SimpleSet add(Object o) { 036 return new SimpleSetImpl().add(this).add(o); 037 } 038 /** 039 * @aspect DataStructures 040 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:127 041 */ 042 public boolean isSingleton() { return true; } 043 /** 044 * @aspect DataStructures 045 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:128 046 */ 047 public boolean isSingleton(Object o) { return contains(o); } 048 /** 049 * @aspect DataStructures 050 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:131 051 */ 052 private VariableDeclaration iterElem; 053 /** 054 * @aspect DataStructures 055 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:132 056 */ 057 public Iterator iterator() { iterElem = this; return this; } 058 /** 059 * @aspect DataStructures 060 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:133 061 */ 062 public boolean hasNext() { return iterElem != null; } 063 /** 064 * @aspect DataStructures 065 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:134 066 */ 067 public Object next() { Object o = iterElem; iterElem = null; return o; } 068 /** 069 * @aspect DataStructures 070 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:135 071 */ 072 public void remove() { throw new UnsupportedOperationException(); } 073 /** 074 * @aspect NodeConstructors 075 * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:85 076 */ 077 public VariableDeclaration(Access type, String name, Expr init) { 078 this(new Modifiers(new List()), type, name, new Opt(init)); 079 } 080 /** 081 * @aspect NodeConstructors 082 * @declaredat /home/jesper/git/extendj/java4/frontend/NodeConstructors.jrag:89 083 */ 084 public VariableDeclaration(Access type, String name) { 085 this(new Modifiers(new List()), type, name, new Opt()); 086 } 087 /** 088 * @aspect TypeCheck 089 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:43 090 */ 091 public void typeCheck() { 092 if (hasInit()) { 093 TypeDecl source = getInit().type(); 094 TypeDecl dest = type(); 095 if (!source.assignConversionTo(dest, getInit())) { 096 errorf("can not assign variable %s of type %s a value of type %s", 097 name(), dest.typeName(), source.typeName()); 098 } 099 } 100 } 101 /** 102 * @aspect CreateBCode 103 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:276 104 */ 105 public void createBCode(CodeGeneration gen) { 106 if (hasInit()) { 107 gen.addLocalVariableEntryAtCurrentPC(name(), type().typeDescriptor(), localNum(), variableScopeEndLabel(gen)); 108 emitInitializerBCode(gen); 109 type().emitStoreLocal(gen, localNum()); 110 } 111 } 112 /** 113 * Generate variable initialization bytecode. 114 * @aspect CreateBCode 115 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:287 116 */ 117 protected void emitInitializerBCode(CodeGeneration gen) { 118 getInit().createBCode(gen); 119 getInit().type().emitAssignConvTo(gen, type()); 120 } 121 /** 122 * @aspect UncheckedConversion 123 * @declaredat /home/jesper/git/extendj/java7/frontend/UncheckedConversion.jrag:41 124 */ 125 public void checkWarnings() { 126 if (hasInit() && !suppressWarnings("unchecked")) { 127 checkUncheckedConversion(getInit().type(), type()); 128 } 129 } 130 /** 131 * @declaredat ASTNode:1 132 */ 133 public VariableDeclaration() { 134 super(); 135 } 136 /** 137 * Initializes the child array to the correct size. 138 * Initializes List and Opt nta children. 139 * @apilevel internal 140 * @ast method 141 * @declaredat ASTNode:10 142 */ 143 public void init$Children() { 144 children = new ASTNode[3]; 145 setChild(new Opt(), 2); 146 } 147 /** 148 * @declaredat ASTNode:14 149 */ 150 public VariableDeclaration(Modifiers p0, Access p1, String p2, Opt<Expr> p3) { 151 setChild(p0, 0); 152 setChild(p1, 1); 153 setID(p2); 154 setChild(p3, 2); 155 } 156 /** 157 * @declaredat ASTNode:20 158 */ 159 public VariableDeclaration(Modifiers p0, Access p1, beaver.Symbol p2, Opt<Expr> p3) { 160 setChild(p0, 0); 161 setChild(p1, 1); 162 setID(p2); 163 setChild(p3, 2); 164 } 165 /** 166 * @apilevel low-level 167 * @declaredat ASTNode:29 168 */ 169 protected int numChildren() { 170 return 3; 171 } 172 /** 173 * @apilevel internal 174 * @declaredat ASTNode:35 175 */ 176 public boolean mayHaveRewrite() { 177 return false; 178 } 179 /** 180 * @apilevel internal 181 * @declaredat ASTNode:41 182 */ 183 public void flushAttrCache() { 184 super.flushAttrCache(); 185 isDAafter_Variable_reset(); 186 isDUafter_Variable_reset(); 187 constant_reset(); 188 localSize_reset(); 189 sourceVariableDecl_reset(); 190 throwTypes_reset(); 191 isEffectivelyFinal_reset(); 192 blockIndex_reset(); 193 localNum_reset(); 194 enclosingLambda_reset(); 195 } 196 /** 197 * @apilevel internal 198 * @declaredat ASTNode:57 199 */ 200 public void flushCollectionCache() { 201 super.flushCollectionCache(); 202 } 203 /** 204 * @apilevel internal 205 * @declaredat ASTNode:63 206 */ 207 public void flushRewriteCache() { 208 super.flushRewriteCache(); 209 } 210 /** 211 * @apilevel internal 212 * @declaredat ASTNode:69 213 */ 214 public VariableDeclaration clone() throws CloneNotSupportedException { 215 VariableDeclaration node = (VariableDeclaration) super.clone(); 216 return node; 217 } 218 /** 219 * @apilevel internal 220 * @declaredat ASTNode:76 221 */ 222 public VariableDeclaration copy() { 223 try { 224 VariableDeclaration node = (VariableDeclaration) clone(); 225 node.parent = null; 226 if (children != null) { 227 node.children = (ASTNode[]) children.clone(); 228 } 229 return node; 230 } catch (CloneNotSupportedException e) { 231 throw new Error("Error: clone not supported for " + getClass().getName()); 232 } 233 } 234 /** 235 * Create a deep copy of the AST subtree at this node. 236 * The copy is dangling, i.e. has no parent. 237 * @return dangling copy of the subtree at this node 238 * @apilevel low-level 239 * @deprecated Please use treeCopy or treeCopyNoTransform instead 240 * @declaredat ASTNode:95 241 */ 242 @Deprecated 243 public VariableDeclaration fullCopy() { 244 return treeCopyNoTransform(); 245 } 246 /** 247 * Create a deep copy of the AST subtree at this node. 248 * The copy is dangling, i.e. has no parent. 249 * @return dangling copy of the subtree at this node 250 * @apilevel low-level 251 * @declaredat ASTNode:105 252 */ 253 public VariableDeclaration treeCopyNoTransform() { 254 VariableDeclaration tree = (VariableDeclaration) copy(); 255 if (children != null) { 256 for (int i = 0; i < children.length; ++i) { 257 ASTNode child = (ASTNode) children[i]; 258 if (child != null) { 259 child = child.treeCopyNoTransform(); 260 tree.setChild(child, i); 261 } 262 } 263 } 264 return tree; 265 } 266 /** 267 * Create a deep copy of the AST subtree at this node. 268 * The subtree of this node is traversed to trigger rewrites before copy. 269 * The copy is dangling, i.e. has no parent. 270 * @return dangling copy of the subtree at this node 271 * @apilevel low-level 272 * @declaredat ASTNode:125 273 */ 274 public VariableDeclaration treeCopy() { 275 doFullTraversal(); 276 return treeCopyNoTransform(); 277 } 278 /** 279 * @apilevel internal 280 * @declaredat ASTNode:132 281 */ 282 protected boolean is$Equal(ASTNode node) { 283 return super.is$Equal(node) && (tokenString_ID == ((VariableDeclaration)node).tokenString_ID); 284 } 285 /** 286 * Replaces the Modifiers child. 287 * @param node The new node to replace the Modifiers child. 288 * @apilevel high-level 289 */ 290 public void setModifiers(Modifiers node) { 291 setChild(node, 0); 292 } 293 /** 294 * Retrieves the Modifiers child. 295 * @return The current node used as the Modifiers child. 296 * @apilevel high-level 297 */ 298 @ASTNodeAnnotation.Child(name="Modifiers") 299 public Modifiers getModifiers() { 300 return (Modifiers) getChild(0); 301 } 302 /** 303 * Retrieves the Modifiers child. 304 * <p><em>This method does not invoke AST transformations.</em></p> 305 * @return The current node used as the Modifiers child. 306 * @apilevel low-level 307 */ 308 public Modifiers getModifiersNoTransform() { 309 return (Modifiers) getChildNoTransform(0); 310 } 311 /** 312 * Replaces the TypeAccess child. 313 * @param node The new node to replace the TypeAccess child. 314 * @apilevel high-level 315 */ 316 public void setTypeAccess(Access node) { 317 setChild(node, 1); 318 } 319 /** 320 * Retrieves the TypeAccess child. 321 * @return The current node used as the TypeAccess child. 322 * @apilevel high-level 323 */ 324 @ASTNodeAnnotation.Child(name="TypeAccess") 325 public Access getTypeAccess() { 326 return (Access) getChild(1); 327 } 328 /** 329 * Retrieves the TypeAccess child. 330 * <p><em>This method does not invoke AST transformations.</em></p> 331 * @return The current node used as the TypeAccess child. 332 * @apilevel low-level 333 */ 334 public Access getTypeAccessNoTransform() { 335 return (Access) getChildNoTransform(1); 336 } 337 /** 338 * Replaces the lexeme ID. 339 * @param value The new value for the lexeme ID. 340 * @apilevel high-level 341 */ 342 public void setID(String value) { 343 tokenString_ID = value; 344 } 345 /** 346 * @apilevel internal 347 */ 348 protected String tokenString_ID; 349 /** 350 */ 351 public int IDstart; 352 /** 353 */ 354 public int IDend; 355 /** 356 * JastAdd-internal setter for lexeme ID using the Beaver parser. 357 * @param symbol Symbol containing the new value for the lexeme ID 358 * @apilevel internal 359 */ 360 public void setID(beaver.Symbol symbol) { 361 if (symbol.value != null && !(symbol.value instanceof String)) 362 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 363 tokenString_ID = (String)symbol.value; 364 IDstart = symbol.getStart(); 365 IDend = symbol.getEnd(); 366 } 367 /** 368 * Retrieves the value for the lexeme ID. 369 * @return The value for the lexeme ID. 370 * @apilevel high-level 371 */ 372 @ASTNodeAnnotation.Token(name="ID") 373 public String getID() { 374 return tokenString_ID != null ? tokenString_ID : ""; 375 } 376 /** 377 * Replaces the optional node for the Init child. This is the <code>Opt</code> 378 * node containing the child Init, not the actual child! 379 * @param opt The new node to be used as the optional node for the Init child. 380 * @apilevel low-level 381 */ 382 public void setInitOpt(Opt<Expr> opt) { 383 setChild(opt, 2); 384 } 385 /** 386 * Replaces the (optional) Init child. 387 * @param node The new node to be used as the Init child. 388 * @apilevel high-level 389 */ 390 public void setInit(Expr node) { 391 getInitOpt().setChild(node, 0); 392 } 393 /** 394 * Check whether the optional Init child exists. 395 * @return {@code true} if the optional Init child exists, {@code false} if it does not. 396 * @apilevel high-level 397 */ 398 public boolean hasInit() { 399 return getInitOpt().getNumChild() != 0; 400 } 401 /** 402 * Retrieves the (optional) Init child. 403 * @return The Init child, if it exists. Returns {@code null} otherwise. 404 * @apilevel low-level 405 */ 406 public Expr getInit() { 407 return (Expr) getInitOpt().getChild(0); 408 } 409 /** 410 * Retrieves the optional node for the Init child. This is the <code>Opt</code> node containing the child Init, not the actual child! 411 * @return The optional node for child the Init child. 412 * @apilevel low-level 413 */ 414 @ASTNodeAnnotation.OptChild(name="Init") 415 public Opt<Expr> getInitOpt() { 416 return (Opt<Expr>) getChild(2); 417 } 418 /** 419 * Retrieves the optional node for child Init. This is the <code>Opt</code> node containing the child Init, not the actual child! 420 * <p><em>This method does not invoke AST transformations.</em></p> 421 * @return The optional node for child Init. 422 * @apilevel low-level 423 */ 424 public Opt<Expr> getInitOptNoTransform() { 425 return (Opt<Expr>) getChildNoTransform(2); 426 } 427 /** 428 * @aspect MultiCatch 429 * @declaredat /home/jesper/git/extendj/java7/frontend/MultiCatch.jrag:245 430 */ 431 432 public void refined_MultiCatch_VariableDeclaration_nameCheck() { 433 SimpleSet decls = outerScope().lookupVariable(name()); 434 for (Iterator iter = decls.iterator(); iter.hasNext(); ) { 435 Variable var = (Variable) iter.next(); 436 if (var instanceof VariableDeclaration) { 437 VariableDeclaration decl = (VariableDeclaration) var; 438 if (decl != this && decl.enclosingBodyDecl() == enclosingBodyDecl()) { 439 errorf("duplicate declaration of local variable %s", name()); 440 } 441 } 442 // 8.4.1 443 else if (var instanceof ParameterDeclaration) { 444 ParameterDeclaration decl = (ParameterDeclaration) var; 445 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 446 errorf("duplicate declaration of local variable %s", name()); 447 } 448 } else if (var instanceof CatchParameterDeclaration) { 449 CatchParameterDeclaration decl = (CatchParameterDeclaration) var; 450 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 451 errorf("duplicate declaration of local variable %s", name()); 452 } 453 } 454 } 455 if (getParent().getParent() instanceof Block) { 456 Block block = (Block) getParent().getParent(); 457 for (int i = 0; i < block.getNumStmt(); i++) { 458 if (block.getStmt(i) instanceof Variable) { 459 Variable v = (Variable) block.getStmt(i); 460 if (v.name().equals(name()) && v != this) { 461 errorf("duplicate declaration of local variable %s", name()); 462 } 463 } 464 } 465 } 466 } 467 /** 468 * @aspect Java8NameCheck 469 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:139 470 */ 471 472 public void nameCheck() { 473 SimpleSet decls = outerScope().lookupVariable(name()); 474 for (Iterator iter = decls.iterator(); iter.hasNext(); ) { 475 Variable var = (Variable) iter.next(); 476 if (var instanceof VariableDeclaration) { 477 VariableDeclaration decl = (VariableDeclaration) var; 478 if (decl != this && decl.enclosingBodyDecl() == enclosingBodyDecl()) { 479 errorf("duplicate declaration of local variable %s", name()); 480 } 481 } 482 // 8.4.1 483 else if (var instanceof ParameterDeclaration) { 484 ParameterDeclaration decl = (ParameterDeclaration) var; 485 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 486 errorf("duplicate declaration of local variable %s", name()); 487 } 488 } else if (var instanceof CatchParameterDeclaration) { 489 CatchParameterDeclaration decl = (CatchParameterDeclaration) var; 490 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 491 errorf("duplicate declaration of local variable %s", name()); 492 } 493 } else if (var instanceof InferredParameterDeclaration) { 494 InferredParameterDeclaration decl = (InferredParameterDeclaration) var; 495 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 496 errorf("duplicate declaration of local variable %s", name()); 497 } 498 } 499 } 500 if (getParent().getParent() instanceof Block) { 501 Block block = (Block) getParent().getParent(); 502 for (int i = 0; i < block.getNumStmt(); i++) { 503 if (block.getStmt(i) instanceof Variable) { 504 Variable v = (Variable) block.getStmt(i); 505 if (v.name().equals(name()) && v != this) { 506 errorf("duplicate declaration of local variable %s", name()); 507 } 508 } 509 } 510 } 511 } 512 /** 513 * @attribute syn 514 * @aspect DataStructures 515 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:121 516 */ 517 @ASTNodeAnnotation.Attribute 518 public int size() { 519 int size_value = 1; 520 521 return size_value; 522 } 523 /** 524 * @attribute syn 525 * @aspect DataStructures 526 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:122 527 */ 528 @ASTNodeAnnotation.Attribute 529 public boolean isEmpty() { 530 boolean isEmpty_value = false; 531 532 return isEmpty_value; 533 } 534 /** 535 * @attribute syn 536 * @aspect DataStructures 537 * @declaredat /home/jesper/git/extendj/java4/frontend/DataStructures.jrag:126 538 */ 539 @ASTNodeAnnotation.Attribute 540 public boolean contains(Object o) { 541 boolean contains_Object_value = this == o; 542 543 return contains_Object_value; 544 } 545 /** 546 * @attribute syn 547 * @aspect DefiniteAssignment 548 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:114 549 */ 550 @ASTNodeAnnotation.Attribute 551 public boolean isBlankFinal() { 552 boolean isBlankFinal_value = isFinal() && (!hasInit() || !getInit().isConstant()); 553 554 return isBlankFinal_value; 555 } 556 /** 557 * @attribute syn 558 * @aspect DefiniteAssignment 559 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:115 560 */ 561 @ASTNodeAnnotation.Attribute 562 public boolean isValue() { 563 boolean isValue_value = isFinal() && hasInit() && getInit().isConstant(); 564 565 return isValue_value; 566 } 567 /** 568 * @apilevel internal 569 */ 570 protected java.util.Map isDAafter_Variable_values; 571 /** 572 * @apilevel internal 573 */ 574 private void isDAafter_Variable_reset() { 575 isDAafter_Variable_values = null; 576 } 577 /** 578 * @attribute syn 579 * @aspect DA 580 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:551 581 */ 582 @ASTNodeAnnotation.Attribute 583 public boolean isDAafter(Variable v) { 584 Object _parameters = v; 585 if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 586 ASTNode$State state = state(); 587 if (isDAafter_Variable_values.containsKey(_parameters)) { 588 return (Boolean) isDAafter_Variable_values.get(_parameters); 589 } 590 boolean intermediate = state.INTERMEDIATE_VALUE; 591 state.INTERMEDIATE_VALUE = false; 592 int num = state.boundariesCrossed; 593 boolean isFinal = this.is$Final(); 594 boolean isDAafter_Variable_value = isDAafter_compute(v); 595 if (isFinal && num == state().boundariesCrossed) { 596 isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value); 597 } else { 598 } 599 state.INTERMEDIATE_VALUE |= intermediate; 600 601 return isDAafter_Variable_value; 602 } 603 /** 604 * @apilevel internal 605 */ 606 private boolean isDAafter_compute(Variable v) { 607 if (v == this) { 608 return hasInit(); 609 } 610 return hasInit() ? getInit().isDAafter(v) : isDAbefore(v); 611 } 612 /** 613 * @apilevel internal 614 */ 615 protected java.util.Map isDUafter_Variable_values; 616 /** 617 * @apilevel internal 618 */ 619 private void isDUafter_Variable_reset() { 620 isDUafter_Variable_values = null; 621 } 622 /** 623 * @attribute syn 624 * @aspect DU 625 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:996 626 */ 627 @ASTNodeAnnotation.Attribute 628 public boolean isDUafter(Variable v) { 629 Object _parameters = v; 630 if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 631 ASTNode$State state = state(); 632 if (isDUafter_Variable_values.containsKey(_parameters)) { 633 return (Boolean) isDUafter_Variable_values.get(_parameters); 634 } 635 boolean intermediate = state.INTERMEDIATE_VALUE; 636 state.INTERMEDIATE_VALUE = false; 637 int num = state.boundariesCrossed; 638 boolean isFinal = this.is$Final(); 639 boolean isDUafter_Variable_value = isDUafter_compute(v); 640 if (isFinal && num == state().boundariesCrossed) { 641 isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value); 642 } else { 643 } 644 state.INTERMEDIATE_VALUE |= intermediate; 645 646 return isDUafter_Variable_value; 647 } 648 /** 649 * @apilevel internal 650 */ 651 private boolean isDUafter_compute(Variable v) { 652 if (v == this) { 653 return !hasInit(); 654 } 655 return hasInit() ? getInit().isDUafter(v) : isDUbefore(v); 656 } 657 /** 658 * @attribute syn 659 * @aspect VariableScope 660 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:216 661 */ 662 @ASTNodeAnnotation.Attribute 663 public boolean declaresVariable(String name) { 664 boolean declaresVariable_String_value = getID().equals(name); 665 666 return declaresVariable_String_value; 667 } 668 /** 669 * @attribute syn 670 * @aspect Modifiers 671 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:260 672 */ 673 @ASTNodeAnnotation.Attribute 674 public boolean isSynthetic() { 675 boolean isSynthetic_value = getModifiers().isSynthetic(); 676 677 return isSynthetic_value; 678 } 679 /** 680 * @attribute syn 681 * @aspect PrettyPrintUtil 682 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:251 683 */ 684 @ASTNodeAnnotation.Attribute 685 public boolean hasModifiers() { 686 boolean hasModifiers_value = getModifiers().getNumModifier() > 0; 687 688 return hasModifiers_value; 689 } 690 /** 691 * @attribute syn 692 * @aspect TypeAnalysis 693 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:276 694 */ 695 @ASTNodeAnnotation.Attribute 696 public TypeDecl type() { 697 TypeDecl type_value = getTypeAccess().type(); 698 699 return type_value; 700 } 701 /** 702 * @attribute syn 703 * @aspect Variables 704 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:34 705 */ 706 @ASTNodeAnnotation.Attribute 707 public boolean isParameter() { 708 boolean isParameter_value = false; 709 710 return isParameter_value; 711 } 712 /** 713 * @attribute syn 714 * @aspect Variables 715 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:36 716 */ 717 @ASTNodeAnnotation.Attribute 718 public boolean isClassVariable() { 719 boolean isClassVariable_value = false; 720 721 return isClassVariable_value; 722 } 723 /** 724 * @attribute syn 725 * @aspect Variables 726 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:37 727 */ 728 @ASTNodeAnnotation.Attribute 729 public boolean isInstanceVariable() { 730 boolean isInstanceVariable_value = false; 731 732 return isInstanceVariable_value; 733 } 734 /** 735 * @attribute syn 736 * @aspect Variables 737 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:38 738 */ 739 @ASTNodeAnnotation.Attribute 740 public boolean isMethodParameter() { 741 boolean isMethodParameter_value = false; 742 743 return isMethodParameter_value; 744 } 745 /** 746 * @attribute syn 747 * @aspect Variables 748 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:39 749 */ 750 @ASTNodeAnnotation.Attribute 751 public boolean isConstructorParameter() { 752 boolean isConstructorParameter_value = false; 753 754 return isConstructorParameter_value; 755 } 756 /** 757 * @attribute syn 758 * @aspect Variables 759 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:40 760 */ 761 @ASTNodeAnnotation.Attribute 762 public boolean isExceptionHandlerParameter() { 763 boolean isExceptionHandlerParameter_value = false; 764 765 return isExceptionHandlerParameter_value; 766 } 767 /** 768 * @attribute syn 769 * @aspect Variables 770 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:41 771 */ 772 @ASTNodeAnnotation.Attribute 773 public boolean isLocalVariable() { 774 boolean isLocalVariable_value = true; 775 776 return isLocalVariable_value; 777 } 778 /** 779 * @attribute syn 780 * @aspect Variables 781 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:43 782 */ 783 @ASTNodeAnnotation.Attribute 784 public boolean isFinal() { 785 boolean isFinal_value = getModifiers().isFinal(); 786 787 return isFinal_value; 788 } 789 /** 790 * @attribute syn 791 * @aspect Variables 792 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:44 793 */ 794 @ASTNodeAnnotation.Attribute 795 public boolean isVolatile() { 796 boolean isVolatile_value = getModifiers().isVolatile(); 797 798 return isVolatile_value; 799 } 800 /** 801 * @attribute syn 802 * @aspect Variables 803 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:45 804 */ 805 @ASTNodeAnnotation.Attribute 806 public boolean isBlank() { 807 boolean isBlank_value = !hasInit(); 808 809 return isBlank_value; 810 } 811 /** 812 * @attribute syn 813 * @aspect Variables 814 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:46 815 */ 816 @ASTNodeAnnotation.Attribute 817 public boolean isStatic() { 818 boolean isStatic_value = false; 819 820 return isStatic_value; 821 } 822 /** 823 * @attribute syn 824 * @aspect Variables 825 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:48 826 */ 827 @ASTNodeAnnotation.Attribute 828 public String name() { 829 String name_value = getID(); 830 831 return name_value; 832 } 833 /** 834 * @apilevel internal 835 */ 836 protected boolean constant_computed = false; 837 /** 838 * @apilevel internal 839 */ 840 protected Constant constant_value; 841 /** 842 * @apilevel internal 843 */ 844 private void constant_reset() { 845 constant_computed = false; 846 constant_value = null; 847 } 848 /** 849 * @attribute syn 850 * @aspect Variables 851 * @declaredat /home/jesper/git/extendj/java4/frontend/VariableDeclaration.jrag:50 852 */ 853 @ASTNodeAnnotation.Attribute 854 public Constant constant() { 855 ASTNode$State state = state(); 856 if (constant_computed) { 857 return constant_value; 858 } 859 boolean intermediate = state.INTERMEDIATE_VALUE; 860 state.INTERMEDIATE_VALUE = false; 861 int num = state.boundariesCrossed; 862 boolean isFinal = this.is$Final(); 863 constant_value = type().cast(getInit().constant()); 864 if (isFinal && num == state().boundariesCrossed) { 865 constant_computed = true; 866 } else { 867 } 868 state.INTERMEDIATE_VALUE |= intermediate; 869 870 return constant_value; 871 } 872 /** 873 * @apilevel internal 874 */ 875 protected boolean localSize_computed = false; 876 /** 877 * @apilevel internal 878 */ 879 protected int localSize_value; 880 /** 881 * @apilevel internal 882 */ 883 private void localSize_reset() { 884 localSize_computed = false; 885 } 886 /** 887 * @attribute syn 888 * @aspect LocalNum 889 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:48 890 */ 891 @ASTNodeAnnotation.Attribute 892 public int localSize() { 893 ASTNode$State state = state(); 894 if (localSize_computed) { 895 return localSize_value; 896 } 897 boolean intermediate = state.INTERMEDIATE_VALUE; 898 state.INTERMEDIATE_VALUE = false; 899 int num = state.boundariesCrossed; 900 boolean isFinal = this.is$Final(); 901 localSize_value = type().variableSize(); 902 if (isFinal && num == state().boundariesCrossed) { 903 localSize_computed = true; 904 } else { 905 } 906 state.INTERMEDIATE_VALUE |= intermediate; 907 908 return localSize_value; 909 } 910 /** 911 * @apilevel internal 912 */ 913 protected boolean sourceVariableDecl_computed = false; 914 /** 915 * @apilevel internal 916 */ 917 protected Variable sourceVariableDecl_value; 918 /** 919 * @apilevel internal 920 */ 921 private void sourceVariableDecl_reset() { 922 sourceVariableDecl_computed = false; 923 sourceVariableDecl_value = null; 924 } 925 /** 926 * @attribute syn 927 * @aspect SourceDeclarations 928 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1637 929 */ 930 @ASTNodeAnnotation.Attribute 931 public Variable sourceVariableDecl() { 932 ASTNode$State state = state(); 933 if (sourceVariableDecl_computed) { 934 return sourceVariableDecl_value; 935 } 936 boolean intermediate = state.INTERMEDIATE_VALUE; 937 state.INTERMEDIATE_VALUE = false; 938 int num = state.boundariesCrossed; 939 boolean isFinal = this.is$Final(); 940 sourceVariableDecl_value = this; 941 if (isFinal && num == state().boundariesCrossed) { 942 sourceVariableDecl_computed = true; 943 } else { 944 } 945 state.INTERMEDIATE_VALUE |= intermediate; 946 947 return sourceVariableDecl_value; 948 } 949 /** 950 * @apilevel internal 951 */ 952 protected boolean throwTypes_computed = false; 953 /** 954 * @apilevel internal 955 */ 956 protected Collection<TypeDecl> throwTypes_value; 957 /** 958 * @apilevel internal 959 */ 960 private void throwTypes_reset() { 961 throwTypes_computed = false; 962 throwTypes_value = null; 963 } 964 /** 965 * @attribute syn 966 * @aspect PreciseRethrow 967 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:41 968 */ 969 @ASTNodeAnnotation.Attribute 970 public Collection<TypeDecl> throwTypes() { 971 ASTNode$State state = state(); 972 if (throwTypes_computed) { 973 return throwTypes_value; 974 } 975 boolean intermediate = state.INTERMEDIATE_VALUE; 976 state.INTERMEDIATE_VALUE = false; 977 int num = state.boundariesCrossed; 978 boolean isFinal = this.is$Final(); 979 throwTypes_value = throwTypes_compute(); 980 if (isFinal && num == state().boundariesCrossed) { 981 throwTypes_computed = true; 982 } else { 983 } 984 state.INTERMEDIATE_VALUE |= intermediate; 985 986 return throwTypes_value; 987 } 988 /** 989 * @apilevel internal 990 */ 991 private Collection<TypeDecl> throwTypes_compute() { 992 Collection<TypeDecl> tts = new LinkedList<TypeDecl>(); 993 tts.add(type()); 994 return tts; 995 } 996 /** 997 * @attribute syn 998 * @aspect PreciseRethrow 999 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:93 1000 */ 1001 @ASTNodeAnnotation.Attribute 1002 public boolean modifiedInScope(Variable var) { 1003 boolean modifiedInScope_Variable_value = hasInit() && getInit().modifiedInScope(var); 1004 1005 return modifiedInScope_Variable_value; 1006 } 1007 /** 1008 * @attribute syn 1009 * @aspect SuppressWarnings 1010 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:32 1011 */ 1012 @ASTNodeAnnotation.Attribute 1013 public boolean hasAnnotationSuppressWarnings(String annot) { 1014 boolean hasAnnotationSuppressWarnings_String_value = getModifiers().hasAnnotationSuppressWarnings(annot); 1015 1016 return hasAnnotationSuppressWarnings_String_value; 1017 } 1018 /** 1019 * @attribute syn 1020 * @aspect SuppressWarnings 1021 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:42 1022 */ 1023 @ASTNodeAnnotation.Attribute 1024 public boolean suppressWarnings(String type) { 1025 boolean suppressWarnings_String_value = hasAnnotationSuppressWarnings(type) || withinSuppressWarnings(type); 1026 1027 return suppressWarnings_String_value; 1028 } 1029 /** 1030 * @apilevel internal 1031 */ 1032 protected boolean isEffectivelyFinal_computed = false; 1033 /** 1034 * @apilevel internal 1035 */ 1036 protected boolean isEffectivelyFinal_value; 1037 /** 1038 * @apilevel internal 1039 */ 1040 private void isEffectivelyFinal_reset() { 1041 isEffectivelyFinal_computed = false; 1042 } 1043 /** 1044 * Note: this attribute deviates from what the JLS says about effectively finalness, 1045 * simply because the attribute name would be confusing if it did not return true 1046 * when the variable was explicitly declared final. The JLS considers declared final 1047 * and effectively final to be mutually exclusive, we don't. 1048 * @attribute syn 1049 * @aspect EffectivelyFinal 1050 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:151 1051 */ 1052 @ASTNodeAnnotation.Attribute 1053 public boolean isEffectivelyFinal() { 1054 ASTNode$State state = state(); 1055 if (isEffectivelyFinal_computed) { 1056 return isEffectivelyFinal_value; 1057 } 1058 boolean intermediate = state.INTERMEDIATE_VALUE; 1059 state.INTERMEDIATE_VALUE = false; 1060 int num = state.boundariesCrossed; 1061 boolean isFinal = this.is$Final(); 1062 isEffectivelyFinal_value = isFinal() || !inhModifiedInScope(this); 1063 if (isFinal && num == state().boundariesCrossed) { 1064 isEffectivelyFinal_computed = true; 1065 } else { 1066 } 1067 state.INTERMEDIATE_VALUE |= intermediate; 1068 1069 return isEffectivelyFinal_value; 1070 } 1071 /** 1072 * @attribute inh 1073 * @aspect DeclareBeforeUse 1074 * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:34 1075 */ 1076 /** 1077 * @attribute inh 1078 * @aspect DeclareBeforeUse 1079 * @declaredat /home/jesper/git/extendj/java4/frontend/DeclareBeforeUse.jrag:34 1080 */ 1081 @ASTNodeAnnotation.Attribute 1082 public int blockIndex() { 1083 ASTNode$State state = state(); 1084 if (blockIndex_computed) { 1085 return blockIndex_value; 1086 } 1087 boolean intermediate = state.INTERMEDIATE_VALUE; 1088 state.INTERMEDIATE_VALUE = false; 1089 int num = state.boundariesCrossed; 1090 boolean isFinal = this.is$Final(); 1091 blockIndex_value = getParent().Define_blockIndex(this, null); 1092 if (isFinal && num == state().boundariesCrossed) { 1093 blockIndex_computed = true; 1094 } else { 1095 } 1096 state.INTERMEDIATE_VALUE |= intermediate; 1097 1098 return blockIndex_value; 1099 } 1100 /** 1101 * @apilevel internal 1102 */ 1103 protected boolean blockIndex_computed = false; 1104 /** 1105 * @apilevel internal 1106 */ 1107 protected int blockIndex_value; 1108 /** 1109 * @apilevel internal 1110 */ 1111 private void blockIndex_reset() { 1112 blockIndex_computed = false; 1113 } 1114 /** 1115 * @attribute inh 1116 * @aspect DA 1117 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:256 1118 */ 1119 /** 1120 * @attribute inh 1121 * @aspect DA 1122 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:256 1123 */ 1124 @ASTNodeAnnotation.Attribute 1125 public boolean isDAbefore(Variable v) { 1126 boolean isDAbefore_Variable_value = getParent().Define_isDAbefore(this, null, v); 1127 1128 return isDAbefore_Variable_value; 1129 } 1130 /** 1131 * @attribute inh 1132 * @aspect DU 1133 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:780 1134 */ 1135 /** 1136 * @attribute inh 1137 * @aspect DU 1138 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:780 1139 */ 1140 @ASTNodeAnnotation.Attribute 1141 public boolean isDUbefore(Variable v) { 1142 boolean isDUbefore_Variable_value = getParent().Define_isDUbefore(this, null, v); 1143 1144 return isDUbefore_Variable_value; 1145 } 1146 /** 1147 * @attribute inh 1148 * @aspect VariableScope 1149 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:42 1150 */ 1151 /** 1152 * @attribute inh 1153 * @aspect VariableScope 1154 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:42 1155 */ 1156 @ASTNodeAnnotation.Attribute 1157 public SimpleSet lookupVariable(String name) { 1158 SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name); 1159 1160 return lookupVariable_String_value; 1161 } 1162 /** 1163 * @attribute inh 1164 * @aspect NameCheck 1165 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:365 1166 */ 1167 /** 1168 * @attribute inh 1169 * @aspect NameCheck 1170 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:365 1171 */ 1172 @ASTNodeAnnotation.Attribute 1173 public VariableScope outerScope() { 1174 VariableScope outerScope_value = getParent().Define_outerScope(this, null); 1175 1176 return outerScope_value; 1177 } 1178 /** 1179 * @attribute inh 1180 * @aspect NestedTypes 1181 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:563 1182 */ 1183 /** 1184 * @attribute inh 1185 * @aspect NestedTypes 1186 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:563 1187 */ 1188 @ASTNodeAnnotation.Attribute 1189 public BodyDecl enclosingBodyDecl() { 1190 BodyDecl enclosingBodyDecl_value = getParent().Define_enclosingBodyDecl(this, null); 1191 1192 return enclosingBodyDecl_value; 1193 } 1194 /** 1195 * @attribute inh 1196 * @aspect NestedTypes 1197 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:640 1198 */ 1199 /** 1200 * @attribute inh 1201 * @aspect NestedTypes 1202 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:640 1203 */ 1204 @ASTNodeAnnotation.Attribute 1205 public TypeDecl hostType() { 1206 TypeDecl hostType_value = getParent().Define_hostType(this, null); 1207 1208 return hostType_value; 1209 } 1210 /** 1211 * @attribute inh 1212 * @aspect CodeGeneration 1213 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:67 1214 */ 1215 /** 1216 * @attribute inh 1217 * @aspect CodeGeneration 1218 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:67 1219 */ 1220 @ASTNodeAnnotation.Attribute 1221 public int variableScopeEndLabel(CodeGeneration gen) { 1222 int variableScopeEndLabel_CodeGeneration_value = getParent().Define_variableScopeEndLabel(this, null, gen); 1223 1224 return variableScopeEndLabel_CodeGeneration_value; 1225 } 1226 /** 1227 * @attribute inh 1228 * @aspect LocalNum 1229 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:50 1230 */ 1231 /** 1232 * @attribute inh 1233 * @aspect LocalNum 1234 * @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:50 1235 */ 1236 @ASTNodeAnnotation.Attribute 1237 public int localNum() { 1238 ASTNode$State state = state(); 1239 if (localNum_computed) { 1240 return localNum_value; 1241 } 1242 boolean intermediate = state.INTERMEDIATE_VALUE; 1243 state.INTERMEDIATE_VALUE = false; 1244 int num = state.boundariesCrossed; 1245 boolean isFinal = this.is$Final(); 1246 localNum_value = getParent().Define_localNum(this, null); 1247 if (isFinal && num == state().boundariesCrossed) { 1248 localNum_computed = true; 1249 } else { 1250 } 1251 state.INTERMEDIATE_VALUE |= intermediate; 1252 1253 return localNum_value; 1254 } 1255 /** 1256 * @apilevel internal 1257 */ 1258 protected boolean localNum_computed = false; 1259 /** 1260 * @apilevel internal 1261 */ 1262 protected int localNum_value; 1263 /** 1264 * @apilevel internal 1265 */ 1266 private void localNum_reset() { 1267 localNum_computed = false; 1268 } 1269 /** 1270 * @attribute inh 1271 * @aspect SuppressWarnings 1272 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:35 1273 */ 1274 /** 1275 * @attribute inh 1276 * @aspect SuppressWarnings 1277 * @declaredat /home/jesper/git/extendj/java7/frontend/SuppressWarnings.jrag:35 1278 */ 1279 @ASTNodeAnnotation.Attribute 1280 public boolean withinSuppressWarnings(String annot) { 1281 boolean withinSuppressWarnings_String_value = getParent().Define_withinSuppressWarnings(this, null, annot); 1282 1283 return withinSuppressWarnings_String_value; 1284 } 1285 /** 1286 * @attribute inh 1287 * @aspect TryWithResources 1288 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:182 1289 */ 1290 /** 1291 * @attribute inh 1292 * @aspect TryWithResources 1293 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:182 1294 */ 1295 @ASTNodeAnnotation.Attribute 1296 public boolean resourcePreviouslyDeclared(String name) { 1297 boolean resourcePreviouslyDeclared_String_value = getParent().Define_resourcePreviouslyDeclared(this, null, name); 1298 1299 return resourcePreviouslyDeclared_String_value; 1300 } 1301 /** 1302 * @attribute inh 1303 * @aspect PreciseRethrow 1304 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:32 1305 */ 1306 /** 1307 * @attribute inh 1308 * @aspect PreciseRethrow 1309 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:32 1310 */ 1311 @ASTNodeAnnotation.Attribute 1312 public boolean inhModifiedInScope(Variable var) { 1313 boolean inhModifiedInScope_Variable_value = getParent().Define_inhModifiedInScope(this, null, var); 1314 1315 return inhModifiedInScope_Variable_value; 1316 } 1317 /** 1318 * @attribute inh 1319 * @aspect EnclosingLambda 1320 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:36 1321 */ 1322 /** 1323 * @attribute inh 1324 * @aspect EnclosingLambda 1325 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:36 1326 */ 1327 @ASTNodeAnnotation.Attribute 1328 public LambdaExpr enclosingLambda() { 1329 ASTNode$State state = state(); 1330 if (enclosingLambda_computed) { 1331 return enclosingLambda_value; 1332 } 1333 boolean intermediate = state.INTERMEDIATE_VALUE; 1334 state.INTERMEDIATE_VALUE = false; 1335 int num = state.boundariesCrossed; 1336 boolean isFinal = this.is$Final(); 1337 enclosingLambda_value = getParent().Define_enclosingLambda(this, null); 1338 if (isFinal && num == state().boundariesCrossed) { 1339 enclosingLambda_computed = true; 1340 } else { 1341 } 1342 state.INTERMEDIATE_VALUE |= intermediate; 1343 1344 return enclosingLambda_value; 1345 } 1346 /** 1347 * @apilevel internal 1348 */ 1349 protected boolean enclosingLambda_computed = false; 1350 /** 1351 * @apilevel internal 1352 */ 1353 protected LambdaExpr enclosingLambda_value; 1354 /** 1355 * @apilevel internal 1356 */ 1357 private void enclosingLambda_reset() { 1358 enclosingLambda_computed = false; 1359 enclosingLambda_value = null; 1360 } 1361 /** 1362 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47 1363 * @apilevel internal 1364 */ 1365 public boolean Define_isSource(ASTNode caller, ASTNode child) { 1366 if (caller == getInitOptNoTransform()) { 1367 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:62 1368 return true; 1369 } 1370 else { 1371 return getParent().Define_isSource(this, caller); 1372 } 1373 } 1374 protected boolean canDefine_isSource(ASTNode caller, ASTNode child) { 1375 return true; 1376 } 1377 /** 1378 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 1379 * @apilevel internal 1380 */ 1381 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1382 if (caller == getInitOptNoTransform()) { 1383 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:557 1384 return isDAbefore(v); 1385 } 1386 else { 1387 return getParent().Define_isDAbefore(this, caller, v); 1388 } 1389 } 1390 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 1391 return true; 1392 } 1393 /** 1394 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 1395 * @apilevel internal 1396 */ 1397 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 1398 if (caller == getInitOptNoTransform()) { 1399 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1002 1400 return isDUbefore(v); 1401 } 1402 else { 1403 return getParent().Define_isDUbefore(this, caller, v); 1404 } 1405 } 1406 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 1407 return true; 1408 } 1409 /** 1410 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:423 1411 * @apilevel internal 1412 */ 1413 public boolean Define_mayBeFinal(ASTNode caller, ASTNode child) { 1414 if (caller == getModifiersNoTransform()) { 1415 // @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:327 1416 return true; 1417 } 1418 else { 1419 return getParent().Define_mayBeFinal(this, caller); 1420 } 1421 } 1422 protected boolean canDefine_mayBeFinal(ASTNode caller, ASTNode child) { 1423 return true; 1424 } 1425 /** 1426 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 1427 * @apilevel internal 1428 */ 1429 public NameType Define_nameType(ASTNode caller, ASTNode child) { 1430 if (caller == getTypeAccessNoTransform()) { 1431 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:112 1432 return NameType.TYPE_NAME; 1433 } 1434 else { 1435 return getParent().Define_nameType(this, caller); 1436 } 1437 } 1438 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 1439 return true; 1440 } 1441 /** 1442 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:601 1443 * @apilevel internal 1444 */ 1445 public TypeDecl Define_declType(ASTNode caller, ASTNode child) { 1446 if (caller == getInitOptNoTransform()) { 1447 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:287 1448 return type(); 1449 } 1450 else { 1451 return getParent().Define_declType(this, caller); 1452 } 1453 } 1454 protected boolean canDefine_declType(ASTNode caller, ASTNode child) { 1455 return true; 1456 } 1457 /** 1458 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:93 1459 * @apilevel internal 1460 */ 1461 public TypeDecl Define_expectedType(ASTNode caller, ASTNode child) { 1462 if (caller == getInitOptNoTransform()) { 1463 // @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:99 1464 return type().componentType(); 1465 } 1466 else { 1467 return getParent().Define_expectedType(this, caller); 1468 } 1469 } 1470 protected boolean canDefine_expectedType(ASTNode caller, ASTNode child) { 1471 return true; 1472 } 1473 /** 1474 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:96 1475 * @apilevel internal 1476 */ 1477 public boolean Define_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 1478 if (caller == getModifiersNoTransform()) { 1479 // @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:119 1480 return name.equals("LOCAL_VARIABLE"); 1481 } 1482 else { 1483 return getParent().Define_mayUseAnnotationTarget(this, caller, name); 1484 } 1485 } 1486 protected boolean canDefine_mayUseAnnotationTarget(ASTNode caller, ASTNode child, String name) { 1487 return true; 1488 } 1489 /** 1490 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:58 1491 * @apilevel internal 1492 */ 1493 public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) { 1494 if (caller == getInitOptNoTransform()) { 1495 // @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:59 1496 return type(); 1497 } 1498 else { 1499 return getParent().Define_assignConvertedType(this, caller); 1500 } 1501 } 1502 protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) { 1503 return true; 1504 } 1505 /** 1506 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30 1507 * @apilevel internal 1508 */ 1509 public TypeDecl Define_targetType(ASTNode caller, ASTNode child) { 1510 if (caller == getInitOptNoTransform()) { 1511 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:39 1512 return getTypeAccess().type(); 1513 } 1514 else { 1515 return getParent().Define_targetType(this, caller); 1516 } 1517 } 1518 protected boolean canDefine_targetType(ASTNode caller, ASTNode child) { 1519 return true; 1520 } 1521 /** 1522 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 1523 * @apilevel internal 1524 */ 1525 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 1526 if (caller == getInitOptNoTransform()) { 1527 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:349 1528 return true; 1529 } 1530 else { 1531 return getParent().Define_assignmentContext(this, caller); 1532 } 1533 } 1534 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 1535 return true; 1536 } 1537 /** 1538 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 1539 * @apilevel internal 1540 */ 1541 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 1542 if (caller == getInitOptNoTransform()) { 1543 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:350 1544 return false; 1545 } 1546 else { 1547 return getParent().Define_invocationContext(this, caller); 1548 } 1549 } 1550 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 1551 return true; 1552 } 1553 /** 1554 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 1555 * @apilevel internal 1556 */ 1557 public boolean Define_castContext(ASTNode caller, ASTNode child) { 1558 if (caller == getInitOptNoTransform()) { 1559 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:351 1560 return false; 1561 } 1562 else { 1563 return getParent().Define_castContext(this, caller); 1564 } 1565 } 1566 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 1567 return true; 1568 } 1569 /** 1570 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 1571 * @apilevel internal 1572 */ 1573 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 1574 if (caller == getInitOptNoTransform()) { 1575 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:352 1576 return false; 1577 } 1578 else { 1579 return getParent().Define_numericContext(this, caller); 1580 } 1581 } 1582 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 1583 return true; 1584 } 1585 /** 1586 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 1587 * @apilevel internal 1588 */ 1589 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 1590 if (caller == getInitOptNoTransform()) { 1591 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:353 1592 return false; 1593 } 1594 else { 1595 return getParent().Define_stringContext(this, caller); 1596 } 1597 } 1598 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 1599 return true; 1600 } 1601 /** 1602 * @apilevel internal 1603 */ 1604 public ASTNode rewriteTo() { 1605 return super.rewriteTo(); 1606 } 1607 }