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/java4/grammar/Java.ast:25 027 * @production ArrayTypeWithSizeAccess : {@link ArrayTypeAccess} ::= <span class="component">{@link Expr}</span>; 028 029 */ 030 public class ArrayTypeWithSizeAccess extends ArrayTypeAccess implements Cloneable { 031 /** 032 * @aspect Java4PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:555 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print(getAccess()); 037 out.print("["); 038 out.print(getExpr()); 039 out.print("]"); 040 } 041 /** 042 * @aspect TypeCheck 043 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:640 044 */ 045 public void typeCheck() { 046 super.typeCheck(); 047 if (!getExpr().type().unaryNumericPromotion().isInt()) { 048 errorf("%s is not int after unary numeric promotion", getExpr().type().typeName()); 049 } 050 } 051 /** 052 * @declaredat ASTNode:1 053 */ 054 public ArrayTypeWithSizeAccess() { 055 super(); 056 } 057 /** 058 * Initializes the child array to the correct size. 059 * Initializes List and Opt nta children. 060 * @apilevel internal 061 * @ast method 062 * @declaredat ASTNode:10 063 */ 064 public void init$Children() { 065 children = new ASTNode[2]; 066 } 067 /** 068 * @declaredat ASTNode:13 069 */ 070 public ArrayTypeWithSizeAccess(Access p0, Expr p1) { 071 setChild(p0, 0); 072 setChild(p1, 1); 073 } 074 /** 075 * @apilevel low-level 076 * @declaredat ASTNode:20 077 */ 078 protected int numChildren() { 079 return 2; 080 } 081 /** 082 * @apilevel internal 083 * @declaredat ASTNode:26 084 */ 085 public boolean mayHaveRewrite() { 086 return false; 087 } 088 /** 089 * @apilevel internal 090 * @declaredat ASTNode:32 091 */ 092 public void flushAttrCache() { 093 super.flushAttrCache(); 094 } 095 /** 096 * @apilevel internal 097 * @declaredat ASTNode:38 098 */ 099 public void flushCollectionCache() { 100 super.flushCollectionCache(); 101 } 102 /** 103 * @apilevel internal 104 * @declaredat ASTNode:44 105 */ 106 public void flushRewriteCache() { 107 super.flushRewriteCache(); 108 } 109 /** 110 * @apilevel internal 111 * @declaredat ASTNode:50 112 */ 113 public ArrayTypeWithSizeAccess clone() throws CloneNotSupportedException { 114 ArrayTypeWithSizeAccess node = (ArrayTypeWithSizeAccess) super.clone(); 115 return node; 116 } 117 /** 118 * @apilevel internal 119 * @declaredat ASTNode:57 120 */ 121 public ArrayTypeWithSizeAccess copy() { 122 try { 123 ArrayTypeWithSizeAccess node = (ArrayTypeWithSizeAccess) clone(); 124 node.parent = null; 125 if (children != null) { 126 node.children = (ASTNode[]) children.clone(); 127 } 128 return node; 129 } catch (CloneNotSupportedException e) { 130 throw new Error("Error: clone not supported for " + getClass().getName()); 131 } 132 } 133 /** 134 * Create a deep copy of the AST subtree at this node. 135 * The copy is dangling, i.e. has no parent. 136 * @return dangling copy of the subtree at this node 137 * @apilevel low-level 138 * @deprecated Please use treeCopy or treeCopyNoTransform instead 139 * @declaredat ASTNode:76 140 */ 141 @Deprecated 142 public ArrayTypeWithSizeAccess fullCopy() { 143 return treeCopyNoTransform(); 144 } 145 /** 146 * Create a deep copy of the AST subtree at this node. 147 * The copy is dangling, i.e. has no parent. 148 * @return dangling copy of the subtree at this node 149 * @apilevel low-level 150 * @declaredat ASTNode:86 151 */ 152 public ArrayTypeWithSizeAccess treeCopyNoTransform() { 153 ArrayTypeWithSizeAccess tree = (ArrayTypeWithSizeAccess) copy(); 154 if (children != null) { 155 for (int i = 0; i < children.length; ++i) { 156 ASTNode child = (ASTNode) children[i]; 157 if (child != null) { 158 child = child.treeCopyNoTransform(); 159 tree.setChild(child, i); 160 } 161 } 162 } 163 return tree; 164 } 165 /** 166 * Create a deep copy of the AST subtree at this node. 167 * The subtree of this node is traversed to trigger rewrites before copy. 168 * The copy is dangling, i.e. has no parent. 169 * @return dangling copy of the subtree at this node 170 * @apilevel low-level 171 * @declaredat ASTNode:106 172 */ 173 public ArrayTypeWithSizeAccess treeCopy() { 174 doFullTraversal(); 175 return treeCopyNoTransform(); 176 } 177 /** 178 * @apilevel internal 179 * @declaredat ASTNode:113 180 */ 181 protected boolean is$Equal(ASTNode node) { 182 return super.is$Equal(node); 183 } 184 /** 185 * Replaces the Access child. 186 * @param node The new node to replace the Access child. 187 * @apilevel high-level 188 */ 189 public void setAccess(Access node) { 190 setChild(node, 0); 191 } 192 /** 193 * Retrieves the Access child. 194 * @return The current node used as the Access child. 195 * @apilevel high-level 196 */ 197 @ASTNodeAnnotation.Child(name="Access") 198 public Access getAccess() { 199 return (Access) getChild(0); 200 } 201 /** 202 * Retrieves the Access child. 203 * <p><em>This method does not invoke AST transformations.</em></p> 204 * @return The current node used as the Access child. 205 * @apilevel low-level 206 */ 207 public Access getAccessNoTransform() { 208 return (Access) getChildNoTransform(0); 209 } 210 /** 211 * Replaces the Expr child. 212 * @param node The new node to replace the Expr child. 213 * @apilevel high-level 214 */ 215 public void setExpr(Expr node) { 216 setChild(node, 1); 217 } 218 /** 219 * Retrieves the Expr child. 220 * @return The current node used as the Expr child. 221 * @apilevel high-level 222 */ 223 @ASTNodeAnnotation.Child(name="Expr") 224 public Expr getExpr() { 225 return (Expr) getChild(1); 226 } 227 /** 228 * Retrieves the Expr child. 229 * <p><em>This method does not invoke AST transformations.</em></p> 230 * @return The current node used as the Expr child. 231 * @apilevel low-level 232 */ 233 public Expr getExprNoTransform() { 234 return (Expr) getChildNoTransform(1); 235 } 236 /** 237 * This method should not be called. This method throws an exception due to 238 * the corresponding child being an NTA shadowing a non-NTA child. 239 * @param node 240 * @apilevel internal 241 */ 242 public void setPackage(String node) { 243 throw new Error("Can not replace NTA child Package in ArrayTypeWithSizeAccess!"); 244 } 245 /** 246 * This method should not be called. This method throws an exception due to 247 * the corresponding child being an NTA shadowing a non-NTA child. 248 * @param node 249 * @apilevel internal 250 */ 251 public void setID(String node) { 252 throw new Error("Can not replace NTA child ID in ArrayTypeWithSizeAccess!"); 253 } 254 /** 255 * @aspect AutoBoxingCodegen 256 * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:309 257 */ 258 public void createBCode(CodeGeneration gen) { 259 getAccess().createBCode(gen); 260 getExpr().createBCode(gen); 261 if (getExpr().type().isReferenceType()) { 262 getExpr().type().emitUnboxingOperation(gen); 263 } 264 } 265 /** 266 * @attribute syn 267 * @aspect DA 268 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259 269 */ 270 @ASTNodeAnnotation.Attribute 271 public boolean isDAafter(Variable v) { 272 boolean isDAafter_Variable_value = getExpr().isDAafter(v); 273 274 return isDAafter_Variable_value; 275 } 276 /** 277 * @attribute syn 278 * @aspect DU 279 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783 280 */ 281 @ASTNodeAnnotation.Attribute 282 public boolean isDUafter(Variable v) { 283 boolean isDUafter_Variable_value = getExpr().isDUafter(v); 284 285 return isDUafter_Variable_value; 286 } 287 /** 288 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:37 289 * @apilevel internal 290 */ 291 public boolean Define_isDest(ASTNode caller, ASTNode child) { 292 if (caller == getExprNoTransform()) { 293 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:58 294 return false; 295 } 296 else { 297 return getParent().Define_isDest(this, caller); 298 } 299 } 300 protected boolean canDefine_isDest(ASTNode caller, ASTNode child) { 301 return true; 302 } 303 /** 304 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47 305 * @apilevel internal 306 */ 307 public boolean Define_isSource(ASTNode caller, ASTNode child) { 308 if (caller == getExprNoTransform()) { 309 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:59 310 return true; 311 } 312 else { 313 return getParent().Define_isSource(this, caller); 314 } 315 } 316 protected boolean canDefine_isSource(ASTNode caller, ASTNode child) { 317 return true; 318 } 319 /** 320 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 321 * @apilevel internal 322 */ 323 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 324 if (caller == getExprNoTransform()) { 325 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:400 326 return getAccess().isDAafter(v); 327 } 328 else { 329 return getParent().Define_isDAbefore(this, caller, v); 330 } 331 } 332 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 333 return true; 334 } 335 /** 336 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 337 * @apilevel internal 338 */ 339 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 340 if (caller == getExprNoTransform()) { 341 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:944 342 return getAccess().isDUafter(v); 343 } 344 else { 345 return getParent().Define_isDUbefore(this, caller, v); 346 } 347 } 348 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 349 return true; 350 } 351 /** 352 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:46 353 * @apilevel internal 354 */ 355 public Collection Define_lookupMethod(ASTNode caller, ASTNode child, String name) { 356 if (caller == getExprNoTransform()) { 357 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupMethod.jrag:53 358 return unqualifiedScope().lookupMethod(name); 359 } 360 else { 361 return getParent().Define_lookupMethod(this, caller, name); 362 } 363 } 364 protected boolean canDefine_lookupMethod(ASTNode caller, ASTNode child, String name) { 365 return true; 366 } 367 /** 368 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:115 369 * @apilevel internal 370 */ 371 public boolean Define_hasPackage(ASTNode caller, ASTNode child, String packageName) { 372 if (caller == getExprNoTransform()) { 373 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:124 374 return unqualifiedScope().hasPackage(packageName); 375 } 376 else { 377 return getParent().Define_hasPackage(this, caller, packageName); 378 } 379 } 380 protected boolean canDefine_hasPackage(ASTNode caller, ASTNode child, String packageName) { 381 return true; 382 } 383 /** 384 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:197 385 * @apilevel internal 386 */ 387 public SimpleSet Define_lookupType(ASTNode caller, ASTNode child, String name) { 388 if (caller == getExprNoTransform()) { 389 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:333 390 return unqualifiedScope().lookupType(name); 391 } 392 else { 393 return getParent().Define_lookupType(this, caller, name); 394 } 395 } 396 protected boolean canDefine_lookupType(ASTNode caller, ASTNode child, String name) { 397 return true; 398 } 399 /** 400 * @declaredat /home/jesper/git/extendj/java8/frontend/LookupVariable.jrag:30 401 * @apilevel internal 402 */ 403 public SimpleSet Define_lookupVariable(ASTNode caller, ASTNode child, String name) { 404 if (caller == getExprNoTransform()) { 405 // @declaredat /home/jesper/git/extendj/java4/frontend/LookupVariable.jrag:225 406 return unqualifiedScope().lookupVariable(name); 407 } 408 else { 409 return getParent().Define_lookupVariable(this, caller, name); 410 } 411 } 412 protected boolean canDefine_lookupVariable(ASTNode caller, ASTNode child, String name) { 413 return true; 414 } 415 /** 416 * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36 417 * @apilevel internal 418 */ 419 public NameType Define_nameType(ASTNode caller, ASTNode child) { 420 if (caller == getExprNoTransform()) { 421 // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:146 422 return NameType.EXPRESSION_NAME; 423 } 424 else { 425 return getParent().Define_nameType(this, caller); 426 } 427 } 428 protected boolean canDefine_nameType(ASTNode caller, ASTNode child) { 429 return true; 430 } 431 /** 432 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 433 * @apilevel internal 434 */ 435 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 436 if (caller == getExprNoTransform()) { 437 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:367 438 return false; 439 } 440 else { 441 return getParent().Define_assignmentContext(this, caller); 442 } 443 } 444 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 445 return true; 446 } 447 /** 448 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 449 * @apilevel internal 450 */ 451 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 452 if (caller == getExprNoTransform()) { 453 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:368 454 return false; 455 } 456 else { 457 return getParent().Define_invocationContext(this, caller); 458 } 459 } 460 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 461 return true; 462 } 463 /** 464 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 465 * @apilevel internal 466 */ 467 public boolean Define_castContext(ASTNode caller, ASTNode child) { 468 if (caller == getExprNoTransform()) { 469 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:369 470 return false; 471 } 472 else { 473 return getParent().Define_castContext(this, caller); 474 } 475 } 476 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 477 return true; 478 } 479 /** 480 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 481 * @apilevel internal 482 */ 483 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 484 if (caller == getExprNoTransform()) { 485 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:370 486 return false; 487 } 488 else { 489 return getParent().Define_stringContext(this, caller); 490 } 491 } 492 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 493 return true; 494 } 495 /** 496 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 497 * @apilevel internal 498 */ 499 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 500 if (caller == getExprNoTransform()) { 501 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:371 502 return false; 503 } 504 else { 505 return getParent().Define_numericContext(this, caller); 506 } 507 } 508 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 509 return true; 510 } 511 /** 512 * @apilevel internal 513 */ 514 public ASTNode rewriteTo() { 515 return super.rewriteTo(); 516 } 517 }