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 }