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:8
027     * @production InferredLambdaParameters : {@link LambdaParameters} ::= <span class="component">Parameter:{@link InferredParameterDeclaration}*</span>;
028    
029     */
030    public class InferredLambdaParameters extends LambdaParameters implements Cloneable {
031      /**
032       * @aspect Java8NameCheck
033       * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:559
034       */
035      public void nameCheck() {
036        for (int i = 0; i < getNumParameter(); i++) {
037          if (getParameter(i).name().equals("_")) {
038            // 15.27.1
039            error("Underscore is not a valid identifier for a lambda parameter");
040            return;
041          }
042        }
043      }
044      /**
045       * @aspect Java8PrettyPrint
046       * @declaredat /home/jesper/git/extendj/java8/frontend/PrettyPrint.jadd:54
047       */
048      public void prettyPrint(PrettyPrinter out) {
049        out.print("(");
050        out.join(getParameters(), new PrettyPrinter.Joiner() {
051          @Override
052          public void printSeparator(PrettyPrinter out) {
053            out.print(", ");
054          }
055        });
056        out.print(")");
057      }
058      /**
059       * @declaredat ASTNode:1
060       */
061      public InferredLambdaParameters() {
062        super();
063      }
064      /**
065       * Initializes the child array to the correct size.
066       * Initializes List and Opt nta children.
067       * @apilevel internal
068       * @ast method
069       * @declaredat ASTNode:10
070       */
071      public void init$Children() {
072        children = new ASTNode[1];
073        setChild(new List(), 0);
074      }
075      /**
076       * @declaredat ASTNode:14
077       */
078      public InferredLambdaParameters(List<InferredParameterDeclaration> p0) {
079        setChild(p0, 0);
080      }
081      /**
082       * @apilevel low-level
083       * @declaredat ASTNode:20
084       */
085      protected int numChildren() {
086        return 1;
087      }
088      /**
089       * @apilevel internal
090       * @declaredat ASTNode:26
091       */
092      public boolean mayHaveRewrite() {
093        return false;
094      }
095      /**
096       * @apilevel internal
097       * @declaredat ASTNode:32
098       */
099      public void flushAttrCache() {
100        super.flushAttrCache();
101        numParameters_reset();
102        congruentTo_FunctionDescriptor_reset();
103        parameterDeclaration_String_reset();
104        toParameterList_reset();
105      }
106      /**
107       * @apilevel internal
108       * @declaredat ASTNode:42
109       */
110      public void flushCollectionCache() {
111        super.flushCollectionCache();
112      }
113      /**
114       * @apilevel internal
115       * @declaredat ASTNode:48
116       */
117      public void flushRewriteCache() {
118        super.flushRewriteCache();
119      }
120      /**
121       * @apilevel internal
122       * @declaredat ASTNode:54
123       */
124      public InferredLambdaParameters clone() throws CloneNotSupportedException {
125        InferredLambdaParameters node = (InferredLambdaParameters) super.clone();
126        return node;
127      }
128      /**
129       * @apilevel internal
130       * @declaredat ASTNode:61
131       */
132      public InferredLambdaParameters copy() {
133        try {
134          InferredLambdaParameters node = (InferredLambdaParameters) clone();
135          node.parent = null;
136          if (children != null) {
137            node.children = (ASTNode[]) children.clone();
138          }
139          return node;
140        } catch (CloneNotSupportedException e) {
141          throw new Error("Error: clone not supported for " + getClass().getName());
142        }
143      }
144      /**
145       * Create a deep copy of the AST subtree at this node.
146       * The copy is dangling, i.e. has no parent.
147       * @return dangling copy of the subtree at this node
148       * @apilevel low-level
149       * @deprecated Please use treeCopy or treeCopyNoTransform instead
150       * @declaredat ASTNode:80
151       */
152      @Deprecated
153      public InferredLambdaParameters fullCopy() {
154        return treeCopyNoTransform();
155      }
156      /**
157       * Create a deep copy of the AST subtree at this node.
158       * The copy is dangling, i.e. has no parent.
159       * @return dangling copy of the subtree at this node
160       * @apilevel low-level
161       * @declaredat ASTNode:90
162       */
163      public InferredLambdaParameters treeCopyNoTransform() {
164        InferredLambdaParameters tree = (InferredLambdaParameters) copy();
165        if (children != null) {
166          for (int i = 0; i < children.length; ++i) {
167            ASTNode child = (ASTNode) children[i];
168            if (child != null) {
169              child = child.treeCopyNoTransform();
170              tree.setChild(child, i);
171            }
172          }
173        }
174        return tree;
175      }
176      /**
177       * Create a deep copy of the AST subtree at this node.
178       * The subtree of this node is traversed to trigger rewrites before copy.
179       * The copy is dangling, i.e. has no parent.
180       * @return dangling copy of the subtree at this node
181       * @apilevel low-level
182       * @declaredat ASTNode:110
183       */
184      public InferredLambdaParameters treeCopy() {
185        doFullTraversal();
186        return treeCopyNoTransform();
187      }
188      /**
189       * @apilevel internal
190       * @declaredat ASTNode:117
191       */
192      protected boolean is$Equal(ASTNode node) {
193        return super.is$Equal(node);    
194      }
195      /**
196       * Replaces the Parameter list.
197       * @param list The new list node to be used as the Parameter list.
198       * @apilevel high-level
199       */
200      public void setParameterList(List<InferredParameterDeclaration> list) {
201        setChild(list, 0);
202      }
203      /**
204       * Retrieves the number of children in the Parameter list.
205       * @return Number of children in the Parameter list.
206       * @apilevel high-level
207       */
208      public int getNumParameter() {
209        return getParameterList().getNumChild();
210      }
211      /**
212       * Retrieves the number of children in the Parameter list.
213       * Calling this method will not trigger rewrites.
214       * @return Number of children in the Parameter list.
215       * @apilevel low-level
216       */
217      public int getNumParameterNoTransform() {
218        return getParameterListNoTransform().getNumChildNoTransform();
219      }
220      /**
221       * Retrieves the element at index {@code i} in the Parameter list.
222       * @param i Index of the element to return.
223       * @return The element at position {@code i} in the Parameter list.
224       * @apilevel high-level
225       */
226      public InferredParameterDeclaration getParameter(int i) {
227        return (InferredParameterDeclaration) getParameterList().getChild(i);
228      }
229      /**
230       * Check whether the Parameter list has any children.
231       * @return {@code true} if it has at least one child, {@code false} otherwise.
232       * @apilevel high-level
233       */
234      public boolean hasParameter() {
235        return getParameterList().getNumChild() != 0;
236      }
237      /**
238       * Append an element to the Parameter list.
239       * @param node The element to append to the Parameter list.
240       * @apilevel high-level
241       */
242      public void addParameter(InferredParameterDeclaration node) {
243        List<InferredParameterDeclaration> list = (parent == null) ? getParameterListNoTransform() : getParameterList();
244        list.addChild(node);
245      }
246      /**
247       * @apilevel low-level
248       */
249      public void addParameterNoTransform(InferredParameterDeclaration node) {
250        List<InferredParameterDeclaration> list = getParameterListNoTransform();
251        list.addChild(node);
252      }
253      /**
254       * Replaces the Parameter list element at index {@code i} with the new node {@code node}.
255       * @param node The new node to replace the old list element.
256       * @param i The list index of the node to be replaced.
257       * @apilevel high-level
258       */
259      public void setParameter(InferredParameterDeclaration node, int i) {
260        List<InferredParameterDeclaration> list = getParameterList();
261        list.setChild(node, i);
262      }
263      /**
264       * Retrieves the Parameter list.
265       * @return The node representing the Parameter list.
266       * @apilevel high-level
267       */
268      @ASTNodeAnnotation.ListChild(name="Parameter")
269      public List<InferredParameterDeclaration> getParameterList() {
270        List<InferredParameterDeclaration> list = (List<InferredParameterDeclaration>) getChild(0);
271        return list;
272      }
273      /**
274       * Retrieves the Parameter list.
275       * <p><em>This method does not invoke AST transformations.</em></p>
276       * @return The node representing the Parameter list.
277       * @apilevel low-level
278       */
279      public List<InferredParameterDeclaration> getParameterListNoTransform() {
280        return (List<InferredParameterDeclaration>) getChildNoTransform(0);
281      }
282      /**
283       * Retrieves the Parameter list.
284       * @return The node representing the Parameter list.
285       * @apilevel high-level
286       */
287      public List<InferredParameterDeclaration> getParameters() {
288        return getParameterList();
289      }
290      /**
291       * Retrieves the Parameter list.
292       * <p><em>This method does not invoke AST transformations.</em></p>
293       * @return The node representing the Parameter list.
294       * @apilevel low-level
295       */
296      public List<InferredParameterDeclaration> getParametersNoTransform() {
297        return getParameterListNoTransform();
298      }
299      /**
300       * @apilevel internal
301       */
302      protected boolean numParameters_computed = false;
303      /**
304       * @apilevel internal
305       */
306      protected int numParameters_value;
307      /**
308       * @apilevel internal
309       */
310      private void numParameters_reset() {
311        numParameters_computed = false;
312      }
313      /**
314       * @attribute syn
315       * @aspect LambdaExpr
316       * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:42
317       */
318      @ASTNodeAnnotation.Attribute
319      public int numParameters() {
320        ASTNode$State state = state();
321        if (numParameters_computed) {
322          return numParameters_value;
323        }
324        boolean intermediate = state.INTERMEDIATE_VALUE;
325        state.INTERMEDIATE_VALUE = false;
326        int num = state.boundariesCrossed;
327        boolean isFinal = this.is$Final();
328        numParameters_value = getNumParameter();
329        if (isFinal && num == state().boundariesCrossed) {
330          numParameters_computed = true;
331        } else {
332        }
333        state.INTERMEDIATE_VALUE |= intermediate;
334    
335        return numParameters_value;
336      }
337      /**
338       * @apilevel internal
339       */
340      protected java.util.Map congruentTo_FunctionDescriptor_values;
341      /**
342       * @apilevel internal
343       */
344      private void congruentTo_FunctionDescriptor_reset() {
345        congruentTo_FunctionDescriptor_values = null;
346      }
347      /**
348       * @attribute syn
349       * @aspect LambdaExpr
350       * @declaredat /home/jesper/git/extendj/java8/frontend/LambdaExpr.jrag:48
351       */
352      @ASTNodeAnnotation.Attribute
353      public boolean congruentTo(FunctionDescriptor f) {
354        Object _parameters = f;
355        if (congruentTo_FunctionDescriptor_values == null) congruentTo_FunctionDescriptor_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
356        ASTNode$State state = state();
357        if (congruentTo_FunctionDescriptor_values.containsKey(_parameters)) {
358          return (Boolean) congruentTo_FunctionDescriptor_values.get(_parameters);
359        }
360        boolean intermediate = state.INTERMEDIATE_VALUE;
361        state.INTERMEDIATE_VALUE = false;
362        int num = state.boundariesCrossed;
363        boolean isFinal = this.is$Final();
364        boolean congruentTo_FunctionDescriptor_value = numParameters() == f.method.getNumParameter();
365        if (isFinal && num == state().boundariesCrossed) {
366          congruentTo_FunctionDescriptor_values.put(_parameters, congruentTo_FunctionDescriptor_value);
367        } else {
368        }
369        state.INTERMEDIATE_VALUE |= intermediate;
370    
371        return congruentTo_FunctionDescriptor_value;
372      }
373      /**
374       * @apilevel internal
375       */
376      protected java.util.Map parameterDeclaration_String_values;
377      /**
378       * @apilevel internal
379       */
380      private void parameterDeclaration_String_reset() {
381        parameterDeclaration_String_values = null;
382      }
383      /**
384       * @attribute syn
385       * @aspect VariableScope
386       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:47
387       */
388      @ASTNodeAnnotation.Attribute
389      public SimpleSet parameterDeclaration(String name) {
390        Object _parameters = name;
391        if (parameterDeclaration_String_values == null) parameterDeclaration_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
392        ASTNode$State state = state();
393        if (parameterDeclaration_String_values.containsKey(_parameters)) {
394          return (SimpleSet) parameterDeclaration_String_values.get(_parameters);
395        }
396        boolean intermediate = state.INTERMEDIATE_VALUE;
397        state.INTERMEDIATE_VALUE = false;
398        int num = state.boundariesCrossed;
399        boolean isFinal = this.is$Final();
400        SimpleSet parameterDeclaration_String_value = parameterDeclaration_compute(name);
401        if (isFinal && num == state().boundariesCrossed) {
402          parameterDeclaration_String_values.put(_parameters, parameterDeclaration_String_value);
403        } else {
404        }
405        state.INTERMEDIATE_VALUE |= intermediate;
406    
407        return parameterDeclaration_String_value;
408      }
409      /**
410       * @apilevel internal
411       */
412      private SimpleSet parameterDeclaration_compute(String name) {
413          for (int i = 0; i < getNumParameter(); i++) {
414            if (getParameter(i).name().equals(name)) {
415              return (InferredParameterDeclaration) getParameter(i);
416            }
417          }
418          return SimpleSet.emptySet;
419        }
420      /**
421       * @apilevel internal
422       */
423      protected boolean toParameterList_computed = false;
424      /**
425       * @apilevel internal
426       */
427      protected List<ParameterDeclaration> toParameterList_value;
428      /**
429       * @apilevel internal
430       */
431      private void toParameterList_reset() {
432        toParameterList_computed = false;
433        toParameterList_value = null;
434      }
435      /**
436       * @attribute syn
437       * @aspect LambdaToClass
438       * @declaredat /home/jesper/git/extendj/java8/backend/LambdaToClass.jrag:106
439       */
440      @ASTNodeAnnotation.Attribute
441      public List<ParameterDeclaration> toParameterList() {
442        ASTNode$State state = state();
443        if (toParameterList_computed) {
444          return toParameterList_value;
445        }
446        boolean intermediate = state.INTERMEDIATE_VALUE;
447        state.INTERMEDIATE_VALUE = false;
448        int num = state.boundariesCrossed;
449        boolean isFinal = this.is$Final();
450        toParameterList_value = toParameterList_compute();
451        if (isFinal && num == state().boundariesCrossed) {
452          toParameterList_computed = true;
453        } else {
454        }
455        state.INTERMEDIATE_VALUE |= intermediate;
456    
457        return toParameterList_value;
458      }
459      /**
460       * @apilevel internal
461       */
462      private List<ParameterDeclaration> toParameterList_compute() {
463          List<ParameterDeclaration> paramList = new List<ParameterDeclaration>();
464          int i = 0;
465          for (InferredParameterDeclaration infDecl : getParameterList()) {
466            ParameterDeclaration funcDecl = enclosingLambda().targetInterface().functionDescriptor().method.getParameter(i);
467            paramList.add(new ParameterDeclaration(funcDecl.getTypeAccess(), infDecl.name()));
468            i++;
469          }
470          return paramList;
471        }
472      /**
473       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30
474       * @apilevel internal
475       */
476      public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
477        if (caller == getParameterListNoTransform()) {
478          // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:37
479          int childIndex = caller.getIndexOfChild(child);
480          return inhModifiedInScope(var);
481        }
482        else {
483          return getParent().Define_inhModifiedInScope(this, caller, var);
484        }
485      }
486      protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) {
487        return true;
488      }
489      /**
490       * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30
491       * @apilevel internal
492       */
493      public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) {
494        if (caller == getParameterListNoTransform()) {
495          // @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:35
496          int childIndex = caller.getIndexOfChild(child);
497          return parameterDeclaration(name);
498        }
499        else {
500          return getParent().Define_lookupVariable(this, caller, name);
501        }
502      }
503      protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) {
504        return true;
505      }
506      /**
507       * @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:453
508       * @apilevel internal
509       */
510      public TypeDecl Define_inferredType(ASTNode caller, ASTNode child) {
511        if (caller == getParameterListNoTransform()) {
512          // @declaredat /home/jesper/git/extendj/java8/frontend/TypeCheck.jrag:454
513          int i = caller.getIndexOfChild(child);
514          {
515              if (enclosingLambda().targetInterface() == null) {
516                return unknownType();
517              }
518              InterfaceDecl iDecl = (InterfaceDecl)enclosingLambda().targetInterface();
519              if (!iDecl.isFunctional()) {
520                return unknownType();
521              } else if (iDecl.functionDescriptor().method.getNumParameter() < i + 1) {
522                return unknownType();
523              } else {
524                return iDecl.functionDescriptor().method.getParameter(i).type();
525              }
526            }
527        }
528        else {
529          return getParent().Define_inferredType(this, caller);
530        }
531      }
532      protected boolean canDefine_inferredType(ASTNode caller, ASTNode child) {
533        return true;
534      }
535      /**
536       * @apilevel internal
537       */
538      public ASTNode rewriteTo() {
539        return super.rewriteTo();
540      }
541    }