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:1 027 * @production LambdaExpr : {@link Expr} ::= <span class="component">{@link LambdaParameters}</span> <span class="component">{@link LambdaBody}</span>; 028 029 */ 030 public class LambdaExpr extends Expr implements Cloneable, VariableScope { 031 /** 032 * @aspect Java8PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java8/frontend/PrettyPrint.jadd:64 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print(getLambdaParameters()); 037 out.print(" -> "); 038 out.print(getLambdaBody()); 039 } 040 /** 041 * @aspect TypeCheck 042 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:115 043 */ 044 public void typeCheck() { 045 if (!assignmentContext() && !castContext() && !invocationContext()) { 046 // 15.27 047 error("Lambda expressions must target a functional interface"); 048 return; 049 } 050 051 // This means there was an error in the overload resolution, will be reported elsewhere 052 if (invocationContext() && targetType() == unknownType()) { 053 return; 054 } 055 056 if (!targetType().isFunctionalInterface()) { 057 // 15.27 058 error("Lambda expressions must target a functional interface"); 059 return; 060 } 061 062 InterfaceDecl iDecl = targetInterface(); 063 064 if (!iDecl.isFunctional()) { 065 // 15.27 066 errorf("Interface %s is not functional and can therefore not be targeted by a lambda expression", 067 iDecl.typeName()); 068 return; 069 } 070 071 FunctionDescriptor f = iDecl.functionDescriptor(); 072 073 if (f.isGeneric()) { 074 // 15.27 075 errorf("Illegal lambda expression: Method %s in interface %s is generic", 076 iDecl.functionDescriptor().method.name(), iDecl.typeName()); 077 return; 078 } 079 080 if (!getLambdaParameters().congruentTo(f)) { 081 errorf("Lambda expression parameters incompatible with" 082 + " parameters in method %s in interface %s", 083 f.method.name(), iDecl.typeName()); 084 } 085 086 if (getLambdaBody() instanceof ExprLambdaBody) { 087 ExprLambdaBody exprBody = (ExprLambdaBody)getLambdaBody(); 088 if (f.method.type().isVoid()) { 089 if (!exprBody.getExpr().stmtCompatible()) { 090 errorf("Lambda expression body must be a statement expression," 091 + " because the method %s in interface %s has return type void", 092 f.method.name(), iDecl.typeName()); 093 } 094 } else { 095 if (!exprBody.getExpr().type().assignConversionTo(f.method.type(), exprBody.getExpr())) { 096 errorf("Lambda expression body is not compatible with" 097 + " the return type %s in method %s in interface %s", 098 f.method.type().typeName(), f.method.name(), iDecl.typeName()); 099 } 100 } 101 } else { 102 BlockLambdaBody blockBody = (BlockLambdaBody)getLambdaBody(); 103 if (f.method.type().isVoid()) { 104 if (!blockBody.voidCompatible()) { 105 errorf("Lambda expression body is not allowed to return a value," 106 + " because the method %s in interface %s has return type void", 107 f.method.name(), iDecl.typeName()); 108 } 109 } else if (!blockBody.valueCompatible()) { 110 errorf("Lambda expression body must not complete normally or contain empty return" 111 + " statments, because the method %s in interface" 112 + " %s has a return type which is non-void", 113 f.method.name(), iDecl.typeName()); 114 } 115 } 116 } 117 /** 118 * @aspect Java8CreateBCode 119 * @declaredat /home/jesper/git/extendj/java8/backend/CreateBCode.jrag:29 120 */ 121 public void createBCode(CodeGeneration gen) { 122 toClass().createBCode(gen); 123 } 124 /** 125 * @aspect Transformations 126 * @declaredat /home/jesper/git/extendj/java8/backend/Transformations.jrag:29 127 */ 128 public void transformation() { 129 toClass().transformation(); 130 } 131 /** 132 * @declaredat ASTNode:1 133 */ 134 public LambdaExpr() { 135 super(); 136 } 137 /** 138 * Initializes the child array to the correct size. 139 * Initializes List and Opt nta children. 140 * @apilevel internal 141 * @ast method 142 * @declaredat ASTNode:10 143 */ 144 public void init$Children() { 145 children = new ASTNode[2]; 146 } 147 /** 148 * @declaredat ASTNode:13 149 */ 150 public LambdaExpr(LambdaParameters p0, LambdaBody p1) { 151 setChild(p0, 0); 152 setChild(p1, 1); 153 } 154 /** 155 * @apilevel low-level 156 * @declaredat ASTNode:20 157 */ 158 protected int numChildren() { 159 return 2; 160 } 161 /** 162 * @apilevel internal 163 * @declaredat ASTNode:26 164 */ 165 public boolean mayHaveRewrite() { 166 return false; 167 } 168 /** 169 * @apilevel internal 170 * @declaredat ASTNode:32 171 */ 172 public void flushAttrCache() { 173 super.flushAttrCache(); 174 arity_reset(); 175 numParameters_reset(); 176 isImplicit_reset(); 177 isExplicit_reset(); 178 congruentTo_FunctionDescriptor_reset(); 179 compatibleStrictContext_TypeDecl_reset(); 180 compatibleLooseContext_TypeDecl_reset(); 181 pertinentToApplicability_Expr_BodyDecl_int_reset(); 182 moreSpecificThan_TypeDecl_TypeDecl_reset(); 183 potentiallyCompatible_TypeDecl_BodyDecl_reset(); 184 isPolyExpression_reset(); 185 assignConversionTo_TypeDecl_reset(); 186 targetInterface_reset(); 187 type_reset(); 188 toClass_reset(); 189 enclosingLambda_reset(); 190 } 191 /** 192 * @apilevel internal 193 * @declaredat ASTNode:54 194 */ 195 public void flushCollectionCache() { 196 super.flushCollectionCache(); 197 } 198 /** 199 * @apilevel internal 200 * @declaredat ASTNode:60 201 */ 202 public void flushRewriteCache() { 203 super.flushRewriteCache(); 204 } 205 /** 206 * @apilevel internal 207 * @declaredat ASTNode:66 208 */ 209 public LambdaExpr clone() throws CloneNotSupportedException { 210 LambdaExpr node = (LambdaExpr) super.clone(); 211 return node; 212 } 213 /** 214 * @apilevel internal 215 * @declaredat ASTNode:73 216 */ 217 public LambdaExpr copy() { 218 try { 219 LambdaExpr node = (LambdaExpr) clone(); 220 node.parent = null; 221 if (children != null) { 222 node.children = (ASTNode[]) children.clone(); 223 } 224 return node; 225 } catch (CloneNotSupportedException e) { 226 throw new Error("Error: clone not supported for " + getClass().getName()); 227 } 228 } 229 /** 230 * Create a deep copy of the AST subtree at this node. 231 * The copy is dangling, i.e. has no parent. 232 * @return dangling copy of the subtree at this node 233 * @apilevel low-level 234 * @deprecated Please use treeCopy or treeCopyNoTransform instead 235 * @declaredat ASTNode:92 236 */ 237 @Deprecated 238 public LambdaExpr fullCopy() { 239 return treeCopyNoTransform(); 240 } 241 /** 242 * Create a deep copy of the AST subtree at this node. 243 * The copy is dangling, i.e. has no parent. 244 * @return dangling copy of the subtree at this node 245 * @apilevel low-level 246 * @declaredat ASTNode:102 247 */ 248 public LambdaExpr treeCopyNoTransform() { 249 LambdaExpr tree = (LambdaExpr) copy(); 250 if (children != null) { 251 for (int i = 0; i < children.length; ++i) { 252 ASTNode child = (ASTNode) children[i]; 253 if (child != null) { 254 child = child.treeCopyNoTransform(); 255 tree.setChild(child, i); 256 } 257 } 258 } 259 return tree; 260 } 261 /** 262 * Create a deep copy of the AST subtree at this node. 263 * The subtree of this node is traversed to trigger rewrites before copy. 264 * The copy is dangling, i.e. has no parent. 265 * @return dangling copy of the subtree at this node 266 * @apilevel low-level 267 * @declaredat ASTNode:122 268 */ 269 public LambdaExpr treeCopy() { 270 doFullTraversal(); 271 return treeCopyNoTransform(); 272 } 273 /** 274 * @apilevel internal 275 * @declaredat ASTNode:129 276 */ 277 protected boolean is$Equal(ASTNode node) { 278 return super.is$Equal(node); 279 } 280 /** 281 * Replaces the LambdaParameters child. 282 * @param node The new node to replace the LambdaParameters child. 283 * @apilevel high-level 284 */ 285 public void setLambdaParameters(LambdaParameters node) { 286 setChild(node, 0); 287 } 288 /** 289 * Retrieves the LambdaParameters child. 290 * @return The current node used as the LambdaParameters child. 291 * @apilevel high-level 292 */ 293 @ASTNodeAnnotation.Child(name="LambdaParameters") 294 public LambdaParameters getLambdaParameters() { 295 return (LambdaParameters) getChild(0); 296 } 297 /** 298 * Retrieves the LambdaParameters child. 299 * <p><em>This method does not invoke AST transformations.</em></p> 300 * @return The current node used as the LambdaParameters child. 301 * @apilevel low-level 302 */ 303 public LambdaParameters getLambdaParametersNoTransform() { 304 return (LambdaParameters) getChildNoTransform(0); 305 } 306 /** 307 * Replaces the LambdaBody child. 308 * @param node The new node to replace the LambdaBody child. 309 * @apilevel high-level 310 */ 311 public void setLambdaBody(LambdaBody node) { 312 setChild(node, 1); 313 } 314 /** 315 * Retrieves the LambdaBody child. 316 * @return The current node used as the LambdaBody child. 317 * @apilevel high-level 318 */ 319 @ASTNodeAnnotation.Child(name="LambdaBody") 320 public LambdaBody getLambdaBody() { 321 return (LambdaBody) getChild(1); 322 } 323 /** 324 * Retrieves the LambdaBody child. 325 * <p><em>This method does not invoke AST transformations.</em></p> 326 * @return The current node used as the LambdaBody child. 327 * @apilevel low-level 328 */ 329 public LambdaBody getLambdaBodyNoTransform() { 330 return (LambdaBody) getChildNoTransform(1); 331 } 332 /** 333 * @attribute syn 334 * @aspect PreciseRethrow 335 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149 336 */ 337 @ASTNodeAnnotation.Attribute 338 public boolean modifiedInScope(Variable var) { 339 boolean modifiedInScope_Variable_value = getLambdaBody().modifiedInScope(var); 340 341 return modifiedInScope_Variable_value; 342 } 343 /** 344 * @apilevel internal 345 */ 346 protected boolean arity_computed = false; 347 /** 348 * @apilevel internal 349 */ 350 protected int arity_value; 351 /** 352 * @apilevel internal 353 */ 354 private void arity_reset() { 355 arity_computed = false; 356 } 357 /** 358 * @attribute syn 359 * @aspect LambdaExpr 360 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:40 361 */ 362 @ASTNodeAnnotation.Attribute 363 public int arity() { 364 ASTNode$State state = state(); 365 if (arity_computed) { 366 return arity_value; 367 } 368 boolean intermediate = state.INTERMEDIATE_VALUE; 369 state.INTERMEDIATE_VALUE = false; 370 int num = state.boundariesCrossed; 371 boolean isFinal = this.is$Final(); 372 arity_value = numParameters(); 373 if (isFinal && num == state().boundariesCrossed) { 374 arity_computed = true; 375 } else { 376 } 377 state.INTERMEDIATE_VALUE |= intermediate; 378 379 return arity_value; 380 } 381 /** 382 * @apilevel internal 383 */ 384 protected boolean numParameters_computed = false; 385 /** 386 * @apilevel internal 387 */ 388 protected int numParameters_value; 389 /** 390 * @apilevel internal 391 */ 392 private void numParameters_reset() { 393 numParameters_computed = false; 394 } 395 /** 396 * @attribute syn 397 * @aspect LambdaExpr 398 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:43 399 */ 400 @ASTNodeAnnotation.Attribute 401 public int numParameters() { 402 ASTNode$State state = state(); 403 if (numParameters_computed) { 404 return numParameters_value; 405 } 406 boolean intermediate = state.INTERMEDIATE_VALUE; 407 state.INTERMEDIATE_VALUE = false; 408 int num = state.boundariesCrossed; 409 boolean isFinal = this.is$Final(); 410 numParameters_value = getLambdaParameters().numParameters(); 411 if (isFinal && num == state().boundariesCrossed) { 412 numParameters_computed = true; 413 } else { 414 } 415 state.INTERMEDIATE_VALUE |= intermediate; 416 417 return numParameters_value; 418 } 419 /** 420 * @apilevel internal 421 */ 422 protected boolean isImplicit_computed = false; 423 /** 424 * @apilevel internal 425 */ 426 protected boolean isImplicit_value; 427 /** 428 * @apilevel internal 429 */ 430 private void isImplicit_reset() { 431 isImplicit_computed = false; 432 } 433 /** 434 * @attribute syn 435 * @aspect LambdaExpr 436 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:68 437 */ 438 @ASTNodeAnnotation.Attribute 439 public boolean isImplicit() { 440 ASTNode$State state = state(); 441 if (isImplicit_computed) { 442 return isImplicit_value; 443 } 444 boolean intermediate = state.INTERMEDIATE_VALUE; 445 state.INTERMEDIATE_VALUE = false; 446 int num = state.boundariesCrossed; 447 boolean isFinal = this.is$Final(); 448 isImplicit_value = getLambdaParameters() instanceof InferredLambdaParameters; 449 if (isFinal && num == state().boundariesCrossed) { 450 isImplicit_computed = true; 451 } else { 452 } 453 state.INTERMEDIATE_VALUE |= intermediate; 454 455 return isImplicit_value; 456 } 457 /** 458 * @apilevel internal 459 */ 460 protected boolean isExplicit_computed = false; 461 /** 462 * @apilevel internal 463 */ 464 protected boolean isExplicit_value; 465 /** 466 * @apilevel internal 467 */ 468 private void isExplicit_reset() { 469 isExplicit_computed = false; 470 } 471 /** 472 * @attribute syn 473 * @aspect LambdaExpr 474 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:69 475 */ 476 @ASTNodeAnnotation.Attribute 477 public boolean isExplicit() { 478 ASTNode$State state = state(); 479 if (isExplicit_computed) { 480 return isExplicit_value; 481 } 482 boolean intermediate = state.INTERMEDIATE_VALUE; 483 state.INTERMEDIATE_VALUE = false; 484 int num = state.boundariesCrossed; 485 boolean isFinal = this.is$Final(); 486 isExplicit_value = !isImplicit(); 487 if (isFinal && num == state().boundariesCrossed) { 488 isExplicit_computed = true; 489 } else { 490 } 491 state.INTERMEDIATE_VALUE |= intermediate; 492 493 return isExplicit_value; 494 } 495 /** 496 * @apilevel internal 497 */ 498 protected java.util.Map congruentTo_FunctionDescriptor_values; 499 /** 500 * @apilevel internal 501 */ 502 private void congruentTo_FunctionDescriptor_reset() { 503 congruentTo_FunctionDescriptor_values = null; 504 } 505 /** 506 * @attribute syn 507 * @aspect LambdaExpr 508 * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:108 509 */ 510 @ASTNodeAnnotation.Attribute 511 public boolean congruentTo(FunctionDescriptor f) { 512 Object _parameters = f; 513 if (congruentTo_FunctionDescriptor_values == null) congruentTo_FunctionDescriptor_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 514 ASTNode$State state = state(); 515 if (congruentTo_FunctionDescriptor_values.containsKey(_parameters)) { 516 return (Boolean) congruentTo_FunctionDescriptor_values.get(_parameters); 517 } 518 boolean intermediate = state.INTERMEDIATE_VALUE; 519 state.INTERMEDIATE_VALUE = false; 520 int num = state.boundariesCrossed; 521 boolean isFinal = this.is$Final(); 522 boolean congruentTo_FunctionDescriptor_value = !f.isGeneric() && getLambdaParameters().congruentTo(f) && getLambdaBody().congruentTo(f); 523 if (isFinal && num == state().boundariesCrossed) { 524 congruentTo_FunctionDescriptor_values.put(_parameters, congruentTo_FunctionDescriptor_value); 525 } else { 526 } 527 state.INTERMEDIATE_VALUE |= intermediate; 528 529 return congruentTo_FunctionDescriptor_value; 530 } 531 /** 532 * @apilevel internal 533 */ 534 protected java.util.Map compatibleStrictContext_TypeDecl_values; 535 /** 536 * @apilevel internal 537 */ 538 private void compatibleStrictContext_TypeDecl_reset() { 539 compatibleStrictContext_TypeDecl_values = null; 540 } 541 /** 542 * @attribute syn 543 * @aspect MethodSignature18 544 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:32 545 */ 546 @ASTNodeAnnotation.Attribute 547 public boolean compatibleStrictContext(TypeDecl type) { 548 Object _parameters = type; 549 if (compatibleStrictContext_TypeDecl_values == null) compatibleStrictContext_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 550 ASTNode$State state = state(); 551 if (compatibleStrictContext_TypeDecl_values.containsKey(_parameters)) { 552 return (Boolean) compatibleStrictContext_TypeDecl_values.get(_parameters); 553 } 554 boolean intermediate = state.INTERMEDIATE_VALUE; 555 state.INTERMEDIATE_VALUE = false; 556 int num = state.boundariesCrossed; 557 boolean isFinal = this.is$Final(); 558 boolean compatibleStrictContext_TypeDecl_value = compatibleStrictContext_compute(type); 559 if (isFinal && num == state().boundariesCrossed) { 560 compatibleStrictContext_TypeDecl_values.put(_parameters, compatibleStrictContext_TypeDecl_value); 561 } else { 562 } 563 state.INTERMEDIATE_VALUE |= intermediate; 564 565 return compatibleStrictContext_TypeDecl_value; 566 } 567 /** 568 * @apilevel internal 569 */ 570 private boolean compatibleStrictContext_compute(TypeDecl type) { 571 if (!type.isFunctionalInterface()) { 572 return false; 573 } 574 InterfaceDecl iDecl = (InterfaceDecl) type; 575 return congruentTo(iDecl.functionDescriptor()); 576 } 577 /** 578 * @apilevel internal 579 */ 580 protected java.util.Map compatibleLooseContext_TypeDecl_values; 581 /** 582 * @apilevel internal 583 */ 584 private void compatibleLooseContext_TypeDecl_reset() { 585 compatibleLooseContext_TypeDecl_values = null; 586 } 587 /** 588 * @attribute syn 589 * @aspect MethodSignature18 590 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:79 591 */ 592 @ASTNodeAnnotation.Attribute 593 public boolean compatibleLooseContext(TypeDecl type) { 594 Object _parameters = type; 595 if (compatibleLooseContext_TypeDecl_values == null) compatibleLooseContext_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 596 ASTNode$State state = state(); 597 if (compatibleLooseContext_TypeDecl_values.containsKey(_parameters)) { 598 return (Boolean) compatibleLooseContext_TypeDecl_values.get(_parameters); 599 } 600 boolean intermediate = state.INTERMEDIATE_VALUE; 601 state.INTERMEDIATE_VALUE = false; 602 int num = state.boundariesCrossed; 603 boolean isFinal = this.is$Final(); 604 boolean compatibleLooseContext_TypeDecl_value = compatibleStrictContext(type); 605 if (isFinal && num == state().boundariesCrossed) { 606 compatibleLooseContext_TypeDecl_values.put(_parameters, compatibleLooseContext_TypeDecl_value); 607 } else { 608 } 609 state.INTERMEDIATE_VALUE |= intermediate; 610 611 return compatibleLooseContext_TypeDecl_value; 612 } 613 /** 614 * @apilevel internal 615 */ 616 protected java.util.Map pertinentToApplicability_Expr_BodyDecl_int_values; 617 /** 618 * @apilevel internal 619 */ 620 private void pertinentToApplicability_Expr_BodyDecl_int_reset() { 621 pertinentToApplicability_Expr_BodyDecl_int_values = null; 622 } 623 /** 624 * @attribute syn 625 * @aspect MethodSignature18 626 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:107 627 */ 628 @ASTNodeAnnotation.Attribute 629 public boolean pertinentToApplicability(Expr access, BodyDecl decl, int argIndex) { 630 java.util.List _parameters = new java.util.ArrayList(3); 631 _parameters.add(access); 632 _parameters.add(decl); 633 _parameters.add(argIndex); 634 if (pertinentToApplicability_Expr_BodyDecl_int_values == null) pertinentToApplicability_Expr_BodyDecl_int_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 635 ASTNode$State state = state(); 636 if (pertinentToApplicability_Expr_BodyDecl_int_values.containsKey(_parameters)) { 637 return (Boolean) pertinentToApplicability_Expr_BodyDecl_int_values.get(_parameters); 638 } 639 boolean intermediate = state.INTERMEDIATE_VALUE; 640 state.INTERMEDIATE_VALUE = false; 641 int num = state.boundariesCrossed; 642 boolean isFinal = this.is$Final(); 643 boolean pertinentToApplicability_Expr_BodyDecl_int_value = pertinentToApplicability_compute(access, decl, argIndex); 644 if (isFinal && num == state().boundariesCrossed) { 645 pertinentToApplicability_Expr_BodyDecl_int_values.put(_parameters, pertinentToApplicability_Expr_BodyDecl_int_value); 646 } else { 647 } 648 state.INTERMEDIATE_VALUE |= intermediate; 649 650 return pertinentToApplicability_Expr_BodyDecl_int_value; 651 } 652 /** 653 * @apilevel internal 654 */ 655 private boolean pertinentToApplicability_compute(Expr access, BodyDecl decl, int argIndex) { 656 if (isImplicit()) { 657 return false; 658 } 659 if (decl instanceof MethodDecl 660 && decl.isGeneric() 661 && !(access instanceof ParMethodAccess) 662 && ((MethodDecl) decl).genericDecl().getParameter(argIndex).type().isTypeVariable()) { 663 GenericMethodDecl genericDecl = ((MethodDecl) decl).genericDecl(); 664 TypeVariable typeVar = (TypeVariable) genericDecl.getParameter(argIndex).type(); 665 for (int i = 0; i < genericDecl.getNumTypeParameter(); i++) { 666 if (typeVar == genericDecl.getTypeParameter(i)) { 667 return false; 668 } 669 } 670 } else if (decl instanceof ConstructorDecl 671 && decl.isGeneric() 672 && !(access instanceof ParConstructorAccess) 673 && !(access instanceof ParSuperConstructorAccess) 674 && !(access instanceof ParClassInstanceExpr) 675 && ((ConstructorDecl) decl).genericDecl().getParameter(argIndex).type().isTypeVariable()) { 676 GenericConstructorDecl genericDecl = ((ConstructorDecl) decl).genericDecl(); 677 TypeVariable typeVar = (TypeVariable) genericDecl.getParameter(argIndex).type(); 678 for (int i = 0; i < genericDecl.getNumTypeParameter(); i++) { 679 if (typeVar == genericDecl.getTypeParameter(i)) { 680 return false; 681 } 682 } 683 } 684 if (getLambdaBody() instanceof ExprLambdaBody) { 685 ExprLambdaBody exprBody = (ExprLambdaBody) getLambdaBody(); 686 if (!exprBody.getExpr().pertinentToApplicability(access, decl, argIndex)) { 687 return false; 688 } 689 } else { 690 BlockLambdaBody blockBody = (BlockLambdaBody) getLambdaBody(); 691 ArrayList<ReturnStmt> returnList = blockBody.lambdaReturns(); 692 for (ReturnStmt returnStmt : returnList) { 693 if (returnStmt.hasResult() 694 && !returnStmt.getResult().pertinentToApplicability(access, decl, argIndex)) { 695 return false; 696 } 697 } 698 } 699 return true; 700 } 701 /** 702 * @apilevel internal 703 */ 704 protected java.util.Map moreSpecificThan_TypeDecl_TypeDecl_values; 705 /** 706 * @apilevel internal 707 */ 708 private void moreSpecificThan_TypeDecl_TypeDecl_reset() { 709 moreSpecificThan_TypeDecl_TypeDecl_values = null; 710 } 711 /** 712 * Computes which type is more specific for a specific argument, as defined in 15.12.2.5 713 * @param type1 714 * @param type2 715 * @return {@code true} if type1 is more specific than type2, {@code false} otherwise 716 * @attribute syn 717 * @aspect MethodSignature18 718 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:233 719 */ 720 @ASTNodeAnnotation.Attribute 721 public boolean moreSpecificThan(TypeDecl type1, TypeDecl type2) { 722 java.util.List _parameters = new java.util.ArrayList(2); 723 _parameters.add(type1); 724 _parameters.add(type2); 725 if (moreSpecificThan_TypeDecl_TypeDecl_values == null) moreSpecificThan_TypeDecl_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 726 ASTNode$State state = state(); 727 if (moreSpecificThan_TypeDecl_TypeDecl_values.containsKey(_parameters)) { 728 return (Boolean) moreSpecificThan_TypeDecl_TypeDecl_values.get(_parameters); 729 } 730 boolean intermediate = state.INTERMEDIATE_VALUE; 731 state.INTERMEDIATE_VALUE = false; 732 int num = state.boundariesCrossed; 733 boolean isFinal = this.is$Final(); 734 boolean moreSpecificThan_TypeDecl_TypeDecl_value = moreSpecificThan_compute(type1, type2); 735 if (isFinal && num == state().boundariesCrossed) { 736 moreSpecificThan_TypeDecl_TypeDecl_values.put(_parameters, moreSpecificThan_TypeDecl_TypeDecl_value); 737 } else { 738 } 739 state.INTERMEDIATE_VALUE |= intermediate; 740 741 return moreSpecificThan_TypeDecl_TypeDecl_value; 742 } 743 /** 744 * @apilevel internal 745 */ 746 private boolean moreSpecificThan_compute(TypeDecl type1, TypeDecl type2) { 747 if (super.moreSpecificThan(type1, type2)) { 748 return true; 749 } 750 if (!type1.isFunctionalInterface() || !type2.isFunctionalInterface()) { 751 return false; 752 } 753 if (type2.instanceOf(type1)) { 754 // type1 can not be more specific than type2 if it is a subtype of type2 755 return false; 756 } 757 InterfaceDecl iDecl1 = (InterfaceDecl) type1; 758 InterfaceDecl iDecl2 = (InterfaceDecl) type2; 759 760 if (isImplicit()) { 761 return false; 762 } 763 764 FunctionDescriptor f1 = iDecl1.functionDescriptor(); 765 FunctionDescriptor f2 = iDecl2.functionDescriptor(); 766 767 // First bullet 768 if (f2.method.type().isVoid()) { 769 return true; 770 } 771 772 // Second bullet 773 if (f1.method.type().instanceOf(f2.method.type())) { 774 return true; 775 } 776 777 // Third bullet 778 if (f1.method.type().isFunctionalInterface() && f2.method.type().isFunctionalInterface()) { 779 if (getLambdaBody().isBlockBody()) { 780 BlockLambdaBody blockBody = (BlockLambdaBody) getLambdaBody(); 781 boolean allMoreSpecific = true; 782 ArrayList<ReturnStmt> returnList = blockBody.lambdaReturns(); 783 for (ReturnStmt returnStmt : returnList) { 784 if (returnStmt.hasResult() && !returnStmt.getResult().moreSpecificThan(f1.method.type(), f2.method.type())) { 785 allMoreSpecific = false; 786 break; 787 } 788 } 789 return allMoreSpecific; 790 } else { 791 ExprLambdaBody exprBody = (ExprLambdaBody) getLambdaBody(); 792 return exprBody.getExpr().moreSpecificThan(f1.method.type(), f2.method.type()); 793 } 794 } 795 796 // Fourth bullet 797 if (f1.method.type().isPrimitiveType() && f2.method.type().isReferenceType()) { 798 if (getLambdaBody().isBlockBody()) { 799 BlockLambdaBody blockBody = (BlockLambdaBody) getLambdaBody(); 800 boolean allPrimitive = true; 801 ArrayList<ReturnStmt> returnList = blockBody.lambdaReturns(); 802 for (ReturnStmt returnStmt : returnList) { 803 if (returnStmt.hasResult() && returnStmt.getResult().isPolyExpression()) { 804 allPrimitive = false; 805 break; 806 } else if (returnStmt.hasResult() && !returnStmt.getResult().type().isPrimitiveType()) { 807 allPrimitive = false; 808 break; 809 } 810 } 811 return allPrimitive; 812 } else { 813 ExprLambdaBody exprBody = (ExprLambdaBody) getLambdaBody(); 814 if (exprBody.getExpr().isPolyExpression()) { 815 return false; 816 } 817 return exprBody.getExpr().type().isPrimitiveType(); 818 } 819 } 820 821 // Fifth bullet 822 if (f1.method.type().isReferenceType() && f2.method.type().isPrimitiveType()) { 823 if (getLambdaBody().isBlockBody()) { 824 BlockLambdaBody blockBody = (BlockLambdaBody) getLambdaBody(); 825 boolean allReference = true; 826 ArrayList<ReturnStmt> returnList = blockBody.lambdaReturns(); 827 for (ReturnStmt returnStmt : returnList) { 828 if (returnStmt.hasResult() && !returnStmt.getResult().isPolyExpression() 829 && !returnStmt.getResult().type().isReferenceType()) { 830 allReference = false; 831 break; 832 } 833 } 834 return allReference; 835 } else { 836 ExprLambdaBody exprBody = (ExprLambdaBody) getLambdaBody(); 837 if (exprBody.getExpr().isPolyExpression()) { 838 return true; 839 } 840 return exprBody.getExpr().type().isReferenceType(); 841 } 842 } 843 return false; 844 } 845 /** 846 * @apilevel internal 847 */ 848 protected java.util.Map potentiallyCompatible_TypeDecl_BodyDecl_values; 849 /** 850 * @apilevel internal 851 */ 852 private void potentiallyCompatible_TypeDecl_BodyDecl_reset() { 853 potentiallyCompatible_TypeDecl_BodyDecl_values = null; 854 } 855 /** 856 * @attribute syn 857 * @aspect MethodSignature18 858 * @declaredat /home/jesper/git/extendj/java8/frontend/MethodSignature.jrag:466 859 */ 860 @ASTNodeAnnotation.Attribute 861 public boolean potentiallyCompatible(TypeDecl type, BodyDecl candidateDecl) { 862 java.util.List _parameters = new java.util.ArrayList(2); 863 _parameters.add(type); 864 _parameters.add(candidateDecl); 865 if (potentiallyCompatible_TypeDecl_BodyDecl_values == null) potentiallyCompatible_TypeDecl_BodyDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 866 ASTNode$State state = state(); 867 if (potentiallyCompatible_TypeDecl_BodyDecl_values.containsKey(_parameters)) { 868 return (Boolean) potentiallyCompatible_TypeDecl_BodyDecl_values.get(_parameters); 869 } 870 boolean intermediate = state.INTERMEDIATE_VALUE; 871 state.INTERMEDIATE_VALUE = false; 872 int num = state.boundariesCrossed; 873 boolean isFinal = this.is$Final(); 874 boolean potentiallyCompatible_TypeDecl_BodyDecl_value = potentiallyCompatible_compute(type, candidateDecl); 875 if (isFinal && num == state().boundariesCrossed) { 876 potentiallyCompatible_TypeDecl_BodyDecl_values.put(_parameters, potentiallyCompatible_TypeDecl_BodyDecl_value); 877 } else { 878 } 879 state.INTERMEDIATE_VALUE |= intermediate; 880 881 return potentiallyCompatible_TypeDecl_BodyDecl_value; 882 } 883 /** 884 * @apilevel internal 885 */ 886 private boolean potentiallyCompatible_compute(TypeDecl type, BodyDecl candidateDecl) { 887 if (type.isTypeVariable()) { 888 if (candidateDecl.isGeneric()) { 889 boolean foundTypeVariable = false; 890 List<TypeVariable> typeParams = candidateDecl.typeParameters(); 891 for (int i = 0; i < typeParams.getNumChild(); i++) { 892 if (type == typeParams.getChild(i)) { 893 foundTypeVariable = true; 894 break; 895 } 896 } 897 return foundTypeVariable; 898 } else { 899 return false; 900 } 901 } 902 903 if (!type.isFunctionalInterface()) { 904 return false; 905 } 906 InterfaceDecl iDecl = (InterfaceDecl) type; 907 908 if (arity() != iDecl.functionDescriptor().method.arity()) { 909 return false; 910 } 911 if (iDecl.functionDescriptor().method.type().isVoid()) { 912 if (getLambdaBody().isExprBody()) { 913 ExprLambdaBody exprBody = (ExprLambdaBody) getLambdaBody(); 914 if (!exprBody.getExpr().stmtCompatible()) { 915 return false; 916 } 917 } else { 918 BlockLambdaBody blockBody = (BlockLambdaBody) getLambdaBody(); 919 if (!blockBody.voidCompatible()) { 920 return false; 921 } 922 } 923 } else { 924 if (getLambdaBody().isBlockBody()) { 925 BlockLambdaBody blockBody = (BlockLambdaBody) getLambdaBody(); 926 if (!blockBody.valueCompatible()) { 927 return false; 928 } 929 } 930 } 931 return true; 932 } 933 /** 934 * @apilevel internal 935 */ 936 protected boolean isPolyExpression_computed = false; 937 /** 938 * @apilevel internal 939 */ 940 protected boolean isPolyExpression_value; 941 /** 942 * @apilevel internal 943 */ 944 private void isPolyExpression_reset() { 945 isPolyExpression_computed = false; 946 } 947 /** 948 * @attribute syn 949 * @aspect PolyExpressions 950 * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:80 951 */ 952 @ASTNodeAnnotation.Attribute 953 public boolean isPolyExpression() { 954 ASTNode$State state = state(); 955 if (isPolyExpression_computed) { 956 return isPolyExpression_value; 957 } 958 boolean intermediate = state.INTERMEDIATE_VALUE; 959 state.INTERMEDIATE_VALUE = false; 960 int num = state.boundariesCrossed; 961 boolean isFinal = this.is$Final(); 962 isPolyExpression_value = true; 963 if (isFinal && num == state().boundariesCrossed) { 964 isPolyExpression_computed = true; 965 } else { 966 } 967 state.INTERMEDIATE_VALUE |= intermediate; 968 969 return isPolyExpression_value; 970 } 971 /** 972 * @apilevel internal 973 */ 974 protected java.util.Map assignConversionTo_TypeDecl_values; 975 /** 976 * @apilevel internal 977 */ 978 private void assignConversionTo_TypeDecl_reset() { 979 assignConversionTo_TypeDecl_values = null; 980 } 981 /** 982 * @attribute syn 983 * @aspect PolyExpressions 984 * @declaredat /home/jesper/git/extendj/java8/frontend/PolyExpressions.jrag:142 985 */ 986 @ASTNodeAnnotation.Attribute 987 public boolean assignConversionTo(TypeDecl type) { 988 Object _parameters = type; 989 if (assignConversionTo_TypeDecl_values == null) assignConversionTo_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 990 ASTNode$State state = state(); 991 if (assignConversionTo_TypeDecl_values.containsKey(_parameters)) { 992 return (Boolean) assignConversionTo_TypeDecl_values.get(_parameters); 993 } 994 boolean intermediate = state.INTERMEDIATE_VALUE; 995 state.INTERMEDIATE_VALUE = false; 996 int num = state.boundariesCrossed; 997 boolean isFinal = this.is$Final(); 998 boolean assignConversionTo_TypeDecl_value = assignConversionTo_compute(type); 999 if (isFinal && num == state().boundariesCrossed) { 1000 assignConversionTo_TypeDecl_values.put(_parameters, assignConversionTo_TypeDecl_value); 1001 } else { 1002 } 1003 state.INTERMEDIATE_VALUE |= intermediate; 1004 1005 return assignConversionTo_TypeDecl_value; 1006 } 1007 /** 1008 * @apilevel internal 1009 */ 1010 private boolean assignConversionTo_compute(TypeDecl type) { 1011 if (!type.isFunctionalInterface()) { 1012 return false; 1013 } 1014 FunctionDescriptor f = ((InterfaceDecl) type).functionDescriptor(); 1015 return congruentTo(f); 1016 } 1017 /** 1018 * @apilevel internal 1019 */ 1020 protected boolean targetInterface_computed = false; 1021 /** 1022 * @apilevel internal 1023 */ 1024 protected InterfaceDecl targetInterface_value; 1025 /** 1026 * @apilevel internal 1027 */ 1028 private void targetInterface_reset() { 1029 targetInterface_computed = false; 1030 targetInterface_value = null; 1031 } 1032 /** 1033 * @attribute syn 1034 * @aspect TargetType 1035 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:142 1036 */ 1037 @ASTNodeAnnotation.Attribute 1038 public InterfaceDecl targetInterface() { 1039 ASTNode$State state = state(); 1040 if (targetInterface_computed) { 1041 return targetInterface_value; 1042 } 1043 boolean intermediate = state.INTERMEDIATE_VALUE; 1044 state.INTERMEDIATE_VALUE = false; 1045 int num = state.boundariesCrossed; 1046 boolean isFinal = this.is$Final(); 1047 targetInterface_value = targetInterface_compute(); 1048 if (isFinal && num == state().boundariesCrossed) { 1049 targetInterface_computed = true; 1050 } else { 1051 } 1052 state.INTERMEDIATE_VALUE |= intermediate; 1053 1054 return targetInterface_value; 1055 } 1056 /** 1057 * @apilevel internal 1058 */ 1059 private InterfaceDecl targetInterface_compute() { 1060 if (targetType().isNull()) { 1061 return null; 1062 } else if (!(targetType() instanceof InterfaceDecl)) { 1063 return null; 1064 } else { 1065 return (InterfaceDecl)targetType(); 1066 } 1067 } 1068 /** 1069 * @apilevel internal 1070 */ 1071 protected boolean type_computed = false; 1072 /** 1073 * @apilevel internal 1074 */ 1075 protected TypeDecl type_value; 1076 /** 1077 * @apilevel internal 1078 */ 1079 private void type_reset() { 1080 type_computed = false; 1081 type_value = null; 1082 } 1083 /** 1084 * @attribute syn 1085 * @aspect TypeCheck 1086 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:55 1087 */ 1088 @ASTNodeAnnotation.Attribute 1089 public TypeDecl type() { 1090 ASTNode$State state = state(); 1091 if (type_computed) { 1092 return type_value; 1093 } 1094 boolean intermediate = state.INTERMEDIATE_VALUE; 1095 state.INTERMEDIATE_VALUE = false; 1096 int num = state.boundariesCrossed; 1097 boolean isFinal = this.is$Final(); 1098 type_value = type_compute(); 1099 if (isFinal && num == state().boundariesCrossed) { 1100 type_computed = true; 1101 } else { 1102 } 1103 state.INTERMEDIATE_VALUE |= intermediate; 1104 1105 return type_value; 1106 } 1107 /** 1108 * @apilevel internal 1109 */ 1110 private TypeDecl type_compute() { 1111 // 15.27.3 1112 if (!assignmentContext() && !castContext() && !invocationContext()) { 1113 return unknownType(); 1114 } 1115 if (targetInterface() == null) { 1116 return unknownType(); 1117 } 1118 1119 InterfaceDecl iDecl = targetInterface(); 1120 if (!iDecl.isFunctional()) { 1121 return unknownType(); 1122 } 1123 if (congruentTo(iDecl.functionDescriptor())) { 1124 return iDecl; 1125 } else { 1126 return unknownType(); 1127 } 1128 } 1129 /** 1130 * @apilevel internal 1131 */ 1132 protected boolean toClass_computed = false; 1133 /** 1134 * @apilevel internal 1135 */ 1136 protected ClassInstanceExpr toClass_value; 1137 /** 1138 * @apilevel internal 1139 */ 1140 private void toClass_reset() { 1141 toClass_computed = false; 1142 toClass_value = null; 1143 } 1144 /** 1145 * @attribute syn 1146 * @aspect LambdaToClass 1147 * @declaredat /home/jesper/git/extendj/java8/backend/LambdaToClass.jrag:32 1148 */ 1149 @ASTNodeAnnotation.Attribute 1150 public ClassInstanceExpr toClass() { 1151 ASTNode$State state = state(); 1152 if (toClass_computed) { 1153 return toClass_value; 1154 } 1155 boolean intermediate = state.INTERMEDIATE_VALUE; 1156 state.INTERMEDIATE_VALUE = false; 1157 int num = state.boundariesCrossed; 1158 boolean isFinal = this.is$Final(); 1159 toClass_value = toClass_compute(); 1160 toClass_value.setParent(this); 1161 toClass_value.is$Final = true; 1162 if (true) { 1163 toClass_computed = true; 1164 } else { 1165 } 1166 state.INTERMEDIATE_VALUE |= intermediate; 1167 1168 return toClass_value; 1169 } 1170 /** 1171 * @apilevel internal 1172 */ 1173 private ClassInstanceExpr toClass_compute() { 1174 List<Access> implementsList = new List<Access>(); 1175 InterfaceDecl iDecl = targetInterface(); 1176 1177 // First compute the interface implemented by the anonymous class 1178 Access implementsInterface = iDecl.createQualifiedAccess(); 1179 implementsList.add(implementsInterface); 1180 1181 // Next compute the BodyDecls for the anonymous class 1182 List<BodyDecl> bodyDecls = new List<BodyDecl>(); 1183 1184 // To do that we must build the method which is the only BodyDecl 1185 Modifiers methodModifiers = new Modifiers(new List<Modifier>().add(new Modifier("public"))); 1186 Access returnType = (Access)iDecl.functionDescriptor().method.getTypeAccess().treeCopyNoTransform(); 1187 List<ParameterDeclaration> methodParams = getLambdaParameters().toParameterList(); 1188 List<Access> methodThrows = new List<Access>(); 1189 for (TypeDecl throwsType : iDecl.functionDescriptor().throwsList) { 1190 methodThrows.add(throwsType.createQualifiedAccess()); 1191 } 1192 Opt<Block> methodBlock = new Opt<Block>(getLambdaBody().toBlock()); 1193 MethodDecl method = new MethodDecl(methodModifiers, returnType, iDecl.functionDescriptor().method.name(), 1194 methodParams, methodThrows, methodBlock); 1195 1196 bodyDecls.add(method); 1197 1198 /* Now the anonymous class can be built. Must use the type LambdaAnonymousDecl instead 1199 of a normal AnonymousDecl in order for this and super keywords to get the type of the outer 1200 scope. */ 1201 LambdaAnonymousDecl anonymousDecl = new LambdaAnonymousDecl(new Modifiers(), "Lambda", bodyDecls); 1202 for (Access impl: implementsList) { 1203 anonymousDecl.addImplements(impl); 1204 } 1205 1206 return new ClassInstanceExpr(implementsInterface, new List<Expr>(), new Opt<TypeDecl>(anonymousDecl)); 1207 } 1208 /** 1209 * @attribute inh 1210 * @aspect EnclosingLambda 1211 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:38 1212 */ 1213 /** 1214 * @attribute inh 1215 * @aspect EnclosingLambda 1216 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:38 1217 */ 1218 @ASTNodeAnnotation.Attribute 1219 public LambdaExpr enclosingLambda() { 1220 ASTNode$State state = state(); 1221 if (enclosingLambda_computed) { 1222 return enclosingLambda_value; 1223 } 1224 boolean intermediate = state.INTERMEDIATE_VALUE; 1225 state.INTERMEDIATE_VALUE = false; 1226 int num = state.boundariesCrossed; 1227 boolean isFinal = this.is$Final(); 1228 enclosingLambda_value = getParent().Define_enclosingLambda(this, null); 1229 if (isFinal && num == state().boundariesCrossed) { 1230 enclosingLambda_computed = true; 1231 } else { 1232 } 1233 state.INTERMEDIATE_VALUE |= intermediate; 1234 1235 return enclosingLambda_value; 1236 } 1237 /** 1238 * @apilevel internal 1239 */ 1240 protected boolean enclosingLambda_computed = false; 1241 /** 1242 * @apilevel internal 1243 */ 1244 protected LambdaExpr enclosingLambda_value; 1245 /** 1246 * @apilevel internal 1247 */ 1248 private void enclosingLambda_reset() { 1249 enclosingLambda_computed = false; 1250 enclosingLambda_value = null; 1251 } 1252 /** 1253 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30 1254 * @apilevel internal 1255 */ 1256 public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 1257 if (caller == getLambdaParametersNoTransform()) { 1258 // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:34 1259 return modifiedInScope(var); 1260 } 1261 else { 1262 return getParent().Define_inhModifiedInScope(this, caller, var); 1263 } 1264 } 1265 protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 1266 return true; 1267 } 1268 /** 1269 * @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:37 1270 * @apilevel internal 1271 */ 1272 public LambdaExpr Define_enclosingLambda(ASTNode caller, ASTNode child) { 1273 if (caller == toClass_value) { 1274 // @declaredat /home/jesper/git/extendj/java8/backend/ToClassInherited.jrag:34 1275 return this; 1276 } 1277 else if (caller == getLambdaParametersNoTransform()) { 1278 // @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:42 1279 return this; 1280 } 1281 else if (caller == getLambdaBodyNoTransform()) { 1282 // @declaredat /home/jesper/git/extendj/java8/frontend/EnclosingLambda.jrag:41 1283 return this; 1284 } 1285 else { 1286 return getParent().Define_enclosingLambda(this, caller); 1287 } 1288 } 1289 protected boolean canDefine_enclosingLambda(ASTNode caller, ASTNode child) { 1290 return true; 1291 } 1292 /** 1293 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:262 1294 * @apilevel internal 1295 */ 1296 public FinallyHost Define_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) { 1297 int childIndex = this.getIndexOfChild(caller); 1298 return null; 1299 } 1300 protected boolean canDefine_enclosingFinally(ASTNode caller, ASTNode child, Stmt branch) { 1301 return true; 1302 } 1303 /** 1304 * @declaredat /home/jesper/git/extendj/java4/frontend/BranchTarget.jrag:227 1305 * @apilevel internal 1306 */ 1307 public Stmt Define_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 1308 int childIndex = this.getIndexOfChild(caller); 1309 { 1310 throw new Error("Found no branch targets for " + branch.getClass().getName()); 1311 } 1312 } 1313 protected boolean canDefine_branchTarget(ASTNode caller, ASTNode child, Stmt branch) { 1314 return true; 1315 } 1316 /** 1317 * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:524 1318 * @apilevel internal 1319 */ 1320 public SimpleSet Define_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) { 1321 int childIndex = this.getIndexOfChild(caller); 1322 return SimpleSet.emptySet; 1323 } 1324 protected boolean canDefine_otherLocalClassDecls(ASTNode caller, ASTNode child, String name) { 1325 return true; 1326 } 1327 /** 1328 * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:113 1329 * @apilevel internal 1330 */ 1331 public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 1332 if (caller == getLambdaBodyNoTransform()) { 1333 // @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:150 1334 { 1335 InterfaceDecl iDecl = targetInterface(); 1336 if (iDecl == null) { 1337 return false; 1338 } else if (!iDecl.isFunctional()) { 1339 return false; 1340 } 1341 for (TypeDecl exception : iDecl.functionDescriptor().throwsList) { 1342 if (exceptionType.strictSubtype(exception)) { 1343 return true; 1344 } 1345 } 1346 return false; 1347 } 1348 } 1349 else { 1350 return getParent().Define_handlesException(this, caller, exceptionType); 1351 } 1352 } 1353 protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) { 1354 return true; 1355 } 1356 /** 1357 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 1358 * @apilevel internal 1359 */ 1360 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 1361 if (caller == getLambdaBodyNoTransform()) { 1362 // @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:56 1363 { 1364 if (getLambdaParameters() instanceof DeclaredLambdaParameters) { 1365 SimpleSet decls = ((DeclaredLambdaParameters) getLambdaParameters()) 1366 .parameterDeclaration(name); 1367 if (!decls.isEmpty()) { 1368 return decls; 1369 } 1370 } else if (getLambdaParameters() instanceof InferredLambdaParameters) { 1371 SimpleSet decls = ((InferredLambdaParameters)getLambdaParameters()) 1372 .parameterDeclaration(name); 1373 if (!decls.isEmpty()) { 1374 return decls; 1375 } 1376 } 1377 return lookupVariable(name); 1378 } 1379 } 1380 else { 1381 return getParent().Define_lookupVariable(this, caller, name); 1382 } 1383 } 1384 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 1385 return true; 1386 } 1387 /** 1388 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:30 1389 * @apilevel internal 1390 */ 1391 public VariableScope Define_outerScope(ASTNode caller, ASTNode child) { 1392 if (caller == getLambdaBodyNoTransform()) { 1393 // @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:35 1394 return this; 1395 } 1396 else if (caller == getLambdaParametersNoTransform()) { 1397 // @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:34 1398 return this; 1399 } 1400 else { 1401 return getParent().Define_outerScope(this, caller); 1402 } 1403 } 1404 protected boolean canDefine_outerScope(ASTNode caller, ASTNode child) { 1405 return true; 1406 } 1407 /** 1408 * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:31 1409 * @apilevel internal 1410 */ 1411 public TypeDecl Define_unknownType(ASTNode caller, ASTNode child) { 1412 if (caller == getLambdaBodyNoTransform()) { 1413 // @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:33 1414 return unknownType(); 1415 } 1416 else if (caller == getLambdaParametersNoTransform()) { 1417 // @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:32 1418 return unknownType(); 1419 } 1420 else { 1421 return getParent().Define_unknownType(this, caller); 1422 } 1423 } 1424 protected boolean canDefine_unknownType(ASTNode caller, ASTNode child) { 1425 return true; 1426 } 1427 /** 1428 * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1836 1429 * @apilevel internal 1430 */ 1431 public boolean Define_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) { 1432 int childIndex = this.getIndexOfChild(caller); 1433 { 1434 throw new Error("Enclosing monitor not found!"); 1435 } 1436 } 1437 protected boolean canDefine_leavesMonitor(ASTNode caller, ASTNode child, Stmt branch, SynchronizedStmt monitor) { 1438 return true; 1439 } 1440 /** 1441 * @apilevel internal 1442 */ 1443 public ASTNode rewriteTo() { 1444 return super.rewriteTo(); 1445 } 1446 }