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:27 027 * @production WildcardExtendsType : {@link AbstractWildcardType} ::= <span class="component">{@link Access}</span>; 028 029 */ 030 public class WildcardExtendsType extends AbstractWildcardType implements Cloneable { 031 /** 032 * @aspect LookupParTypeDecl 033 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1070 034 */ 035 public Access substitute(Parameterization parTypeDecl) { 036 if (!usesTypeVariable()) { 037 return super.substitute(parTypeDecl); 038 } 039 return new WildcardExtends(getAccess().type().substitute(parTypeDecl)); 040 } 041 /** 042 * @declaredat ASTNode:1 043 */ 044 public WildcardExtendsType() { 045 super(); 046 } 047 /** 048 * Initializes the child array to the correct size. 049 * Initializes List and Opt nta children. 050 * @apilevel internal 051 * @ast method 052 * @declaredat ASTNode:10 053 */ 054 public void init$Children() { 055 children = new ASTNode[3]; 056 setChild(new List(), 1); 057 } 058 /** 059 * @declaredat ASTNode:14 060 */ 061 public WildcardExtendsType(Modifiers p0, String p1, List<BodyDecl> p2, Access p3) { 062 setChild(p0, 0); 063 setID(p1); 064 setChild(p2, 1); 065 setChild(p3, 2); 066 } 067 /** 068 * @declaredat ASTNode:20 069 */ 070 public WildcardExtendsType(Modifiers p0, beaver.Symbol p1, List<BodyDecl> p2, Access p3) { 071 setChild(p0, 0); 072 setID(p1); 073 setChild(p2, 1); 074 setChild(p3, 2); 075 } 076 /** 077 * @apilevel low-level 078 * @declaredat ASTNode:29 079 */ 080 protected int numChildren() { 081 return 3; 082 } 083 /** 084 * @apilevel internal 085 * @declaredat ASTNode:35 086 */ 087 public boolean mayHaveRewrite() { 088 return false; 089 } 090 /** 091 * @apilevel internal 092 * @declaredat ASTNode:41 093 */ 094 public void flushAttrCache() { 095 super.flushAttrCache(); 096 involvesTypeParameters_reset(); 097 usesTypeVariable_reset(); 098 subtype_TypeDecl_reset(); 099 containedIn_TypeDecl_reset(); 100 sameStructure_TypeDecl_reset(); 101 instanceOf_TypeDecl_reset(); 102 fieldTypeSignature_reset(); 103 strictSubtype_TypeDecl_reset(); 104 strictContainedIn_TypeDecl_reset(); 105 } 106 /** 107 * @apilevel internal 108 * @declaredat ASTNode:56 109 */ 110 public void flushCollectionCache() { 111 super.flushCollectionCache(); 112 } 113 /** 114 * @apilevel internal 115 * @declaredat ASTNode:62 116 */ 117 public void flushRewriteCache() { 118 super.flushRewriteCache(); 119 } 120 /** 121 * @apilevel internal 122 * @declaredat ASTNode:68 123 */ 124 public WildcardExtendsType clone() throws CloneNotSupportedException { 125 WildcardExtendsType node = (WildcardExtendsType) super.clone(); 126 return node; 127 } 128 /** 129 * @apilevel internal 130 * @declaredat ASTNode:75 131 */ 132 public WildcardExtendsType copy() { 133 try { 134 WildcardExtendsType node = (WildcardExtendsType) clone(); 135 node.parent = null; 136 if (children != null) { 137 node.children = (ASTNode[]) children.clone(); 138 } 139 return node; 140 } catch (CloneNotSupportedException e) { 141 throw new Error("Error: clone not supported for " + getClass().getName()); 142 } 143 } 144 /** 145 * Create a deep copy of the AST subtree at this node. 146 * The copy is dangling, i.e. has no parent. 147 * @return dangling copy of the subtree at this node 148 * @apilevel low-level 149 * @deprecated Please use treeCopy or treeCopyNoTransform instead 150 * @declaredat ASTNode:94 151 */ 152 @Deprecated 153 public WildcardExtendsType fullCopy() { 154 return treeCopyNoTransform(); 155 } 156 /** 157 * Create a deep copy of the AST subtree at this node. 158 * The copy is dangling, i.e. has no parent. 159 * @return dangling copy of the subtree at this node 160 * @apilevel low-level 161 * @declaredat ASTNode:104 162 */ 163 public WildcardExtendsType treeCopyNoTransform() { 164 WildcardExtendsType tree = (WildcardExtendsType) copy(); 165 if (children != null) { 166 for (int i = 0; i < children.length; ++i) { 167 ASTNode child = (ASTNode) children[i]; 168 if (child != null) { 169 child = child.treeCopyNoTransform(); 170 tree.setChild(child, i); 171 } 172 } 173 } 174 return tree; 175 } 176 /** 177 * Create a deep copy of the AST subtree at this node. 178 * The subtree of this node is traversed to trigger rewrites before copy. 179 * The copy is dangling, i.e. has no parent. 180 * @return dangling copy of the subtree at this node 181 * @apilevel low-level 182 * @declaredat ASTNode:124 183 */ 184 public WildcardExtendsType treeCopy() { 185 doFullTraversal(); 186 return treeCopyNoTransform(); 187 } 188 /** 189 * @apilevel internal 190 * @declaredat ASTNode:131 191 */ 192 protected boolean is$Equal(ASTNode node) { 193 return super.is$Equal(node) && (tokenString_ID == ((WildcardExtendsType)node).tokenString_ID); 194 } 195 /** 196 * Replaces the Modifiers child. 197 * @param node The new node to replace the Modifiers child. 198 * @apilevel high-level 199 */ 200 public void setModifiers(Modifiers node) { 201 setChild(node, 0); 202 } 203 /** 204 * Retrieves the Modifiers child. 205 * @return The current node used as the Modifiers child. 206 * @apilevel high-level 207 */ 208 @ASTNodeAnnotation.Child(name="Modifiers") 209 public Modifiers getModifiers() { 210 return (Modifiers) getChild(0); 211 } 212 /** 213 * Retrieves the Modifiers child. 214 * <p><em>This method does not invoke AST transformations.</em></p> 215 * @return The current node used as the Modifiers child. 216 * @apilevel low-level 217 */ 218 public Modifiers getModifiersNoTransform() { 219 return (Modifiers) getChildNoTransform(0); 220 } 221 /** 222 * Replaces the lexeme ID. 223 * @param value The new value for the lexeme ID. 224 * @apilevel high-level 225 */ 226 public void setID(String value) { 227 tokenString_ID = value; 228 } 229 /** 230 * JastAdd-internal setter for lexeme ID using the Beaver parser. 231 * @param symbol Symbol containing the new value for the lexeme ID 232 * @apilevel internal 233 */ 234 public void setID(beaver.Symbol symbol) { 235 if (symbol.value != null && !(symbol.value instanceof String)) 236 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 237 tokenString_ID = (String)symbol.value; 238 IDstart = symbol.getStart(); 239 IDend = symbol.getEnd(); 240 } 241 /** 242 * Retrieves the value for the lexeme ID. 243 * @return The value for the lexeme ID. 244 * @apilevel high-level 245 */ 246 @ASTNodeAnnotation.Token(name="ID") 247 public String getID() { 248 return tokenString_ID != null ? tokenString_ID : ""; 249 } 250 /** 251 * Replaces the BodyDecl list. 252 * @param list The new list node to be used as the BodyDecl list. 253 * @apilevel high-level 254 */ 255 public void setBodyDeclList(List<BodyDecl> list) { 256 setChild(list, 1); 257 } 258 /** 259 * Retrieves the number of children in the BodyDecl list. 260 * @return Number of children in the BodyDecl list. 261 * @apilevel high-level 262 */ 263 public int getNumBodyDecl() { 264 return getBodyDeclList().getNumChild(); 265 } 266 /** 267 * Retrieves the number of children in the BodyDecl list. 268 * Calling this method will not trigger rewrites. 269 * @return Number of children in the BodyDecl list. 270 * @apilevel low-level 271 */ 272 public int getNumBodyDeclNoTransform() { 273 return getBodyDeclListNoTransform().getNumChildNoTransform(); 274 } 275 /** 276 * Retrieves the element at index {@code i} in the BodyDecl list. 277 * @param i Index of the element to return. 278 * @return The element at position {@code i} in the BodyDecl list. 279 * @apilevel high-level 280 */ 281 public BodyDecl getBodyDecl(int i) { 282 return (BodyDecl) getBodyDeclList().getChild(i); 283 } 284 /** 285 * Check whether the BodyDecl list has any children. 286 * @return {@code true} if it has at least one child, {@code false} otherwise. 287 * @apilevel high-level 288 */ 289 public boolean hasBodyDecl() { 290 return getBodyDeclList().getNumChild() != 0; 291 } 292 /** 293 * Append an element to the BodyDecl list. 294 * @param node The element to append to the BodyDecl list. 295 * @apilevel high-level 296 */ 297 public void addBodyDecl(BodyDecl node) { 298 List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList(); 299 list.addChild(node); 300 } 301 /** 302 * @apilevel low-level 303 */ 304 public void addBodyDeclNoTransform(BodyDecl node) { 305 List<BodyDecl> list = getBodyDeclListNoTransform(); 306 list.addChild(node); 307 } 308 /** 309 * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}. 310 * @param node The new node to replace the old list element. 311 * @param i The list index of the node to be replaced. 312 * @apilevel high-level 313 */ 314 public void setBodyDecl(BodyDecl node, int i) { 315 List<BodyDecl> list = getBodyDeclList(); 316 list.setChild(node, i); 317 } 318 /** 319 * Retrieves the BodyDecl list. 320 * @return The node representing the BodyDecl list. 321 * @apilevel high-level 322 */ 323 @ASTNodeAnnotation.ListChild(name="BodyDecl") 324 public List<BodyDecl> getBodyDeclList() { 325 List<BodyDecl> list = (List<BodyDecl>) getChild(1); 326 return list; 327 } 328 /** 329 * Retrieves the BodyDecl list. 330 * <p><em>This method does not invoke AST transformations.</em></p> 331 * @return The node representing the BodyDecl list. 332 * @apilevel low-level 333 */ 334 public List<BodyDecl> getBodyDeclListNoTransform() { 335 return (List<BodyDecl>) getChildNoTransform(1); 336 } 337 /** 338 * Retrieves the BodyDecl list. 339 * @return The node representing the BodyDecl list. 340 * @apilevel high-level 341 */ 342 public List<BodyDecl> getBodyDecls() { 343 return getBodyDeclList(); 344 } 345 /** 346 * Retrieves the BodyDecl list. 347 * <p><em>This method does not invoke AST transformations.</em></p> 348 * @return The node representing the BodyDecl list. 349 * @apilevel low-level 350 */ 351 public List<BodyDecl> getBodyDeclsNoTransform() { 352 return getBodyDeclListNoTransform(); 353 } 354 /** 355 * Replaces the Access child. 356 * @param node The new node to replace the Access child. 357 * @apilevel high-level 358 */ 359 public void setAccess(Access node) { 360 setChild(node, 2); 361 } 362 /** 363 * Retrieves the Access child. 364 * @return The current node used as the Access child. 365 * @apilevel high-level 366 */ 367 @ASTNodeAnnotation.Child(name="Access") 368 public Access getAccess() { 369 return (Access) getChild(2); 370 } 371 /** 372 * Retrieves the Access child. 373 * <p><em>This method does not invoke AST transformations.</em></p> 374 * @return The current node used as the Access child. 375 * @apilevel low-level 376 */ 377 public Access getAccessNoTransform() { 378 return (Access) getChildNoTransform(2); 379 } 380 /** 381 * @param bound the bounded type variable 382 * @param par a parameterization of the type for which the type variable 383 * occurs in the type parameter list 384 * @return {@code true} if this type is within the bounds of the parameter type 385 * @attribute syn 386 * @aspect GenericBoundCheck 387 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericBoundCheck.jrag:42 388 */ 389 @ASTNodeAnnotation.Attribute 390 public boolean withinBounds(TypeDecl bound, Parameterization par) { 391 boolean withinBounds_TypeDecl_Parameterization_value = bound.boundOf(extendsType(), par) || extendsType().boundOf(bound, par); 392 393 return withinBounds_TypeDecl_Parameterization_value; 394 } 395 /** 396 * @apilevel internal 397 */ 398 protected int involvesTypeParameters_visited = -1; 399 /** 400 * @apilevel internal 401 */ 402 private void involvesTypeParameters_reset() { 403 involvesTypeParameters_computed = false; 404 involvesTypeParameters_initialized = false; 405 involvesTypeParameters_visited = -1; 406 } 407 /** 408 * @apilevel internal 409 */ 410 protected boolean involvesTypeParameters_computed = false; 411 /** 412 * @apilevel internal 413 */ 414 protected boolean involvesTypeParameters_initialized = false; 415 /** 416 * @apilevel internal 417 */ 418 protected boolean involvesTypeParameters_value; 419 @ASTNodeAnnotation.Attribute 420 public boolean involvesTypeParameters() { 421 if (involvesTypeParameters_computed) { 422 return involvesTypeParameters_value; 423 } 424 ASTNode$State state = state(); 425 boolean new_involvesTypeParameters_value; 426 if (!involvesTypeParameters_initialized) { 427 involvesTypeParameters_initialized = true; 428 involvesTypeParameters_value = false; 429 } 430 if (!state.IN_CIRCLE) { 431 state.IN_CIRCLE = true; 432 int num = state.boundariesCrossed; 433 boolean isFinal = this.is$Final(); 434 do { 435 involvesTypeParameters_visited = state.CIRCLE_INDEX; 436 state.CHANGE = false; 437 new_involvesTypeParameters_value = extendsType().involvesTypeParameters(); 438 if (new_involvesTypeParameters_value != involvesTypeParameters_value) { 439 state.CHANGE = true; 440 } 441 involvesTypeParameters_value = new_involvesTypeParameters_value; 442 state.CIRCLE_INDEX++; 443 } while (state.CHANGE); 444 if (isFinal && num == state().boundariesCrossed) { 445 involvesTypeParameters_computed = true; 446 } else { 447 state.RESET_CYCLE = true; 448 boolean $tmp = extendsType().involvesTypeParameters(); 449 state.RESET_CYCLE = false; 450 involvesTypeParameters_computed = false; 451 involvesTypeParameters_initialized = false; 452 } 453 state.IN_CIRCLE = false; 454 state.INTERMEDIATE_VALUE = false; 455 return involvesTypeParameters_value; 456 } 457 if (involvesTypeParameters_visited != state.CIRCLE_INDEX) { 458 involvesTypeParameters_visited = state.CIRCLE_INDEX; 459 if (state.RESET_CYCLE) { 460 involvesTypeParameters_computed = false; 461 involvesTypeParameters_initialized = false; 462 involvesTypeParameters_visited = -1; 463 return involvesTypeParameters_value; 464 } 465 new_involvesTypeParameters_value = extendsType().involvesTypeParameters(); 466 if (new_involvesTypeParameters_value != involvesTypeParameters_value) { 467 state.CHANGE = true; 468 } 469 involvesTypeParameters_value = new_involvesTypeParameters_value; 470 state.INTERMEDIATE_VALUE = true; 471 return involvesTypeParameters_value; 472 } 473 state.INTERMEDIATE_VALUE = true; 474 return involvesTypeParameters_value; 475 } 476 /** 477 * @attribute syn 478 * @aspect LookupParTypeDecl 479 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:806 480 */ 481 @ASTNodeAnnotation.Attribute 482 public boolean sameSignature(Access a) { 483 { 484 if (a instanceof WildcardExtends) { 485 return getAccess().type().sameSignature(((WildcardExtends) a).getAccess()); 486 } 487 return super.sameSignature(a); 488 } 489 } 490 /** 491 * @apilevel internal 492 */ 493 protected int usesTypeVariable_visited = -1; 494 /** 495 * @apilevel internal 496 */ 497 private void usesTypeVariable_reset() { 498 usesTypeVariable_computed = false; 499 usesTypeVariable_initialized = false; 500 usesTypeVariable_visited = -1; 501 } 502 /** 503 * @apilevel internal 504 */ 505 protected boolean usesTypeVariable_computed = false; 506 /** 507 * @apilevel internal 508 */ 509 protected boolean usesTypeVariable_initialized = false; 510 /** 511 * @apilevel internal 512 */ 513 protected boolean usesTypeVariable_value; 514 @ASTNodeAnnotation.Attribute 515 public boolean usesTypeVariable() { 516 if (usesTypeVariable_computed) { 517 return usesTypeVariable_value; 518 } 519 ASTNode$State state = state(); 520 boolean new_usesTypeVariable_value; 521 if (!usesTypeVariable_initialized) { 522 usesTypeVariable_initialized = true; 523 usesTypeVariable_value = false; 524 } 525 if (!state.IN_CIRCLE) { 526 state.IN_CIRCLE = true; 527 int num = state.boundariesCrossed; 528 boolean isFinal = this.is$Final(); 529 do { 530 usesTypeVariable_visited = state.CIRCLE_INDEX; 531 state.CHANGE = false; 532 new_usesTypeVariable_value = getAccess().type().usesTypeVariable(); 533 if (new_usesTypeVariable_value != usesTypeVariable_value) { 534 state.CHANGE = true; 535 } 536 usesTypeVariable_value = new_usesTypeVariable_value; 537 state.CIRCLE_INDEX++; 538 } while (state.CHANGE); 539 if (isFinal && num == state().boundariesCrossed) { 540 usesTypeVariable_computed = true; 541 } else { 542 state.RESET_CYCLE = true; 543 boolean $tmp = getAccess().type().usesTypeVariable(); 544 state.RESET_CYCLE = false; 545 usesTypeVariable_computed = false; 546 usesTypeVariable_initialized = false; 547 } 548 state.IN_CIRCLE = false; 549 state.INTERMEDIATE_VALUE = false; 550 return usesTypeVariable_value; 551 } 552 if (usesTypeVariable_visited != state.CIRCLE_INDEX) { 553 usesTypeVariable_visited = state.CIRCLE_INDEX; 554 if (state.RESET_CYCLE) { 555 usesTypeVariable_computed = false; 556 usesTypeVariable_initialized = false; 557 usesTypeVariable_visited = -1; 558 return usesTypeVariable_value; 559 } 560 new_usesTypeVariable_value = getAccess().type().usesTypeVariable(); 561 if (new_usesTypeVariable_value != usesTypeVariable_value) { 562 state.CHANGE = true; 563 } 564 usesTypeVariable_value = new_usesTypeVariable_value; 565 state.INTERMEDIATE_VALUE = true; 566 return usesTypeVariable_value; 567 } 568 state.INTERMEDIATE_VALUE = true; 569 return usesTypeVariable_value; 570 } 571 /** 572 * @attribute syn 573 * @aspect LookupParTypeDecl 574 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1472 575 */ 576 @ASTNodeAnnotation.Attribute 577 public TypeDecl extendsType() { 578 TypeDecl extendsType_value = getAccess().type(); 579 580 return extendsType_value; 581 } 582 /** 583 * @attribute syn 584 * @aspect GenericsSubtype 585 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:66 586 */ 587 @ASTNodeAnnotation.Attribute 588 public boolean supertypeWildcard(WildcardType type) { 589 boolean supertypeWildcard_WildcardType_value = typeObject().subtype(this); 590 591 return supertypeWildcard_WildcardType_value; 592 } 593 /** 594 * @apilevel internal 595 */ 596 private void subtype_TypeDecl_reset() { 597 subtype_TypeDecl_values = null; 598 } 599 protected java.util.Map subtype_TypeDecl_values; 600 @ASTNodeAnnotation.Attribute 601 public boolean subtype(TypeDecl type) { 602 Object _parameters = type; 603 if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 604 ASTNode$State.CircularValue _value; 605 if (subtype_TypeDecl_values.containsKey(_parameters)) { 606 Object _o = subtype_TypeDecl_values.get(_parameters); 607 if (!(_o instanceof ASTNode$State.CircularValue)) { 608 return (Boolean) _o; 609 } else { 610 _value = (ASTNode$State.CircularValue) _o; 611 } 612 } else { 613 _value = new ASTNode$State.CircularValue(); 614 subtype_TypeDecl_values.put(_parameters, _value); 615 _value.value = true; 616 } 617 ASTNode$State state = state(); 618 boolean new_subtype_TypeDecl_value; 619 if (!state.IN_CIRCLE) { 620 state.IN_CIRCLE = true; 621 int num = state.boundariesCrossed; 622 boolean isFinal = this.is$Final(); 623 // TODO: fixme 624 // state().CIRCLE_INDEX = 1; 625 do { 626 _value.visited = state.CIRCLE_INDEX; 627 state.CHANGE = false; 628 new_subtype_TypeDecl_value = type.supertypeWildcardExtends(this); 629 if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 630 state.CHANGE = true; 631 _value.value = new_subtype_TypeDecl_value; 632 } 633 state.CIRCLE_INDEX++; 634 } while (state.CHANGE); 635 if (isFinal && num == state().boundariesCrossed) { 636 subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value); 637 } else { 638 subtype_TypeDecl_values.remove(_parameters); 639 state.RESET_CYCLE = true; 640 boolean $tmp = type.supertypeWildcardExtends(this); 641 state.RESET_CYCLE = false; 642 } 643 state.IN_CIRCLE = false; 644 state.INTERMEDIATE_VALUE = false; 645 return new_subtype_TypeDecl_value; 646 } 647 if (state.CIRCLE_INDEX != _value.visited) { 648 _value.visited = state.CIRCLE_INDEX; 649 new_subtype_TypeDecl_value = type.supertypeWildcardExtends(this); 650 if (state.RESET_CYCLE) { 651 subtype_TypeDecl_values.remove(_parameters); 652 } 653 else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 654 state.CHANGE = true; 655 _value.value = new_subtype_TypeDecl_value; 656 } 657 state.INTERMEDIATE_VALUE = true; 658 return new_subtype_TypeDecl_value; 659 } 660 state.INTERMEDIATE_VALUE = true; 661 return (Boolean) _value.value; 662 } 663 /** 664 * @attribute syn 665 * @aspect GenericsSubtype 666 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:73 667 */ 668 @ASTNodeAnnotation.Attribute 669 public boolean supertypeWildcardExtends(WildcardExtendsType type) { 670 boolean supertypeWildcardExtends_WildcardExtendsType_value = type.extendsType().subtype(extendsType()); 671 672 return supertypeWildcardExtends_WildcardExtendsType_value; 673 } 674 /** 675 * @attribute syn 676 * @aspect GenericsSubtype 677 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:448 678 */ 679 @ASTNodeAnnotation.Attribute 680 public boolean supertypeClassDecl(ClassDecl type) { 681 boolean supertypeClassDecl_ClassDecl_value = type.subtype(extendsType()); 682 683 return supertypeClassDecl_ClassDecl_value; 684 } 685 /** 686 * @attribute syn 687 * @aspect GenericsSubtype 688 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:465 689 */ 690 @ASTNodeAnnotation.Attribute 691 public boolean supertypeInterfaceDecl(InterfaceDecl type) { 692 boolean supertypeInterfaceDecl_InterfaceDecl_value = type.subtype(extendsType()); 693 694 return supertypeInterfaceDecl_InterfaceDecl_value; 695 } 696 /** 697 * @attribute syn 698 * @aspect GenericsSubtype 699 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:134 700 */ 701 @ASTNodeAnnotation.Attribute 702 public boolean supertypeParClassDecl(ParClassDecl type) { 703 boolean supertypeParClassDecl_ParClassDecl_value = type.subtype(extendsType()); 704 705 return supertypeParClassDecl_ParClassDecl_value; 706 } 707 /** 708 * @attribute syn 709 * @aspect GenericsSubtype 710 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:137 711 */ 712 @ASTNodeAnnotation.Attribute 713 public boolean supertypeParInterfaceDecl(ParInterfaceDecl type) { 714 boolean supertypeParInterfaceDecl_ParInterfaceDecl_value = type.subtype(extendsType()); 715 716 return supertypeParInterfaceDecl_ParInterfaceDecl_value; 717 } 718 /** 719 * @attribute syn 720 * @aspect GenericsSubtype 721 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:46 722 */ 723 @ASTNodeAnnotation.Attribute 724 public boolean supertypeRawClassDecl(RawClassDecl type) { 725 boolean supertypeRawClassDecl_RawClassDecl_value = type.subtype(extendsType()); 726 727 return supertypeRawClassDecl_RawClassDecl_value; 728 } 729 /** 730 * @attribute syn 731 * @aspect GenericsSubtype 732 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:50 733 */ 734 @ASTNodeAnnotation.Attribute 735 public boolean supertypeRawInterfaceDecl(RawInterfaceDecl type) { 736 boolean supertypeRawInterfaceDecl_RawInterfaceDecl_value = type.subtype(extendsType()); 737 738 return supertypeRawInterfaceDecl_RawInterfaceDecl_value; 739 } 740 /** 741 * @attribute syn 742 * @aspect GenericsSubtype 743 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:321 744 */ 745 @ASTNodeAnnotation.Attribute 746 public boolean supertypeTypeVariable(TypeVariable type) { 747 boolean supertypeTypeVariable_TypeVariable_value = type.subtype(extendsType()); 748 749 return supertypeTypeVariable_TypeVariable_value; 750 } 751 /** 752 * @attribute syn 753 * @aspect GenericsSubtype 754 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:480 755 */ 756 @ASTNodeAnnotation.Attribute 757 public boolean supertypeArrayDecl(ArrayDecl type) { 758 boolean supertypeArrayDecl_ArrayDecl_value = type.subtype(extendsType()); 759 760 return supertypeArrayDecl_ArrayDecl_value; 761 } 762 /** 763 * @apilevel internal 764 */ 765 private void containedIn_TypeDecl_reset() { 766 containedIn_TypeDecl_values = null; 767 } 768 protected java.util.Map containedIn_TypeDecl_values; 769 @ASTNodeAnnotation.Attribute 770 public boolean containedIn(TypeDecl type) { 771 Object _parameters = type; 772 if (containedIn_TypeDecl_values == null) containedIn_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 773 ASTNode$State.CircularValue _value; 774 if (containedIn_TypeDecl_values.containsKey(_parameters)) { 775 Object _o = containedIn_TypeDecl_values.get(_parameters); 776 if (!(_o instanceof ASTNode$State.CircularValue)) { 777 return (Boolean) _o; 778 } else { 779 _value = (ASTNode$State.CircularValue) _o; 780 } 781 } else { 782 _value = new ASTNode$State.CircularValue(); 783 containedIn_TypeDecl_values.put(_parameters, _value); 784 _value.value = true; 785 } 786 ASTNode$State state = state(); 787 boolean new_containedIn_TypeDecl_value; 788 if (!state.IN_CIRCLE) { 789 state.IN_CIRCLE = true; 790 int num = state.boundariesCrossed; 791 boolean isFinal = this.is$Final(); 792 // TODO: fixme 793 // state().CIRCLE_INDEX = 1; 794 do { 795 _value.visited = state.CIRCLE_INDEX; 796 state.CHANGE = false; 797 new_containedIn_TypeDecl_value = containedIn_compute(type); 798 if (new_containedIn_TypeDecl_value != ((Boolean)_value.value)) { 799 state.CHANGE = true; 800 _value.value = new_containedIn_TypeDecl_value; 801 } 802 state.CIRCLE_INDEX++; 803 } while (state.CHANGE); 804 if (isFinal && num == state().boundariesCrossed) { 805 containedIn_TypeDecl_values.put(_parameters, new_containedIn_TypeDecl_value); 806 } else { 807 containedIn_TypeDecl_values.remove(_parameters); 808 state.RESET_CYCLE = true; 809 boolean $tmp = containedIn_compute(type); 810 state.RESET_CYCLE = false; 811 } 812 state.IN_CIRCLE = false; 813 state.INTERMEDIATE_VALUE = false; 814 return new_containedIn_TypeDecl_value; 815 } 816 if (state.CIRCLE_INDEX != _value.visited) { 817 _value.visited = state.CIRCLE_INDEX; 818 new_containedIn_TypeDecl_value = containedIn_compute(type); 819 if (state.RESET_CYCLE) { 820 containedIn_TypeDecl_values.remove(_parameters); 821 } 822 else if (new_containedIn_TypeDecl_value != ((Boolean)_value.value)) { 823 state.CHANGE = true; 824 _value.value = new_containedIn_TypeDecl_value; 825 } 826 state.INTERMEDIATE_VALUE = true; 827 return new_containedIn_TypeDecl_value; 828 } 829 state.INTERMEDIATE_VALUE = true; 830 return (Boolean) _value.value; 831 } 832 /** 833 * @apilevel internal 834 */ 835 private boolean containedIn_compute(TypeDecl type) { 836 if (type == this || type instanceof WildcardType) { 837 return true; 838 } else if (type instanceof WildcardExtendsType) { 839 return extendsType().subtype(((WildcardExtendsType) type).extendsType()); 840 } else { 841 return false; 842 } 843 } 844 /** 845 * @apilevel internal 846 */ 847 private void sameStructure_TypeDecl_reset() { 848 sameStructure_TypeDecl_values = null; 849 } 850 protected java.util.Map sameStructure_TypeDecl_values; 851 @ASTNodeAnnotation.Attribute 852 public boolean sameStructure(TypeDecl t) { 853 Object _parameters = t; 854 if (sameStructure_TypeDecl_values == null) sameStructure_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 855 ASTNode$State.CircularValue _value; 856 if (sameStructure_TypeDecl_values.containsKey(_parameters)) { 857 Object _o = sameStructure_TypeDecl_values.get(_parameters); 858 if (!(_o instanceof ASTNode$State.CircularValue)) { 859 return (Boolean) _o; 860 } else { 861 _value = (ASTNode$State.CircularValue) _o; 862 } 863 } else { 864 _value = new ASTNode$State.CircularValue(); 865 sameStructure_TypeDecl_values.put(_parameters, _value); 866 _value.value = true; 867 } 868 ASTNode$State state = state(); 869 boolean new_sameStructure_TypeDecl_value; 870 if (!state.IN_CIRCLE) { 871 state.IN_CIRCLE = true; 872 int num = state.boundariesCrossed; 873 boolean isFinal = this.is$Final(); 874 // TODO: fixme 875 // state().CIRCLE_INDEX = 1; 876 do { 877 _value.visited = state.CIRCLE_INDEX; 878 state.CHANGE = false; 879 new_sameStructure_TypeDecl_value = super.sameStructure(t) || t instanceof WildcardExtendsType 880 && ((WildcardExtendsType) t).extendsType().sameStructure(extendsType()); 881 if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) { 882 state.CHANGE = true; 883 _value.value = new_sameStructure_TypeDecl_value; 884 } 885 state.CIRCLE_INDEX++; 886 } while (state.CHANGE); 887 if (isFinal && num == state().boundariesCrossed) { 888 sameStructure_TypeDecl_values.put(_parameters, new_sameStructure_TypeDecl_value); 889 } else { 890 sameStructure_TypeDecl_values.remove(_parameters); 891 state.RESET_CYCLE = true; 892 boolean $tmp = super.sameStructure(t) || t instanceof WildcardExtendsType 893 && ((WildcardExtendsType) t).extendsType().sameStructure(extendsType()); 894 state.RESET_CYCLE = false; 895 } 896 state.IN_CIRCLE = false; 897 state.INTERMEDIATE_VALUE = false; 898 return new_sameStructure_TypeDecl_value; 899 } 900 if (state.CIRCLE_INDEX != _value.visited) { 901 _value.visited = state.CIRCLE_INDEX; 902 new_sameStructure_TypeDecl_value = super.sameStructure(t) || t instanceof WildcardExtendsType 903 && ((WildcardExtendsType) t).extendsType().sameStructure(extendsType()); 904 if (state.RESET_CYCLE) { 905 sameStructure_TypeDecl_values.remove(_parameters); 906 } 907 else if (new_sameStructure_TypeDecl_value != ((Boolean)_value.value)) { 908 state.CHANGE = true; 909 _value.value = new_sameStructure_TypeDecl_value; 910 } 911 state.INTERMEDIATE_VALUE = true; 912 return new_sameStructure_TypeDecl_value; 913 } 914 state.INTERMEDIATE_VALUE = true; 915 return (Boolean) _value.value; 916 } 917 /** 918 * @apilevel internal 919 */ 920 protected java.util.Map instanceOf_TypeDecl_values; 921 /** 922 * @apilevel internal 923 */ 924 private void instanceOf_TypeDecl_reset() { 925 instanceOf_TypeDecl_values = null; 926 } 927 /** 928 * @attribute syn 929 * @aspect TypeWideningAndIdentity 930 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442 931 */ 932 @ASTNodeAnnotation.Attribute 933 public boolean instanceOf(TypeDecl type) { 934 Object _parameters = type; 935 if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 936 ASTNode$State state = state(); 937 if (instanceOf_TypeDecl_values.containsKey(_parameters)) { 938 return (Boolean) instanceOf_TypeDecl_values.get(_parameters); 939 } 940 boolean intermediate = state.INTERMEDIATE_VALUE; 941 state.INTERMEDIATE_VALUE = false; 942 int num = state.boundariesCrossed; 943 boolean isFinal = this.is$Final(); 944 boolean instanceOf_TypeDecl_value = subtype(type); 945 if (isFinal && num == state().boundariesCrossed) { 946 instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value); 947 } else { 948 } 949 state.INTERMEDIATE_VALUE |= intermediate; 950 951 return instanceOf_TypeDecl_value; 952 } 953 /** 954 * @apilevel internal 955 */ 956 protected boolean fieldTypeSignature_computed = false; 957 /** 958 * @apilevel internal 959 */ 960 protected String fieldTypeSignature_value; 961 /** 962 * @apilevel internal 963 */ 964 private void fieldTypeSignature_reset() { 965 fieldTypeSignature_computed = false; 966 fieldTypeSignature_value = null; 967 } 968 /** 969 * @attribute syn 970 * @aspect GenericsCodegen 971 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:467 972 */ 973 @ASTNodeAnnotation.Attribute 974 public String fieldTypeSignature() { 975 ASTNode$State state = state(); 976 if (fieldTypeSignature_computed) { 977 return fieldTypeSignature_value; 978 } 979 boolean intermediate = state.INTERMEDIATE_VALUE; 980 state.INTERMEDIATE_VALUE = false; 981 int num = state.boundariesCrossed; 982 boolean isFinal = this.is$Final(); 983 fieldTypeSignature_value = "+" + extendsType().fieldTypeSignature(); 984 if (isFinal && num == state().boundariesCrossed) { 985 fieldTypeSignature_computed = true; 986 } else { 987 } 988 state.INTERMEDIATE_VALUE |= intermediate; 989 990 return fieldTypeSignature_value; 991 } 992 /** 993 * @attribute syn 994 * @aspect StrictSubtype 995 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:68 996 */ 997 @ASTNodeAnnotation.Attribute 998 public boolean strictSupertypeWildcard(WildcardType type) { 999 boolean strictSupertypeWildcard_WildcardType_value = typeObject().strictSubtype(this); 1000 1001 return strictSupertypeWildcard_WildcardType_value; 1002 } 1003 /** 1004 * @apilevel internal 1005 */ 1006 private void strictSubtype_TypeDecl_reset() { 1007 strictSubtype_TypeDecl_values = null; 1008 } 1009 protected java.util.Map strictSubtype_TypeDecl_values; 1010 @ASTNodeAnnotation.Attribute 1011 public boolean strictSubtype(TypeDecl type) { 1012 Object _parameters = type; 1013 if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1014 ASTNode$State.CircularValue _value; 1015 if (strictSubtype_TypeDecl_values.containsKey(_parameters)) { 1016 Object _o = strictSubtype_TypeDecl_values.get(_parameters); 1017 if (!(_o instanceof ASTNode$State.CircularValue)) { 1018 return (Boolean) _o; 1019 } else { 1020 _value = (ASTNode$State.CircularValue) _o; 1021 } 1022 } else { 1023 _value = new ASTNode$State.CircularValue(); 1024 strictSubtype_TypeDecl_values.put(_parameters, _value); 1025 _value.value = true; 1026 } 1027 ASTNode$State state = state(); 1028 boolean new_strictSubtype_TypeDecl_value; 1029 if (!state.IN_CIRCLE) { 1030 state.IN_CIRCLE = true; 1031 int num = state.boundariesCrossed; 1032 boolean isFinal = this.is$Final(); 1033 // TODO: fixme 1034 // state().CIRCLE_INDEX = 1; 1035 do { 1036 _value.visited = state.CIRCLE_INDEX; 1037 state.CHANGE = false; 1038 new_strictSubtype_TypeDecl_value = type.strictSupertypeWildcardExtends(this); 1039 if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 1040 state.CHANGE = true; 1041 _value.value = new_strictSubtype_TypeDecl_value; 1042 } 1043 state.CIRCLE_INDEX++; 1044 } while (state.CHANGE); 1045 if (isFinal && num == state().boundariesCrossed) { 1046 strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value); 1047 } else { 1048 strictSubtype_TypeDecl_values.remove(_parameters); 1049 state.RESET_CYCLE = true; 1050 boolean $tmp = type.strictSupertypeWildcardExtends(this); 1051 state.RESET_CYCLE = false; 1052 } 1053 state.IN_CIRCLE = false; 1054 state.INTERMEDIATE_VALUE = false; 1055 return new_strictSubtype_TypeDecl_value; 1056 } 1057 if (state.CIRCLE_INDEX != _value.visited) { 1058 _value.visited = state.CIRCLE_INDEX; 1059 new_strictSubtype_TypeDecl_value = type.strictSupertypeWildcardExtends(this); 1060 if (state.RESET_CYCLE) { 1061 strictSubtype_TypeDecl_values.remove(_parameters); 1062 } 1063 else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 1064 state.CHANGE = true; 1065 _value.value = new_strictSubtype_TypeDecl_value; 1066 } 1067 state.INTERMEDIATE_VALUE = true; 1068 return new_strictSubtype_TypeDecl_value; 1069 } 1070 state.INTERMEDIATE_VALUE = true; 1071 return (Boolean) _value.value; 1072 } 1073 /** 1074 * @attribute syn 1075 * @aspect StrictSubtype 1076 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:77 1077 */ 1078 @ASTNodeAnnotation.Attribute 1079 public boolean strictSupertypeWildcardExtends(WildcardExtendsType type) { 1080 boolean strictSupertypeWildcardExtends_WildcardExtendsType_value = type.extendsType().strictSubtype(extendsType()); 1081 1082 return strictSupertypeWildcardExtends_WildcardExtendsType_value; 1083 } 1084 /** 1085 * @attribute syn 1086 * @aspect StrictSubtype 1087 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:370 1088 */ 1089 @ASTNodeAnnotation.Attribute 1090 public boolean strictSupertypeClassDecl(ClassDecl type) { 1091 boolean strictSupertypeClassDecl_ClassDecl_value = type.strictSubtype(extendsType()); 1092 1093 return strictSupertypeClassDecl_ClassDecl_value; 1094 } 1095 /** 1096 * @attribute syn 1097 * @aspect StrictSubtype 1098 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:390 1099 */ 1100 @ASTNodeAnnotation.Attribute 1101 public boolean strictSupertypeInterfaceDecl(InterfaceDecl type) { 1102 boolean strictSupertypeInterfaceDecl_InterfaceDecl_value = type.strictSubtype(extendsType()); 1103 1104 return strictSupertypeInterfaceDecl_InterfaceDecl_value; 1105 } 1106 /** 1107 * @attribute syn 1108 * @aspect StrictSubtype 1109 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:155 1110 */ 1111 @ASTNodeAnnotation.Attribute 1112 public boolean strictSupertypeParClassDecl(ParClassDecl type) { 1113 boolean strictSupertypeParClassDecl_ParClassDecl_value = type.strictSubtype(extendsType()); 1114 1115 return strictSupertypeParClassDecl_ParClassDecl_value; 1116 } 1117 /** 1118 * @attribute syn 1119 * @aspect StrictSubtype 1120 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:159 1121 */ 1122 @ASTNodeAnnotation.Attribute 1123 public boolean strictSupertypeParInterfaceDecl(ParInterfaceDecl type) { 1124 boolean strictSupertypeParInterfaceDecl_ParInterfaceDecl_value = type.strictSubtype(extendsType()); 1125 1126 return strictSupertypeParInterfaceDecl_ParInterfaceDecl_value; 1127 } 1128 /** 1129 * @attribute syn 1130 * @aspect StrictSubtype 1131 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:52 1132 */ 1133 @ASTNodeAnnotation.Attribute 1134 public boolean strictSupertypeRawClassDecl(RawClassDecl type) { 1135 boolean strictSupertypeRawClassDecl_RawClassDecl_value = type.strictSubtype(extendsType()); 1136 1137 return strictSupertypeRawClassDecl_RawClassDecl_value; 1138 } 1139 /** 1140 * @attribute syn 1141 * @aspect StrictSubtype 1142 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:56 1143 */ 1144 @ASTNodeAnnotation.Attribute 1145 public boolean strictSupertypeRawInterfaceDecl(RawInterfaceDecl type) { 1146 boolean strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value = type.strictSubtype(extendsType()); 1147 1148 return strictSupertypeRawInterfaceDecl_RawInterfaceDecl_value; 1149 } 1150 /** 1151 * @attribute syn 1152 * @aspect StrictSubtype 1153 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:276 1154 */ 1155 @ASTNodeAnnotation.Attribute 1156 public boolean strictSupertypeTypeVariable(TypeVariable type) { 1157 boolean strictSupertypeTypeVariable_TypeVariable_value = type.strictSubtype(extendsType()); 1158 1159 return strictSupertypeTypeVariable_TypeVariable_value; 1160 } 1161 /** 1162 * @attribute syn 1163 * @aspect StrictSubtype 1164 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:407 1165 */ 1166 @ASTNodeAnnotation.Attribute 1167 public boolean strictSupertypeArrayDecl(ArrayDecl type) { 1168 boolean strictSupertypeArrayDecl_ArrayDecl_value = type.strictSubtype(extendsType()); 1169 1170 return strictSupertypeArrayDecl_ArrayDecl_value; 1171 } 1172 /** 1173 * @apilevel internal 1174 */ 1175 private void strictContainedIn_TypeDecl_reset() { 1176 strictContainedIn_TypeDecl_values = null; 1177 } 1178 protected java.util.Map strictContainedIn_TypeDecl_values; 1179 @ASTNodeAnnotation.Attribute 1180 public boolean strictContainedIn(TypeDecl type) { 1181 Object _parameters = type; 1182 if (strictContainedIn_TypeDecl_values == null) strictContainedIn_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 1183 ASTNode$State.CircularValue _value; 1184 if (strictContainedIn_TypeDecl_values.containsKey(_parameters)) { 1185 Object _o = strictContainedIn_TypeDecl_values.get(_parameters); 1186 if (!(_o instanceof ASTNode$State.CircularValue)) { 1187 return (Boolean) _o; 1188 } else { 1189 _value = (ASTNode$State.CircularValue) _o; 1190 } 1191 } else { 1192 _value = new ASTNode$State.CircularValue(); 1193 strictContainedIn_TypeDecl_values.put(_parameters, _value); 1194 _value.value = true; 1195 } 1196 ASTNode$State state = state(); 1197 boolean new_strictContainedIn_TypeDecl_value; 1198 if (!state.IN_CIRCLE) { 1199 state.IN_CIRCLE = true; 1200 int num = state.boundariesCrossed; 1201 boolean isFinal = this.is$Final(); 1202 // TODO: fixme 1203 // state().CIRCLE_INDEX = 1; 1204 do { 1205 _value.visited = state.CIRCLE_INDEX; 1206 state.CHANGE = false; 1207 new_strictContainedIn_TypeDecl_value = strictContainedIn_compute(type); 1208 if (new_strictContainedIn_TypeDecl_value != ((Boolean)_value.value)) { 1209 state.CHANGE = true; 1210 _value.value = new_strictContainedIn_TypeDecl_value; 1211 } 1212 state.CIRCLE_INDEX++; 1213 } while (state.CHANGE); 1214 if (isFinal && num == state().boundariesCrossed) { 1215 strictContainedIn_TypeDecl_values.put(_parameters, new_strictContainedIn_TypeDecl_value); 1216 } else { 1217 strictContainedIn_TypeDecl_values.remove(_parameters); 1218 state.RESET_CYCLE = true; 1219 boolean $tmp = strictContainedIn_compute(type); 1220 state.RESET_CYCLE = false; 1221 } 1222 state.IN_CIRCLE = false; 1223 state.INTERMEDIATE_VALUE = false; 1224 return new_strictContainedIn_TypeDecl_value; 1225 } 1226 if (state.CIRCLE_INDEX != _value.visited) { 1227 _value.visited = state.CIRCLE_INDEX; 1228 new_strictContainedIn_TypeDecl_value = strictContainedIn_compute(type); 1229 if (state.RESET_CYCLE) { 1230 strictContainedIn_TypeDecl_values.remove(_parameters); 1231 } 1232 else if (new_strictContainedIn_TypeDecl_value != ((Boolean)_value.value)) { 1233 state.CHANGE = true; 1234 _value.value = new_strictContainedIn_TypeDecl_value; 1235 } 1236 state.INTERMEDIATE_VALUE = true; 1237 return new_strictContainedIn_TypeDecl_value; 1238 } 1239 state.INTERMEDIATE_VALUE = true; 1240 return (Boolean) _value.value; 1241 } 1242 /** 1243 * @apilevel internal 1244 */ 1245 private boolean strictContainedIn_compute(TypeDecl type) { 1246 if (type == this || type instanceof WildcardType) { 1247 return true; 1248 } else if (type instanceof WildcardExtendsType) { 1249 return extendsType().strictSubtype(((WildcardExtendsType) type).extendsType()); 1250 } else { 1251 return false; 1252 } 1253 } 1254 /** 1255 * @apilevel internal 1256 */ 1257 public ASTNode rewriteTo() { 1258 return super.rewriteTo(); 1259 } 1260 }