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