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/java5/grammar/GenericMethods.ast:10 027 * @production ParConstructorDecl : {@link ConstructorDecl} ::= <span class="component">TypeArgument:{@link Access}*</span> <span class="component"><GenericConstructorDecl:GenericConstructorDecl></span>; 028 029 */ 030 public class ParConstructorDecl extends ConstructorDecl implements Cloneable, Parameterization { 031 /** 032 * @aspect LookupParTypeDecl 033 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:977 034 */ 035 public boolean isRawType() { 036 return false; 037 } 038 /** 039 * @aspect LookupParTypeDecl 040 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:981 041 */ 042 public TypeDecl substitute(TypeVariable typeVariable) { 043 for (int i = 0; i < numTypeParameter(); i++) { 044 if (typeParameter(i) == typeVariable) { 045 return getTypeArgument(i).type(); 046 } 047 } 048 return genericConstructorDecl().hostType().substitute(typeVariable); 049 } 050 /** 051 * @aspect LookupParTypeDecl 052 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1013 053 */ 054 public int numTypeParameter() { 055 return genericConstructorDecl().original().getNumTypeParameter(); 056 } 057 /** 058 * @aspect LookupParTypeDecl 059 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1021 060 */ 061 public TypeVariable typeParameter(int index) { 062 return genericConstructorDecl().original().getTypeParameter(index); 063 } 064 /** 065 * @aspect GenericsCodegen 066 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:203 067 */ 068 public void emitInvokeConstructor(CodeGeneration gen) { 069 genericConstructorDecl().emitInvokeConstructor(gen); 070 } 071 /** 072 * A raw type parameterization. Performs no substitutions. 073 * @aspect MethodSignature15 074 * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:240 075 */ 076 public static final Parameterization RAW = new Parameterization() { 077 @Override 078 public boolean isRawType() { 079 return true; 080 } 081 @Override 082 public TypeDecl substitute(TypeVariable typeVariable) { 083 return typeVariable; 084 } 085 }; 086 /** 087 * @declaredat ASTNode:1 088 */ 089 public ParConstructorDecl() { 090 super(); 091 } 092 /** 093 * Initializes the child array to the correct size. 094 * Initializes List and Opt nta children. 095 * @apilevel internal 096 * @ast method 097 * @declaredat ASTNode:10 098 */ 099 public void init$Children() { 100 children = new ASTNode[7]; 101 setChild(new List(), 1); 102 setChild(new List(), 2); 103 setChild(new Opt(), 3); 104 setChild(new List(), 5); 105 } 106 /** 107 * @declaredat ASTNode:17 108 */ 109 public ParConstructorDecl(Modifiers p0, String p1, List<ParameterDeclaration> p2, List<Access> p3, Opt<Stmt> p4, Block p5, List<Access> p6, GenericConstructorDecl p7) { 110 setChild(p0, 0); 111 setID(p1); 112 setChild(p2, 1); 113 setChild(p3, 2); 114 setChild(p4, 3); 115 setChild(p5, 4); 116 setChild(p6, 5); 117 setGenericConstructorDecl(p7); 118 } 119 /** 120 * @declaredat ASTNode:27 121 */ 122 public ParConstructorDecl(Modifiers p0, beaver.Symbol p1, List<ParameterDeclaration> p2, List<Access> p3, Opt<Stmt> p4, Block p5, List<Access> p6, GenericConstructorDecl p7) { 123 setChild(p0, 0); 124 setID(p1); 125 setChild(p2, 1); 126 setChild(p3, 2); 127 setChild(p4, 3); 128 setChild(p5, 4); 129 setChild(p6, 5); 130 setGenericConstructorDecl(p7); 131 } 132 /** 133 * @apilevel low-level 134 * @declaredat ASTNode:40 135 */ 136 protected int numChildren() { 137 return 6; 138 } 139 /** 140 * @apilevel internal 141 * @declaredat ASTNode:46 142 */ 143 public boolean mayHaveRewrite() { 144 return false; 145 } 146 /** 147 * @apilevel internal 148 * @declaredat ASTNode:52 149 */ 150 public void flushAttrCache() { 151 super.flushAttrCache(); 152 genericConstructorDecl_reset(); 153 sourceConstructorDecl_reset(); 154 } 155 /** 156 * @apilevel internal 157 * @declaredat ASTNode:60 158 */ 159 public void flushCollectionCache() { 160 super.flushCollectionCache(); 161 } 162 /** 163 * @apilevel internal 164 * @declaredat ASTNode:66 165 */ 166 public void flushRewriteCache() { 167 super.flushRewriteCache(); 168 } 169 /** 170 * @apilevel internal 171 * @declaredat ASTNode:72 172 */ 173 public ParConstructorDecl clone() throws CloneNotSupportedException { 174 ParConstructorDecl node = (ParConstructorDecl) super.clone(); 175 return node; 176 } 177 /** 178 * @apilevel internal 179 * @declaredat ASTNode:79 180 */ 181 public ParConstructorDecl copy() { 182 try { 183 ParConstructorDecl node = (ParConstructorDecl) clone(); 184 node.parent = null; 185 if (children != null) { 186 node.children = (ASTNode[]) children.clone(); 187 } 188 return node; 189 } catch (CloneNotSupportedException e) { 190 throw new Error("Error: clone not supported for " + getClass().getName()); 191 } 192 } 193 /** 194 * Create a deep copy of the AST subtree at this node. 195 * The copy is dangling, i.e. has no parent. 196 * @return dangling copy of the subtree at this node 197 * @apilevel low-level 198 * @deprecated Please use treeCopy or treeCopyNoTransform instead 199 * @declaredat ASTNode:98 200 */ 201 @Deprecated 202 public ParConstructorDecl fullCopy() { 203 return treeCopyNoTransform(); 204 } 205 /** 206 * Create a deep copy of the AST subtree at this node. 207 * The copy is dangling, i.e. has no parent. 208 * @return dangling copy of the subtree at this node 209 * @apilevel low-level 210 * @declaredat ASTNode:108 211 */ 212 public ParConstructorDecl treeCopyNoTransform() { 213 ParConstructorDecl tree = (ParConstructorDecl) copy(); 214 if (children != null) { 215 for (int i = 0; i < children.length; ++i) { 216 switch (i) { 217 case 6: 218 tree.children[i] = null; 219 continue; 220 } 221 ASTNode child = (ASTNode) children[i]; 222 if (child != null) { 223 child = child.treeCopyNoTransform(); 224 tree.setChild(child, i); 225 } 226 } 227 } 228 return tree; 229 } 230 /** 231 * Create a deep copy of the AST subtree at this node. 232 * The subtree of this node is traversed to trigger rewrites before copy. 233 * The copy is dangling, i.e. has no parent. 234 * @return dangling copy of the subtree at this node 235 * @apilevel low-level 236 * @declaredat ASTNode:133 237 */ 238 public ParConstructorDecl treeCopy() { 239 doFullTraversal(); 240 return treeCopyNoTransform(); 241 } 242 /** 243 * @apilevel internal 244 * @declaredat ASTNode:140 245 */ 246 protected boolean is$Equal(ASTNode node) { 247 return super.is$Equal(node) && (tokenString_ID == ((ParConstructorDecl)node).tokenString_ID) && (tokenGenericConstructorDecl_GenericConstructorDecl == ((ParConstructorDecl)node).tokenGenericConstructorDecl_GenericConstructorDecl); 248 } 249 /** 250 * Replaces the Modifiers child. 251 * @param node The new node to replace the Modifiers child. 252 * @apilevel high-level 253 */ 254 public void setModifiers(Modifiers node) { 255 setChild(node, 0); 256 } 257 /** 258 * Retrieves the Modifiers child. 259 * @return The current node used as the Modifiers child. 260 * @apilevel high-level 261 */ 262 @ASTNodeAnnotation.Child(name="Modifiers") 263 public Modifiers getModifiers() { 264 return (Modifiers) getChild(0); 265 } 266 /** 267 * Retrieves the Modifiers child. 268 * <p><em>This method does not invoke AST transformations.</em></p> 269 * @return The current node used as the Modifiers child. 270 * @apilevel low-level 271 */ 272 public Modifiers getModifiersNoTransform() { 273 return (Modifiers) getChildNoTransform(0); 274 } 275 /** 276 * Replaces the lexeme ID. 277 * @param value The new value for the lexeme ID. 278 * @apilevel high-level 279 */ 280 public void setID(String value) { 281 tokenString_ID = value; 282 } 283 /** 284 * JastAdd-internal setter for lexeme ID using the Beaver parser. 285 * @param symbol Symbol containing the new value for the lexeme ID 286 * @apilevel internal 287 */ 288 public void setID(beaver.Symbol symbol) { 289 if (symbol.value != null && !(symbol.value instanceof String)) 290 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 291 tokenString_ID = (String)symbol.value; 292 IDstart = symbol.getStart(); 293 IDend = symbol.getEnd(); 294 } 295 /** 296 * Retrieves the value for the lexeme ID. 297 * @return The value for the lexeme ID. 298 * @apilevel high-level 299 */ 300 @ASTNodeAnnotation.Token(name="ID") 301 public String getID() { 302 return tokenString_ID != null ? tokenString_ID : ""; 303 } 304 /** 305 * Replaces the Parameter list. 306 * @param list The new list node to be used as the Parameter list. 307 * @apilevel high-level 308 */ 309 public void setParameterList(List<ParameterDeclaration> list) { 310 setChild(list, 1); 311 } 312 /** 313 * Retrieves the number of children in the Parameter list. 314 * @return Number of children in the Parameter list. 315 * @apilevel high-level 316 */ 317 public int getNumParameter() { 318 return getParameterList().getNumChild(); 319 } 320 /** 321 * Retrieves the number of children in the Parameter list. 322 * Calling this method will not trigger rewrites. 323 * @return Number of children in the Parameter list. 324 * @apilevel low-level 325 */ 326 public int getNumParameterNoTransform() { 327 return getParameterListNoTransform().getNumChildNoTransform(); 328 } 329 /** 330 * Retrieves the element at index {@code i} in the Parameter list. 331 * @param i Index of the element to return. 332 * @return The element at position {@code i} in the Parameter list. 333 * @apilevel high-level 334 */ 335 public ParameterDeclaration getParameter(int i) { 336 return (ParameterDeclaration) getParameterList().getChild(i); 337 } 338 /** 339 * Check whether the Parameter list has any children. 340 * @return {@code true} if it has at least one child, {@code false} otherwise. 341 * @apilevel high-level 342 */ 343 public boolean hasParameter() { 344 return getParameterList().getNumChild() != 0; 345 } 346 /** 347 * Append an element to the Parameter list. 348 * @param node The element to append to the Parameter list. 349 * @apilevel high-level 350 */ 351 public void addParameter(ParameterDeclaration node) { 352 List<ParameterDeclaration> list = (parent == null) ? getParameterListNoTransform() : getParameterList(); 353 list.addChild(node); 354 } 355 /** 356 * @apilevel low-level 357 */ 358 public void addParameterNoTransform(ParameterDeclaration node) { 359 List<ParameterDeclaration> list = getParameterListNoTransform(); 360 list.addChild(node); 361 } 362 /** 363 * Replaces the Parameter list element at index {@code i} with the new node {@code node}. 364 * @param node The new node to replace the old list element. 365 * @param i The list index of the node to be replaced. 366 * @apilevel high-level 367 */ 368 public void setParameter(ParameterDeclaration node, int i) { 369 List<ParameterDeclaration> list = getParameterList(); 370 list.setChild(node, i); 371 } 372 /** 373 * Retrieves the Parameter list. 374 * @return The node representing the Parameter list. 375 * @apilevel high-level 376 */ 377 @ASTNodeAnnotation.ListChild(name="Parameter") 378 public List<ParameterDeclaration> getParameterList() { 379 List<ParameterDeclaration> list = (List<ParameterDeclaration>) getChild(1); 380 return list; 381 } 382 /** 383 * Retrieves the Parameter list. 384 * <p><em>This method does not invoke AST transformations.</em></p> 385 * @return The node representing the Parameter list. 386 * @apilevel low-level 387 */ 388 public List<ParameterDeclaration> getParameterListNoTransform() { 389 return (List<ParameterDeclaration>) getChildNoTransform(1); 390 } 391 /** 392 * Retrieves the Parameter list. 393 * @return The node representing the Parameter list. 394 * @apilevel high-level 395 */ 396 public List<ParameterDeclaration> getParameters() { 397 return getParameterList(); 398 } 399 /** 400 * Retrieves the Parameter list. 401 * <p><em>This method does not invoke AST transformations.</em></p> 402 * @return The node representing the Parameter list. 403 * @apilevel low-level 404 */ 405 public List<ParameterDeclaration> getParametersNoTransform() { 406 return getParameterListNoTransform(); 407 } 408 /** 409 * Replaces the Exception list. 410 * @param list The new list node to be used as the Exception list. 411 * @apilevel high-level 412 */ 413 public void setExceptionList(List<Access> list) { 414 setChild(list, 2); 415 } 416 /** 417 * Retrieves the number of children in the Exception list. 418 * @return Number of children in the Exception list. 419 * @apilevel high-level 420 */ 421 public int getNumException() { 422 return getExceptionList().getNumChild(); 423 } 424 /** 425 * Retrieves the number of children in the Exception list. 426 * Calling this method will not trigger rewrites. 427 * @return Number of children in the Exception list. 428 * @apilevel low-level 429 */ 430 public int getNumExceptionNoTransform() { 431 return getExceptionListNoTransform().getNumChildNoTransform(); 432 } 433 /** 434 * Retrieves the element at index {@code i} in the Exception list. 435 * @param i Index of the element to return. 436 * @return The element at position {@code i} in the Exception list. 437 * @apilevel high-level 438 */ 439 public Access getException(int i) { 440 return (Access) getExceptionList().getChild(i); 441 } 442 /** 443 * Check whether the Exception list has any children. 444 * @return {@code true} if it has at least one child, {@code false} otherwise. 445 * @apilevel high-level 446 */ 447 public boolean hasException() { 448 return getExceptionList().getNumChild() != 0; 449 } 450 /** 451 * Append an element to the Exception list. 452 * @param node The element to append to the Exception list. 453 * @apilevel high-level 454 */ 455 public void addException(Access node) { 456 List<Access> list = (parent == null) ? getExceptionListNoTransform() : getExceptionList(); 457 list.addChild(node); 458 } 459 /** 460 * @apilevel low-level 461 */ 462 public void addExceptionNoTransform(Access node) { 463 List<Access> list = getExceptionListNoTransform(); 464 list.addChild(node); 465 } 466 /** 467 * Replaces the Exception list element at index {@code i} with the new node {@code node}. 468 * @param node The new node to replace the old list element. 469 * @param i The list index of the node to be replaced. 470 * @apilevel high-level 471 */ 472 public void setException(Access node, int i) { 473 List<Access> list = getExceptionList(); 474 list.setChild(node, i); 475 } 476 /** 477 * Retrieves the Exception list. 478 * @return The node representing the Exception list. 479 * @apilevel high-level 480 */ 481 @ASTNodeAnnotation.ListChild(name="Exception") 482 public List<Access> getExceptionList() { 483 List<Access> list = (List<Access>) getChild(2); 484 return list; 485 } 486 /** 487 * Retrieves the Exception list. 488 * <p><em>This method does not invoke AST transformations.</em></p> 489 * @return The node representing the Exception list. 490 * @apilevel low-level 491 */ 492 public List<Access> getExceptionListNoTransform() { 493 return (List<Access>) getChildNoTransform(2); 494 } 495 /** 496 * Retrieves the Exception list. 497 * @return The node representing the Exception list. 498 * @apilevel high-level 499 */ 500 public List<Access> getExceptions() { 501 return getExceptionList(); 502 } 503 /** 504 * Retrieves the Exception list. 505 * <p><em>This method does not invoke AST transformations.</em></p> 506 * @return The node representing the Exception list. 507 * @apilevel low-level 508 */ 509 public List<Access> getExceptionsNoTransform() { 510 return getExceptionListNoTransform(); 511 } 512 /** 513 * Replaces the optional node for the ParsedConstructorInvocation child. This is the <code>Opt</code> 514 * node containing the child ParsedConstructorInvocation, not the actual child! 515 * @param opt The new node to be used as the optional node for the ParsedConstructorInvocation child. 516 * @apilevel low-level 517 */ 518 public void setParsedConstructorInvocationOpt(Opt<Stmt> opt) { 519 setChild(opt, 3); 520 } 521 /** 522 * Replaces the (optional) ParsedConstructorInvocation child. 523 * @param node The new node to be used as the ParsedConstructorInvocation child. 524 * @apilevel high-level 525 */ 526 public void setParsedConstructorInvocation(Stmt node) { 527 getParsedConstructorInvocationOpt().setChild(node, 0); 528 } 529 /** 530 * Check whether the optional ParsedConstructorInvocation child exists. 531 * @return {@code true} if the optional ParsedConstructorInvocation child exists, {@code false} if it does not. 532 * @apilevel high-level 533 */ 534 public boolean hasParsedConstructorInvocation() { 535 return getParsedConstructorInvocationOpt().getNumChild() != 0; 536 } 537 /** 538 * Retrieves the (optional) ParsedConstructorInvocation child. 539 * @return The ParsedConstructorInvocation child, if it exists. Returns {@code null} otherwise. 540 * @apilevel low-level 541 */ 542 public Stmt getParsedConstructorInvocation() { 543 return (Stmt) getParsedConstructorInvocationOpt().getChild(0); 544 } 545 /** 546 * Retrieves the optional node for the ParsedConstructorInvocation child. This is the <code>Opt</code> node containing the child ParsedConstructorInvocation, not the actual child! 547 * @return The optional node for child the ParsedConstructorInvocation child. 548 * @apilevel low-level 549 */ 550 @ASTNodeAnnotation.OptChild(name="ParsedConstructorInvocation") 551 public Opt<Stmt> getParsedConstructorInvocationOpt() { 552 return (Opt<Stmt>) getChild(3); 553 } 554 /** 555 * Retrieves the optional node for child ParsedConstructorInvocation. This is the <code>Opt</code> node containing the child ParsedConstructorInvocation, not the actual child! 556 * <p><em>This method does not invoke AST transformations.</em></p> 557 * @return The optional node for child ParsedConstructorInvocation. 558 * @apilevel low-level 559 */ 560 public Opt<Stmt> getParsedConstructorInvocationOptNoTransform() { 561 return (Opt<Stmt>) getChildNoTransform(3); 562 } 563 /** 564 * Replaces the Block child. 565 * @param node The new node to replace the Block child. 566 * @apilevel high-level 567 */ 568 public void setBlock(Block node) { 569 setChild(node, 4); 570 } 571 /** 572 * Retrieves the Block child. 573 * @return The current node used as the Block child. 574 * @apilevel high-level 575 */ 576 @ASTNodeAnnotation.Child(name="Block") 577 public Block getBlock() { 578 return (Block) getChild(4); 579 } 580 /** 581 * Retrieves the Block child. 582 * <p><em>This method does not invoke AST transformations.</em></p> 583 * @return The current node used as the Block child. 584 * @apilevel low-level 585 */ 586 public Block getBlockNoTransform() { 587 return (Block) getChildNoTransform(4); 588 } 589 /** 590 * Replaces the TypeArgument list. 591 * @param list The new list node to be used as the TypeArgument list. 592 * @apilevel high-level 593 */ 594 public void setTypeArgumentList(List<Access> list) { 595 setChild(list, 5); 596 } 597 /** 598 * Retrieves the number of children in the TypeArgument list. 599 * @return Number of children in the TypeArgument list. 600 * @apilevel high-level 601 */ 602 public int getNumTypeArgument() { 603 return getTypeArgumentList().getNumChild(); 604 } 605 /** 606 * Retrieves the number of children in the TypeArgument list. 607 * Calling this method will not trigger rewrites. 608 * @return Number of children in the TypeArgument list. 609 * @apilevel low-level 610 */ 611 public int getNumTypeArgumentNoTransform() { 612 return getTypeArgumentListNoTransform().getNumChildNoTransform(); 613 } 614 /** 615 * Retrieves the element at index {@code i} in the TypeArgument list. 616 * @param i Index of the element to return. 617 * @return The element at position {@code i} in the TypeArgument list. 618 * @apilevel high-level 619 */ 620 public Access getTypeArgument(int i) { 621 return (Access) getTypeArgumentList().getChild(i); 622 } 623 /** 624 * Check whether the TypeArgument list has any children. 625 * @return {@code true} if it has at least one child, {@code false} otherwise. 626 * @apilevel high-level 627 */ 628 public boolean hasTypeArgument() { 629 return getTypeArgumentList().getNumChild() != 0; 630 } 631 /** 632 * Append an element to the TypeArgument list. 633 * @param node The element to append to the TypeArgument list. 634 * @apilevel high-level 635 */ 636 public void addTypeArgument(Access node) { 637 List<Access> list = (parent == null) ? getTypeArgumentListNoTransform() : getTypeArgumentList(); 638 list.addChild(node); 639 } 640 /** 641 * @apilevel low-level 642 */ 643 public void addTypeArgumentNoTransform(Access node) { 644 List<Access> list = getTypeArgumentListNoTransform(); 645 list.addChild(node); 646 } 647 /** 648 * Replaces the TypeArgument list element at index {@code i} with the new node {@code node}. 649 * @param node The new node to replace the old list element. 650 * @param i The list index of the node to be replaced. 651 * @apilevel high-level 652 */ 653 public void setTypeArgument(Access node, int i) { 654 List<Access> list = getTypeArgumentList(); 655 list.setChild(node, i); 656 } 657 /** 658 * Retrieves the TypeArgument list. 659 * @return The node representing the TypeArgument list. 660 * @apilevel high-level 661 */ 662 @ASTNodeAnnotation.ListChild(name="TypeArgument") 663 public List<Access> getTypeArgumentList() { 664 List<Access> list = (List<Access>) getChild(5); 665 return list; 666 } 667 /** 668 * Retrieves the TypeArgument list. 669 * <p><em>This method does not invoke AST transformations.</em></p> 670 * @return The node representing the TypeArgument list. 671 * @apilevel low-level 672 */ 673 public List<Access> getTypeArgumentListNoTransform() { 674 return (List<Access>) getChildNoTransform(5); 675 } 676 /** 677 * Retrieves the TypeArgument list. 678 * @return The node representing the TypeArgument list. 679 * @apilevel high-level 680 */ 681 public List<Access> getTypeArguments() { 682 return getTypeArgumentList(); 683 } 684 /** 685 * Retrieves the TypeArgument list. 686 * <p><em>This method does not invoke AST transformations.</em></p> 687 * @return The node representing the TypeArgument list. 688 * @apilevel low-level 689 */ 690 public List<Access> getTypeArgumentsNoTransform() { 691 return getTypeArgumentListNoTransform(); 692 } 693 /** 694 * Replaces the lexeme GenericConstructorDecl. 695 * @param value The new value for the lexeme GenericConstructorDecl. 696 * @apilevel high-level 697 */ 698 public void setGenericConstructorDecl(GenericConstructorDecl value) { 699 tokenGenericConstructorDecl_GenericConstructorDecl = value; 700 } 701 /** 702 * @apilevel internal 703 */ 704 protected GenericConstructorDecl tokenGenericConstructorDecl_GenericConstructorDecl; 705 /** 706 * Retrieves the value for the lexeme GenericConstructorDecl. 707 * @return The value for the lexeme GenericConstructorDecl. 708 * @apilevel high-level 709 */ 710 @ASTNodeAnnotation.Token(name="GenericConstructorDecl") 711 public GenericConstructorDecl getGenericConstructorDecl() { 712 return tokenGenericConstructorDecl_GenericConstructorDecl; 713 } 714 /** 715 * Retrieves the ImplicitConstructorInvocation child. 716 * <p><em>This method does not invoke AST transformations.</em></p> 717 * @return The current node used as the ImplicitConstructorInvocation child. 718 * @apilevel low-level 719 */ 720 public Stmt getImplicitConstructorInvocationNoTransform() { 721 return (Stmt) getChildNoTransform(6); 722 } 723 /** 724 * Retrieves the child position of the optional child ImplicitConstructorInvocation. 725 * @return The the child position of the optional child ImplicitConstructorInvocation. 726 * @apilevel low-level 727 */ 728 protected int getImplicitConstructorInvocationChildPosition() { 729 return 6; 730 } 731 /** 732 * @apilevel internal 733 */ 734 protected boolean genericConstructorDecl_computed = false; 735 /** 736 * @apilevel internal 737 */ 738 protected GenericConstructorDecl genericConstructorDecl_value; 739 /** 740 * @apilevel internal 741 */ 742 private void genericConstructorDecl_reset() { 743 genericConstructorDecl_computed = false; 744 genericConstructorDecl_value = null; 745 } 746 /** 747 * @attribute syn 748 * @aspect GenericMethods 749 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:53 750 */ 751 @ASTNodeAnnotation.Attribute 752 public GenericConstructorDecl genericConstructorDecl() { 753 ASTNode$State state = state(); 754 if (genericConstructorDecl_computed) { 755 return genericConstructorDecl_value; 756 } 757 boolean intermediate = state.INTERMEDIATE_VALUE; 758 state.INTERMEDIATE_VALUE = false; 759 int num = state.boundariesCrossed; 760 boolean isFinal = this.is$Final(); 761 genericConstructorDecl_value = getGenericConstructorDecl(); 762 if (isFinal && num == state().boundariesCrossed) { 763 genericConstructorDecl_computed = true; 764 } else { 765 } 766 state.INTERMEDIATE_VALUE |= intermediate; 767 768 return genericConstructorDecl_value; 769 } 770 /** 771 * @apilevel internal 772 */ 773 protected boolean sourceConstructorDecl_computed = false; 774 /** 775 * @apilevel internal 776 */ 777 protected ConstructorDecl sourceConstructorDecl_value; 778 /** 779 * @apilevel internal 780 */ 781 private void sourceConstructorDecl_reset() { 782 sourceConstructorDecl_computed = false; 783 sourceConstructorDecl_value = null; 784 } 785 /** 786 * @attribute syn 787 * @aspect SourceDeclarations 788 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1629 789 */ 790 @ASTNodeAnnotation.Attribute 791 public ConstructorDecl sourceConstructorDecl() { 792 ASTNode$State state = state(); 793 if (sourceConstructorDecl_computed) { 794 return sourceConstructorDecl_value; 795 } 796 boolean intermediate = state.INTERMEDIATE_VALUE; 797 state.INTERMEDIATE_VALUE = false; 798 int num = state.boundariesCrossed; 799 boolean isFinal = this.is$Final(); 800 sourceConstructorDecl_value = genericConstructorDecl().original().sourceConstructorDecl(); 801 if (isFinal && num == state().boundariesCrossed) { 802 sourceConstructorDecl_computed = true; 803 } else { 804 } 805 state.INTERMEDIATE_VALUE |= intermediate; 806 807 return sourceConstructorDecl_value; 808 } 809 /** 810 * @apilevel internal 811 */ 812 public ASTNode rewriteTo() { 813 return super.rewriteTo(); 814 } 815 }