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:6 027 * @production ParClassDecl : {@link ClassDecl} ::= <span class="component">Argument:{@link Access}*</span> <span class="component">[SuperClass:{@link Access}]</span> <span class="component">Implements:{@link Access}*</span> <span class="component">{@link BodyDecl}*</span>; 028 029 */ 030 public class ParClassDecl extends ClassDecl implements Cloneable, ParTypeDecl, MemberSubstitutor { 031 /** 032 * @aspect GenericsNameBinding 033 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:789 034 */ 035 public void collectErrors() { 036 // Disable error check for ParClassDecl which is an instanciated GenericClassDecl 037 } 038 /** 039 * @aspect Java5PrettyPrint 040 * @declaredat /home/jesper/git/extendj/java5/frontend/PrettyPrint.jadd:35 041 */ 042 public void prettyPrint(PrettyPrinter out) { 043 if (hasDocComment()) { 044 out.print(docComment()); 045 } 046 if (!out.isNewLine()) { 047 out.println(); 048 } 049 out.print(getModifiers()); 050 out.print("class "); 051 out.print(getID()); 052 out.print("<"); 053 out.join(getArgumentList(), new PrettyPrinter.Joiner() { 054 @Override 055 public void printSeparator(PrettyPrinter out) { 056 out.print(", "); 057 } 058 }); 059 out.print(">"); 060 if (hasSuperClass()) { 061 out.print(" extends "); 062 out.print(getSuperClass()); 063 } 064 if (hasImplements()) { 065 out.print(" implements "); 066 out.join(getImplementss(), new PrettyPrinter.Joiner() { 067 @Override 068 public void printSeparator(PrettyPrinter out) { 069 out.print(", "); 070 } 071 }); 072 } 073 out.print(" {"); 074 out.println(); 075 out.indent(1); 076 out.join(getBodyDecls(), new PrettyPrinter.Joiner() { 077 @Override 078 public void printSeparator(PrettyPrinter out) { 079 out.println(); 080 out.println(); 081 } 082 }); 083 if (!out.isNewLine()) { 084 out.println(); 085 } 086 out.print("}"); 087 } 088 /** 089 * @aspect LookupParTypeDecl 090 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:959 091 */ 092 public TypeDecl substitute(TypeVariable typeVariable) { 093 for (int i = 0; i < numTypeParameter(); i++) { 094 if (typeParameter(i) == typeVariable) { 095 return getArgument(i).type(); 096 } 097 } 098 return super.substitute(typeVariable); 099 } 100 /** 101 * @aspect LookupParTypeDecl 102 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:990 103 */ 104 public int numTypeParameter() { 105 return ((GenericTypeDecl) original()).getNumTypeParameter(); 106 } 107 /** 108 * @aspect LookupParTypeDecl 109 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:994 110 */ 111 public TypeVariable typeParameter(int index) { 112 return ((GenericTypeDecl) original()).getTypeParameter(index); 113 } 114 /** 115 * @aspect GenericsParTypeDecl 116 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:99 117 */ 118 public Access createQualifiedAccess() { 119 List typeArgumentList = new List(); 120 for (int i = 0; i < getNumArgument(); i++) { 121 Access a = (Access) getArgument(i); 122 if (a instanceof TypeAccess) { 123 typeArgumentList.add(a.type().createQualifiedAccess()); 124 } else { 125 typeArgumentList.add(a.treeCopyNoTransform()); 126 } 127 } 128 if (!isTopLevelType()) { 129 if (isRawType()) { 130 return enclosingType().createQualifiedAccess().qualifiesAccess( 131 new TypeAccess("", getID()) 132 ); 133 } else { 134 return enclosingType().createQualifiedAccess().qualifiesAccess( 135 new ParTypeAccess(new TypeAccess("", getID()), typeArgumentList) 136 ); 137 } 138 } else { 139 if (isRawType()) { 140 return new TypeAccess(packageName(), getID()); 141 } else { 142 return new ParTypeAccess(new TypeAccess(packageName(), getID()), typeArgumentList); 143 } 144 } 145 } 146 /** 147 * @aspect GenericsCodegen 148 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:302 149 */ 150 public void transformation() { 151 } 152 /** 153 * @aspect LambdaExpr 154 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:111 155 */ 156 157 public Access substitute(Parameterization parTypeDecl) { 158 // TODO: include nesting as well.... 159 if (parTypeDecl.isRawType()) { 160 return ((GenericTypeDecl) genericDecl()).rawType().createBoundAccess(); 161 } 162 163 /* These lines have been removed because they erase arguments from 164 parameter types when they are not using type variables, for example 165 C<String> is substituted to only C, which I don't think is correct? 166 And if the ParTypeDecl doesn't use any type variables, why is there 167 even any need for further substitution? 168 169 if (!usesTypeVariable()) { 170 return super.substitute(parTypeDecl); 171 } 172 */ 173 List<Access> list = new List<Access>(); 174 for (Access argument : getArgumentList()) { 175 list.add(argument.type().substitute(parTypeDecl)); 176 } 177 return new ParTypeAccess(genericDecl().createQualifiedAccess(), list); 178 } 179 /** 180 * @declaredat ASTNode:1 181 */ 182 public ParClassDecl() { 183 super(); 184 } 185 /** 186 * Initializes the child array to the correct size. 187 * Initializes List and Opt nta children. 188 * @apilevel internal 189 * @ast method 190 * @declaredat ASTNode:10 191 */ 192 public void init$Children() { 193 children = new ASTNode[6]; 194 setChild(new List(), 1); 195 setChild(new Opt(), 2); 196 setChild(new Opt(), 3); 197 setChild(new List(), 4); 198 setChild(new List(), 5); 199 } 200 /** 201 * @declaredat ASTNode:18 202 */ 203 public ParClassDecl(Modifiers p0, String p1, List<Access> p2) { 204 setChild(p0, 0); 205 setID(p1); 206 setChild(p2, 1); 207 } 208 /** 209 * @declaredat ASTNode:23 210 */ 211 public ParClassDecl(Modifiers p0, beaver.Symbol p1, List<Access> p2) { 212 setChild(p0, 0); 213 setID(p1); 214 setChild(p2, 1); 215 } 216 /** 217 * @apilevel low-level 218 * @declaredat ASTNode:31 219 */ 220 protected int numChildren() { 221 return 2; 222 } 223 /** 224 * @apilevel internal 225 * @declaredat ASTNode:37 226 */ 227 public boolean mayHaveRewrite() { 228 return false; 229 } 230 /** 231 * @apilevel internal 232 * @declaredat ASTNode:43 233 */ 234 public void flushAttrCache() { 235 super.flushAttrCache(); 236 involvesTypeParameters_reset(); 237 erasure_reset(); 238 getSuperClassOpt_reset(); 239 getImplementsList_reset(); 240 getBodyDeclList_reset(); 241 subtype_TypeDecl_reset(); 242 sameStructure_TypeDecl_reset(); 243 instanceOf_TypeDecl_reset(); 244 typeDescriptor_reset(); 245 constantPoolName_reset(); 246 needsSignatureAttribute_reset(); 247 strictSubtype_TypeDecl_reset(); 248 sameSignature_java_util_List_TypeDecl__reset(); 249 usesTypeVariable_reset(); 250 sourceTypeDecl_reset(); 251 fullName_reset(); 252 typeName_reset(); 253 unimplementedMethods_reset(); 254 uniqueIndex_reset(); 255 localMethodsSignatureMap_reset(); 256 localFields_String_reset(); 257 localTypeDecls_String_reset(); 258 constructors_reset(); 259 genericDecl_reset(); 260 } 261 /** 262 * @apilevel internal 263 * @declaredat ASTNode:73 264 */ 265 public void flushCollectionCache() { 266 super.flushCollectionCache(); 267 } 268 /** 269 * @apilevel internal 270 * @declaredat ASTNode:79 271 */ 272 public void flushRewriteCache() { 273 super.flushRewriteCache(); 274 } 275 /** 276 * @apilevel internal 277 * @declaredat ASTNode:85 278 */ 279 public ParClassDecl clone() throws CloneNotSupportedException { 280 ParClassDecl node = (ParClassDecl) super.clone(); 281 return node; 282 } 283 /** 284 * @apilevel internal 285 * @declaredat ASTNode:92 286 */ 287 public ParClassDecl copy() { 288 try { 289 ParClassDecl node = (ParClassDecl) clone(); 290 node.parent = null; 291 if (children != null) { 292 node.children = (ASTNode[]) children.clone(); 293 } 294 return node; 295 } catch (CloneNotSupportedException e) { 296 throw new Error("Error: clone not supported for " + getClass().getName()); 297 } 298 } 299 /** 300 * Create a deep copy of the AST subtree at this node. 301 * The copy is dangling, i.e. has no parent. 302 * @return dangling copy of the subtree at this node 303 * @apilevel low-level 304 * @deprecated Please use treeCopy or treeCopyNoTransform instead 305 * @declaredat ASTNode:111 306 */ 307 @Deprecated 308 public ParClassDecl fullCopy() { 309 return treeCopyNoTransform(); 310 } 311 /** 312 * Create a deep copy of the AST subtree at this node. 313 * The copy is dangling, i.e. has no parent. 314 * @return dangling copy of the subtree at this node 315 * @apilevel low-level 316 * @declaredat ASTNode:121 317 */ 318 public ParClassDecl treeCopyNoTransform() { 319 ParClassDecl tree = (ParClassDecl) copy(); 320 if (children != null) { 321 for (int i = 0; i < children.length; ++i) { 322 switch (i) { 323 case 2: 324 case 3: 325 tree.children[i] = new Opt(); 326 continue; 327 case 4: 328 case 5: 329 tree.children[i] = new List(); 330 continue; 331 } 332 ASTNode child = (ASTNode) children[i]; 333 if (child != null) { 334 child = child.treeCopyNoTransform(); 335 tree.setChild(child, i); 336 } 337 } 338 } 339 return tree; 340 } 341 /** 342 * Create a deep copy of the AST subtree at this node. 343 * The subtree of this node is traversed to trigger rewrites before copy. 344 * The copy is dangling, i.e. has no parent. 345 * @return dangling copy of the subtree at this node 346 * @apilevel low-level 347 * @declaredat ASTNode:151 348 */ 349 public ParClassDecl treeCopy() { 350 doFullTraversal(); 351 return treeCopyNoTransform(); 352 } 353 /** 354 * @apilevel internal 355 * @declaredat ASTNode:158 356 */ 357 protected boolean is$Equal(ASTNode node) { 358 return super.is$Equal(node) && (tokenString_ID == ((ParClassDecl)node).tokenString_ID); 359 } 360 /** 361 * Replaces the Modifiers child. 362 * @param node The new node to replace the Modifiers child. 363 * @apilevel high-level 364 */ 365 public void setModifiers(Modifiers node) { 366 setChild(node, 0); 367 } 368 /** 369 * Retrieves the Modifiers child. 370 * @return The current node used as the Modifiers child. 371 * @apilevel high-level 372 */ 373 @ASTNodeAnnotation.Child(name="Modifiers") 374 public Modifiers getModifiers() { 375 return (Modifiers) getChild(0); 376 } 377 /** 378 * Retrieves the Modifiers child. 379 * <p><em>This method does not invoke AST transformations.</em></p> 380 * @return The current node used as the Modifiers child. 381 * @apilevel low-level 382 */ 383 public Modifiers getModifiersNoTransform() { 384 return (Modifiers) getChildNoTransform(0); 385 } 386 /** 387 * Replaces the lexeme ID. 388 * @param value The new value for the lexeme ID. 389 * @apilevel high-level 390 */ 391 public void setID(String value) { 392 tokenString_ID = value; 393 } 394 /** 395 * JastAdd-internal setter for lexeme ID using the Beaver parser. 396 * @param symbol Symbol containing the new value for the lexeme ID 397 * @apilevel internal 398 */ 399 public void setID(beaver.Symbol symbol) { 400 if (symbol.value != null && !(symbol.value instanceof String)) 401 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 402 tokenString_ID = (String)symbol.value; 403 IDstart = symbol.getStart(); 404 IDend = symbol.getEnd(); 405 } 406 /** 407 * Retrieves the value for the lexeme ID. 408 * @return The value for the lexeme ID. 409 * @apilevel high-level 410 */ 411 @ASTNodeAnnotation.Token(name="ID") 412 public String getID() { 413 return tokenString_ID != null ? tokenString_ID : ""; 414 } 415 /** 416 * Replaces the Argument list. 417 * @param list The new list node to be used as the Argument list. 418 * @apilevel high-level 419 */ 420 public void setArgumentList(List<Access> list) { 421 setChild(list, 1); 422 } 423 /** 424 * Retrieves the number of children in the Argument list. 425 * @return Number of children in the Argument list. 426 * @apilevel high-level 427 */ 428 public int getNumArgument() { 429 return getArgumentList().getNumChild(); 430 } 431 /** 432 * Retrieves the number of children in the Argument list. 433 * Calling this method will not trigger rewrites. 434 * @return Number of children in the Argument list. 435 * @apilevel low-level 436 */ 437 public int getNumArgumentNoTransform() { 438 return getArgumentListNoTransform().getNumChildNoTransform(); 439 } 440 /** 441 * Retrieves the element at index {@code i} in the Argument list. 442 * @param i Index of the element to return. 443 * @return The element at position {@code i} in the Argument list. 444 * @apilevel high-level 445 */ 446 public Access getArgument(int i) { 447 return (Access) getArgumentList().getChild(i); 448 } 449 /** 450 * Check whether the Argument list has any children. 451 * @return {@code true} if it has at least one child, {@code false} otherwise. 452 * @apilevel high-level 453 */ 454 public boolean hasArgument() { 455 return getArgumentList().getNumChild() != 0; 456 } 457 /** 458 * Append an element to the Argument list. 459 * @param node The element to append to the Argument list. 460 * @apilevel high-level 461 */ 462 public void addArgument(Access node) { 463 List<Access> list = (parent == null) ? getArgumentListNoTransform() : getArgumentList(); 464 list.addChild(node); 465 } 466 /** 467 * @apilevel low-level 468 */ 469 public void addArgumentNoTransform(Access node) { 470 List<Access> list = getArgumentListNoTransform(); 471 list.addChild(node); 472 } 473 /** 474 * Replaces the Argument list element at index {@code i} with the new node {@code node}. 475 * @param node The new node to replace the old list element. 476 * @param i The list index of the node to be replaced. 477 * @apilevel high-level 478 */ 479 public void setArgument(Access node, int i) { 480 List<Access> list = getArgumentList(); 481 list.setChild(node, i); 482 } 483 /** 484 * Retrieves the Argument list. 485 * @return The node representing the Argument list. 486 * @apilevel high-level 487 */ 488 @ASTNodeAnnotation.ListChild(name="Argument") 489 public List<Access> getArgumentList() { 490 List<Access> list = (List<Access>) getChild(1); 491 return list; 492 } 493 /** 494 * Retrieves the Argument list. 495 * <p><em>This method does not invoke AST transformations.</em></p> 496 * @return The node representing the Argument list. 497 * @apilevel low-level 498 */ 499 public List<Access> getArgumentListNoTransform() { 500 return (List<Access>) getChildNoTransform(1); 501 } 502 /** 503 * Retrieves the Argument list. 504 * @return The node representing the Argument list. 505 * @apilevel high-level 506 */ 507 public List<Access> getArguments() { 508 return getArgumentList(); 509 } 510 /** 511 * Retrieves the Argument list. 512 * <p><em>This method does not invoke AST transformations.</em></p> 513 * @return The node representing the Argument list. 514 * @apilevel low-level 515 */ 516 public List<Access> getArgumentsNoTransform() { 517 return getArgumentListNoTransform(); 518 } 519 /** 520 * Replaces the (optional) ImplicitConstructor child. 521 * @param node The new node to be used as the ImplicitConstructor child. 522 * @apilevel high-level 523 */ 524 public void setImplicitConstructor(ConstructorDecl node) { 525 getImplicitConstructorOpt().setChild(node, 0); 526 } 527 /** 528 * Check whether the optional ImplicitConstructor child exists. 529 * @return {@code true} if the optional ImplicitConstructor child exists, {@code false} if it does not. 530 * @apilevel high-level 531 */ 532 public boolean hasImplicitConstructor() { 533 return getImplicitConstructorOpt().getNumChild() != 0; 534 } 535 /** 536 * Retrieves the (optional) ImplicitConstructor child. 537 * @return The ImplicitConstructor child, if it exists. Returns {@code null} otherwise. 538 * @apilevel low-level 539 */ 540 public ConstructorDecl getImplicitConstructor() { 541 return (ConstructorDecl) getImplicitConstructorOpt().getChild(0); 542 } 543 /** 544 * Retrieves the optional node for child ImplicitConstructor. This is the <code>Opt</code> node containing the child ImplicitConstructor, not the actual child! 545 * <p><em>This method does not invoke AST transformations.</em></p> 546 * @return The optional node for child ImplicitConstructor. 547 * @apilevel low-level 548 */ 549 public Opt<ConstructorDecl> getImplicitConstructorOptNoTransform() { 550 return (Opt<ConstructorDecl>) getChildNoTransform(2); 551 } 552 /** 553 * Retrieves the child position of the optional child ImplicitConstructor. 554 * @return The the child position of the optional child ImplicitConstructor. 555 * @apilevel low-level 556 */ 557 protected int getImplicitConstructorOptChildPosition() { 558 return 2; 559 } 560 /** 561 * This method should not be called. This method throws an exception due to 562 * the corresponding child being an NTA shadowing a non-NTA child. 563 * @param node 564 * @apilevel internal 565 */ 566 public void setSuperClassOpt(Opt<Access> node) { 567 throw new Error("Can not replace NTA child SuperClassOpt in ParClassDecl!"); 568 } 569 /** 570 * Replaces the (optional) SuperClass child. 571 * @param node The new node to be used as the SuperClass child. 572 * @apilevel high-level 573 */ 574 public void setSuperClass(Access node) { 575 getSuperClassOpt().setChild(node, 0); 576 } 577 /** 578 * Check whether the optional SuperClass child exists. 579 * @return {@code true} if the optional SuperClass child exists, {@code false} if it does not. 580 * @apilevel high-level 581 */ 582 public boolean hasSuperClass() { 583 return getSuperClassOpt().getNumChild() != 0; 584 } 585 /** 586 * Retrieves the (optional) SuperClass child. 587 * @return The SuperClass child, if it exists. Returns {@code null} otherwise. 588 * @apilevel low-level 589 */ 590 public Access getSuperClass() { 591 return (Access) getSuperClassOpt().getChild(0); 592 } 593 /** 594 * Retrieves the optional node for child SuperClass. This is the <code>Opt</code> node containing the child SuperClass, not the actual child! 595 * <p><em>This method does not invoke AST transformations.</em></p> 596 * @return The optional node for child SuperClass. 597 * @apilevel low-level 598 */ 599 public Opt<Access> getSuperClassOptNoTransform() { 600 return (Opt<Access>) getChildNoTransform(3); 601 } 602 /** 603 * Retrieves the child position of the optional child SuperClass. 604 * @return The the child position of the optional child SuperClass. 605 * @apilevel low-level 606 */ 607 protected int getSuperClassOptChildPosition() { 608 return 3; 609 } 610 /** 611 * This method should not be called. This method throws an exception due to 612 * the corresponding child being an NTA shadowing a non-NTA child. 613 * @param node 614 * @apilevel internal 615 */ 616 public void setImplementsList(List<Access> node) { 617 throw new Error("Can not replace NTA child ImplementsList in ParClassDecl!"); 618 } 619 /** 620 * Retrieves the number of children in the Implements list. 621 * @return Number of children in the Implements list. 622 * @apilevel high-level 623 */ 624 public int getNumImplements() { 625 return getImplementsList().getNumChild(); 626 } 627 /** 628 * Retrieves the number of children in the Implements list. 629 * Calling this method will not trigger rewrites. 630 * @return Number of children in the Implements list. 631 * @apilevel low-level 632 */ 633 public int getNumImplementsNoTransform() { 634 return getImplementsListNoTransform().getNumChildNoTransform(); 635 } 636 /** 637 * Retrieves the element at index {@code i} in the Implements list. 638 * @param i Index of the element to return. 639 * @return The element at position {@code i} in the Implements list. 640 * @apilevel high-level 641 */ 642 public Access getImplements(int i) { 643 return (Access) getImplementsList().getChild(i); 644 } 645 /** 646 * Check whether the Implements list has any children. 647 * @return {@code true} if it has at least one child, {@code false} otherwise. 648 * @apilevel high-level 649 */ 650 public boolean hasImplements() { 651 return getImplementsList().getNumChild() != 0; 652 } 653 /** 654 * Append an element to the Implements list. 655 * @param node The element to append to the Implements list. 656 * @apilevel high-level 657 */ 658 public void addImplements(Access node) { 659 List<Access> list = (parent == null) ? getImplementsListNoTransform() : getImplementsList(); 660 list.addChild(node); 661 } 662 /** 663 * @apilevel low-level 664 */ 665 public void addImplementsNoTransform(Access node) { 666 List<Access> list = getImplementsListNoTransform(); 667 list.addChild(node); 668 } 669 /** 670 * Replaces the Implements list element at index {@code i} with the new node {@code node}. 671 * @param node The new node to replace the old list element. 672 * @param i The list index of the node to be replaced. 673 * @apilevel high-level 674 */ 675 public void setImplements(Access node, int i) { 676 List<Access> list = getImplementsList(); 677 list.setChild(node, i); 678 } 679 /** 680 * Retrieves the child position of the Implements list. 681 * @return The the child position of the Implements list. 682 * @apilevel low-level 683 */ 684 protected int getImplementsListChildPosition() { 685 return 4; 686 } 687 /** 688 * Retrieves the Implements list. 689 * <p><em>This method does not invoke AST transformations.</em></p> 690 * @return The node representing the Implements list. 691 * @apilevel low-level 692 */ 693 public List<Access> getImplementsListNoTransform() { 694 return (List<Access>) getChildNoTransform(4); 695 } 696 /** 697 * Retrieves the Implements list. 698 * @return The node representing the Implements list. 699 * @apilevel high-level 700 */ 701 public List<Access> getImplementss() { 702 return getImplementsList(); 703 } 704 /** 705 * Retrieves the Implements list. 706 * <p><em>This method does not invoke AST transformations.</em></p> 707 * @return The node representing the Implements list. 708 * @apilevel low-level 709 */ 710 public List<Access> getImplementssNoTransform() { 711 return getImplementsListNoTransform(); 712 } 713 /** 714 * This method should not be called. This method throws an exception due to 715 * the corresponding child being an NTA shadowing a non-NTA child. 716 * @param node 717 * @apilevel internal 718 */ 719 public void setBodyDeclList(List<BodyDecl> node) { 720 throw new Error("Can not replace NTA child BodyDeclList in ParClassDecl!"); 721 } 722 /** 723 * Retrieves the number of children in the BodyDecl list. 724 * @return Number of children in the BodyDecl list. 725 * @apilevel high-level 726 */ 727 public int getNumBodyDecl() { 728 return getBodyDeclList().getNumChild(); 729 } 730 /** 731 * Retrieves the number of children in the BodyDecl list. 732 * Calling this method will not trigger rewrites. 733 * @return Number of children in the BodyDecl list. 734 * @apilevel low-level 735 */ 736 public int getNumBodyDeclNoTransform() { 737 return getBodyDeclListNoTransform().getNumChildNoTransform(); 738 } 739 /** 740 * Retrieves the element at index {@code i} in the BodyDecl list. 741 * @param i Index of the element to return. 742 * @return The element at position {@code i} in the BodyDecl list. 743 * @apilevel high-level 744 */ 745 public BodyDecl getBodyDecl(int i) { 746 return (BodyDecl) getBodyDeclList().getChild(i); 747 } 748 /** 749 * Check whether the BodyDecl list has any children. 750 * @return {@code true} if it has at least one child, {@code false} otherwise. 751 * @apilevel high-level 752 */ 753 public boolean hasBodyDecl() { 754 return getBodyDeclList().getNumChild() != 0; 755 } 756 /** 757 * Append an element to the BodyDecl list. 758 * @param node The element to append to the BodyDecl list. 759 * @apilevel high-level 760 */ 761 public void addBodyDecl(BodyDecl node) { 762 List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList(); 763 list.addChild(node); 764 } 765 /** 766 * @apilevel low-level 767 */ 768 public void addBodyDeclNoTransform(BodyDecl node) { 769 List<BodyDecl> list = getBodyDeclListNoTransform(); 770 list.addChild(node); 771 } 772 /** 773 * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}. 774 * @param node The new node to replace the old list element. 775 * @param i The list index of the node to be replaced. 776 * @apilevel high-level 777 */ 778 public void setBodyDecl(BodyDecl node, int i) { 779 List<BodyDecl> list = getBodyDeclList(); 780 list.setChild(node, i); 781 } 782 /** 783 * Retrieves the child position of the BodyDecl list. 784 * @return The the child position of the BodyDecl list. 785 * @apilevel low-level 786 */ 787 protected int getBodyDeclListChildPosition() { 788 return 5; 789 } 790 /** 791 * Retrieves the BodyDecl list. 792 * <p><em>This method does not invoke AST transformations.</em></p> 793 * @return The node representing the BodyDecl list. 794 * @apilevel low-level 795 */ 796 public List<BodyDecl> getBodyDeclListNoTransform() { 797 return (List<BodyDecl>) getChildNoTransform(5); 798 } 799 /** 800 * Retrieves the BodyDecl list. 801 * @return The node representing the BodyDecl list. 802 * @apilevel high-level 803 */ 804 public List<BodyDecl> getBodyDecls() { 805 return getBodyDeclList(); 806 } 807 /** 808 * Retrieves the BodyDecl list. 809 * <p><em>This method does not invoke AST transformations.</em></p> 810 * @return The node representing the BodyDecl list. 811 * @apilevel low-level 812 */ 813 public List<BodyDecl> getBodyDeclsNoTransform() { 814 return getBodyDeclListNoTransform(); 815 } 816 /** 817 * @apilevel internal 818 */ 819 protected int involvesTypeParameters_visited = -1; 820 /** 821 * @apilevel internal 822 */ 823 private void involvesTypeParameters_reset() { 824 involvesTypeParameters_computed = false; 825 involvesTypeParameters_initialized = false; 826 involvesTypeParameters_visited = -1; 827 } 828 /** 829 * @apilevel internal 830 */ 831 protected boolean involvesTypeParameters_computed = false; 832 /** 833 * @apilevel internal 834 */ 835 protected boolean involvesTypeParameters_initialized = false; 836 /** 837 * @apilevel internal 838 */ 839 protected boolean involvesTypeParameters_value; 840 @ASTNodeAnnotation.Attribute 841 public boolean involvesTypeParameters() { 842 if (involvesTypeParameters_computed) { 843 return involvesTypeParameters_value; 844 } 845 ASTNode$State state = state(); 846 boolean new_involvesTypeParameters_value; 847 if (!involvesTypeParameters_initialized) { 848 involvesTypeParameters_initialized = true; 849 involvesTypeParameters_value = false; 850 } 851 if (!state.IN_CIRCLE) { 852 state.IN_CIRCLE = true; 853 int num = state.boundariesCrossed; 854 boolean isFinal = this.is$Final(); 855 do { 856 involvesTypeParameters_visited = state.CIRCLE_INDEX; 857 state.CHANGE = false; 858 new_involvesTypeParameters_value = involvesTypeParameters_compute(); 859 if (new_involvesTypeParameters_value != involvesTypeParameters_value) { 860 state.CHANGE = true; 861 } 862 involvesTypeParameters_value = new_involvesTypeParameters_value; 863 state.CIRCLE_INDEX++; 864 } while (state.CHANGE); 865 if (isFinal && num == state().boundariesCrossed) { 866 involvesTypeParameters_computed = true; 867 } else { 868 state.RESET_CYCLE = true; 869 boolean $tmp = involvesTypeParameters_compute(); 870 state.RESET_CYCLE = false; 871 involvesTypeParameters_computed = false; 872 involvesTypeParameters_initialized = false; 873 } 874 state.IN_CIRCLE = false; 875 state.INTERMEDIATE_VALUE = false; 876 return involvesTypeParameters_value; 877 } 878 if (involvesTypeParameters_visited != state.CIRCLE_INDEX) { 879 involvesTypeParameters_visited = state.CIRCLE_INDEX; 880 if (state.RESET_CYCLE) { 881 involvesTypeParameters_computed = false; 882 involvesTypeParameters_initialized = false; 883 involvesTypeParameters_visited = -1; 884 return involvesTypeParameters_value; 885 } 886 new_involvesTypeParameters_value = involvesTypeParameters_compute(); 887 if (new_involvesTypeParameters_value != involvesTypeParameters_value) { 888 state.CHANGE = true; 889 } 890 involvesTypeParameters_value = new_involvesTypeParameters_value; 891 state.INTERMEDIATE_VALUE = true; 892 return involvesTypeParameters_value; 893 } 894 state.INTERMEDIATE_VALUE = true; 895 return involvesTypeParameters_value; 896 } 897 /** 898 * @apilevel internal 899 */ 900 private boolean involvesTypeParameters_compute() { 901 for (int i = 0; i < getNumArgument(); i++) { 902 if (getArgument(i).type().involvesTypeParameters()) { 903 return true; 904 } 905 } 906 return false; 907 } 908 /** 909 * @attribute syn 910 * @aspect NestedTypes 911 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:624 912 */ 913 @ASTNodeAnnotation.Attribute 914 public TypeDecl hostType() { 915 TypeDecl hostType_value = original(); 916 917 return hostType_value; 918 } 919 /** 920 * @attribute syn 921 * @aspect NestedTypes 922 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:545 923 */ 924 @ASTNodeAnnotation.Attribute 925 public TypeDecl topLevelType() { 926 TypeDecl topLevelType_value = erasure().topLevelType(); 927 928 return topLevelType_value; 929 } 930 /** 931 * @attribute syn 932 * @aspect Generics 933 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:307 934 */ 935 @ASTNodeAnnotation.Attribute 936 public boolean isRawType() { 937 boolean isRawType_value = isNestedType() && enclosingType().isRawType(); 938 939 return isRawType_value; 940 } 941 /** 942 * @apilevel internal 943 */ 944 protected boolean erasure_computed = false; 945 /** 946 * @apilevel internal 947 */ 948 protected TypeDecl erasure_value; 949 /** 950 * @apilevel internal 951 */ 952 private void erasure_reset() { 953 erasure_computed = false; 954 erasure_value = null; 955 } 956 /** 957 * @attribute syn 958 * @aspect GenericsErasure 959 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:422 960 */ 961 @ASTNodeAnnotation.Attribute 962 public TypeDecl erasure() { 963 ASTNode$State state = state(); 964 if (erasure_computed) { 965 return erasure_value; 966 } 967 boolean intermediate = state.INTERMEDIATE_VALUE; 968 state.INTERMEDIATE_VALUE = false; 969 int num = state.boundariesCrossed; 970 boolean isFinal = this.is$Final(); 971 erasure_value = genericDecl(); 972 if (isFinal && num == state().boundariesCrossed) { 973 erasure_computed = true; 974 } else { 975 } 976 state.INTERMEDIATE_VALUE |= intermediate; 977 978 return erasure_value; 979 } 980 /** 981 * @apilevel internal 982 */ 983 protected boolean getSuperClassOpt_computed = false; 984 /** 985 * @apilevel internal 986 */ 987 protected Opt getSuperClassOpt_value; 988 /** 989 * @apilevel internal 990 */ 991 private void getSuperClassOpt_reset() { 992 getSuperClassOpt_computed = false; 993 getSuperClassOpt_value = null; 994 } 995 /** 996 * @attribute syn nta 997 * @aspect LookupParTypeDecl 998 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1201 999 */ 1000 @ASTNodeAnnotation.Attribute 1001 public Opt getSuperClassOpt() { 1002 ASTNode$State state = state(); 1003 if (getSuperClassOpt_computed) { 1004 return (Opt) getChild(getSuperClassOptChildPosition()); 1005 } 1006 boolean intermediate = state.INTERMEDIATE_VALUE; 1007 state.INTERMEDIATE_VALUE = false; 1008 int num = state.boundariesCrossed; 1009 boolean isFinal = this.is$Final(); 1010 getSuperClassOpt_value = getSuperClassOpt_compute(); 1011 setChild(getSuperClassOpt_value, getSuperClassOptChildPosition()); 1012 if (isFinal && num == state().boundariesCrossed) { 1013 getSuperClassOpt_computed = true; 1014 } else { 1015 } 1016 state.INTERMEDIATE_VALUE |= intermediate; 1017 1018 Opt node = (Opt) this.getChild(getSuperClassOptChildPosition()); 1019 return node; 1020 } 1021 /** 1022 * @apilevel internal 1023 */ 1024 private Opt getSuperClassOpt_compute() { 1025 GenericClassDecl decl = (GenericClassDecl) genericDecl(); 1026 Opt opt; 1027 //System.err.println("Begin substituting extends clause"); 1028 if (decl.hasSuperClass()) { 1029 opt = new Opt((decl.getSuperClass().type().substitute(this))); 1030 } else { 1031 opt = new Opt(); 1032 } 1033 //System.err.println("End substituting extends clause"); 1034 return opt; 1035 } 1036 /** 1037 * @apilevel internal 1038 */ 1039 protected boolean getImplementsList_computed = false; 1040 /** 1041 * @apilevel internal 1042 */ 1043 protected List getImplementsList_value; 1044 /** 1045 * @apilevel internal 1046 */ 1047 private void getImplementsList_reset() { 1048 getImplementsList_computed = false; 1049 getImplementsList_value = null; 1050 } 1051 /** 1052 * @attribute syn nta 1053 * @aspect LookupParTypeDecl 1054 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1214 1055 */ 1056 @ASTNodeAnnotation.Attribute 1057 public List getImplementsList() { 1058 ASTNode$State state = state(); 1059 if (getImplementsList_computed) { 1060 return (List) getChild(getImplementsListChildPosition()); 1061 } 1062 boolean intermediate = state.INTERMEDIATE_VALUE; 1063 state.INTERMEDIATE_VALUE = false; 1064 int num = state.boundariesCrossed; 1065 boolean isFinal = this.is$Final(); 1066 getImplementsList_value = getImplementsList_compute(); 1067 setChild(getImplementsList_value, getImplementsListChildPosition()); 1068 if (isFinal && num == state().boundariesCrossed) { 1069 getImplementsList_computed = true; 1070 } else { 1071 } 1072 state.INTERMEDIATE_VALUE |= intermediate; 1073 1074 List node = (List) this.getChild(getImplementsListChildPosition()); 1075 return node; 1076 } 1077 /** 1078 * @apilevel internal 1079 */ 1080 private List getImplementsList_compute() { 1081 GenericClassDecl decl = (GenericClassDecl) genericDecl(); 1082 //System.err.println("Begin substituting implements list"); 1083 List list = decl.getImplementsList().substitute(this); 1084 //System.err.println("End substituting implements list"); 1085 return list; 1086 } 1087 /** 1088 * @apilevel internal 1089 */ 1090 protected boolean getBodyDeclList_computed = false; 1091 /** 1092 * @apilevel internal 1093 */ 1094 protected List getBodyDeclList_value; 1095 /** 1096 * @apilevel internal 1097 */ 1098 private void getBodyDeclList_reset() { 1099 getBodyDeclList_computed = false; 1100 getBodyDeclList_value = null; 1101 } 1102 /** 1103 * @attribute syn nta 1104 * @aspect LookupParTypeDecl 1105 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1222 1106 */ 1107 @ASTNodeAnnotation.Attribute 1108 public List getBodyDeclList() { 1109 ASTNode$State state = state(); 1110 if (getBodyDeclList_computed) { 1111 return (List) getChild(getBodyDeclListChildPosition()); 1112 } 1113 boolean intermediate = state.INTERMEDIATE_VALUE; 1114 state.INTERMEDIATE_VALUE = false; 1115 int num = state.boundariesCrossed; 1116 boolean isFinal = this.is$Final(); 1117 getBodyDeclList_value = new BodyDeclList(); 1118 setChild(getBodyDeclList_value, getBodyDeclListChildPosition()); 1119 if (isFinal && num == state().boundariesCrossed) { 1120 getBodyDeclList_computed = true; 1121 } else { 1122 } 1123 state.INTERMEDIATE_VALUE |= intermediate; 1124 1125 List node = (List) this.getChild(getBodyDeclListChildPosition()); 1126 return node; 1127 } 1128 /** 1129 * @attribute syn 1130 * @aspect GenericsSubtype 1131 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:35 1132 */ 1133 @ASTNodeAnnotation.Attribute 1134 public boolean supertypeGenericClassDecl(GenericClassDecl type) { 1135 boolean supertypeGenericClassDecl_GenericClassDecl_value = type.subtype(genericDecl().original()); 1136 1137 return supertypeGenericClassDecl_GenericClassDecl_value; 1138 } 1139 /** 1140 * @attribute syn 1141 * @aspect GenericsSubtype 1142 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:448 1143 */ 1144 @ASTNodeAnnotation.Attribute 1145 public boolean supertypeClassDecl(ClassDecl type) { 1146 boolean supertypeClassDecl_ClassDecl_value = super.supertypeClassDecl(type); 1147 1148 return supertypeClassDecl_ClassDecl_value; 1149 } 1150 /** 1151 * @apilevel internal 1152 */ 1153 private void subtype_TypeDecl_reset() { 1154 subtype_TypeDecl_values = null; 1155 } 1156 protected java.util.Map subtype_TypeDecl_values; 1157 @ASTNodeAnnotation.Attribute 1158 public boolean subtype(TypeDecl type) { 1159 Object _parameters = type; 1160 if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1161 ASTNode$State.CircularValue _value; 1162 if (subtype_TypeDecl_values.containsKey(_parameters)) { 1163 Object _o = subtype_TypeDecl_values.get(_parameters); 1164 if (!(_o instanceof ASTNode$State.CircularValue)) { 1165 return (Boolean) _o; 1166 } else { 1167 _value = (ASTNode$State.CircularValue) _o; 1168 } 1169 } else { 1170 _value = new ASTNode$State.CircularValue(); 1171 subtype_TypeDecl_values.put(_parameters, _value); 1172 _value.value = true; 1173 } 1174 ASTNode$State state = state(); 1175 boolean new_subtype_TypeDecl_value; 1176 if (!state.IN_CIRCLE) { 1177 state.IN_CIRCLE = true; 1178 int num = state.boundariesCrossed; 1179 boolean isFinal = this.is$Final(); 1180 // TODO: fixme 1181 // state().CIRCLE_INDEX = 1; 1182 do { 1183 _value.visited = state.CIRCLE_INDEX; 1184 state.CHANGE = false; 1185 new_subtype_TypeDecl_value = type.supertypeParClassDecl(this); 1186 if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 1187 state.CHANGE = true; 1188 _value.value = new_subtype_TypeDecl_value; 1189 } 1190 state.CIRCLE_INDEX++; 1191 } while (state.CHANGE); 1192 if (isFinal && num == state().boundariesCrossed) { 1193 subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value); 1194 } else { 1195 subtype_TypeDecl_values.remove(_parameters); 1196 state.RESET_CYCLE = true; 1197 boolean $tmp = type.supertypeParClassDecl(this); 1198 state.RESET_CYCLE = false; 1199 } 1200 state.IN_CIRCLE = false; 1201 state.INTERMEDIATE_VALUE = false; 1202 return new_subtype_TypeDecl_value; 1203 } 1204 if (state.CIRCLE_INDEX != _value.visited) { 1205 _value.visited = state.CIRCLE_INDEX; 1206 new_subtype_TypeDecl_value = type.supertypeParClassDecl(this); 1207 if (state.RESET_CYCLE) { 1208 subtype_TypeDecl_values.remove(_parameters); 1209 } 1210 else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 1211 state.CHANGE = true; 1212 _value.value = new_subtype_TypeDecl_value; 1213 } 1214 state.INTERMEDIATE_VALUE = true; 1215 return new_subtype_TypeDecl_value; 1216 } 1217 state.INTERMEDIATE_VALUE = true; 1218 return (Boolean) _value.value; 1219 } 1220 /** 1221 * @attribute syn 1222 * @aspect GenericsSubtype 1223 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:46 1224 */ 1225 @ASTNodeAnnotation.Attribute 1226 public boolean supertypeRawClassDecl(RawClassDecl type) { 1227 boolean supertypeRawClassDecl_RawClassDecl_value = type.genericDecl().original().subtype(genericDecl().original()); 1228 1229 return supertypeRawClassDecl_RawClassDecl_value; 1230 } 1231 /** 1232 * @attribute syn 1233 * @aspect GenericsSubtype 1234 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:50 1235 */ 1236 @ASTNodeAnnotation.Attribute 1237 public boolean supertypeRawInterfaceDecl(RawInterfaceDecl type) { 1238 boolean supertypeRawInterfaceDecl_RawInterfaceDecl_value = type.genericDecl().original().subtype(genericDecl().original()); 1239 1240 return supertypeRawInterfaceDecl_RawInterfaceDecl_value; 1241 } 1242 /** 1243 * @apilevel internal 1244 */ 1245 private void sameStructure_TypeDecl_reset() { 1246 sameStructure_TypeDecl_values = null; 1247 } 1248 protected java.util.Map sameStructure_TypeDecl_values; 1249 @ASTNodeAnnotation.Attribute 1250 public boolean sameStructure(TypeDecl t) { 1251 Object _parameters = t; 1252 if (sameStructure_TypeDecl_values == null) sameStructure_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1253 ASTNode$State.CircularValue _value; 1254 if (sameStructure_TypeDecl_values.containsKey(_parameters)) { 1255 Object _o = sameStructure_TypeDecl_values.get(_parameters); 1256 if (!(_o instanceof ASTNode$State.CircularValue)) { 1257 return (Boolean) _o; 1258 } else { 1259 _value = (ASTNode$State.CircularValue) _o; 1260 } 1261 } else { 1262 _value = new ASTNode$State.CircularValue(); 1263 sameStructure_TypeDecl_values.put(_parameters, _value); 1264 _value.value = true; 1265 } 1266 ASTNode$State state = state(); 1267 boolean new_sameStructure_TypeDecl_value; 1268 if (!state.IN_CIRCLE) { 1269 state.IN_CIRCLE = true; 1270 int num = state.boundariesCrossed; 1271 boolean isFinal = this.is$Final(); 1272 // TODO: fixme 1273 // state().CIRCLE_INDEX = 1; 1274 do { 1275 _value.visited = state.CIRCLE_INDEX; 1276 state.CHANGE = false; 1277 new_sameStructure_TypeDecl_value = sameStructure_compute(t); 1278 if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) { 1279 state.CHANGE = true; 1280 _value.value = new_sameStructure_TypeDecl_value; 1281 } 1282 state.CIRCLE_INDEX++; 1283 } while (state.CHANGE); 1284 if (isFinal && num == state().boundariesCrossed) { 1285 sameStructure_TypeDecl_values.put(_parameters, new_sameStructure_TypeDecl_value); 1286 } else { 1287 sameStructure_TypeDecl_values.remove(_parameters); 1288 state.RESET_CYCLE = true; 1289 boolean $tmp = sameStructure_compute(t); 1290 state.RESET_CYCLE = false; 1291 } 1292 state.IN_CIRCLE = false; 1293 state.INTERMEDIATE_VALUE = false; 1294 return new_sameStructure_TypeDecl_value; 1295 } 1296 if (state.CIRCLE_INDEX != _value.visited) { 1297 _value.visited = state.CIRCLE_INDEX; 1298 new_sameStructure_TypeDecl_value = sameStructure_compute(t); 1299 if (state.RESET_CYCLE) { 1300 sameStructure_TypeDecl_values.remove(_parameters); 1301 } 1302 else if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) { 1303 state.CHANGE = true; 1304 _value.value = new_sameStructure_TypeDecl_value; 1305 } 1306 state.INTERMEDIATE_VALUE = true; 1307 return new_sameStructure_TypeDecl_value; 1308 } 1309 state.INTERMEDIATE_VALUE = true; 1310 return (Boolean) _value.value; 1311 } 1312 /** 1313 * @apilevel internal 1314 */ 1315 private boolean sameStructure_compute(TypeDecl t) { 1316 if (!(t instanceof ParClassDecl)) { 1317 return false; 1318 } 1319 ParClassDecl type = (ParClassDecl) t; 1320 if (type.genericDecl().original() == genericDecl().original() && 1321 type.getNumArgument() == getNumArgument()) { 1322 for (int i = 0; i < getNumArgument(); i++) 1323 if (!type.getArgument(i).type().sameStructure(getArgument(i).type())) { 1324 return false; 1325 } 1326 if (isNestedType() && type.isNestedType()) { 1327 return type.enclosingType().sameStructure(enclosingType()); 1328 } 1329 return true; 1330 } 1331 return false; 1332 } 1333 /** 1334 * @attribute syn 1335 * @aspect GenericsSubtype 1336 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:134 1337 */ 1338 @ASTNodeAnnotation.Attribute 1339 public boolean supertypeParClassDecl(ParClassDecl type) { 1340 { 1341 if (type.genericDecl().original() == genericDecl().original() && 1342 type.getNumArgument() == getNumArgument()) { 1343 for (int i = 0; i < getNumArgument(); i++) 1344 if (!type.getArgument(i).type().containedIn(getArgument(i).type())) { 1345 return false; 1346 } 1347 if (isNestedType() && type.isNestedType()) { 1348 return type.enclosingType().subtype(enclosingType()); 1349 } 1350 return true; 1351 } 1352 return supertypeClassDecl(type); 1353 } 1354 } 1355 /** 1356 * @attribute syn 1357 * @aspect GenericsSubtype 1358 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:137 1359 */ 1360 @ASTNodeAnnotation.Attribute 1361 public boolean supertypeParInterfaceDecl(ParInterfaceDecl type) { 1362 boolean supertypeParInterfaceDecl_ParInterfaceDecl_value = false; 1363 1364 return supertypeParInterfaceDecl_ParInterfaceDecl_value; 1365 } 1366 /** 1367 * @apilevel internal 1368 */ 1369 protected java.util.Map instanceOf_TypeDecl_values; 1370 /** 1371 * @apilevel internal 1372 */ 1373 private void instanceOf_TypeDecl_reset() { 1374 instanceOf_TypeDecl_values = null; 1375 } 1376 /** 1377 * @attribute syn 1378 * @aspect TypeWideningAndIdentity 1379 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442 1380 */ 1381 @ASTNodeAnnotation.Attribute 1382 public boolean instanceOf(TypeDecl type) { 1383 Object _parameters = type; 1384 if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1385 ASTNode$State state = state(); 1386 if (instanceOf_TypeDecl_values.containsKey(_parameters)) { 1387 return (Boolean) instanceOf_TypeDecl_values.get(_parameters); 1388 } 1389 boolean intermediate = state.INTERMEDIATE_VALUE; 1390 state.INTERMEDIATE_VALUE = false; 1391 int num = state.boundariesCrossed; 1392 boolean isFinal = this.is$Final(); 1393 boolean instanceOf_TypeDecl_value = subtype(type); 1394 if (isFinal && num == state().boundariesCrossed) { 1395 instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value); 1396 } else { 1397 } 1398 state.INTERMEDIATE_VALUE |= intermediate; 1399 1400 return instanceOf_TypeDecl_value; 1401 } 1402 /** 1403 * A type is reifiable if it either refers to a non-parameterized type, 1404 * is a raw type, is a parameterized type with only unbound wildcard 1405 * parameters or is an array type with a reifiable type parameter. 1406 * 1407 * @see "JLS SE7 §4.7" 1408 * @attribute syn 1409 * @aspect ReifiableTypes 1410 * @declaredat /home/jesper/git/extendj/java5/frontend/ReifiableTypes.jrag:39 1411 */ 1412 @ASTNodeAnnotation.Attribute 1413 public boolean isReifiable() { 1414 { 1415 if (original().isInnerClass() && !original().enclosingType().isReifiable()) { 1416 return false; 1417 } 1418 for (Access argument: getArgumentList()) { 1419 if (!argument.isWildcard()) { 1420 return false; 1421 } 1422 } 1423 return true; 1424 } 1425 } 1426 /** 1427 * @apilevel internal 1428 */ 1429 protected boolean typeDescriptor_computed = false; 1430 /** 1431 * @apilevel internal 1432 */ 1433 protected String typeDescriptor_value; 1434 /** 1435 * @apilevel internal 1436 */ 1437 private void typeDescriptor_reset() { 1438 typeDescriptor_computed = false; 1439 typeDescriptor_value = null; 1440 } 1441 /** 1442 * @attribute syn 1443 * @aspect ConstantPoolNames 1444 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77 1445 */ 1446 @ASTNodeAnnotation.Attribute 1447 public String typeDescriptor() { 1448 ASTNode$State state = state(); 1449 if (typeDescriptor_computed) { 1450 return typeDescriptor_value; 1451 } 1452 boolean intermediate = state.INTERMEDIATE_VALUE; 1453 state.INTERMEDIATE_VALUE = false; 1454 int num = state.boundariesCrossed; 1455 boolean isFinal = this.is$Final(); 1456 typeDescriptor_value = erasure().typeDescriptor(); 1457 if (isFinal && num == state().boundariesCrossed) { 1458 typeDescriptor_computed = true; 1459 } else { 1460 } 1461 state.INTERMEDIATE_VALUE |= intermediate; 1462 1463 return typeDescriptor_value; 1464 } 1465 /** 1466 * @attribute syn 1467 * @aspect CreateBCode 1468 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:900 1469 */ 1470 @ASTNodeAnnotation.Attribute 1471 public String arrayTypeDescriptor() { 1472 String arrayTypeDescriptor_value = erasure().arrayTypeDescriptor(); 1473 1474 return arrayTypeDescriptor_value; 1475 } 1476 /** 1477 * @apilevel internal 1478 */ 1479 protected boolean constantPoolName_computed = false; 1480 /** 1481 * @apilevel internal 1482 */ 1483 protected String constantPoolName_value; 1484 /** 1485 * @apilevel internal 1486 */ 1487 private void constantPoolName_reset() { 1488 constantPoolName_computed = false; 1489 constantPoolName_value = null; 1490 } 1491 /** 1492 * For a top-level type the constant pool name of the type is the same as the 1493 * canonical name but with dots replaced by solidus. 1494 * 1495 * <p>For nested types the constant pool name is based on the enclosing top-level 1496 * types constant pool name followed by a dollar sign and a unique index and/or 1497 * the type name. 1498 * 1499 * @return constant pool name of this type 1500 * @attribute syn 1501 * @aspect ConstantPoolNames 1502 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:44 1503 */ 1504 @ASTNodeAnnotation.Attribute 1505 public String constantPoolName() { 1506 ASTNode$State state = state(); 1507 if (constantPoolName_computed) { 1508 return constantPoolName_value; 1509 } 1510 boolean intermediate = state.INTERMEDIATE_VALUE; 1511 state.INTERMEDIATE_VALUE = false; 1512 int num = state.boundariesCrossed; 1513 boolean isFinal = this.is$Final(); 1514 constantPoolName_value = genericDecl().constantPoolName(); 1515 if (isFinal && num == state().boundariesCrossed) { 1516 constantPoolName_computed = true; 1517 } else { 1518 } 1519 state.INTERMEDIATE_VALUE |= intermediate; 1520 1521 return constantPoolName_value; 1522 } 1523 /** 1524 * @apilevel internal 1525 */ 1526 protected boolean needsSignatureAttribute_computed = false; 1527 /** 1528 * @apilevel internal 1529 */ 1530 protected boolean needsSignatureAttribute_value; 1531 /** 1532 * @apilevel internal 1533 */ 1534 private void needsSignatureAttribute_reset() { 1535 needsSignatureAttribute_computed = false; 1536 } 1537 /** 1538 * @attribute syn 1539 * @aspect GenericsCodegen 1540 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:345 1541 */ 1542 @ASTNodeAnnotation.Attribute 1543 public boolean needsSignatureAttribute() { 1544 ASTNode$State state = state(); 1545 if (needsSignatureAttribute_computed) { 1546 return needsSignatureAttribute_value; 1547 } 1548 boolean intermediate = state.INTERMEDIATE_VALUE; 1549 state.INTERMEDIATE_VALUE = false; 1550 int num = state.boundariesCrossed; 1551 boolean isFinal = this.is$Final(); 1552 needsSignatureAttribute_value = true; 1553 if (isFinal && num == state().boundariesCrossed) { 1554 needsSignatureAttribute_computed = true; 1555 } else { 1556 } 1557 state.INTERMEDIATE_VALUE |= intermediate; 1558 1559 return needsSignatureAttribute_value; 1560 } 1561 /** 1562 * @attribute syn 1563 * @aspect StrictSubtype 1564 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:39 1565 */ 1566 @ASTNodeAnnotation.Attribute 1567 public boolean strictSupertypeGenericClassDecl(GenericClassDecl type) { 1568 boolean strictSupertypeGenericClassDecl_GenericClassDecl_value = type.strictSubtype(genericDecl().original()); 1569 1570 return strictSupertypeGenericClassDecl_GenericClassDecl_value; 1571 } 1572 /** 1573 * @attribute syn 1574 * @aspect StrictSubtype 1575 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:370 1576 */ 1577 @ASTNodeAnnotation.Attribute 1578 public boolean strictSupertypeClassDecl(ClassDecl type) { 1579 boolean strictSupertypeClassDecl_ClassDecl_value = super.strictSupertypeClassDecl(type); 1580 1581 return strictSupertypeClassDecl_ClassDecl_value; 1582 } 1583 /** 1584 * @apilevel internal 1585 */ 1586 private void strictSubtype_TypeDecl_reset() { 1587 strictSubtype_TypeDecl_values = null; 1588 } 1589 protected java.util.Map strictSubtype_TypeDecl_values; 1590 @ASTNodeAnnotation.Attribute 1591 public boolean strictSubtype(TypeDecl type) { 1592 Object _parameters = type; 1593 if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1594 ASTNode$State.CircularValue _value; 1595 if (strictSubtype_TypeDecl_values.containsKey(_parameters)) { 1596 Object _o = strictSubtype_TypeDecl_values.get(_parameters); 1597 if (!(_o instanceof ASTNode$State.CircularValue)) { 1598 return (Boolean) _o; 1599 } else { 1600 _value = (ASTNode$State.CircularValue) _o; 1601 } 1602 } else { 1603 _value = new ASTNode$State.CircularValue(); 1604 strictSubtype_TypeDecl_values.put(_parameters, _value); 1605 _value.value = true; 1606 } 1607 ASTNode$State state = state(); 1608 boolean new_strictSubtype_TypeDecl_value; 1609 if (!state.IN_CIRCLE) { 1610 state.IN_CIRCLE = true; 1611 int num = state.boundariesCrossed; 1612 boolean isFinal = this.is$Final(); 1613 // TODO: fixme 1614 // state().CIRCLE_INDEX = 1; 1615 do { 1616 _value.visited = state.CIRCLE_INDEX; 1617 state.CHANGE = false; 1618 new_strictSubtype_TypeDecl_value = type.strictSupertypeParClassDecl(this); 1619 if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 1620 state.CHANGE = true; 1621 _value.value = new_strictSubtype_TypeDecl_value; 1622 } 1623 state.CIRCLE_INDEX++; 1624 } while (state.CHANGE); 1625 if (isFinal && num == state().boundariesCrossed) { 1626 strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value); 1627 } else { 1628 strictSubtype_TypeDecl_values.remove(_parameters); 1629 state.RESET_CYCLE = true; 1630 boolean $tmp = type.strictSupertypeParClassDecl(this); 1631 state.RESET_CYCLE = false; 1632 } 1633 state.IN_CIRCLE = false; 1634 state.INTERMEDIATE_VALUE = false; 1635 return new_strictSubtype_TypeDecl_value; 1636 } 1637 if (state.CIRCLE_INDEX != _value.visited) { 1638 _value.visited = state.CIRCLE_INDEX; 1639 new_strictSubtype_TypeDecl_value = type.strictSupertypeParClassDecl(this); 1640 if (state.RESET_CYCLE) { 1641 strictSubtype_TypeDecl_values.remove(_parameters); 1642 } 1643 else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 1644 state.CHANGE = true; 1645 _value.value = new_strictSubtype_TypeDecl_value; 1646 } 1647 state.INTERMEDIATE_VALUE = true; 1648 return new_strictSubtype_TypeDecl_value; 1649 } 1650 state.INTERMEDIATE_VALUE = true; 1651 return (Boolean) _value.value; 1652 } 1653 /** 1654 * @attribute syn 1655 * @aspect StrictSubtype 1656 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:52 1657 */ 1658 @ASTNodeAnnotation.Attribute 1659 public boolean strictSupertypeRawClassDecl(RawClassDecl type) { 1660 boolean strictSupertypeRawClassDecl_RawClassDecl_value = type.genericDecl().original().strictSubtype(genericDecl().original()); 1661 1662 return strictSupertypeRawClassDecl_RawClassDecl_value; 1663 } 1664 /** 1665 * @attribute syn 1666 * @aspect StrictSubtype 1667 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:56 1668 */ 1669 @ASTNodeAnnotation.Attribute 1670 public boolean strictSupertypeRawInterfaceDecl(RawInterfaceDecl type) { 1671 boolean strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value = type.genericDecl().original().strictSubtype(genericDecl().original()); 1672 1673 return strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value; 1674 } 1675 /** 1676 * @attribute syn 1677 * @aspect StrictSubtype 1678 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:155 1679 */ 1680 @ASTNodeAnnotation.Attribute 1681 public boolean strictSupertypeParClassDecl(ParClassDecl type) { 1682 { 1683 if (type.genericDecl().original() == genericDecl().original() 1684 && type.getNumArgument() == getNumArgument()) { 1685 for (int i = 0; i < getNumArgument(); i++) { 1686 if (!type.getArgument(i).type().strictContainedIn(getArgument(i).type())) { 1687 return false; 1688 } 1689 } 1690 if (isNestedType() && type.isNestedType()) { 1691 return type.enclosingType().strictSubtype(enclosingType()); 1692 } 1693 return true; 1694 } 1695 return strictSupertypeClassDecl(type); 1696 } 1697 } 1698 /** 1699 * @attribute syn 1700 * @aspect StrictSubtype 1701 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:159 1702 */ 1703 @ASTNodeAnnotation.Attribute 1704 public boolean strictSupertypeParInterfaceDecl(ParInterfaceDecl type) { 1705 boolean strictSupertypeParInterfaceDecl_ParInterfaceDecl_value = false; 1706 1707 return strictSupertypeParInterfaceDecl_ParInterfaceDecl_value; 1708 } 1709 /** 1710 * @attribute syn 1711 * @aspect Generics 1712 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:306 1713 */ 1714 @ASTNodeAnnotation.Attribute 1715 public boolean isParameterizedType() { 1716 boolean isParameterizedType_value = true; 1717 1718 return isParameterizedType_value; 1719 } 1720 /** 1721 * @attribute syn 1722 * @aspect GenericsTypeCheck 1723 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:591 1724 */ 1725 @ASTNodeAnnotation.Attribute 1726 public boolean sameArgument(ParTypeDecl decl) { 1727 { 1728 if (this == decl) { 1729 return true; 1730 } 1731 if (genericDecl() != decl.genericDecl()) { 1732 return false; 1733 } 1734 for (int i = 0; i < getNumArgument(); i++) { 1735 TypeDecl t1 = getArgument(i).type(); 1736 TypeDecl t2 = decl.getArgument(i).type(); 1737 if (t1 instanceof ParTypeDecl && t2 instanceof ParTypeDecl) { 1738 if (!((ParTypeDecl) t1).sameArgument((ParTypeDecl) t2)) { 1739 return false; 1740 } 1741 } else { 1742 if (t1 != t2) { 1743 return false; 1744 } 1745 } 1746 } 1747 return true; 1748 } 1749 } 1750 /** 1751 * @attribute syn 1752 * @aspect LookupParTypeDecl 1753 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:816 1754 */ 1755 @ASTNodeAnnotation.Attribute 1756 public boolean sameSignature(Access a) { 1757 { 1758 if (a instanceof ParTypeAccess) { 1759 ParTypeAccess ta = (ParTypeAccess) a; 1760 if (genericDecl() != ta.genericDecl()) { 1761 return false; 1762 } 1763 if (getNumArgument() != ta.getNumTypeArgument()) { 1764 return false; 1765 } 1766 for (int i = 0; i < getNumArgument(); i++) { 1767 if (!getArgument(i).type().sameSignature(ta.getTypeArgument(i))) { 1768 return false; 1769 } 1770 } 1771 return true; 1772 } else if (a instanceof TypeAccess && ((TypeAccess) a).isRaw()) { 1773 return false; 1774 } 1775 return super.sameSignature(a); 1776 } 1777 } 1778 /** 1779 * @apilevel internal 1780 */ 1781 private void sameSignature_java_util_List_TypeDecl__reset() { 1782 sameSignature_java_util_List_TypeDecl__values = null; 1783 } 1784 protected java.util.Map sameSignature_java_util_List_TypeDecl__values; 1785 @ASTNodeAnnotation.Attribute 1786 public boolean sameSignature(java.util.List<TypeDecl> list) { 1787 Object _parameters = list; 1788 if (sameSignature_java_util_List_TypeDecl__values == null) sameSignature_java_util_List_TypeDecl__values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1789 ASTNode$State.CircularValue _value; 1790 if (sameSignature_java_util_List_TypeDecl__values.containsKey(_parameters)) { 1791 Object _o = sameSignature_java_util_List_TypeDecl__values.get(_parameters); 1792 if (!(_o instanceof ASTNode$State.CircularValue)) { 1793 return (Boolean) _o; 1794 } else { 1795 _value = (ASTNode$State.CircularValue) _o; 1796 } 1797 } else { 1798 _value = new ASTNode$State.CircularValue(); 1799 sameSignature_java_util_List_TypeDecl__values.put(_parameters, _value); 1800 _value.value = true; 1801 } 1802 ASTNode$State state = state(); 1803 boolean new_sameSignature_java_util_List_TypeDecl__value; 1804 if (!state.IN_CIRCLE) { 1805 state.IN_CIRCLE = true; 1806 int num = state.boundariesCrossed; 1807 boolean isFinal = this.is$Final(); 1808 // TODO: fixme 1809 // state().CIRCLE_INDEX = 1; 1810 do { 1811 _value.visited = state.CIRCLE_INDEX; 1812 state.CHANGE = false; 1813 new_sameSignature_java_util_List_TypeDecl__value = sameSignature_compute(list); 1814 if (new_sameSignature_java_util_List_TypeDecl__value != ((Boolean)_value.value)) { 1815 state.CHANGE = true; 1816 _value.value = new_sameSignature_java_util_List_TypeDecl__value; 1817 } 1818 state.CIRCLE_INDEX++; 1819 } while (state.CHANGE); 1820 if (isFinal && num == state().boundariesCrossed) { 1821 sameSignature_java_util_List_TypeDecl__values.put(_parameters, new_sameSignature_java_util_List_TypeDecl__value); 1822 } else { 1823 sameSignature_java_util_List_TypeDecl__values.remove(_parameters); 1824 state.RESET_CYCLE = true; 1825 boolean $tmp = sameSignature_compute(list); 1826 state.RESET_CYCLE = false; 1827 } 1828 state.IN_CIRCLE = false; 1829 state.INTERMEDIATE_VALUE = false; 1830 return new_sameSignature_java_util_List_TypeDecl__value; 1831 } 1832 if (state.CIRCLE_INDEX != _value.visited) { 1833 _value.visited = state.CIRCLE_INDEX; 1834 new_sameSignature_java_util_List_TypeDecl__value = sameSignature_compute(list); 1835 if (state.RESET_CYCLE) { 1836 sameSignature_java_util_List_TypeDecl__values.remove(_parameters); 1837 } 1838 else if (new_sameSignature_java_util_List_TypeDecl__value != ((Boolean)_value.value)) { 1839 state.CHANGE = true; 1840 _value.value = new_sameSignature_java_util_List_TypeDecl__value; 1841 } 1842 state.INTERMEDIATE_VALUE = true; 1843 return new_sameSignature_java_util_List_TypeDecl__value; 1844 } 1845 state.INTERMEDIATE_VALUE = true; 1846 return (Boolean) _value.value; 1847 } 1848 /** 1849 * @apilevel internal 1850 */ 1851 private boolean sameSignature_compute(java.util.List<TypeDecl> list) { 1852 if (getNumArgument() != list.size()) { 1853 return false; 1854 } 1855 for (int i = 0; i < list.size(); i++) { 1856 if (getArgument(i).type() != list.get(i)) { 1857 return false; 1858 } 1859 } 1860 return true; 1861 } 1862 /** 1863 * @apilevel internal 1864 */ 1865 protected int usesTypeVariable_visited = -1; 1866 /** 1867 * @apilevel internal 1868 */ 1869 private void usesTypeVariable_reset() { 1870 usesTypeVariable_computed = false; 1871 usesTypeVariable_initialized = false; 1872 usesTypeVariable_visited = -1; 1873 } 1874 /** 1875 * @apilevel internal 1876 */ 1877 protected boolean usesTypeVariable_computed = false; 1878 /** 1879 * @apilevel internal 1880 */ 1881 protected boolean usesTypeVariable_initialized = false; 1882 /** 1883 * @apilevel internal 1884 */ 1885 protected boolean usesTypeVariable_value; 1886 @ASTNodeAnnotation.Attribute 1887 public boolean usesTypeVariable() { 1888 if (usesTypeVariable_computed) { 1889 return usesTypeVariable_value; 1890 } 1891 ASTNode$State state = state(); 1892 boolean new_usesTypeVariable_value; 1893 if (!usesTypeVariable_initialized) { 1894 usesTypeVariable_initialized = true; 1895 usesTypeVariable_value = false; 1896 } 1897 if (!state.IN_CIRCLE) { 1898 state.IN_CIRCLE = true; 1899 int num = state.boundariesCrossed; 1900 boolean isFinal = this.is$Final(); 1901 do { 1902 usesTypeVariable_visited = state.CIRCLE_INDEX; 1903 state.CHANGE = false; 1904 new_usesTypeVariable_value = usesTypeVariable_compute(); 1905 if (new_usesTypeVariable_value != usesTypeVariable_value) { 1906 state.CHANGE = true; 1907 } 1908 usesTypeVariable_value = new_usesTypeVariable_value; 1909 state.CIRCLE_INDEX++; 1910 } while (state.CHANGE); 1911 if (isFinal && num == state().boundariesCrossed) { 1912 usesTypeVariable_computed = true; 1913 } else { 1914 state.RESET_CYCLE = true; 1915 boolean $tmp = usesTypeVariable_compute(); 1916 state.RESET_CYCLE = false; 1917 usesTypeVariable_computed = false; 1918 usesTypeVariable_initialized = false; 1919 } 1920 state.IN_CIRCLE = false; 1921 state.INTERMEDIATE_VALUE = false; 1922 return usesTypeVariable_value; 1923 } 1924 if (usesTypeVariable_visited != state.CIRCLE_INDEX) { 1925 usesTypeVariable_visited = state.CIRCLE_INDEX; 1926 if (state.RESET_CYCLE) { 1927 usesTypeVariable_computed = false; 1928 usesTypeVariable_initialized = false; 1929 usesTypeVariable_visited = -1; 1930 return usesTypeVariable_value; 1931 } 1932 new_usesTypeVariable_value = usesTypeVariable_compute(); 1933 if (new_usesTypeVariable_value != usesTypeVariable_value) { 1934 state.CHANGE = true; 1935 } 1936 usesTypeVariable_value = new_usesTypeVariable_value; 1937 state.INTERMEDIATE_VALUE = true; 1938 return usesTypeVariable_value; 1939 } 1940 state.INTERMEDIATE_VALUE = true; 1941 return usesTypeVariable_value; 1942 } 1943 /** 1944 * @apilevel internal 1945 */ 1946 private boolean usesTypeVariable_compute() { 1947 if (super.usesTypeVariable()) { 1948 return true; 1949 } 1950 for (int i = 0; i < getNumArgument(); i++) 1951 if (getArgument(i).type().usesTypeVariable()) { 1952 return true; 1953 } 1954 return false; 1955 } 1956 /** 1957 * @attribute syn 1958 * @aspect LookupParTypeDecl 1959 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1417 1960 */ 1961 @ASTNodeAnnotation.Attribute 1962 public TypeDecl original() { 1963 TypeDecl original_value = genericDecl().original(); 1964 1965 return original_value; 1966 } 1967 /** 1968 * @apilevel internal 1969 */ 1970 protected boolean sourceTypeDecl_computed = false; 1971 /** 1972 * @apilevel internal 1973 */ 1974 protected TypeDecl sourceTypeDecl_value; 1975 /** 1976 * @apilevel internal 1977 */ 1978 private void sourceTypeDecl_reset() { 1979 sourceTypeDecl_computed = false; 1980 sourceTypeDecl_value = null; 1981 } 1982 /** 1983 * @attribute syn 1984 * @aspect SourceDeclarations 1985 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1618 1986 */ 1987 @ASTNodeAnnotation.Attribute 1988 public TypeDecl sourceTypeDecl() { 1989 ASTNode$State state = state(); 1990 if (sourceTypeDecl_computed) { 1991 return sourceTypeDecl_value; 1992 } 1993 boolean intermediate = state.INTERMEDIATE_VALUE; 1994 state.INTERMEDIATE_VALUE = false; 1995 int num = state.boundariesCrossed; 1996 boolean isFinal = this.is$Final(); 1997 sourceTypeDecl_value = genericDecl().original().sourceTypeDecl(); 1998 if (isFinal && num == state().boundariesCrossed) { 1999 sourceTypeDecl_computed = true; 2000 } else { 2001 } 2002 state.INTERMEDIATE_VALUE |= intermediate; 2003 2004 return sourceTypeDecl_value; 2005 } 2006 /** 2007 * @apilevel internal 2008 */ 2009 protected boolean fullName_computed = false; 2010 /** 2011 * @apilevel internal 2012 */ 2013 protected String fullName_value; 2014 /** 2015 * @apilevel internal 2016 */ 2017 private void fullName_reset() { 2018 fullName_computed = false; 2019 fullName_value = null; 2020 } 2021 /** 2022 * @attribute syn 2023 * @aspect TypeName 2024 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:80 2025 */ 2026 @ASTNodeAnnotation.Attribute 2027 public String fullName() { 2028 ASTNode$State state = state(); 2029 if (fullName_computed) { 2030 return fullName_value; 2031 } 2032 boolean intermediate = state.INTERMEDIATE_VALUE; 2033 state.INTERMEDIATE_VALUE = false; 2034 int num = state.boundariesCrossed; 2035 boolean isFinal = this.is$Final(); 2036 fullName_value = fullName_compute(); 2037 if (isFinal && num == state().boundariesCrossed) { 2038 fullName_computed = true; 2039 } else { 2040 } 2041 state.INTERMEDIATE_VALUE |= intermediate; 2042 2043 return fullName_value; 2044 } 2045 /** 2046 * @apilevel internal 2047 */ 2048 private String fullName_compute() { 2049 if (isNestedType()) { 2050 return enclosingType().fullName() + "." + nameWithArgs(); 2051 } 2052 String packageName = packageName(); 2053 if (packageName.equals("")) { 2054 return nameWithArgs(); 2055 } 2056 return packageName + "." + nameWithArgs(); 2057 } 2058 /** 2059 * @apilevel internal 2060 */ 2061 protected boolean typeName_computed = false; 2062 /** 2063 * @apilevel internal 2064 */ 2065 protected String typeName_value; 2066 /** 2067 * @apilevel internal 2068 */ 2069 private void typeName_reset() { 2070 typeName_computed = false; 2071 typeName_value = null; 2072 } 2073 /** 2074 * @attribute syn 2075 * @aspect TypeName 2076 * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:91 2077 */ 2078 @ASTNodeAnnotation.Attribute 2079 public String typeName() { 2080 ASTNode$State state = state(); 2081 if (typeName_computed) { 2082 return typeName_value; 2083 } 2084 boolean intermediate = state.INTERMEDIATE_VALUE; 2085 state.INTERMEDIATE_VALUE = false; 2086 int num = state.boundariesCrossed; 2087 boolean isFinal = this.is$Final(); 2088 typeName_value = typeName_compute(); 2089 if (isFinal && num == state().boundariesCrossed) { 2090 typeName_computed = true; 2091 } else { 2092 } 2093 state.INTERMEDIATE_VALUE |= intermediate; 2094 2095 return typeName_value; 2096 } 2097 /** 2098 * @apilevel internal 2099 */ 2100 private String typeName_compute() { 2101 if (isNestedType()) { 2102 return enclosingType().typeName() + "." + nameWithArgs(); 2103 } 2104 String packageName = packageName(); 2105 if (packageName.equals("") || packageName.equals(PRIMITIVE_PACKAGE_NAME)) { 2106 return nameWithArgs(); 2107 } 2108 return packageName + "." + nameWithArgs(); 2109 } 2110 /** 2111 * @attribute syn 2112 * @aspect GenericsParTypeDecl 2113 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:55 2114 */ 2115 @ASTNodeAnnotation.Attribute 2116 public String nameWithArgs() { 2117 { 2118 StringBuilder sb = new StringBuilder(); 2119 sb.append(name()); 2120 sb.append("<"); 2121 for (int i = 0; i < getNumArgument(); i++) { 2122 if (i != 0) { 2123 sb.append(", "); 2124 } 2125 sb.append(getArgument(i).type().fullName()); 2126 } 2127 sb.append(">"); 2128 return sb.toString(); 2129 } 2130 } 2131 /** 2132 * @apilevel internal 2133 */ 2134 protected boolean unimplementedMethods_computed = false; 2135 /** 2136 * @apilevel internal 2137 */ 2138 protected Collection unimplementedMethods_value; 2139 /** 2140 * @apilevel internal 2141 */ 2142 private void unimplementedMethods_reset() { 2143 unimplementedMethods_computed = false; 2144 unimplementedMethods_value = null; 2145 } 2146 /** 2147 * @attribute syn 2148 * @aspect Modifiers 2149 * @declaredat /home/jesper/git/extendj/java4/frontend/Modifiers.jrag:37 2150 */ 2151 @ASTNodeAnnotation.Attribute 2152 public Collection unimplementedMethods() { 2153 ASTNode$State state = state(); 2154 if (unimplementedMethods_computed) { 2155 return unimplementedMethods_value; 2156 } 2157 boolean intermediate = state.INTERMEDIATE_VALUE; 2158 state.INTERMEDIATE_VALUE = false; 2159 int num = state.boundariesCrossed; 2160 boolean isFinal = this.is$Final(); 2161 unimplementedMethods_value = unimplementedMethods_compute(); 2162 if (isFinal && num == state().boundariesCrossed) { 2163 unimplementedMethods_computed = true; 2164 } else { 2165 } 2166 state.INTERMEDIATE_VALUE |= intermediate; 2167 2168 return unimplementedMethods_value; 2169 } 2170 /** 2171 * @apilevel internal 2172 */ 2173 private Collection unimplementedMethods_compute() { 2174 HashSet set = new HashSet(); 2175 HashSet result = new HashSet(); 2176 for (Iterator iter = genericDecl().unimplementedMethods().iterator(); iter.hasNext(); ) { 2177 MethodDecl m = (MethodDecl) iter.next(); 2178 set.add(m.sourceMethodDecl()); 2179 } 2180 for (Iterator iter = super.unimplementedMethods().iterator(); iter.hasNext(); ) { 2181 MethodDecl m = (MethodDecl) iter.next(); 2182 if (set.contains(m.sourceMethodDecl())) { 2183 result.add(m); 2184 } 2185 } 2186 return result; 2187 } 2188 /** 2189 * @apilevel internal 2190 */ 2191 protected boolean uniqueIndex_computed = false; 2192 /** 2193 * @apilevel internal 2194 */ 2195 protected int uniqueIndex_value; 2196 /** 2197 * @apilevel internal 2198 */ 2199 private void uniqueIndex_reset() { 2200 uniqueIndex_computed = false; 2201 } 2202 /** 2203 * @attribute syn 2204 * @aspect Java2Rewrites 2205 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:33 2206 */ 2207 @ASTNodeAnnotation.Attribute 2208 public int uniqueIndex() { 2209 ASTNode$State state = state(); 2210 if (uniqueIndex_computed) { 2211 return uniqueIndex_value; 2212 } 2213 boolean intermediate = state.INTERMEDIATE_VALUE; 2214 state.INTERMEDIATE_VALUE = false; 2215 int num = state.boundariesCrossed; 2216 boolean isFinal = this.is$Final(); 2217 uniqueIndex_value = genericDecl().uniqueIndex(); 2218 if (isFinal && num == state().boundariesCrossed) { 2219 uniqueIndex_computed = true; 2220 } else { 2221 } 2222 state.INTERMEDIATE_VALUE |= intermediate; 2223 2224 return uniqueIndex_value; 2225 } 2226 /** 2227 * @attribute syn 2228 * @aspect GenericsCodegen 2229 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:495 2230 */ 2231 @ASTNodeAnnotation.Attribute 2232 public String typeArgumentsOpt() { 2233 { 2234 StringBuilder buf = new StringBuilder(); 2235 buf.append("<"); 2236 for (int i = 0; i < getNumArgument(); i++) { 2237 buf.append(getArgument(i).type().fieldTypeSignature()); 2238 } 2239 buf.append(">"); 2240 return buf.toString(); 2241 } 2242 } 2243 /** 2244 * @apilevel internal 2245 */ 2246 protected boolean localMethodsSignatureMap_computed = false; 2247 /** 2248 * @apilevel internal 2249 */ 2250 protected Map<String,SimpleSet> localMethodsSignatureMap_value; 2251 /** 2252 * @apilevel internal 2253 */ 2254 private void localMethodsSignatureMap_reset() { 2255 localMethodsSignatureMap_computed = false; 2256 localMethodsSignatureMap_value = null; 2257 } 2258 /** 2259 * @attribute syn 2260 * @aspect LookupParTypeDecl 2261 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1278 2262 */ 2263 @ASTNodeAnnotation.Attribute 2264 public Map<String,SimpleSet> localMethodsSignatureMap() { 2265 ASTNode$State state = state(); 2266 if (localMethodsSignatureMap_computed) { 2267 return localMethodsSignatureMap_value; 2268 } 2269 boolean intermediate = state.INTERMEDIATE_VALUE; 2270 state.INTERMEDIATE_VALUE = false; 2271 int num = state.boundariesCrossed; 2272 boolean isFinal = this.is$Final(); 2273 localMethodsSignatureMap_value = localMethodsSignatureMap_compute(); 2274 if (true) { 2275 localMethodsSignatureMap_computed = true; 2276 } else { 2277 } 2278 state.INTERMEDIATE_VALUE |= intermediate; 2279 2280 return localMethodsSignatureMap_value; 2281 } 2282 /** 2283 * @apilevel internal 2284 */ 2285 private Map<String,SimpleSet> localMethodsSignatureMap_compute() { 2286 Map<String,SimpleSet> map = new HashMap<String,SimpleSet>(); 2287 for (Iterator<MethodDecl> iter = original().localMethodsIterator(); iter.hasNext(); ) { 2288 MethodDecl decl = iter.next(); 2289 2290 if (!decl.isStatic() && (decl.usesTypeVariable() || isRawType())) { 2291 BodyDecl copyDecl = ((BodyDeclList) getBodyDeclList()).localMethodSignatureCopy(decl, this); 2292 decl = (MethodDecl) copyDecl; 2293 } 2294 putSimpleSetElement(map, decl.signature(), decl); 2295 2296 } 2297 return map; 2298 } 2299 /** 2300 * @apilevel internal 2301 */ 2302 protected java.util.Map localFields_String_values; 2303 /** 2304 * @apilevel internal 2305 */ 2306 private void localFields_String_reset() { 2307 localFields_String_values = null; 2308 } 2309 /** 2310 * @attribute syn 2311 * @aspect LookupParTypeDecl 2312 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1296 2313 */ 2314 @ASTNodeAnnotation.Attribute 2315 public SimpleSet localFields(String name) { 2316 Object _parameters = name; 2317 if (localFields_String_values == null) localFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2318 ASTNode$State state = state(); 2319 if (localFields_String_values.containsKey(_parameters)) { 2320 return (SimpleSet) localFields_String_values.get(_parameters); 2321 } 2322 boolean intermediate = state.INTERMEDIATE_VALUE; 2323 state.INTERMEDIATE_VALUE = false; 2324 int num = state.boundariesCrossed; 2325 boolean isFinal = this.is$Final(); 2326 SimpleSet localFields_String_value = localFields_compute(name); 2327 if (true) { 2328 localFields_String_values.put(_parameters, localFields_String_value); 2329 } else { 2330 } 2331 state.INTERMEDIATE_VALUE |= intermediate; 2332 2333 return localFields_String_value; 2334 } 2335 /** 2336 * @apilevel internal 2337 */ 2338 private SimpleSet localFields_compute(String name) { 2339 SimpleSet set = SimpleSet.emptySet; 2340 for (Iterator iter = original().localFields(name).iterator(); iter.hasNext(); ) { 2341 FieldDeclaration f = (FieldDeclaration) iter.next(); 2342 2343 if (!f.isStatic() && (f.usesTypeVariable() || isRawType())) { 2344 BodyDecl fCopy = ((BodyDeclList) getBodyDeclList()).localFieldCopy(f, this); 2345 f = (FieldDeclaration) fCopy; 2346 } 2347 set = set.add(f); 2348 2349 } 2350 return set; 2351 } 2352 /** 2353 * @apilevel internal 2354 */ 2355 private void localTypeDecls_String_reset() { 2356 localTypeDecls_String_values = null; 2357 } 2358 protected java.util.Map localTypeDecls_String_values; 2359 @ASTNodeAnnotation.Attribute 2360 public SimpleSet localTypeDecls(String name) { 2361 Object _parameters = name; 2362 if (localTypeDecls_String_values == null) localTypeDecls_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 2363 ASTNode$State.CircularValue _value; 2364 if (localTypeDecls_String_values.containsKey(_parameters)) { 2365 Object _o = localTypeDecls_String_values.get(_parameters); 2366 if (!(_o instanceof ASTNode$State.CircularValue)) { 2367 return (SimpleSet) _o; 2368 } else { 2369 _value = (ASTNode$State.CircularValue) _o; 2370 } 2371 } else { 2372 _value = new ASTNode$State.CircularValue(); 2373 localTypeDecls_String_values.put(_parameters, _value); 2374 _value.value = SimpleSet.emptySet; 2375 } 2376 ASTNode$State state = state(); 2377 SimpleSet new_localTypeDecls_String_value; 2378 if (!state.IN_CIRCLE) { 2379 state.IN_CIRCLE = true; 2380 int num = state.boundariesCrossed; 2381 boolean isFinal = this.is$Final(); 2382 // TODO: fixme 2383 // state().CIRCLE_INDEX = 1; 2384 do { 2385 _value.visited = state.CIRCLE_INDEX; 2386 state.CHANGE = false; 2387 new_localTypeDecls_String_value = localTypeDecls_compute(name); 2388 if ((new_localTypeDecls_String_value==null && (SimpleSet)_value.value!=null) || (new_localTypeDecls_String_value!=null && !new_localTypeDecls_String_value.equals((SimpleSet)_value.value))) { 2389 state.CHANGE = true; 2390 _value.value = new_localTypeDecls_String_value; 2391 } 2392 state.CIRCLE_INDEX++; 2393 } while (state.CHANGE); 2394 if (true) { 2395 localTypeDecls_String_values.put(_parameters, new_localTypeDecls_String_value); 2396 } else { 2397 localTypeDecls_String_values.remove(_parameters); 2398 state.RESET_CYCLE = true; 2399 SimpleSet $tmp = localTypeDecls_compute(name); 2400 state.RESET_CYCLE = false; 2401 } 2402 state.IN_CIRCLE = false; 2403 state.INTERMEDIATE_VALUE = false; 2404 return new_localTypeDecls_String_value; 2405 } 2406 if (state.CIRCLE_INDEX != _value.visited) { 2407 _value.visited = state.CIRCLE_INDEX; 2408 new_localTypeDecls_String_value = localTypeDecls_compute(name); 2409 if (state.RESET_CYCLE) { 2410 localTypeDecls_String_values.remove(_parameters); 2411 } 2412 else if ((new_localTypeDecls_String_value==null && (SimpleSet)_value.value!=null) || (new_localTypeDecls_String_value!=null && !new_localTypeDecls_String_value.equals((SimpleSet)_value.value))) { 2413 state.CHANGE = true; 2414 _value.value = new_localTypeDecls_String_value; 2415 } 2416 state.INTERMEDIATE_VALUE = true; 2417 return new_localTypeDecls_String_value; 2418 } 2419 state.INTERMEDIATE_VALUE = true; 2420 return (SimpleSet) _value.value; 2421 } 2422 /** 2423 * @apilevel internal 2424 */ 2425 private SimpleSet localTypeDecls_compute(String name) { 2426 SimpleSet set = SimpleSet.emptySet; 2427 for (Iterator iter = original().localTypeDecls(name).iterator(); iter.hasNext(); ) { 2428 TypeDecl t = (TypeDecl) iter.next(); 2429 2430 if (t.isStatic()) { 2431 set = set.add(t); 2432 } else if (t instanceof ClassDecl) { 2433 MemberClassDecl copy = 2434 ((BodyDeclList) getBodyDeclList()).localClassDeclCopy((ClassDecl) t, this); 2435 set = set.add(copy.getClassDecl()); 2436 } else if (t instanceof InterfaceDecl) { 2437 MemberInterfaceDecl copy = 2438 ((BodyDeclList) getBodyDeclList()).localInterfaceDeclCopy((InterfaceDecl) t, this); 2439 set = set.add(copy.getInterfaceDecl()); 2440 } 2441 } 2442 return set; 2443 } 2444 /** 2445 * @apilevel internal 2446 */ 2447 protected boolean constructors_computed = false; 2448 /** 2449 * @apilevel internal 2450 */ 2451 protected Collection<ConstructorDecl> constructors_value; 2452 /** 2453 * @apilevel internal 2454 */ 2455 private void constructors_reset() { 2456 constructors_computed = false; 2457 constructors_value = null; 2458 } 2459 /** 2460 * @attribute syn 2461 * @aspect LookupParTypeDecl 2462 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1347 2463 */ 2464 @ASTNodeAnnotation.Attribute 2465 public Collection<ConstructorDecl> constructors() { 2466 ASTNode$State state = state(); 2467 if (constructors_computed) { 2468 return constructors_value; 2469 } 2470 boolean intermediate = state.INTERMEDIATE_VALUE; 2471 state.INTERMEDIATE_VALUE = false; 2472 int num = state.boundariesCrossed; 2473 boolean isFinal = this.is$Final(); 2474 constructors_value = constructors_compute(); 2475 if (isFinal && num == state().boundariesCrossed) { 2476 constructors_computed = true; 2477 } else { 2478 } 2479 state.INTERMEDIATE_VALUE |= intermediate; 2480 2481 return constructors_value; 2482 } 2483 /** 2484 * @apilevel internal 2485 */ 2486 private Collection<ConstructorDecl> constructors_compute() { 2487 Collection<ConstructorDecl> constructors = new ArrayList<ConstructorDecl>(); 2488 for (Iterator iter = original().constructors().iterator(); iter.hasNext(); ) { 2489 ConstructorDecl c = (ConstructorDecl) iter.next(); 2490 2491 ConstructorDecl b = ((BodyDeclList) getBodyDeclList()).constructorCopy(c, this); 2492 constructors.add(b); 2493 } 2494 return constructors; 2495 } 2496 /** 2497 * @attribute inh 2498 * @aspect GenericsParTypeDecl 2499 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:71 2500 */ 2501 /** 2502 * @attribute inh 2503 * @aspect GenericsParTypeDecl 2504 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:71 2505 */ 2506 @ASTNodeAnnotation.Attribute 2507 public TypeDecl genericDecl() { 2508 ASTNode$State state = state(); 2509 if (genericDecl_computed) { 2510 return genericDecl_value; 2511 } 2512 boolean intermediate = state.INTERMEDIATE_VALUE; 2513 state.INTERMEDIATE_VALUE = false; 2514 int num = state.boundariesCrossed; 2515 boolean isFinal = this.is$Final(); 2516 genericDecl_value = getParent().Define_genericDecl(this, null); 2517 if (isFinal && num == state().boundariesCrossed) { 2518 genericDecl_computed = true; 2519 } else { 2520 } 2521 state.INTERMEDIATE_VALUE |= intermediate; 2522 2523 return genericDecl_value; 2524 } 2525 /** 2526 * @apilevel internal 2527 */ 2528 protected boolean genericDecl_computed = false; 2529 /** 2530 * @apilevel internal 2531 */ 2532 protected TypeDecl genericDecl_value; 2533 /** 2534 * @apilevel internal 2535 */ 2536 private void genericDecl_reset() { 2537 genericDecl_computed = false; 2538 genericDecl_value = null; 2539 } 2540 /** 2541 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 2542 * @apilevel internal 2543 */ 2544 public NameType Define_nameType(ASTNode caller, ASTNode child) { 2545 if (caller == getArgumentListNoTransform()) { 2546 // @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:703 2547 int childIndex = caller.getIndexOfChild(child); 2548 return NameType.TYPE_NAME; 2549 } 2550 else { 2551 return super.Define_nameType(caller, child); 2552 } 2553 } 2554 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 2555 return true; 2556 } 2557 /** 2558 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:71 2559 * @apilevel internal 2560 */ 2561 public TypeDecl Define_genericDecl(ASTNode caller, ASTNode child) { 2562 if (caller == getBodyDeclListNoTransform()) { 2563 // @declaredat /home/jesper/git/extendj/java5/frontend/GenericsParTypeDecl.jrag:75 2564 int index = caller.getIndexOfChild(child); 2565 { 2566 if (getBodyDecl(index) instanceof MemberTypeDecl) { 2567 MemberTypeDecl m = (MemberTypeDecl) getBodyDecl(index); 2568 return extractSingleType(genericDecl().memberTypes(m.typeDecl().name())); 2569 } 2570 return genericDecl(); 2571 } 2572 } 2573 else { 2574 return getParent().Define_genericDecl(this, caller); 2575 } 2576 } 2577 protected boolean canDefine_genericDecl(ASTNode caller, ASTNode child) { 2578 return true; 2579 } 2580 /** 2581 * @apilevel internal 2582 */ 2583 public ASTNode rewriteTo() { 2584 return super.rewriteTo(); 2585 } 2586 }