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    }