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:9 027 * @production DeclaredLambdaParameters : {@link LambdaParameters} ::= <span class="component">Parameter:{@link ParameterDeclaration}*</span>; 028 029 */ 030 public class DeclaredLambdaParameters extends LambdaParameters implements Cloneable { 031 /** 032 * @aspect Java8NameCheck 033 * @declaredat /home/jesper/git/extendj/java8/frontend/NameCheck.jrag:549 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:41 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 DeclaredLambdaParameters() { 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 DeclaredLambdaParameters(List<ParameterDeclaration> 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 DeclaredLambdaParameters clone() throws CloneNotSupportedException { 125 DeclaredLambdaParameters node = (DeclaredLambdaParameters) super.clone(); 126 return node; 127 } 128 /** 129 * @apilevel internal 130 * @declaredat ASTNode:61 131 */ 132 public DeclaredLambdaParameters copy() { 133 try { 134 DeclaredLambdaParameters node = (DeclaredLambdaParameters) 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 DeclaredLambdaParameters 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 DeclaredLambdaParameters treeCopyNoTransform() { 164 DeclaredLambdaParameters tree = (DeclaredLambdaParameters) 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 DeclaredLambdaParameters 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<ParameterDeclaration> 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 ParameterDeclaration getParameter(int i) { 227 return (ParameterDeclaration) 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(ParameterDeclaration node) { 243 List<ParameterDeclaration> list = (parent == null) ? getParameterListNoTransform() : getParameterList(); 244 list.addChild(node); 245 } 246 /** 247 * @apilevel low-level 248 */ 249 public void addParameterNoTransform(ParameterDeclaration node) { 250 List<ParameterDeclaration> 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(ParameterDeclaration node, int i) { 260 List<ParameterDeclaration> 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<ParameterDeclaration> getParameterList() { 270 List<ParameterDeclaration> list = (List<ParameterDeclaration>) 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<ParameterDeclaration> getParameterListNoTransform() { 280 return (List<ParameterDeclaration>) 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<ParameterDeclaration> 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<ParameterDeclaration> 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 = congruentTo_compute(f); 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 private boolean congruentTo_compute(FunctionDescriptor f) { 377 if (numParameters() != f.method.getNumParameter()) { 378 return false; 379 } 380 for (int i = 0; i < numParameters(); i++) { 381 //Lambdas can't declare type variables so that doesn't need to be taken into account 382 if (getParameter(i).type() != f.method.getParameter(i).type()) { 383 return false; 384 } 385 } 386 return true; 387 } 388 /** 389 * @apilevel internal 390 */ 391 protected java.util.Map parameterDeclaration_String_values; 392 /** 393 * @apilevel internal 394 */ 395 private void parameterDeclaration_String_reset() { 396 parameterDeclaration_String_values = null; 397 } 398 /** 399 * @attribute syn 400 * @aspect VariableScope 401 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:38 402 */ 403 @ASTNodeAnnotation.Attribute 404 public SimpleSet parameterDeclaration(String name) { 405 Object _parameters = name; 406 if (parameterDeclaration_String_values == null) parameterDeclaration_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 407 ASTNode$State state = state(); 408 if (parameterDeclaration_String_values.containsKey(_parameters)) { 409 return (SimpleSet) parameterDeclaration_String_values.get(_parameters); 410 } 411 boolean intermediate = state.INTERMEDIATE_VALUE; 412 state.INTERMEDIATE_VALUE = false; 413 int num = state.boundariesCrossed; 414 boolean isFinal = this.is$Final(); 415 SimpleSet parameterDeclaration_String_value = parameterDeclaration_compute(name); 416 if (isFinal && num == state().boundariesCrossed) { 417 parameterDeclaration_String_values.put(_parameters, parameterDeclaration_String_value); 418 } else { 419 } 420 state.INTERMEDIATE_VALUE |= intermediate; 421 422 return parameterDeclaration_String_value; 423 } 424 /** 425 * @apilevel internal 426 */ 427 private SimpleSet parameterDeclaration_compute(String name) { 428 for (int i = 0; i < getNumParameter(); i++) { 429 if (getParameter(i).name().equals(name)) { 430 return (ParameterDeclaration) getParameter(i); 431 } 432 } 433 return SimpleSet.emptySet; 434 } 435 /** 436 * @apilevel internal 437 */ 438 protected boolean toParameterList_computed = false; 439 /** 440 * @apilevel internal 441 */ 442 protected List<ParameterDeclaration> toParameterList_value; 443 /** 444 * @apilevel internal 445 */ 446 private void toParameterList_reset() { 447 toParameterList_computed = false; 448 toParameterList_value = null; 449 } 450 /** 451 * @attribute syn 452 * @aspect LambdaToClass 453 * @declaredat /home/jesper/git/extendj/java8/backend/LambdaToClass.jrag:106 454 */ 455 @ASTNodeAnnotation.Attribute 456 public List<ParameterDeclaration> toParameterList() { 457 ASTNode$State state = state(); 458 if (toParameterList_computed) { 459 return toParameterList_value; 460 } 461 boolean intermediate = state.INTERMEDIATE_VALUE; 462 state.INTERMEDIATE_VALUE = false; 463 int num = state.boundariesCrossed; 464 boolean isFinal = this.is$Final(); 465 toParameterList_value = getParameterList().treeCopyNoTransform(); 466 if (isFinal && num == state().boundariesCrossed) { 467 toParameterList_computed = true; 468 } else { 469 } 470 state.INTERMEDIATE_VALUE |= intermediate; 471 472 return toParameterList_value; 473 } 474 /** 475 * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:30 476 * @apilevel internal 477 */ 478 public boolean Define_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 479 if (caller == getParameterListNoTransform()) { 480 // @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:35 481 int childIndex = caller.getIndexOfChild(child); 482 return inhModifiedInScope(var); 483 } 484 else { 485 return getParent().Define_inhModifiedInScope(this, caller, var); 486 } 487 } 488 protected boolean canDefine_inhModifiedInScope(ASTNode caller, ASTNode child, Variable var) { 489 return true; 490 } 491 /** 492 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 493 * @apilevel internal 494 */ 495 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 496 if (caller == getParameterListNoTransform()) { 497 // @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:33 498 int childIndex = caller.getIndexOfChild(child); 499 return parameterDeclaration(name); 500 } 501 else { 502 return getParent().Define_lookupVariable(this, caller, name); 503 } 504 } 505 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 506 return true; 507 } 508 /** 509 * @declaredat /home/jesper/git/extendj/java5/frontend/VariableArityParameters.jrag:48 510 * @apilevel internal 511 */ 512 public boolean Define_variableArityValid(ASTNode caller, ASTNode child) { 513 if (caller == getParameterListNoTransform()) { 514 // @declaredat /home/jesper/git/extendj/java8/frontend/VariableArityParameters.jrag:30 515 int i = caller.getIndexOfChild(child); 516 return i == getNumParameter() - 1; 517 } 518 else { 519 return getParent().Define_variableArityValid(this, caller); 520 } 521 } 522 protected boolean canDefine_variableArityValid(ASTNode caller, ASTNode child) { 523 return true; 524 } 525 /** 526 * @apilevel internal 527 */ 528 public ASTNode rewriteTo() { 529 return super.rewriteTo(); 530 } 531 }