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/Generics.ast:43 027 * @production GenericClassDeclSubstituted : {@link GenericClassDecl} ::= <span class="component"><Original:TypeDecl></span> <span class="component">{@link BodyDecl}*</span>; 028 029 */ 030 public class GenericClassDeclSubstituted extends GenericClassDecl implements Cloneable, MemberSubstitutor { 031 /** 032 * @declaredat ASTNode:1 033 */ 034 public GenericClassDeclSubstituted() { 035 super(); 036 } 037 /** 038 * Initializes the child array to the correct size. 039 * Initializes List and Opt nta children. 040 * @apilevel internal 041 * @ast method 042 * @declaredat ASTNode:10 043 */ 044 public void init$Children() { 045 children = new ASTNode[6]; 046 setChild(new Opt(), 1); 047 setChild(new List(), 2); 048 setChild(new List(), 3); 049 setChild(new Opt(), 4); 050 setChild(new List(), 5); 051 } 052 /** 053 * @declaredat ASTNode:18 054 */ 055 public GenericClassDeclSubstituted(Modifiers p0, String p1, Opt<Access> p2, List<Access> p3, List<TypeVariable> p4, TypeDecl p5) { 056 setChild(p0, 0); 057 setID(p1); 058 setChild(p2, 1); 059 setChild(p3, 2); 060 setChild(p4, 3); 061 setOriginal(p5); 062 } 063 /** 064 * @declaredat ASTNode:26 065 */ 066 public GenericClassDeclSubstituted(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<Access> p3, List<TypeVariable> p4, TypeDecl p5) { 067 setChild(p0, 0); 068 setID(p1); 069 setChild(p2, 1); 070 setChild(p3, 2); 071 setChild(p4, 3); 072 setOriginal(p5); 073 } 074 /** 075 * @apilevel low-level 076 * @declaredat ASTNode:37 077 */ 078 protected int numChildren() { 079 return 4; 080 } 081 /** 082 * @apilevel internal 083 * @declaredat ASTNode:43 084 */ 085 public boolean mayHaveRewrite() { 086 return false; 087 } 088 /** 089 * @apilevel internal 090 * @declaredat ASTNode:49 091 */ 092 public void flushAttrCache() { 093 super.flushAttrCache(); 094 getBodyDeclList_reset(); 095 sourceTypeDecl_reset(); 096 instanceOf_TypeDecl_reset(); 097 subtype_TypeDecl_reset(); 098 typeDescriptor_reset(); 099 constantPoolName_reset(); 100 uniqueIndex_reset(); 101 strictSubtype_TypeDecl_reset(); 102 localMethodsSignatureMap_reset(); 103 localFields_String_reset(); 104 localTypeDecls_String_reset(); 105 constructors_reset(); 106 } 107 /** 108 * @apilevel internal 109 * @declaredat ASTNode:67 110 */ 111 public void flushCollectionCache() { 112 super.flushCollectionCache(); 113 } 114 /** 115 * @apilevel internal 116 * @declaredat ASTNode:73 117 */ 118 public void flushRewriteCache() { 119 super.flushRewriteCache(); 120 } 121 /** 122 * @apilevel internal 123 * @declaredat ASTNode:79 124 */ 125 public GenericClassDeclSubstituted clone() throws CloneNotSupportedException { 126 GenericClassDeclSubstituted node = (GenericClassDeclSubstituted) super.clone(); 127 return node; 128 } 129 /** 130 * @apilevel internal 131 * @declaredat ASTNode:86 132 */ 133 public GenericClassDeclSubstituted copy() { 134 try { 135 GenericClassDeclSubstituted node = (GenericClassDeclSubstituted) clone(); 136 node.parent = null; 137 if (children != null) { 138 node.children = (ASTNode[]) children.clone(); 139 } 140 return node; 141 } catch (CloneNotSupportedException e) { 142 throw new Error("Error: clone not supported for " + getClass().getName()); 143 } 144 } 145 /** 146 * Create a deep copy of the AST subtree at this node. 147 * The copy is dangling, i.e. has no parent. 148 * @return dangling copy of the subtree at this node 149 * @apilevel low-level 150 * @deprecated Please use treeCopy or treeCopyNoTransform instead 151 * @declaredat ASTNode:105 152 */ 153 @Deprecated 154 public GenericClassDeclSubstituted fullCopy() { 155 return treeCopyNoTransform(); 156 } 157 /** 158 * Create a deep copy of the AST subtree at this node. 159 * The copy is dangling, i.e. has no parent. 160 * @return dangling copy of the subtree at this node 161 * @apilevel low-level 162 * @declaredat ASTNode:115 163 */ 164 public GenericClassDeclSubstituted treeCopyNoTransform() { 165 GenericClassDeclSubstituted tree = (GenericClassDeclSubstituted) copy(); 166 if (children != null) { 167 for (int i = 0; i < children.length; ++i) { 168 switch (i) { 169 case 4: 170 tree.children[i] = new Opt(); 171 continue; 172 case 5: 173 tree.children[i] = new List(); 174 continue; 175 } 176 ASTNode child = (ASTNode) children[i]; 177 if (child != null) { 178 child = child.treeCopyNoTransform(); 179 tree.setChild(child, i); 180 } 181 } 182 } 183 return tree; 184 } 185 /** 186 * Create a deep copy of the AST subtree at this node. 187 * The subtree of this node is traversed to trigger rewrites before copy. 188 * The copy is dangling, i.e. has no parent. 189 * @return dangling copy of the subtree at this node 190 * @apilevel low-level 191 * @declaredat ASTNode:143 192 */ 193 public GenericClassDeclSubstituted treeCopy() { 194 doFullTraversal(); 195 return treeCopyNoTransform(); 196 } 197 /** 198 * @apilevel internal 199 * @declaredat ASTNode:150 200 */ 201 protected boolean is$Equal(ASTNode node) { 202 return super.is$Equal(node) && (tokenString_ID == ((GenericClassDeclSubstituted)node).tokenString_ID) && (tokenTypeDecl_Original == ((GenericClassDeclSubstituted)node).tokenTypeDecl_Original); 203 } 204 /** 205 * Replaces the Modifiers child. 206 * @param node The new node to replace the Modifiers child. 207 * @apilevel high-level 208 */ 209 public void setModifiers(Modifiers node) { 210 setChild(node, 0); 211 } 212 /** 213 * Retrieves the Modifiers child. 214 * @return The current node used as the Modifiers child. 215 * @apilevel high-level 216 */ 217 @ASTNodeAnnotation.Child(name="Modifiers") 218 public Modifiers getModifiers() { 219 return (Modifiers) getChild(0); 220 } 221 /** 222 * Retrieves the Modifiers child. 223 * <p><em>This method does not invoke AST transformations.</em></p> 224 * @return The current node used as the Modifiers child. 225 * @apilevel low-level 226 */ 227 public Modifiers getModifiersNoTransform() { 228 return (Modifiers) getChildNoTransform(0); 229 } 230 /** 231 * Replaces the lexeme ID. 232 * @param value The new value for the lexeme ID. 233 * @apilevel high-level 234 */ 235 public void setID(String value) { 236 tokenString_ID = value; 237 } 238 /** 239 * JastAdd-internal setter for lexeme ID using the Beaver parser. 240 * @param symbol Symbol containing the new value for the lexeme ID 241 * @apilevel internal 242 */ 243 public void setID(beaver.Symbol symbol) { 244 if (symbol.value != null && !(symbol.value instanceof String)) 245 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 246 tokenString_ID = (String)symbol.value; 247 IDstart = symbol.getStart(); 248 IDend = symbol.getEnd(); 249 } 250 /** 251 * Retrieves the value for the lexeme ID. 252 * @return The value for the lexeme ID. 253 * @apilevel high-level 254 */ 255 @ASTNodeAnnotation.Token(name="ID") 256 public String getID() { 257 return tokenString_ID != null ? tokenString_ID : ""; 258 } 259 /** 260 * Replaces the optional node for the SuperClass child. This is the <code>Opt</code> 261 * node containing the child SuperClass, not the actual child! 262 * @param opt The new node to be used as the optional node for the SuperClass child. 263 * @apilevel low-level 264 */ 265 public void setSuperClassOpt(Opt<Access> opt) { 266 setChild(opt, 1); 267 } 268 /** 269 * Replaces the (optional) SuperClass child. 270 * @param node The new node to be used as the SuperClass child. 271 * @apilevel high-level 272 */ 273 public void setSuperClass(Access node) { 274 getSuperClassOpt().setChild(node, 0); 275 } 276 /** 277 * Check whether the optional SuperClass child exists. 278 * @return {@code true} if the optional SuperClass child exists, {@code false} if it does not. 279 * @apilevel high-level 280 */ 281 public boolean hasSuperClass() { 282 return getSuperClassOpt().getNumChild() != 0; 283 } 284 /** 285 * Retrieves the (optional) SuperClass child. 286 * @return The SuperClass child, if it exists. Returns {@code null} otherwise. 287 * @apilevel low-level 288 */ 289 public Access getSuperClass() { 290 return (Access) getSuperClassOpt().getChild(0); 291 } 292 /** 293 * Retrieves the optional node for the SuperClass child. This is the <code>Opt</code> node containing the child SuperClass, not the actual child! 294 * @return The optional node for child the SuperClass child. 295 * @apilevel low-level 296 */ 297 @ASTNodeAnnotation.OptChild(name="SuperClass") 298 public Opt<Access> getSuperClassOpt() { 299 return (Opt<Access>) getChild(1); 300 } 301 /** 302 * Retrieves the optional node for child SuperClass. This is the <code>Opt</code> node containing the child SuperClass, not the actual child! 303 * <p><em>This method does not invoke AST transformations.</em></p> 304 * @return The optional node for child SuperClass. 305 * @apilevel low-level 306 */ 307 public Opt<Access> getSuperClassOptNoTransform() { 308 return (Opt<Access>) getChildNoTransform(1); 309 } 310 /** 311 * Replaces the Implements list. 312 * @param list The new list node to be used as the Implements list. 313 * @apilevel high-level 314 */ 315 public void setImplementsList(List<Access> list) { 316 setChild(list, 2); 317 } 318 /** 319 * Retrieves the number of children in the Implements list. 320 * @return Number of children in the Implements list. 321 * @apilevel high-level 322 */ 323 public int getNumImplements() { 324 return getImplementsList().getNumChild(); 325 } 326 /** 327 * Retrieves the number of children in the Implements list. 328 * Calling this method will not trigger rewrites. 329 * @return Number of children in the Implements list. 330 * @apilevel low-level 331 */ 332 public int getNumImplementsNoTransform() { 333 return getImplementsListNoTransform().getNumChildNoTransform(); 334 } 335 /** 336 * Retrieves the element at index {@code i} in the Implements list. 337 * @param i Index of the element to return. 338 * @return The element at position {@code i} in the Implements list. 339 * @apilevel high-level 340 */ 341 public Access getImplements(int i) { 342 return (Access) getImplementsList().getChild(i); 343 } 344 /** 345 * Check whether the Implements list has any children. 346 * @return {@code true} if it has at least one child, {@code false} otherwise. 347 * @apilevel high-level 348 */ 349 public boolean hasImplements() { 350 return getImplementsList().getNumChild() != 0; 351 } 352 /** 353 * Append an element to the Implements list. 354 * @param node The element to append to the Implements list. 355 * @apilevel high-level 356 */ 357 public void addImplements(Access node) { 358 List<Access> list = (parent == null) ? getImplementsListNoTransform() : getImplementsList(); 359 list.addChild(node); 360 } 361 /** 362 * @apilevel low-level 363 */ 364 public void addImplementsNoTransform(Access node) { 365 List<Access> list = getImplementsListNoTransform(); 366 list.addChild(node); 367 } 368 /** 369 * Replaces the Implements list element at index {@code i} with the new node {@code node}. 370 * @param node The new node to replace the old list element. 371 * @param i The list index of the node to be replaced. 372 * @apilevel high-level 373 */ 374 public void setImplements(Access node, int i) { 375 List<Access> list = getImplementsList(); 376 list.setChild(node, i); 377 } 378 /** 379 * Retrieves the Implements list. 380 * @return The node representing the Implements list. 381 * @apilevel high-level 382 */ 383 @ASTNodeAnnotation.ListChild(name="Implements") 384 public List<Access> getImplementsList() { 385 List<Access> list = (List<Access>) getChild(2); 386 return list; 387 } 388 /** 389 * Retrieves the Implements list. 390 * <p><em>This method does not invoke AST transformations.</em></p> 391 * @return The node representing the Implements list. 392 * @apilevel low-level 393 */ 394 public List<Access> getImplementsListNoTransform() { 395 return (List<Access>) getChildNoTransform(2); 396 } 397 /** 398 * Retrieves the Implements list. 399 * @return The node representing the Implements list. 400 * @apilevel high-level 401 */ 402 public List<Access> getImplementss() { 403 return getImplementsList(); 404 } 405 /** 406 * Retrieves the Implements list. 407 * <p><em>This method does not invoke AST transformations.</em></p> 408 * @return The node representing the Implements list. 409 * @apilevel low-level 410 */ 411 public List<Access> getImplementssNoTransform() { 412 return getImplementsListNoTransform(); 413 } 414 /** 415 * Replaces the TypeParameter list. 416 * @param list The new list node to be used as the TypeParameter list. 417 * @apilevel high-level 418 */ 419 public void setTypeParameterList(List<TypeVariable> list) { 420 setChild(list, 3); 421 } 422 /** 423 * Retrieves the number of children in the TypeParameter list. 424 * @return Number of children in the TypeParameter list. 425 * @apilevel high-level 426 */ 427 public int getNumTypeParameter() { 428 return getTypeParameterList().getNumChild(); 429 } 430 /** 431 * Retrieves the number of children in the TypeParameter list. 432 * Calling this method will not trigger rewrites. 433 * @return Number of children in the TypeParameter list. 434 * @apilevel low-level 435 */ 436 public int getNumTypeParameterNoTransform() { 437 return getTypeParameterListNoTransform().getNumChildNoTransform(); 438 } 439 /** 440 * Retrieves the element at index {@code i} in the TypeParameter list. 441 * @param i Index of the element to return. 442 * @return The element at position {@code i} in the TypeParameter list. 443 * @apilevel high-level 444 */ 445 public TypeVariable getTypeParameter(int i) { 446 return (TypeVariable) getTypeParameterList().getChild(i); 447 } 448 /** 449 * Check whether the TypeParameter list has any children. 450 * @return {@code true} if it has at least one child, {@code false} otherwise. 451 * @apilevel high-level 452 */ 453 public boolean hasTypeParameter() { 454 return getTypeParameterList().getNumChild() != 0; 455 } 456 /** 457 * Append an element to the TypeParameter list. 458 * @param node The element to append to the TypeParameter list. 459 * @apilevel high-level 460 */ 461 public void addTypeParameter(TypeVariable node) { 462 List<TypeVariable> list = (parent == null) ? getTypeParameterListNoTransform() : getTypeParameterList(); 463 list.addChild(node); 464 } 465 /** 466 * @apilevel low-level 467 */ 468 public void addTypeParameterNoTransform(TypeVariable node) { 469 List<TypeVariable> list = getTypeParameterListNoTransform(); 470 list.addChild(node); 471 } 472 /** 473 * Replaces the TypeParameter list element at index {@code i} with the new node {@code node}. 474 * @param node The new node to replace the old list element. 475 * @param i The list index of the node to be replaced. 476 * @apilevel high-level 477 */ 478 public void setTypeParameter(TypeVariable node, int i) { 479 List<TypeVariable> list = getTypeParameterList(); 480 list.setChild(node, i); 481 } 482 /** 483 * Retrieves the TypeParameter list. 484 * @return The node representing the TypeParameter list. 485 * @apilevel high-level 486 */ 487 @ASTNodeAnnotation.ListChild(name="TypeParameter") 488 public List<TypeVariable> getTypeParameterList() { 489 List<TypeVariable> list = (List<TypeVariable>) getChild(3); 490 return list; 491 } 492 /** 493 * Retrieves the TypeParameter list. 494 * <p><em>This method does not invoke AST transformations.</em></p> 495 * @return The node representing the TypeParameter list. 496 * @apilevel low-level 497 */ 498 public List<TypeVariable> getTypeParameterListNoTransform() { 499 return (List<TypeVariable>) getChildNoTransform(3); 500 } 501 /** 502 * Retrieves the TypeParameter list. 503 * @return The node representing the TypeParameter list. 504 * @apilevel high-level 505 */ 506 public List<TypeVariable> getTypeParameters() { 507 return getTypeParameterList(); 508 } 509 /** 510 * Retrieves the TypeParameter list. 511 * <p><em>This method does not invoke AST transformations.</em></p> 512 * @return The node representing the TypeParameter list. 513 * @apilevel low-level 514 */ 515 public List<TypeVariable> getTypeParametersNoTransform() { 516 return getTypeParameterListNoTransform(); 517 } 518 /** 519 * Replaces the lexeme Original. 520 * @param value The new value for the lexeme Original. 521 * @apilevel high-level 522 */ 523 public void setOriginal(TypeDecl value) { 524 tokenTypeDecl_Original = value; 525 } 526 /** 527 * @apilevel internal 528 */ 529 protected TypeDecl tokenTypeDecl_Original; 530 /** 531 * Retrieves the value for the lexeme Original. 532 * @return The value for the lexeme Original. 533 * @apilevel high-level 534 */ 535 @ASTNodeAnnotation.Token(name="Original") 536 public TypeDecl getOriginal() { 537 return tokenTypeDecl_Original; 538 } 539 /** 540 * Replaces the (optional) ImplicitConstructor child. 541 * @param node The new node to be used as the ImplicitConstructor child. 542 * @apilevel high-level 543 */ 544 public void setImplicitConstructor(ConstructorDecl node) { 545 getImplicitConstructorOpt().setChild(node, 0); 546 } 547 /** 548 * Check whether the optional ImplicitConstructor child exists. 549 * @return {@code true} if the optional ImplicitConstructor child exists, {@code false} if it does not. 550 * @apilevel high-level 551 */ 552 public boolean hasImplicitConstructor() { 553 return getImplicitConstructorOpt().getNumChild() != 0; 554 } 555 /** 556 * Retrieves the (optional) ImplicitConstructor child. 557 * @return The ImplicitConstructor child, if it exists. Returns {@code null} otherwise. 558 * @apilevel low-level 559 */ 560 public ConstructorDecl getImplicitConstructor() { 561 return (ConstructorDecl) getImplicitConstructorOpt().getChild(0); 562 } 563 /** 564 * Retrieves the optional node for child ImplicitConstructor. This is the <code>Opt</code> node containing the child ImplicitConstructor, not the actual child! 565 * <p><em>This method does not invoke AST transformations.</em></p> 566 * @return The optional node for child ImplicitConstructor. 567 * @apilevel low-level 568 */ 569 public Opt<ConstructorDecl> getImplicitConstructorOptNoTransform() { 570 return (Opt<ConstructorDecl>) getChildNoTransform(4); 571 } 572 /** 573 * Retrieves the child position of the optional child ImplicitConstructor. 574 * @return The the child position of the optional child ImplicitConstructor. 575 * @apilevel low-level 576 */ 577 protected int getImplicitConstructorOptChildPosition() { 578 return 4; 579 } 580 /** 581 * This method should not be called. This method throws an exception due to 582 * the corresponding child being an NTA shadowing a non-NTA child. 583 * @param node 584 * @apilevel internal 585 */ 586 public void setBodyDeclList(List<BodyDecl> node) { 587 throw new Error("Can not replace NTA child BodyDeclList in GenericClassDeclSubstituted!"); 588 } 589 /** 590 * Retrieves the number of children in the BodyDecl list. 591 * @return Number of children in the BodyDecl list. 592 * @apilevel high-level 593 */ 594 public int getNumBodyDecl() { 595 return getBodyDeclList().getNumChild(); 596 } 597 /** 598 * Retrieves the number of children in the BodyDecl list. 599 * Calling this method will not trigger rewrites. 600 * @return Number of children in the BodyDecl list. 601 * @apilevel low-level 602 */ 603 public int getNumBodyDeclNoTransform() { 604 return getBodyDeclListNoTransform().getNumChildNoTransform(); 605 } 606 /** 607 * Retrieves the element at index {@code i} in the BodyDecl list. 608 * @param i Index of the element to return. 609 * @return The element at position {@code i} in the BodyDecl list. 610 * @apilevel high-level 611 */ 612 public BodyDecl getBodyDecl(int i) { 613 return (BodyDecl) getBodyDeclList().getChild(i); 614 } 615 /** 616 * Check whether the BodyDecl list has any children. 617 * @return {@code true} if it has at least one child, {@code false} otherwise. 618 * @apilevel high-level 619 */ 620 public boolean hasBodyDecl() { 621 return getBodyDeclList().getNumChild() != 0; 622 } 623 /** 624 * Append an element to the BodyDecl list. 625 * @param node The element to append to the BodyDecl list. 626 * @apilevel high-level 627 */ 628 public void addBodyDecl(BodyDecl node) { 629 List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList(); 630 list.addChild(node); 631 } 632 /** 633 * @apilevel low-level 634 */ 635 public void addBodyDeclNoTransform(BodyDecl node) { 636 List<BodyDecl> list = getBodyDeclListNoTransform(); 637 list.addChild(node); 638 } 639 /** 640 * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}. 641 * @param node The new node to replace the old list element. 642 * @param i The list index of the node to be replaced. 643 * @apilevel high-level 644 */ 645 public void setBodyDecl(BodyDecl node, int i) { 646 List<BodyDecl> list = getBodyDeclList(); 647 list.setChild(node, i); 648 } 649 /** 650 * Retrieves the child position of the BodyDecl list. 651 * @return The the child position of the BodyDecl list. 652 * @apilevel low-level 653 */ 654 protected int getBodyDeclListChildPosition() { 655 return 5; 656 } 657 /** 658 * Retrieves the BodyDecl list. 659 * <p><em>This method does not invoke AST transformations.</em></p> 660 * @return The node representing the BodyDecl list. 661 * @apilevel low-level 662 */ 663 public List<BodyDecl> getBodyDeclListNoTransform() { 664 return (List<BodyDecl>) getChildNoTransform(5); 665 } 666 /** 667 * Retrieves the BodyDecl list. 668 * @return The node representing the BodyDecl list. 669 * @apilevel high-level 670 */ 671 public List<BodyDecl> getBodyDecls() { 672 return getBodyDeclList(); 673 } 674 /** 675 * Retrieves the BodyDecl list. 676 * <p><em>This method does not invoke AST transformations.</em></p> 677 * @return The node representing the BodyDecl list. 678 * @apilevel low-level 679 */ 680 public List<BodyDecl> getBodyDeclsNoTransform() { 681 return getBodyDeclListNoTransform(); 682 } 683 /** 684 * @attribute syn 685 * @aspect NestedTypes 686 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:624 687 */ 688 @ASTNodeAnnotation.Attribute 689 public TypeDecl hostType() { 690 TypeDecl hostType_value = getOriginal(); 691 692 return hostType_value; 693 } 694 /** 695 * @apilevel internal 696 */ 697 protected boolean getBodyDeclList_computed = false; 698 /** 699 * @apilevel internal 700 */ 701 protected List getBodyDeclList_value; 702 /** 703 * @apilevel internal 704 */ 705 private void getBodyDeclList_reset() { 706 getBodyDeclList_computed = false; 707 getBodyDeclList_value = null; 708 } 709 /** 710 * @attribute syn nta 711 * @aspect LookupParTypeDecl 712 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1236 713 */ 714 @ASTNodeAnnotation.Attribute 715 public List getBodyDeclList() { 716 ASTNode$State state = state(); 717 if (getBodyDeclList_computed) { 718 return (List) getChild(getBodyDeclListChildPosition()); 719 } 720 boolean intermediate = state.INTERMEDIATE_VALUE; 721 state.INTERMEDIATE_VALUE = false; 722 int num = state.boundariesCrossed; 723 boolean isFinal = this.is$Final(); 724 getBodyDeclList_value = new BodyDeclList(); 725 setChild(getBodyDeclList_value, getBodyDeclListChildPosition()); 726 if (isFinal && num == state().boundariesCrossed) { 727 getBodyDeclList_computed = true; 728 } else { 729 } 730 state.INTERMEDIATE_VALUE |= intermediate; 731 732 List node = (List) this.getChild(getBodyDeclListChildPosition()); 733 return node; 734 } 735 /** 736 * @attribute syn 737 * @aspect LookupParTypeDecl 738 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1417 739 */ 740 @ASTNodeAnnotation.Attribute 741 public TypeDecl original() { 742 TypeDecl original_value = getOriginal().original(); 743 744 return original_value; 745 } 746 /** 747 * @apilevel internal 748 */ 749 protected boolean sourceTypeDecl_computed = false; 750 /** 751 * @apilevel internal 752 */ 753 protected TypeDecl sourceTypeDecl_value; 754 /** 755 * @apilevel internal 756 */ 757 private void sourceTypeDecl_reset() { 758 sourceTypeDecl_computed = false; 759 sourceTypeDecl_value = null; 760 } 761 /** 762 * @attribute syn 763 * @aspect SourceDeclarations 764 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1618 765 */ 766 @ASTNodeAnnotation.Attribute 767 public TypeDecl sourceTypeDecl() { 768 ASTNode$State state = state(); 769 if (sourceTypeDecl_computed) { 770 return sourceTypeDecl_value; 771 } 772 boolean intermediate = state.INTERMEDIATE_VALUE; 773 state.INTERMEDIATE_VALUE = false; 774 int num = state.boundariesCrossed; 775 boolean isFinal = this.is$Final(); 776 sourceTypeDecl_value = original().sourceTypeDecl(); 777 if (isFinal && num == state().boundariesCrossed) { 778 sourceTypeDecl_computed = true; 779 } else { 780 } 781 state.INTERMEDIATE_VALUE |= intermediate; 782 783 return sourceTypeDecl_value; 784 } 785 /** 786 * @apilevel internal 787 */ 788 protected java.util.Map instanceOf_TypeDecl_values; 789 /** 790 * @apilevel internal 791 */ 792 private void instanceOf_TypeDecl_reset() { 793 instanceOf_TypeDecl_values = null; 794 } 795 /** 796 * @attribute syn 797 * @aspect TypeWideningAndIdentity 798 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442 799 */ 800 @ASTNodeAnnotation.Attribute 801 public boolean instanceOf(TypeDecl type) { 802 Object _parameters = type; 803 if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 804 ASTNode$State state = state(); 805 if (instanceOf_TypeDecl_values.containsKey(_parameters)) { 806 return (Boolean) instanceOf_TypeDecl_values.get(_parameters); 807 } 808 boolean intermediate = state.INTERMEDIATE_VALUE; 809 state.INTERMEDIATE_VALUE = false; 810 int num = state.boundariesCrossed; 811 boolean isFinal = this.is$Final(); 812 boolean instanceOf_TypeDecl_value = subtype(type); 813 if (isFinal && num == state().boundariesCrossed) { 814 instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value); 815 } else { 816 } 817 state.INTERMEDIATE_VALUE |= intermediate; 818 819 return instanceOf_TypeDecl_value; 820 } 821 /** 822 * @apilevel internal 823 */ 824 private void subtype_TypeDecl_reset() { 825 subtype_TypeDecl_values = null; 826 } 827 protected java.util.Map subtype_TypeDecl_values; 828 @ASTNodeAnnotation.Attribute 829 public boolean subtype(TypeDecl type) { 830 Object _parameters = type; 831 if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 832 ASTNode$State.CircularValue _value; 833 if (subtype_TypeDecl_values.containsKey(_parameters)) { 834 Object _o = subtype_TypeDecl_values.get(_parameters); 835 if (!(_o instanceof ASTNode$State.CircularValue)) { 836 return (Boolean) _o; 837 } else { 838 _value = (ASTNode$State.CircularValue) _o; 839 } 840 } else { 841 _value = new ASTNode$State.CircularValue(); 842 subtype_TypeDecl_values.put(_parameters, _value); 843 _value.value = true; 844 } 845 ASTNode$State state = state(); 846 boolean new_subtype_TypeDecl_value; 847 if (!state.IN_CIRCLE) { 848 state.IN_CIRCLE = true; 849 int num = state.boundariesCrossed; 850 boolean isFinal = this.is$Final(); 851 // TODO: fixme 852 // state().CIRCLE_INDEX = 1; 853 do { 854 _value.visited = state.CIRCLE_INDEX; 855 state.CHANGE = false; 856 new_subtype_TypeDecl_value = type.supertypeGenericClassDeclSubstituted(this); 857 if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 858 state.CHANGE = true; 859 _value.value = new_subtype_TypeDecl_value; 860 } 861 state.CIRCLE_INDEX++; 862 } while (state.CHANGE); 863 if (isFinal && num == state().boundariesCrossed) { 864 subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value); 865 } else { 866 subtype_TypeDecl_values.remove(_parameters); 867 state.RESET_CYCLE = true; 868 boolean $tmp = type.supertypeGenericClassDeclSubstituted(this); 869 state.RESET_CYCLE = false; 870 } 871 state.IN_CIRCLE = false; 872 state.INTERMEDIATE_VALUE = false; 873 return new_subtype_TypeDecl_value; 874 } 875 if (state.CIRCLE_INDEX != _value.visited) { 876 _value.visited = state.CIRCLE_INDEX; 877 new_subtype_TypeDecl_value = type.supertypeGenericClassDeclSubstituted(this); 878 if (state.RESET_CYCLE) { 879 subtype_TypeDecl_values.remove(_parameters); 880 } 881 else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 882 state.CHANGE = true; 883 _value.value = new_subtype_TypeDecl_value; 884 } 885 state.INTERMEDIATE_VALUE = true; 886 return new_subtype_TypeDecl_value; 887 } 888 state.INTERMEDIATE_VALUE = true; 889 return (Boolean) _value.value; 890 } 891 /** 892 * @attribute syn 893 * @aspect GenericsSubtype 894 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:548 895 */ 896 @ASTNodeAnnotation.Attribute 897 public boolean supertypeGenericClassDeclSubstituted(GenericClassDeclSubstituted type) { 898 boolean supertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value = original() == type.original() && type.enclosingType().subtype(enclosingType()) 899 || super.supertypeGenericClassDeclSubstituted(type); 900 901 return supertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value; 902 } 903 /** 904 * @attribute syn 905 * @aspect GenericsSubtype 906 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:35 907 */ 908 @ASTNodeAnnotation.Attribute 909 public boolean supertypeGenericClassDecl(GenericClassDecl type) { 910 boolean supertypeGenericClassDecl_GenericClassDecl_value = super.supertypeGenericClassDecl(type) || original().supertypeGenericClassDecl(type); 911 912 return supertypeGenericClassDecl_GenericClassDecl_value; 913 } 914 /** 915 * @apilevel internal 916 */ 917 protected boolean typeDescriptor_computed = false; 918 /** 919 * @apilevel internal 920 */ 921 protected String typeDescriptor_value; 922 /** 923 * @apilevel internal 924 */ 925 private void typeDescriptor_reset() { 926 typeDescriptor_computed = false; 927 typeDescriptor_value = null; 928 } 929 /** 930 * @attribute syn 931 * @aspect ConstantPoolNames 932 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77 933 */ 934 @ASTNodeAnnotation.Attribute 935 public String typeDescriptor() { 936 ASTNode$State state = state(); 937 if (typeDescriptor_computed) { 938 return typeDescriptor_value; 939 } 940 boolean intermediate = state.INTERMEDIATE_VALUE; 941 state.INTERMEDIATE_VALUE = false; 942 int num = state.boundariesCrossed; 943 boolean isFinal = this.is$Final(); 944 typeDescriptor_value = original().typeDescriptor(); 945 if (isFinal && num == state().boundariesCrossed) { 946 typeDescriptor_computed = true; 947 } else { 948 } 949 state.INTERMEDIATE_VALUE |= intermediate; 950 951 return typeDescriptor_value; 952 } 953 /** 954 * @apilevel internal 955 */ 956 protected boolean constantPoolName_computed = false; 957 /** 958 * @apilevel internal 959 */ 960 protected String constantPoolName_value; 961 /** 962 * @apilevel internal 963 */ 964 private void constantPoolName_reset() { 965 constantPoolName_computed = false; 966 constantPoolName_value = null; 967 } 968 /** 969 * For a top-level type the constant pool name of the type is the same as the 970 * canonical name but with dots replaced by solidus. 971 * 972 * <p>For nested types the constant pool name is based on the enclosing top-level 973 * types constant pool name followed by a dollar sign and a unique index and/or 974 * the type name. 975 * 976 * @return constant pool name of this type 977 * @attribute syn 978 * @aspect ConstantPoolNames 979 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:44 980 */ 981 @ASTNodeAnnotation.Attribute 982 public String constantPoolName() { 983 ASTNode$State state = state(); 984 if (constantPoolName_computed) { 985 return constantPoolName_value; 986 } 987 boolean intermediate = state.INTERMEDIATE_VALUE; 988 state.INTERMEDIATE_VALUE = false; 989 int num = state.boundariesCrossed; 990 boolean isFinal = this.is$Final(); 991 constantPoolName_value = original().constantPoolName(); 992 if (isFinal && num == state().boundariesCrossed) { 993 constantPoolName_computed = true; 994 } else { 995 } 996 state.INTERMEDIATE_VALUE |= intermediate; 997 998 return constantPoolName_value; 999 } 1000 /** 1001 * @apilevel internal 1002 */ 1003 protected boolean uniqueIndex_computed = false; 1004 /** 1005 * @apilevel internal 1006 */ 1007 protected int uniqueIndex_value; 1008 /** 1009 * @apilevel internal 1010 */ 1011 private void uniqueIndex_reset() { 1012 uniqueIndex_computed = false; 1013 } 1014 /** 1015 * @attribute syn 1016 * @aspect Java2Rewrites 1017 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:33 1018 */ 1019 @ASTNodeAnnotation.Attribute 1020 public int uniqueIndex() { 1021 ASTNode$State state = state(); 1022 if (uniqueIndex_computed) { 1023 return uniqueIndex_value; 1024 } 1025 boolean intermediate = state.INTERMEDIATE_VALUE; 1026 state.INTERMEDIATE_VALUE = false; 1027 int num = state.boundariesCrossed; 1028 boolean isFinal = this.is$Final(); 1029 uniqueIndex_value = original().uniqueIndex(); 1030 if (isFinal && num == state().boundariesCrossed) { 1031 uniqueIndex_computed = true; 1032 } else { 1033 } 1034 state.INTERMEDIATE_VALUE |= intermediate; 1035 1036 return uniqueIndex_value; 1037 } 1038 /** 1039 * @attribute syn 1040 * @aspect CreateBCode 1041 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:900 1042 */ 1043 @ASTNodeAnnotation.Attribute 1044 public String arrayTypeDescriptor() { 1045 String arrayTypeDescriptor_value = original().arrayTypeDescriptor(); 1046 1047 return arrayTypeDescriptor_value; 1048 } 1049 /** 1050 * @apilevel internal 1051 */ 1052 private void strictSubtype_TypeDecl_reset() { 1053 strictSubtype_TypeDecl_values = null; 1054 } 1055 protected java.util.Map strictSubtype_TypeDecl_values; 1056 @ASTNodeAnnotation.Attribute 1057 public boolean strictSubtype(TypeDecl type) { 1058 Object _parameters = type; 1059 if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1060 ASTNode$State.CircularValue _value; 1061 if (strictSubtype_TypeDecl_values.containsKey(_parameters)) { 1062 Object _o = strictSubtype_TypeDecl_values.get(_parameters); 1063 if (!(_o instanceof ASTNode$State.CircularValue)) { 1064 return (Boolean) _o; 1065 } else { 1066 _value = (ASTNode$State.CircularValue) _o; 1067 } 1068 } else { 1069 _value = new ASTNode$State.CircularValue(); 1070 strictSubtype_TypeDecl_values.put(_parameters, _value); 1071 _value.value = true; 1072 } 1073 ASTNode$State state = state(); 1074 boolean new_strictSubtype_TypeDecl_value; 1075 if (!state.IN_CIRCLE) { 1076 state.IN_CIRCLE = true; 1077 int num = state.boundariesCrossed; 1078 boolean isFinal = this.is$Final(); 1079 // TODO: fixme 1080 // state().CIRCLE_INDEX = 1; 1081 do { 1082 _value.visited = state.CIRCLE_INDEX; 1083 state.CHANGE = false; 1084 new_strictSubtype_TypeDecl_value = type.strictSupertypeGenericClassDeclSubstituted(this); 1085 if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 1086 state.CHANGE = true; 1087 _value.value = new_strictSubtype_TypeDecl_value; 1088 } 1089 state.CIRCLE_INDEX++; 1090 } while (state.CHANGE); 1091 if (isFinal && num == state().boundariesCrossed) { 1092 strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value); 1093 } else { 1094 strictSubtype_TypeDecl_values.remove(_parameters); 1095 state.RESET_CYCLE = true; 1096 boolean $tmp = type.strictSupertypeGenericClassDeclSubstituted(this); 1097 state.RESET_CYCLE = false; 1098 } 1099 state.IN_CIRCLE = false; 1100 state.INTERMEDIATE_VALUE = false; 1101 return new_strictSubtype_TypeDecl_value; 1102 } 1103 if (state.CIRCLE_INDEX != _value.visited) { 1104 _value.visited = state.CIRCLE_INDEX; 1105 new_strictSubtype_TypeDecl_value = type.strictSupertypeGenericClassDeclSubstituted(this); 1106 if (state.RESET_CYCLE) { 1107 strictSubtype_TypeDecl_values.remove(_parameters); 1108 } 1109 else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 1110 state.CHANGE = true; 1111 _value.value = new_strictSubtype_TypeDecl_value; 1112 } 1113 state.INTERMEDIATE_VALUE = true; 1114 return new_strictSubtype_TypeDecl_value; 1115 } 1116 state.INTERMEDIATE_VALUE = true; 1117 return (Boolean) _value.value; 1118 } 1119 /** 1120 * @attribute syn 1121 * @aspect StrictSubtype 1122 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:478 1123 */ 1124 @ASTNodeAnnotation.Attribute 1125 public boolean strictSupertypeGenericClassDeclSubstituted(GenericClassDeclSubstituted type) { 1126 boolean strictSupertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value = original() == type.original() && type.enclosingType().strictSubtype(enclosingType()) 1127 || super.strictSupertypeGenericClassDeclSubstituted(type); 1128 1129 return strictSupertypeGenericClassDeclSubstituted_GenericClassDeclSubstituted_value; 1130 } 1131 /** 1132 * @attribute syn 1133 * @aspect StrictSubtype 1134 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:39 1135 */ 1136 @ASTNodeAnnotation.Attribute 1137 public boolean strictSupertypeGenericClassDecl(GenericClassDecl type) { 1138 boolean strictSupertypeGenericClassDecl_GenericClassDecl_value = super.strictSupertypeGenericClassDecl(type) 1139 || original().strictSupertypeGenericClassDecl(type); 1140 1141 return strictSupertypeGenericClassDecl_GenericClassDecl_value; 1142 } 1143 /** 1144 * @apilevel internal 1145 */ 1146 protected boolean localMethodsSignatureMap_computed = false; 1147 /** 1148 * @apilevel internal 1149 */ 1150 protected Map<String,SimpleSet> localMethodsSignatureMap_value; 1151 /** 1152 * @apilevel internal 1153 */ 1154 private void localMethodsSignatureMap_reset() { 1155 localMethodsSignatureMap_computed = false; 1156 localMethodsSignatureMap_value = null; 1157 } 1158 /** 1159 * @attribute syn 1160 * @aspect LookupParTypeDecl 1161 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1278 1162 */ 1163 @ASTNodeAnnotation.Attribute 1164 public Map<String,SimpleSet> localMethodsSignatureMap() { 1165 ASTNode$State state = state(); 1166 if (localMethodsSignatureMap_computed) { 1167 return localMethodsSignatureMap_value; 1168 } 1169 boolean intermediate = state.INTERMEDIATE_VALUE; 1170 state.INTERMEDIATE_VALUE = false; 1171 int num = state.boundariesCrossed; 1172 boolean isFinal = this.is$Final(); 1173 localMethodsSignatureMap_value = localMethodsSignatureMap_compute(); 1174 if (true) { 1175 localMethodsSignatureMap_computed = true; 1176 } else { 1177 } 1178 state.INTERMEDIATE_VALUE |= intermediate; 1179 1180 return localMethodsSignatureMap_value; 1181 } 1182 /** 1183 * @apilevel internal 1184 */ 1185 private Map<String,SimpleSet> localMethodsSignatureMap_compute() { 1186 Map<String,SimpleSet> map = new HashMap<String,SimpleSet>(); 1187 for (Iterator<MethodDecl> iter = original().localMethodsIterator(); iter.hasNext(); ) { 1188 MethodDecl decl = iter.next(); 1189 1190 if (!decl.isStatic() && (decl.usesTypeVariable() || isRawType())) { 1191 BodyDecl copyDecl = ((BodyDeclList) getBodyDeclList()).localMethodSignatureCopy(decl, this); 1192 decl = (MethodDecl) copyDecl; 1193 } 1194 putSimpleSetElement(map, decl.signature(), decl); 1195 1196 } 1197 return map; 1198 } 1199 /** 1200 * @apilevel internal 1201 */ 1202 protected java.util.Map localFields_String_values; 1203 /** 1204 * @apilevel internal 1205 */ 1206 private void localFields_String_reset() { 1207 localFields_String_values = null; 1208 } 1209 /** 1210 * @attribute syn 1211 * @aspect LookupParTypeDecl 1212 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1296 1213 */ 1214 @ASTNodeAnnotation.Attribute 1215 public SimpleSet localFields(String name) { 1216 Object _parameters = name; 1217 if (localFields_String_values == null) localFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1218 ASTNode$State state = state(); 1219 if (localFields_String_values.containsKey(_parameters)) { 1220 return (SimpleSet) localFields_String_values.get(_parameters); 1221 } 1222 boolean intermediate = state.INTERMEDIATE_VALUE; 1223 state.INTERMEDIATE_VALUE = false; 1224 int num = state.boundariesCrossed; 1225 boolean isFinal = this.is$Final(); 1226 SimpleSet localFields_String_value = localFields_compute(name); 1227 if (true) { 1228 localFields_String_values.put(_parameters, localFields_String_value); 1229 } else { 1230 } 1231 state.INTERMEDIATE_VALUE |= intermediate; 1232 1233 return localFields_String_value; 1234 } 1235 /** 1236 * @apilevel internal 1237 */ 1238 private SimpleSet localFields_compute(String name) { 1239 SimpleSet set = SimpleSet.emptySet; 1240 for (Iterator iter = original().localFields(name).iterator(); iter.hasNext(); ) { 1241 FieldDeclaration f = (FieldDeclaration) iter.next(); 1242 1243 if (!f.isStatic() && (f.usesTypeVariable() || isRawType())) { 1244 BodyDecl fCopy = ((BodyDeclList) getBodyDeclList()).localFieldCopy(f, this); 1245 f = (FieldDeclaration) fCopy; 1246 } 1247 set = set.add(f); 1248 1249 } 1250 return set; 1251 } 1252 /** 1253 * @apilevel internal 1254 */ 1255 private void localTypeDecls_String_reset() { 1256 localTypeDecls_String_values = null; 1257 } 1258 protected java.util.Map localTypeDecls_String_values; 1259 @ASTNodeAnnotation.Attribute 1260 public SimpleSet localTypeDecls(String name) { 1261 Object _parameters = name; 1262 if (localTypeDecls_String_values == null) localTypeDecls_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1263 ASTNode$State.CircularValue _value; 1264 if (localTypeDecls_String_values.containsKey(_parameters)) { 1265 Object _o = localTypeDecls_String_values.get(_parameters); 1266 if (!(_o instanceof ASTNode$State.CircularValue)) { 1267 return (SimpleSet) _o; 1268 } else { 1269 _value = (ASTNode$State.CircularValue) _o; 1270 } 1271 } else { 1272 _value = new ASTNode$State.CircularValue(); 1273 localTypeDecls_String_values.put(_parameters, _value); 1274 _value.value = SimpleSet.emptySet; 1275 } 1276 ASTNode$State state = state(); 1277 SimpleSet new_localTypeDecls_String_value; 1278 if (!state.IN_CIRCLE) { 1279 state.IN_CIRCLE = true; 1280 int num = state.boundariesCrossed; 1281 boolean isFinal = this.is$Final(); 1282 // TODO: fixme 1283 // state().CIRCLE_INDEX = 1; 1284 do { 1285 _value.visited = state.CIRCLE_INDEX; 1286 state.CHANGE = false; 1287 new_localTypeDecls_String_value = localTypeDecls_compute(name); 1288 if ((new_localTypeDecls_String_value==null && (SimpleSet)_value.value!=null) || (new_localTypeDecls_String_value!=null && !new_localTypeDecls_String_value.equals((SimpleSet)_value.value))) { 1289 state.CHANGE = true; 1290 _value.value = new_localTypeDecls_String_value; 1291 } 1292 state.CIRCLE_INDEX++; 1293 } while (state.CHANGE); 1294 if (true) { 1295 localTypeDecls_String_values.put(_parameters, new_localTypeDecls_String_value); 1296 } else { 1297 localTypeDecls_String_values.remove(_parameters); 1298 state.RESET_CYCLE = true; 1299 SimpleSet $tmp = localTypeDecls_compute(name); 1300 state.RESET_CYCLE = false; 1301 } 1302 state.IN_CIRCLE = false; 1303 state.INTERMEDIATE_VALUE = false; 1304 return new_localTypeDecls_String_value; 1305 } 1306 if (state.CIRCLE_INDEX != _value.visited) { 1307 _value.visited = state.CIRCLE_INDEX; 1308 new_localTypeDecls_String_value = localTypeDecls_compute(name); 1309 if (state.RESET_CYCLE) { 1310 localTypeDecls_String_values.remove(_parameters); 1311 } 1312 else if ((new_localTypeDecls_String_value==null && (SimpleSet)_value.value!=null) || (new_localTypeDecls_String_value!=null && !new_localTypeDecls_String_value.equals((SimpleSet)_value.value))) { 1313 state.CHANGE = true; 1314 _value.value = new_localTypeDecls_String_value; 1315 } 1316 state.INTERMEDIATE_VALUE = true; 1317 return new_localTypeDecls_String_value; 1318 } 1319 state.INTERMEDIATE_VALUE = true; 1320 return (SimpleSet) _value.value; 1321 } 1322 /** 1323 * @apilevel internal 1324 */ 1325 private SimpleSet localTypeDecls_compute(String name) { 1326 SimpleSet set = SimpleSet.emptySet; 1327 for (Iterator iter = original().localTypeDecls(name).iterator(); iter.hasNext(); ) { 1328 TypeDecl t = (TypeDecl) iter.next(); 1329 1330 if (t.isStatic()) { 1331 set = set.add(t); 1332 } else if (t instanceof ClassDecl) { 1333 MemberClassDecl copy = 1334 ((BodyDeclList) getBodyDeclList()).localClassDeclCopy((ClassDecl) t, this); 1335 set = set.add(copy.getClassDecl()); 1336 } else if (t instanceof InterfaceDecl) { 1337 MemberInterfaceDecl copy = 1338 ((BodyDeclList) getBodyDeclList()).localInterfaceDeclCopy((InterfaceDecl) t, this); 1339 set = set.add(copy.getInterfaceDecl()); 1340 } 1341 } 1342 return set; 1343 } 1344 /** 1345 * @apilevel internal 1346 */ 1347 protected boolean constructors_computed = false; 1348 /** 1349 * @apilevel internal 1350 */ 1351 protected Collection<ConstructorDecl> constructors_value; 1352 /** 1353 * @apilevel internal 1354 */ 1355 private void constructors_reset() { 1356 constructors_computed = false; 1357 constructors_value = null; 1358 } 1359 /** 1360 * @attribute syn 1361 * @aspect LookupParTypeDecl 1362 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1347 1363 */ 1364 @ASTNodeAnnotation.Attribute 1365 public Collection<ConstructorDecl> constructors() { 1366 ASTNode$State state = state(); 1367 if (constructors_computed) { 1368 return constructors_value; 1369 } 1370 boolean intermediate = state.INTERMEDIATE_VALUE; 1371 state.INTERMEDIATE_VALUE = false; 1372 int num = state.boundariesCrossed; 1373 boolean isFinal = this.is$Final(); 1374 constructors_value = constructors_compute(); 1375 if (isFinal && num == state().boundariesCrossed) { 1376 constructors_computed = true; 1377 } else { 1378 } 1379 state.INTERMEDIATE_VALUE |= intermediate; 1380 1381 return constructors_value; 1382 } 1383 /** 1384 * @apilevel internal 1385 */ 1386 private Collection<ConstructorDecl> constructors_compute() { 1387 Collection<ConstructorDecl> constructors = new ArrayList<ConstructorDecl>(); 1388 for (Iterator iter = original().constructors().iterator(); iter.hasNext(); ) { 1389 ConstructorDecl c = (ConstructorDecl) iter.next(); 1390 1391 ConstructorDecl b = ((BodyDeclList) getBodyDeclList()).constructorCopy(c, this); 1392 constructors.add(b); 1393 } 1394 return constructors; 1395 } 1396 /** 1397 * @apilevel internal 1398 */ 1399 public ASTNode rewriteTo() { 1400 return super.rewriteTo(); 1401 } 1402 }