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/java4/grammar/Java.ast:45 027 * @production VoidType : {@link TypeDecl}; 028 029 */ 030 public class VoidType extends TypeDecl implements Cloneable { 031 /** 032 * @aspect Java4PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:607 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print("void"); 037 } 038 /** 039 * @aspect CodeGeneration 040 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:241 041 */ 042 public void emitReturn(CodeGeneration gen) { gen.emit(Bytecode.RETURN);} 043 /** 044 * @aspect CodeGeneration 045 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:482 046 */ 047 public void emitDup(CodeGeneration gen) { } 048 /** 049 * @aspect CodeGeneration 050 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:487 051 */ 052 public void emitDup_x1(CodeGeneration gen) { } 053 /** 054 * @aspect CodeGeneration 055 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:492 056 */ 057 public void emitDup_x2(CodeGeneration gen) { } 058 /** 059 * @aspect CodeGeneration 060 * @declaredat /home/jesper/git/extendj/java4/backend/CodeGeneration.jrag:497 061 */ 062 public void emitPop(CodeGeneration gen) { } 063 /** 064 * @declaredat ASTNode:1 065 */ 066 public VoidType() { 067 super(); 068 } 069 /** 070 * Initializes the child array to the correct size. 071 * Initializes List and Opt nta children. 072 * @apilevel internal 073 * @ast method 074 * @declaredat ASTNode:10 075 */ 076 public void init$Children() { 077 children = new ASTNode[2]; 078 setChild(new List(), 1); 079 } 080 /** 081 * @declaredat ASTNode:14 082 */ 083 public VoidType(Modifiers p0, String p1, List<BodyDecl> p2) { 084 setChild(p0, 0); 085 setID(p1); 086 setChild(p2, 1); 087 } 088 /** 089 * @declaredat ASTNode:19 090 */ 091 public VoidType(Modifiers p0, beaver.Symbol p1, List<BodyDecl> p2) { 092 setChild(p0, 0); 093 setID(p1); 094 setChild(p2, 1); 095 } 096 /** 097 * @apilevel low-level 098 * @declaredat ASTNode:27 099 */ 100 protected int numChildren() { 101 return 2; 102 } 103 /** 104 * @apilevel internal 105 * @declaredat ASTNode:33 106 */ 107 public boolean mayHaveRewrite() { 108 return false; 109 } 110 /** 111 * @apilevel internal 112 * @declaredat ASTNode:39 113 */ 114 public void flushAttrCache() { 115 super.flushAttrCache(); 116 instanceOf_TypeDecl_reset(); 117 typeDescriptor_reset(); 118 subtype_TypeDecl_reset(); 119 fieldTypeSignature_reset(); 120 classTypeSignature_reset(); 121 strictSubtype_TypeDecl_reset(); 122 } 123 /** 124 * @apilevel internal 125 * @declaredat ASTNode:51 126 */ 127 public void flushCollectionCache() { 128 super.flushCollectionCache(); 129 } 130 /** 131 * @apilevel internal 132 * @declaredat ASTNode:57 133 */ 134 public void flushRewriteCache() { 135 super.flushRewriteCache(); 136 } 137 /** 138 * @apilevel internal 139 * @declaredat ASTNode:63 140 */ 141 public VoidType clone() throws CloneNotSupportedException { 142 VoidType node = (VoidType) super.clone(); 143 return node; 144 } 145 /** 146 * @apilevel internal 147 * @declaredat ASTNode:70 148 */ 149 public VoidType copy() { 150 try { 151 VoidType node = (VoidType) clone(); 152 node.parent = null; 153 if (children != null) { 154 node.children = (ASTNode[]) children.clone(); 155 } 156 return node; 157 } catch (CloneNotSupportedException e) { 158 throw new Error("Error: clone not supported for " + getClass().getName()); 159 } 160 } 161 /** 162 * Create a deep copy of the AST subtree at this node. 163 * The copy is dangling, i.e. has no parent. 164 * @return dangling copy of the subtree at this node 165 * @apilevel low-level 166 * @deprecated Please use treeCopy or treeCopyNoTransform instead 167 * @declaredat ASTNode:89 168 */ 169 @Deprecated 170 public VoidType fullCopy() { 171 return treeCopyNoTransform(); 172 } 173 /** 174 * Create a deep copy of the AST subtree at this node. 175 * The copy is dangling, i.e. has no parent. 176 * @return dangling copy of the subtree at this node 177 * @apilevel low-level 178 * @declaredat ASTNode:99 179 */ 180 public VoidType treeCopyNoTransform() { 181 VoidType tree = (VoidType) copy(); 182 if (children != null) { 183 for (int i = 0; i < children.length; ++i) { 184 ASTNode child = (ASTNode) children[i]; 185 if (child != null) { 186 child = child.treeCopyNoTransform(); 187 tree.setChild(child, i); 188 } 189 } 190 } 191 return tree; 192 } 193 /** 194 * Create a deep copy of the AST subtree at this node. 195 * The subtree of this node is traversed to trigger rewrites before copy. 196 * The copy is dangling, i.e. has no parent. 197 * @return dangling copy of the subtree at this node 198 * @apilevel low-level 199 * @declaredat ASTNode:119 200 */ 201 public VoidType treeCopy() { 202 doFullTraversal(); 203 return treeCopyNoTransform(); 204 } 205 /** 206 * @apilevel internal 207 * @declaredat ASTNode:126 208 */ 209 protected boolean is$Equal(ASTNode node) { 210 return super.is$Equal(node) && (tokenString_ID == ((VoidType)node).tokenString_ID); 211 } 212 /** 213 * Replaces the Modifiers child. 214 * @param node The new node to replace the Modifiers child. 215 * @apilevel high-level 216 */ 217 public void setModifiers(Modifiers node) { 218 setChild(node, 0); 219 } 220 /** 221 * Retrieves the Modifiers child. 222 * @return The current node used as the Modifiers child. 223 * @apilevel high-level 224 */ 225 @ASTNodeAnnotation.Child(name="Modifiers") 226 public Modifiers getModifiers() { 227 return (Modifiers) getChild(0); 228 } 229 /** 230 * Retrieves the Modifiers child. 231 * <p><em>This method does not invoke AST transformations.</em></p> 232 * @return The current node used as the Modifiers child. 233 * @apilevel low-level 234 */ 235 public Modifiers getModifiersNoTransform() { 236 return (Modifiers) getChildNoTransform(0); 237 } 238 /** 239 * Replaces the lexeme ID. 240 * @param value The new value for the lexeme ID. 241 * @apilevel high-level 242 */ 243 public void setID(String value) { 244 tokenString_ID = value; 245 } 246 /** 247 * JastAdd-internal setter for lexeme ID using the Beaver parser. 248 * @param symbol Symbol containing the new value for the lexeme ID 249 * @apilevel internal 250 */ 251 public void setID(beaver.Symbol symbol) { 252 if (symbol.value != null && !(symbol.value instanceof String)) 253 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 254 tokenString_ID = (String)symbol.value; 255 IDstart = symbol.getStart(); 256 IDend = symbol.getEnd(); 257 } 258 /** 259 * Retrieves the value for the lexeme ID. 260 * @return The value for the lexeme ID. 261 * @apilevel high-level 262 */ 263 @ASTNodeAnnotation.Token(name="ID") 264 public String getID() { 265 return tokenString_ID != null ? tokenString_ID : ""; 266 } 267 /** 268 * Replaces the BodyDecl list. 269 * @param list The new list node to be used as the BodyDecl list. 270 * @apilevel high-level 271 */ 272 public void setBodyDeclList(List<BodyDecl> list) { 273 setChild(list, 1); 274 } 275 /** 276 * Retrieves the number of children in the BodyDecl list. 277 * @return Number of children in the BodyDecl list. 278 * @apilevel high-level 279 */ 280 public int getNumBodyDecl() { 281 return getBodyDeclList().getNumChild(); 282 } 283 /** 284 * Retrieves the number of children in the BodyDecl list. 285 * Calling this method will not trigger rewrites. 286 * @return Number of children in the BodyDecl list. 287 * @apilevel low-level 288 */ 289 public int getNumBodyDeclNoTransform() { 290 return getBodyDeclListNoTransform().getNumChildNoTransform(); 291 } 292 /** 293 * Retrieves the element at index {@code i} in the BodyDecl list. 294 * @param i Index of the element to return. 295 * @return The element at position {@code i} in the BodyDecl list. 296 * @apilevel high-level 297 */ 298 public BodyDecl getBodyDecl(int i) { 299 return (BodyDecl) getBodyDeclList().getChild(i); 300 } 301 /** 302 * Check whether the BodyDecl list has any children. 303 * @return {@code true} if it has at least one child, {@code false} otherwise. 304 * @apilevel high-level 305 */ 306 public boolean hasBodyDecl() { 307 return getBodyDeclList().getNumChild() != 0; 308 } 309 /** 310 * Append an element to the BodyDecl list. 311 * @param node The element to append to the BodyDecl list. 312 * @apilevel high-level 313 */ 314 public void addBodyDecl(BodyDecl node) { 315 List<BodyDecl> list = (parent == null) ? getBodyDeclListNoTransform() : getBodyDeclList(); 316 list.addChild(node); 317 } 318 /** 319 * @apilevel low-level 320 */ 321 public void addBodyDeclNoTransform(BodyDecl node) { 322 List<BodyDecl> list = getBodyDeclListNoTransform(); 323 list.addChild(node); 324 } 325 /** 326 * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}. 327 * @param node The new node to replace the old list element. 328 * @param i The list index of the node to be replaced. 329 * @apilevel high-level 330 */ 331 public void setBodyDecl(BodyDecl node, int i) { 332 List<BodyDecl> list = getBodyDeclList(); 333 list.setChild(node, i); 334 } 335 /** 336 * Retrieves the BodyDecl list. 337 * @return The node representing the BodyDecl list. 338 * @apilevel high-level 339 */ 340 @ASTNodeAnnotation.ListChild(name="BodyDecl") 341 public List<BodyDecl> getBodyDeclList() { 342 List<BodyDecl> list = (List<BodyDecl>) getChild(1); 343 return list; 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> getBodyDeclListNoTransform() { 352 return (List<BodyDecl>) getChildNoTransform(1); 353 } 354 /** 355 * Retrieves the BodyDecl list. 356 * @return The node representing the BodyDecl list. 357 * @apilevel high-level 358 */ 359 public List<BodyDecl> getBodyDecls() { 360 return getBodyDeclList(); 361 } 362 /** 363 * Retrieves the BodyDecl list. 364 * <p><em>This method does not invoke AST transformations.</em></p> 365 * @return The node representing the BodyDecl list. 366 * @apilevel low-level 367 */ 368 public List<BodyDecl> getBodyDeclsNoTransform() { 369 return getBodyDeclListNoTransform(); 370 } 371 /** 372 * @attribute syn 373 * @aspect TypeConversion 374 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:82 375 */ 376 @ASTNodeAnnotation.Attribute 377 public boolean stringConversion() { 378 boolean stringConversion_value = false; 379 380 return stringConversion_value; 381 } 382 /** 383 * @attribute syn 384 * @aspect TypeAnalysis 385 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:224 386 */ 387 @ASTNodeAnnotation.Attribute 388 public boolean isVoid() { 389 boolean isVoid_value = true; 390 391 return isVoid_value; 392 } 393 /** 394 * @apilevel internal 395 */ 396 protected java.util.Map instanceOf_TypeDecl_values; 397 /** 398 * @apilevel internal 399 */ 400 private void instanceOf_TypeDecl_reset() { 401 instanceOf_TypeDecl_values = null; 402 } 403 /** 404 * @attribute syn 405 * @aspect TypeWideningAndIdentity 406 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:442 407 */ 408 @ASTNodeAnnotation.Attribute 409 public boolean instanceOf(TypeDecl type) { 410 Object _parameters = type; 411 if (instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 412 ASTNode$State state = state(); 413 if (instanceOf_TypeDecl_values.containsKey(_parameters)) { 414 return (Boolean) instanceOf_TypeDecl_values.get(_parameters); 415 } 416 boolean intermediate = state.INTERMEDIATE_VALUE; 417 state.INTERMEDIATE_VALUE = false; 418 int num = state.boundariesCrossed; 419 boolean isFinal = this.is$Final(); 420 boolean instanceOf_TypeDecl_value = instanceOf_compute(type); 421 if (isFinal && num == state().boundariesCrossed) { 422 instanceOf_TypeDecl_values.put(_parameters, instanceOf_TypeDecl_value); 423 } else { 424 } 425 state.INTERMEDIATE_VALUE |= intermediate; 426 427 return instanceOf_TypeDecl_value; 428 } 429 /** 430 * @apilevel internal 431 */ 432 private boolean instanceOf_compute(TypeDecl type) { return subtype(type); } 433 /** 434 * @attribute syn 435 * @aspect TypeWideningAndIdentity 436 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:531 437 */ 438 @ASTNodeAnnotation.Attribute 439 public boolean isSupertypeOfVoidType(VoidType type) { 440 boolean isSupertypeOfVoidType_VoidType_value = true; 441 442 return isSupertypeOfVoidType_VoidType_value; 443 } 444 /** 445 * @apilevel internal 446 */ 447 protected boolean typeDescriptor_computed = false; 448 /** 449 * @apilevel internal 450 */ 451 protected String typeDescriptor_value; 452 /** 453 * @apilevel internal 454 */ 455 private void typeDescriptor_reset() { 456 typeDescriptor_computed = false; 457 typeDescriptor_value = null; 458 } 459 /** 460 * @attribute syn 461 * @aspect ConstantPoolNames 462 * @declaredat /home/jesper/git/extendj/java4/backend/ConstantPoolNames.jrag:77 463 */ 464 @ASTNodeAnnotation.Attribute 465 public String typeDescriptor() { 466 ASTNode$State state = state(); 467 if (typeDescriptor_computed) { 468 return typeDescriptor_value; 469 } 470 boolean intermediate = state.INTERMEDIATE_VALUE; 471 state.INTERMEDIATE_VALUE = false; 472 int num = state.boundariesCrossed; 473 boolean isFinal = this.is$Final(); 474 typeDescriptor_value = "V"; 475 if (isFinal && num == state().boundariesCrossed) { 476 typeDescriptor_computed = true; 477 } else { 478 } 479 state.INTERMEDIATE_VALUE |= intermediate; 480 481 return typeDescriptor_value; 482 } 483 /** 484 * @attribute syn 485 * @aspect Java2Rewrites 486 * @declaredat /home/jesper/git/extendj/java4/backend/Java2Rewrites.jrag:68 487 */ 488 @ASTNodeAnnotation.Attribute 489 public String primitiveClassName() { 490 String primitiveClassName_value = "Void"; 491 492 return primitiveClassName_value; 493 } 494 /** 495 * @apilevel internal 496 */ 497 private void subtype_TypeDecl_reset() { 498 subtype_TypeDecl_values = null; 499 } 500 protected java.util.Map subtype_TypeDecl_values; 501 @ASTNodeAnnotation.Attribute 502 public boolean subtype(TypeDecl type) { 503 Object _parameters = type; 504 if (subtype_TypeDecl_values == null) subtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 505 ASTNode$State.CircularValue _value; 506 if (subtype_TypeDecl_values.containsKey(_parameters)) { 507 Object _o = subtype_TypeDecl_values.get(_parameters); 508 if (!(_o instanceof ASTNode$State.CircularValue)) { 509 return (Boolean) _o; 510 } else { 511 _value = (ASTNode$State.CircularValue) _o; 512 } 513 } else { 514 _value = new ASTNode$State.CircularValue(); 515 subtype_TypeDecl_values.put(_parameters, _value); 516 _value.value = true; 517 } 518 ASTNode$State state = state(); 519 boolean new_subtype_TypeDecl_value; 520 if (!state.IN_CIRCLE) { 521 state.IN_CIRCLE = true; 522 int num = state.boundariesCrossed; 523 boolean isFinal = this.is$Final(); 524 // TODO: fixme 525 // state().CIRCLE_INDEX = 1; 526 do { 527 _value.visited = state.CIRCLE_INDEX; 528 state.CHANGE = false; 529 new_subtype_TypeDecl_value = type.supertypeVoidType(this); 530 if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 531 state.CHANGE = true; 532 _value.value = new_subtype_TypeDecl_value; 533 } 534 state.CIRCLE_INDEX++; 535 } while (state.CHANGE); 536 if (isFinal && num == state().boundariesCrossed) { 537 subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value); 538 } else { 539 subtype_TypeDecl_values.remove(_parameters); 540 state.RESET_CYCLE = true; 541 boolean $tmp = type.supertypeVoidType(this); 542 state.RESET_CYCLE = false; 543 } 544 state.IN_CIRCLE = false; 545 state.INTERMEDIATE_VALUE = false; 546 return new_subtype_TypeDecl_value; 547 } 548 if (state.CIRCLE_INDEX != _value.visited) { 549 _value.visited = state.CIRCLE_INDEX; 550 new_subtype_TypeDecl_value = type.supertypeVoidType(this); 551 if (state.RESET_CYCLE) { 552 subtype_TypeDecl_values.remove(_parameters); 553 } 554 else if (new_subtype_TypeDecl_value != ((Boolean)_value.value)) { 555 state.CHANGE = true; 556 _value.value = new_subtype_TypeDecl_value; 557 } 558 state.INTERMEDIATE_VALUE = true; 559 return new_subtype_TypeDecl_value; 560 } 561 state.INTERMEDIATE_VALUE = true; 562 return (Boolean) _value.value; 563 } 564 /** 565 * @attribute syn 566 * @aspect GenericsSubtype 567 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericsSubtype.jrag:518 568 */ 569 @ASTNodeAnnotation.Attribute 570 public boolean supertypeVoidType(VoidType type) { 571 boolean supertypeVoidType_VoidType_value = true; 572 573 return supertypeVoidType_VoidType_value; 574 } 575 /** 576 * @apilevel internal 577 */ 578 protected boolean fieldTypeSignature_computed = false; 579 /** 580 * @apilevel internal 581 */ 582 protected String fieldTypeSignature_value; 583 /** 584 * @apilevel internal 585 */ 586 private void fieldTypeSignature_reset() { 587 fieldTypeSignature_computed = false; 588 fieldTypeSignature_value = null; 589 } 590 /** 591 * @attribute syn 592 * @aspect GenericsCodegen 593 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:467 594 */ 595 @ASTNodeAnnotation.Attribute 596 public String fieldTypeSignature() { 597 ASTNode$State state = state(); 598 if (fieldTypeSignature_computed) { 599 return fieldTypeSignature_value; 600 } 601 boolean intermediate = state.INTERMEDIATE_VALUE; 602 state.INTERMEDIATE_VALUE = false; 603 int num = state.boundariesCrossed; 604 boolean isFinal = this.is$Final(); 605 fieldTypeSignature_value = classTypeSignature(); 606 if (isFinal && num == state().boundariesCrossed) { 607 fieldTypeSignature_computed = true; 608 } else { 609 } 610 state.INTERMEDIATE_VALUE |= intermediate; 611 612 return fieldTypeSignature_value; 613 } 614 /** 615 * @apilevel internal 616 */ 617 protected boolean classTypeSignature_computed = false; 618 /** 619 * @apilevel internal 620 */ 621 protected String classTypeSignature_value; 622 /** 623 * @apilevel internal 624 */ 625 private void classTypeSignature_reset() { 626 classTypeSignature_computed = false; 627 classTypeSignature_value = null; 628 } 629 /** 630 * @attribute syn 631 * @aspect GenericsCodegen 632 * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:476 633 */ 634 @ASTNodeAnnotation.Attribute 635 public String classTypeSignature() { 636 ASTNode$State state = state(); 637 if (classTypeSignature_computed) { 638 return classTypeSignature_value; 639 } 640 boolean intermediate = state.INTERMEDIATE_VALUE; 641 state.INTERMEDIATE_VALUE = false; 642 int num = state.boundariesCrossed; 643 boolean isFinal = this.is$Final(); 644 classTypeSignature_value = typeDescriptor(); 645 if (isFinal && num == state().boundariesCrossed) { 646 classTypeSignature_computed = true; 647 } else { 648 } 649 state.INTERMEDIATE_VALUE |= intermediate; 650 651 return classTypeSignature_value; 652 } 653 /** 654 * @apilevel internal 655 */ 656 private void strictSubtype_TypeDecl_reset() { 657 strictSubtype_TypeDecl_values = null; 658 } 659 protected java.util.Map strictSubtype_TypeDecl_values; 660 @ASTNodeAnnotation.Attribute 661 public boolean strictSubtype(TypeDecl type) { 662 Object _parameters = type; 663 if (strictSubtype_TypeDecl_values == null) strictSubtype_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 664 ASTNode$State.CircularValue _value; 665 if (strictSubtype_TypeDecl_values.containsKey(_parameters)) { 666 Object _o = strictSubtype_TypeDecl_values.get(_parameters); 667 if (!(_o instanceof ASTNode$State.CircularValue)) { 668 return (Boolean) _o; 669 } else { 670 _value = (ASTNode$State.CircularValue) _o; 671 } 672 } else { 673 _value = new ASTNode$State.CircularValue(); 674 strictSubtype_TypeDecl_values.put(_parameters, _value); 675 _value.value = true; 676 } 677 ASTNode$State state = state(); 678 boolean new_strictSubtype_TypeDecl_value; 679 if (!state.IN_CIRCLE) { 680 state.IN_CIRCLE = true; 681 int num = state.boundariesCrossed; 682 boolean isFinal = this.is$Final(); 683 // TODO: fixme 684 // state().CIRCLE_INDEX = 1; 685 do { 686 _value.visited = state.CIRCLE_INDEX; 687 state.CHANGE = false; 688 new_strictSubtype_TypeDecl_value = type.strictSupertypeVoidType(this); 689 if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 690 state.CHANGE = true; 691 _value.value = new_strictSubtype_TypeDecl_value; 692 } 693 state.CIRCLE_INDEX++; 694 } while (state.CHANGE); 695 if (isFinal && num == state().boundariesCrossed) { 696 strictSubtype_TypeDecl_values.put(_parameters, new_strictSubtype_TypeDecl_value); 697 } else { 698 strictSubtype_TypeDecl_values.remove(_parameters); 699 state.RESET_CYCLE = true; 700 boolean $tmp = type.strictSupertypeVoidType(this); 701 state.RESET_CYCLE = false; 702 } 703 state.IN_CIRCLE = false; 704 state.INTERMEDIATE_VALUE = false; 705 return new_strictSubtype_TypeDecl_value; 706 } 707 if (state.CIRCLE_INDEX != _value.visited) { 708 _value.visited = state.CIRCLE_INDEX; 709 new_strictSubtype_TypeDecl_value = type.strictSupertypeVoidType(this); 710 if (state.RESET_CYCLE) { 711 strictSubtype_TypeDecl_values.remove(_parameters); 712 } 713 else if (new_strictSubtype_TypeDecl_value != ((Boolean)_value.value)) { 714 state.CHANGE = true; 715 _value.value = new_strictSubtype_TypeDecl_value; 716 } 717 state.INTERMEDIATE_VALUE = true; 718 return new_strictSubtype_TypeDecl_value; 719 } 720 state.INTERMEDIATE_VALUE = true; 721 return (Boolean) _value.value; 722 } 723 /** 724 * @attribute syn 725 * @aspect StrictSubtype 726 * @declaredat /home/jesper/git/extendj/java8/frontend/GenericsSubtype.jrag:450 727 */ 728 @ASTNodeAnnotation.Attribute 729 public boolean strictSupertypeVoidType(VoidType type) { 730 boolean strictSupertypeVoidType_VoidType_value = true; 731 732 return strictSupertypeVoidType_VoidType_value; 733 } 734 /** 735 * @apilevel internal 736 */ 737 public ASTNode rewriteTo() { 738 return super.rewriteTo(); 739 } 740 }