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/java8/grammar/Lambda.ast:6 027 * @production InferredParameterDeclaration : {@link ASTNode} ::= <span class="component"><ID:String></span>; 028 029 */ 030 public class InferredParameterDeclaration extends ASTNode<ASTNode> implements Cloneable, SimpleSet, Iterator, Variable { 031 /** 032 * @aspect DataStructures 033 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:34 034 */ 035 public SimpleSet add(Object o) { 036 return new SimpleSetImpl().add(this).add(o); 037 } 038 /** 039 * @aspect DataStructures 040 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:38 041 */ 042 public boolean isSingleton() { return true; } 043 /** 044 * @aspect DataStructures 045 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:39 046 */ 047 public boolean isSingleton(Object o) { return contains(o); } 048 /** 049 * @aspect DataStructures 050 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:42 051 */ 052 private InferredParameterDeclaration iterElem; 053 /** 054 * @aspect DataStructures 055 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:43 056 */ 057 public Iterator iterator() { iterElem = this; return this; } 058 /** 059 * @aspect DataStructures 060 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:44 061 */ 062 public boolean hasNext() { return iterElem != null; } 063 /** 064 * @aspect DataStructures 065 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:45 066 */ 067 public Object next() { Object o = iterElem; iterElem = null; return o; } 068 /** 069 * @aspect DataStructures 070 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:46 071 */ 072 public void remove() { throw new UnsupportedOperationException(); } 073 /** 074 * @aspect Java8NameCheck 075 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:38 076 */ 077 public void nameCheck() { 078 SimpleSet decls = outerScope().lookupVariable(name()); 079 for (Iterator iter = decls.iterator(); iter.hasNext(); ) { 080 Variable var = (Variable) iter.next(); 081 if (var instanceof VariableDeclaration) { 082 VariableDeclaration decl = (VariableDeclaration) var; 083 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 084 errorf("duplicate declaration of parameter %s", name()); 085 } 086 } else if (var instanceof ParameterDeclaration) { 087 ParameterDeclaration decl = (ParameterDeclaration) var; 088 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 089 errorf("duplicate declaration of parameter %s", name()); 090 } 091 } else if (var instanceof InferredParameterDeclaration) { 092 InferredParameterDeclaration decl = (InferredParameterDeclaration) var; 093 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 094 errorf("duplicate declaration of parameter %s", name()); 095 } 096 } else if (var instanceof CatchParameterDeclaration) { 097 CatchParameterDeclaration decl = (CatchParameterDeclaration) var; 098 if (decl.enclosingBodyDecl() == enclosingBodyDecl()) { 099 errorf("duplicate declaration of parameter %s", name()); 100 } 101 } 102 } 103 104 // 8.4.1 105 if (!lookupVariable(name()).contains(this)) { 106 errorf("duplicate declaration of parameter %s", name()); 107 } 108 } 109 /** 110 * @aspect Java8PrettyPrint 111 * @declaredat /home/jesper/git/extendj/java8/frontend/PrettyPrint.jadd:35 112 */ 113 public void prettyPrint(PrettyPrinter out) { 114 out.print(name()); 115 } 116 /** 117 * @declaredat ASTNode:1 118 */ 119 public InferredParameterDeclaration() { 120 super(); 121 } 122 /** 123 * Initializes the child array to the correct size. 124 * Initializes List and Opt nta children. 125 * @apilevel internal 126 * @ast method 127 * @declaredat ASTNode:10 128 */ 129 public void init$Children() { 130 } 131 /** 132 * @declaredat ASTNode:12 133 */ 134 public InferredParameterDeclaration(String p0) { 135 setID(p0); 136 } 137 /** 138 * @declaredat ASTNode:15 139 */ 140 public InferredParameterDeclaration(beaver.Symbol p0) { 141 setID(p0); 142 } 143 /** 144 * @apilevel low-level 145 * @declaredat ASTNode:21 146 */ 147 protected int numChildren() { 148 return 0; 149 } 150 /** 151 * @apilevel internal 152 * @declaredat ASTNode:27 153 */ 154 public boolean mayHaveRewrite() { 155 return false; 156 } 157 /** 158 * @apilevel internal 159 * @declaredat ASTNode:33 160 */ 161 public void flushAttrCache() { 162 super.flushAttrCache(); 163 isEffectivelyFinal_reset(); 164 sourceVariableDecl_reset(); 165 enclosingLambda_reset(); 166 lookupVariable_String_reset(); 167 inferredType_reset(); 168 } 169 /** 170 * @apilevel internal 171 * @declaredat ASTNode:44 172 */ 173 public void flushCollectionCache() { 174 super.flushCollectionCache(); 175 } 176 /** 177 * @apilevel internal 178 * @declaredat ASTNode:50 179 */ 180 public void flushRewriteCache() { 181 super.flushRewriteCache(); 182 } 183 /** 184 * @apilevel internal 185 * @declaredat ASTNode:56 186 */ 187 public InferredParameterDeclaration clone() throws CloneNotSupportedException { 188 InferredParameterDeclaration node = (InferredParameterDeclaration) super.clone(); 189 return node; 190 } 191 /** 192 * @apilevel internal 193 * @declaredat ASTNode:63 194 */ 195 public InferredParameterDeclaration copy() { 196 try { 197 InferredParameterDeclaration node = (InferredParameterDeclaration) clone(); 198 node.parent = null; 199 if (children != null) { 200 node.children = (ASTNode[]) children.clone(); 201 } 202 return node; 203 } catch (CloneNotSupportedException e) { 204 throw new Error("Error: clone not supported for " + getClass().getName()); 205 } 206 } 207 /** 208 * Create a deep copy of the AST subtree at this node. 209 * The copy is dangling, i.e. has no parent. 210 * @return dangling copy of the subtree at this node 211 * @apilevel low-level 212 * @deprecated Please use treeCopy or treeCopyNoTransform instead 213 * @declaredat ASTNode:82 214 */ 215 @Deprecated 216 public InferredParameterDeclaration fullCopy() { 217 return treeCopyNoTransform(); 218 } 219 /** 220 * Create a deep copy of the AST subtree at this node. 221 * The copy is dangling, i.e. has no parent. 222 * @return dangling copy of the subtree at this node 223 * @apilevel low-level 224 * @declaredat ASTNode:92 225 */ 226 public InferredParameterDeclaration treeCopyNoTransform() { 227 InferredParameterDeclaration tree = (InferredParameterDeclaration) copy(); 228 if (children != null) { 229 for (int i = 0; i < children.length; ++i) { 230 ASTNode child = (ASTNode) children[i]; 231 if (child != null) { 232 child = child.treeCopyNoTransform(); 233 tree.setChild(child, i); 234 } 235 } 236 } 237 return tree; 238 } 239 /** 240 * Create a deep copy of the AST subtree at this node. 241 * The subtree of this node is traversed to trigger rewrites before copy. 242 * The copy is dangling, i.e. has no parent. 243 * @return dangling copy of the subtree at this node 244 * @apilevel low-level 245 * @declaredat ASTNode:112 246 */ 247 public InferredParameterDeclaration treeCopy() { 248 doFullTraversal(); 249 return treeCopyNoTransform(); 250 } 251 /** 252 * @apilevel internal 253 * @declaredat ASTNode:119 254 */ 255 protected boolean is$Equal(ASTNode node) { 256 return super.is$Equal(node) && (tokenString_ID == ((InferredParameterDeclaration)node).tokenString_ID); 257 } 258 /** 259 * Replaces the lexeme ID. 260 * @param value The new value for the lexeme ID. 261 * @apilevel high-level 262 */ 263 public void setID(String value) { 264 tokenString_ID = value; 265 } 266 /** 267 * @apilevel internal 268 */ 269 protected String tokenString_ID; 270 /** 271 */ 272 public int IDstart; 273 /** 274 */ 275 public int IDend; 276 /** 277 * JastAdd-internal setter for lexeme ID using the Beaver parser. 278 * @param symbol Symbol containing the new value for the lexeme ID 279 * @apilevel internal 280 */ 281 public void setID(beaver.Symbol symbol) { 282 if (symbol.value != null && !(symbol.value instanceof String)) 283 throw new UnsupportedOperationException("setID is only valid for String lexemes"); 284 tokenString_ID = (String)symbol.value; 285 IDstart = symbol.getStart(); 286 IDend = symbol.getEnd(); 287 } 288 /** 289 * Retrieves the value for the lexeme ID. 290 * @return The value for the lexeme ID. 291 * @apilevel high-level 292 */ 293 @ASTNodeAnnotation.Token(name="ID") 294 public String getID() { 295 return tokenString_ID != null ? tokenString_ID : ""; 296 } 297 /** 298 * @attribute syn 299 * @aspect DataStructures 300 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:32 301 */ 302 @ASTNodeAnnotation.Attribute 303 public int size() { 304 int size_value = 1; 305 306 return size_value; 307 } 308 /** 309 * @attribute syn 310 * @aspect DataStructures 311 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:33 312 */ 313 @ASTNodeAnnotation.Attribute 314 public boolean isEmpty() { 315 boolean isEmpty_value = false; 316 317 return isEmpty_value; 318 } 319 /** 320 * @attribute syn 321 * @aspect DataStructures 322 * @declaredat /home/jesper/git/extendj/java8/frontend/DataStructures.jrag:37 323 */ 324 @ASTNodeAnnotation.Attribute 325 public boolean contains(Object o) { 326 boolean contains_Object_value = this == o; 327 328 return contains_Object_value; 329 } 330 /** 331 * @apilevel internal 332 */ 333 protected boolean isEffectivelyFinal_computed = false; 334 /** 335 * @apilevel internal 336 */ 337 protected boolean isEffectivelyFinal_value; 338 /** 339 * @apilevel internal 340 */ 341 private void isEffectivelyFinal_reset() { 342 isEffectivelyFinal_computed = false; 343 } 344 /** 345 * @attribute syn 346 * @aspect EffectivelyFinal 347 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:136 348 */ 349 @ASTNodeAnnotation.Attribute 350 public boolean isEffectivelyFinal() { 351 ASTNode$State state = state(); 352 if (isEffectivelyFinal_computed) { 353 return isEffectivelyFinal_value; 354 } 355 boolean intermediate = state.INTERMEDIATE_VALUE; 356 state.INTERMEDIATE_VALUE = false; 357 int num = state.boundariesCrossed; 358 boolean isFinal = this.is$Final(); 359 isEffectivelyFinal_value = isFinal() || !inhModifiedInScope(this); 360 if (isFinal && num == state().boundariesCrossed) { 361 isEffectivelyFinal_computed = true; 362 } else { 363 } 364 state.INTERMEDIATE_VALUE |= intermediate; 365 366 return isEffectivelyFinal_value; 367 } 368 /** 369 * @attribute syn 370 * @aspect Names 371 * @declaredat /home/jesper/git/extendj/java8/frontend/QualifiedNames.jrag:29 372 */ 373 @ASTNodeAnnotation.Attribute 374 public String name() { 375 String name_value = getID(); 376 377 return name_value; 378 } 379 /** 380 * @attribute syn 381 * @aspect Variables 382 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:30 383 */ 384 @ASTNodeAnnotation.Attribute 385 public boolean isParameter() { 386 boolean isParameter_value = true; 387 388 return isParameter_value; 389 } 390 /** 391 * @attribute syn 392 * @aspect Variables 393 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:31 394 */ 395 @ASTNodeAnnotation.Attribute 396 public boolean isClassVariable() { 397 boolean isClassVariable_value = false; 398 399 return isClassVariable_value; 400 } 401 /** 402 * @attribute syn 403 * @aspect Variables 404 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:32 405 */ 406 @ASTNodeAnnotation.Attribute 407 public boolean isInstanceVariable() { 408 boolean isInstanceVariable_value = false; 409 410 return isInstanceVariable_value; 411 } 412 /** 413 * @attribute syn 414 * @aspect Variables 415 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:33 416 */ 417 @ASTNodeAnnotation.Attribute 418 public boolean isConstructorParameter() { 419 boolean isConstructorParameter_value = false; 420 421 return isConstructorParameter_value; 422 } 423 /** 424 * @attribute syn 425 * @aspect Variables 426 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:34 427 */ 428 @ASTNodeAnnotation.Attribute 429 public boolean isExceptionHandlerParameter() { 430 boolean isExceptionHandlerParameter_value = false; 431 432 return isExceptionHandlerParameter_value; 433 } 434 /** 435 * @attribute syn 436 * @aspect Variables 437 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:35 438 */ 439 @ASTNodeAnnotation.Attribute 440 public boolean isMethodParameter() { 441 boolean isMethodParameter_value = false; 442 443 return isMethodParameter_value; 444 } 445 /** 446 * @attribute syn 447 * @aspect Variables 448 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:36 449 */ 450 @ASTNodeAnnotation.Attribute 451 public boolean isLocalVariable() { 452 boolean isLocalVariable_value = false; 453 454 return isLocalVariable_value; 455 } 456 /** 457 * @attribute syn 458 * @aspect Variables 459 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:37 460 */ 461 @ASTNodeAnnotation.Attribute 462 public boolean isFinal() { 463 boolean isFinal_value = false; 464 465 return isFinal_value; 466 } 467 /** 468 * @attribute syn 469 * @aspect Variables 470 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:38 471 */ 472 @ASTNodeAnnotation.Attribute 473 public boolean isVolatile() { 474 boolean isVolatile_value = false; 475 476 return isVolatile_value; 477 } 478 /** 479 * @attribute syn 480 * @aspect Variables 481 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:39 482 */ 483 @ASTNodeAnnotation.Attribute 484 public boolean isBlank() { 485 boolean isBlank_value = true; 486 487 return isBlank_value; 488 } 489 /** 490 * @attribute syn 491 * @aspect Variables 492 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:40 493 */ 494 @ASTNodeAnnotation.Attribute 495 public boolean isStatic() { 496 boolean isStatic_value = false; 497 498 return isStatic_value; 499 } 500 /** 501 * @attribute syn 502 * @aspect Variables 503 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:41 504 */ 505 @ASTNodeAnnotation.Attribute 506 public boolean isSynthetic() { 507 boolean isSynthetic_value = false; 508 509 return isSynthetic_value; 510 } 511 /** 512 * @apilevel internal 513 */ 514 protected boolean sourceVariableDecl_computed = false; 515 /** 516 * @apilevel internal 517 */ 518 protected Variable sourceVariableDecl_value; 519 /** 520 * @apilevel internal 521 */ 522 private void sourceVariableDecl_reset() { 523 sourceVariableDecl_computed = false; 524 sourceVariableDecl_value = null; 525 } 526 /** 527 * @attribute syn 528 * @aspect SourceDeclarations 529 * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1637 530 */ 531 @ASTNodeAnnotation.Attribute 532 public Variable sourceVariableDecl() { 533 ASTNode$State state = state(); 534 if (sourceVariableDecl_computed) { 535 return sourceVariableDecl_value; 536 } 537 boolean intermediate = state.INTERMEDIATE_VALUE; 538 state.INTERMEDIATE_VALUE = false; 539 int num = state.boundariesCrossed; 540 boolean isFinal = this.is$Final(); 541 sourceVariableDecl_value = this; 542 if (isFinal && num == state().boundariesCrossed) { 543 sourceVariableDecl_computed = true; 544 } else { 545 } 546 state.INTERMEDIATE_VALUE |= intermediate; 547 548 return sourceVariableDecl_value; 549 } 550 /** 551 * @attribute syn 552 * @aspect Variables 553 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:45 554 */ 555 @ASTNodeAnnotation.Attribute 556 public Modifiers getModifiers() { 557 Modifiers getModifiers_value = null; 558 559 return getModifiers_value; 560 } 561 /** 562 * @attribute syn 563 * @aspect Variables 564 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:47 565 */ 566 @ASTNodeAnnotation.Attribute 567 public boolean hasInit() { 568 boolean hasInit_value = false; 569 570 return hasInit_value; 571 } 572 /** 573 * @attribute syn 574 * @aspect Variables 575 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:49 576 */ 577 @ASTNodeAnnotation.Attribute 578 public Expr getInit() { 579 { 580 throw new UnsupportedOperationException(); 581 } 582 } 583 /** 584 * @attribute syn 585 * @aspect Variables 586 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:53 587 */ 588 @ASTNodeAnnotation.Attribute 589 public Constant constant() { 590 { 591 throw new UnsupportedOperationException(); 592 } 593 } 594 /** 595 * @attribute syn 596 * @aspect Variables 597 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:57 598 */ 599 @ASTNodeAnnotation.Attribute 600 public Collection<TypeDecl> throwTypes() { 601 Collection<TypeDecl> throwTypes_value = null; 602 603 return throwTypes_value; 604 } 605 /** 606 * @attribute syn 607 * @aspect Variables 608 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:59 609 */ 610 @ASTNodeAnnotation.Attribute 611 public TypeDecl type() { 612 TypeDecl type_value = inferredType(); 613 614 return type_value; 615 } 616 /** 617 * @attribute syn 618 * @aspect Variables 619 * @declaredat /home/jesper/git/extendj/java8/frontend/VariableDeclaration.jrag:61 620 */ 621 @ASTNodeAnnotation.Attribute 622 public TypeDecl hostType() { 623 { 624 if (getParent().getParent() instanceof LambdaExpr) { 625 return ((LambdaExpr)getParent().getParent()).hostType(); 626 } else { 627 return ((LambdaExpr)getParent().getParent().getParent()).hostType(); 628 } 629 } 630 } 631 /** 632 * @attribute inh 633 * @aspect PreciseRethrow 634 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30 635 */ 636 /** 637 * @attribute inh 638 * @aspect PreciseRethrow 639 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30 640 */ 641 @ASTNodeAnnotation.Attribute 642 public boolean inhModifiedInScope(Variable var) { 643 boolean inhModifiedInScope_Variable_value = getParent().Define_inhModifiedInScope(this, null, var); 644 645 return inhModifiedInScope_Variable_value; 646 } 647 /** 648 * @attribute inh 649 * @aspect EnclosingLambda 650 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:35 651 */ 652 /** 653 * @attribute inh 654 * @aspect EnclosingLambda 655 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:35 656 */ 657 @ASTNodeAnnotation.Attribute 658 public LambdaExpr enclosingLambda() { 659 ASTNode$State state = state(); 660 if (enclosingLambda_computed) { 661 return enclosingLambda_value; 662 } 663 boolean intermediate = state.INTERMEDIATE_VALUE; 664 state.INTERMEDIATE_VALUE = false; 665 int num = state.boundariesCrossed; 666 boolean isFinal = this.is$Final(); 667 enclosingLambda_value = getParent().Define_enclosingLambda(this, null); 668 if (isFinal && num == state().boundariesCrossed) { 669 enclosingLambda_computed = true; 670 } else { 671 } 672 state.INTERMEDIATE_VALUE |= intermediate; 673 674 return enclosingLambda_value; 675 } 676 /** 677 * @apilevel internal 678 */ 679 protected boolean enclosingLambda_computed = false; 680 /** 681 * @apilevel internal 682 */ 683 protected LambdaExpr enclosingLambda_value; 684 /** 685 * @apilevel internal 686 */ 687 private void enclosingLambda_reset() { 688 enclosingLambda_computed = false; 689 enclosingLambda_value = null; 690 } 691 /** 692 * @attribute inh 693 * @aspect VariableScope 694 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:31 695 */ 696 /** 697 * @attribute inh 698 * @aspect VariableScope 699 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:31 700 */ 701 @ASTNodeAnnotation.Attribute 702 public SimpleSet lookupVariable(String name) { 703 Object _parameters = name; 704 if (lookupVariable_String_values == null) lookupVariable_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 705 ASTNode$State state = state(); 706 if (lookupVariable_String_values.containsKey(_parameters)) { 707 return (SimpleSet) lookupVariable_String_values.get(_parameters); 708 } 709 boolean intermediate = state.INTERMEDIATE_VALUE; 710 state.INTERMEDIATE_VALUE = false; 711 int num = state.boundariesCrossed; 712 boolean isFinal = this.is$Final(); 713 SimpleSet lookupVariable_String_value = getParent().Define_lookupVariable(this, null, name); 714 if (isFinal && num == state().boundariesCrossed) { 715 lookupVariable_String_values.put(_parameters, lookupVariable_String_value); 716 } else { 717 } 718 state.INTERMEDIATE_VALUE |= intermediate; 719 720 return lookupVariable_String_value; 721 } 722 /** 723 * @apilevel internal 724 */ 725 protected java.util.Map lookupVariable_String_values; 726 /** 727 * @apilevel internal 728 */ 729 private void lookupVariable_String_reset() { 730 lookupVariable_String_values = null; 731 } 732 /** 733 * @attribute inh 734 * @aspect Java8NameCheck 735 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:29 736 */ 737 /** 738 * @attribute inh 739 * @aspect Java8NameCheck 740 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:29 741 */ 742 @ASTNodeAnnotation.Attribute 743 public BodyDecl enclosingBodyDecl() { 744 BodyDecl enclosingBodyDecl_value = getParent().Define_enclosingBodyDecl(this, null); 745 746 return enclosingBodyDecl_value; 747 } 748 /** 749 * @attribute inh 750 * @aspect Java8NameCheck 751 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:30 752 */ 753 /** 754 * @attribute inh 755 * @aspect Java8NameCheck 756 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:30 757 */ 758 @ASTNodeAnnotation.Attribute 759 public VariableScope outerScope() { 760 VariableScope outerScope_value = getParent().Define_outerScope(this, null); 761 762 return outerScope_value; 763 } 764 /** 765 * @attribute inh 766 * @aspect TypeCheck 767 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:30 768 */ 769 /** 770 * @attribute inh 771 * @aspect TypeCheck 772 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:30 773 */ 774 @ASTNodeAnnotation.Attribute 775 public TypeDecl unknownType() { 776 TypeDecl unknownType_value = getParent().Define_unknownType(this, null); 777 778 return unknownType_value; 779 } 780 /** 781 * @attribute inh 782 * @aspect LambdaParametersInference 783 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:453 784 */ 785 /** 786 * @attribute inh 787 * @aspect LambdaParametersInference 788 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:453 789 */ 790 @ASTNodeAnnotation.Attribute 791 public TypeDecl inferredType() { 792 ASTNode$State state = state(); 793 if (inferredType_computed) { 794 return inferredType_value; 795 } 796 boolean intermediate = state.INTERMEDIATE_VALUE; 797 state.INTERMEDIATE_VALUE = false; 798 int num = state.boundariesCrossed; 799 boolean isFinal = this.is$Final(); 800 inferredType_value = getParent().Define_inferredType(this, null); 801 if (isFinal && num == state().boundariesCrossed) { 802 inferredType_computed = true; 803 } else { 804 } 805 state.INTERMEDIATE_VALUE |= intermediate; 806 807 return inferredType_value; 808 } 809 /** 810 * @apilevel internal 811 */ 812 protected boolean inferredType_computed = false; 813 /** 814 * @apilevel internal 815 */ 816 protected TypeDecl inferredType_value; 817 /** 818 * @apilevel internal 819 */ 820 private void inferredType_reset() { 821 inferredType_computed = false; 822 inferredType_value = null; 823 } 824 /** 825 * @apilevel internal 826 */ 827 public ASTNode rewriteTo() { 828 return super.rewriteTo(); 829 } 830 }