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:90 027 * @production ArrayInit : {@link Expr} ::= <span class="component">Init:{@link Expr}*</span>; 028 029 */ 030 public class ArrayInit extends Expr implements Cloneable { 031 /** 032 * @aspect Java4PrettyPrint 033 * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:610 034 */ 035 public void prettyPrint(PrettyPrinter out) { 036 out.print("{ "); 037 out.join(getInitList(), new PrettyPrinter.Joiner() { 038 @Override 039 public void printSeparator(PrettyPrinter out) { 040 out.print(", "); 041 } 042 }); 043 out.print(" }"); 044 } 045 /** 046 * @aspect TypeCheck 047 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:169 048 */ 049 public void typeCheck() { 050 TypeDecl initializerType = declType().componentType(); 051 if (initializerType.isUnknown()) { 052 error("the dimension of the initializer is larger than the expected dimension"); 053 } 054 for (int i = 0; i < getNumInit(); i++) { 055 Expr e = getInit(i); 056 if (!e.type().assignConversionTo(initializerType, e)) { 057 errorf("the type %s of the initializer is not compatible with %s", 058 e.type().name(), initializerType.name()); 059 } 060 } 061 } 062 /** 063 * @declaredat ASTNode:1 064 */ 065 public ArrayInit() { 066 super(); 067 } 068 /** 069 * Initializes the child array to the correct size. 070 * Initializes List and Opt nta children. 071 * @apilevel internal 072 * @ast method 073 * @declaredat ASTNode:10 074 */ 075 public void init$Children() { 076 children = new ASTNode[1]; 077 setChild(new List(), 0); 078 } 079 /** 080 * @declaredat ASTNode:14 081 */ 082 public ArrayInit(List<Expr> p0) { 083 setChild(p0, 0); 084 } 085 /** 086 * @apilevel low-level 087 * @declaredat ASTNode:20 088 */ 089 protected int numChildren() { 090 return 1; 091 } 092 /** 093 * @apilevel internal 094 * @declaredat ASTNode:26 095 */ 096 public boolean mayHaveRewrite() { 097 return false; 098 } 099 /** 100 * @apilevel internal 101 * @declaredat ASTNode:32 102 */ 103 public void flushAttrCache() { 104 super.flushAttrCache(); 105 computeDABefore_int_Variable_reset(); 106 computeDUbefore_int_Variable_reset(); 107 type_reset(); 108 declType_reset(); 109 } 110 /** 111 * @apilevel internal 112 * @declaredat ASTNode:42 113 */ 114 public void flushCollectionCache() { 115 super.flushCollectionCache(); 116 } 117 /** 118 * @apilevel internal 119 * @declaredat ASTNode:48 120 */ 121 public void flushRewriteCache() { 122 super.flushRewriteCache(); 123 } 124 /** 125 * @apilevel internal 126 * @declaredat ASTNode:54 127 */ 128 public ArrayInit clone() throws CloneNotSupportedException { 129 ArrayInit node = (ArrayInit) super.clone(); 130 return node; 131 } 132 /** 133 * @apilevel internal 134 * @declaredat ASTNode:61 135 */ 136 public ArrayInit copy() { 137 try { 138 ArrayInit node = (ArrayInit) clone(); 139 node.parent = null; 140 if (children != null) { 141 node.children = (ASTNode[]) children.clone(); 142 } 143 return node; 144 } catch (CloneNotSupportedException e) { 145 throw new Error("Error: clone not supported for " + getClass().getName()); 146 } 147 } 148 /** 149 * Create a deep copy of the AST subtree at this node. 150 * The copy is dangling, i.e. has no parent. 151 * @return dangling copy of the subtree at this node 152 * @apilevel low-level 153 * @deprecated Please use treeCopy or treeCopyNoTransform instead 154 * @declaredat ASTNode:80 155 */ 156 @Deprecated 157 public ArrayInit fullCopy() { 158 return treeCopyNoTransform(); 159 } 160 /** 161 * Create a deep copy of the AST subtree at this node. 162 * The copy is dangling, i.e. has no parent. 163 * @return dangling copy of the subtree at this node 164 * @apilevel low-level 165 * @declaredat ASTNode:90 166 */ 167 public ArrayInit treeCopyNoTransform() { 168 ArrayInit tree = (ArrayInit) copy(); 169 if (children != null) { 170 for (int i = 0; i < children.length; ++i) { 171 ASTNode child = (ASTNode) children[i]; 172 if (child != null) { 173 child = child.treeCopyNoTransform(); 174 tree.setChild(child, i); 175 } 176 } 177 } 178 return tree; 179 } 180 /** 181 * Create a deep copy of the AST subtree at this node. 182 * The subtree of this node is traversed to trigger rewrites before copy. 183 * The copy is dangling, i.e. has no parent. 184 * @return dangling copy of the subtree at this node 185 * @apilevel low-level 186 * @declaredat ASTNode:110 187 */ 188 public ArrayInit treeCopy() { 189 doFullTraversal(); 190 return treeCopyNoTransform(); 191 } 192 /** 193 * @apilevel internal 194 * @declaredat ASTNode:117 195 */ 196 protected boolean is$Equal(ASTNode node) { 197 return super.is$Equal(node); 198 } 199 /** 200 * Replaces the Init list. 201 * @param list The new list node to be used as the Init list. 202 * @apilevel high-level 203 */ 204 public void setInitList(List<Expr> list) { 205 setChild(list, 0); 206 } 207 /** 208 * Retrieves the number of children in the Init list. 209 * @return Number of children in the Init list. 210 * @apilevel high-level 211 */ 212 public int getNumInit() { 213 return getInitList().getNumChild(); 214 } 215 /** 216 * Retrieves the number of children in the Init list. 217 * Calling this method will not trigger rewrites. 218 * @return Number of children in the Init list. 219 * @apilevel low-level 220 */ 221 public int getNumInitNoTransform() { 222 return getInitListNoTransform().getNumChildNoTransform(); 223 } 224 /** 225 * Retrieves the element at index {@code i} in the Init list. 226 * @param i Index of the element to return. 227 * @return The element at position {@code i} in the Init list. 228 * @apilevel high-level 229 */ 230 public Expr getInit(int i) { 231 return (Expr) getInitList().getChild(i); 232 } 233 /** 234 * Check whether the Init list has any children. 235 * @return {@code true} if it has at least one child, {@code false} otherwise. 236 * @apilevel high-level 237 */ 238 public boolean hasInit() { 239 return getInitList().getNumChild() != 0; 240 } 241 /** 242 * Append an element to the Init list. 243 * @param node The element to append to the Init list. 244 * @apilevel high-level 245 */ 246 public void addInit(Expr node) { 247 List<Expr> list = (parent == null) ? getInitListNoTransform() : getInitList(); 248 list.addChild(node); 249 } 250 /** 251 * @apilevel low-level 252 */ 253 public void addInitNoTransform(Expr node) { 254 List<Expr> list = getInitListNoTransform(); 255 list.addChild(node); 256 } 257 /** 258 * Replaces the Init list element at index {@code i} with the new node {@code node}. 259 * @param node The new node to replace the old list element. 260 * @param i The list index of the node to be replaced. 261 * @apilevel high-level 262 */ 263 public void setInit(Expr node, int i) { 264 List<Expr> list = getInitList(); 265 list.setChild(node, i); 266 } 267 /** 268 * Retrieves the Init list. 269 * @return The node representing the Init list. 270 * @apilevel high-level 271 */ 272 @ASTNodeAnnotation.ListChild(name="Init") 273 public List<Expr> getInitList() { 274 List<Expr> list = (List<Expr>) getChild(0); 275 return list; 276 } 277 /** 278 * Retrieves the Init list. 279 * <p><em>This method does not invoke AST transformations.</em></p> 280 * @return The node representing the Init list. 281 * @apilevel low-level 282 */ 283 public List<Expr> getInitListNoTransform() { 284 return (List<Expr>) getChildNoTransform(0); 285 } 286 /** 287 * Retrieves the Init list. 288 * @return The node representing the Init list. 289 * @apilevel high-level 290 */ 291 public List<Expr> getInits() { 292 return getInitList(); 293 } 294 /** 295 * Retrieves the Init list. 296 * <p><em>This method does not invoke AST transformations.</em></p> 297 * @return The node representing the Init list. 298 * @apilevel low-level 299 */ 300 public List<Expr> getInitsNoTransform() { 301 return getInitListNoTransform(); 302 } 303 /** 304 * @aspect AutoBoxingCodegen 305 * @declaredat /home/jesper/git/extendj/java5/backend/AutoBoxingCodegen.jrag:317 306 */ 307 public void createBCode(CodeGeneration gen) { 308 IntegerLiteral.push(gen, getNumInit()); 309 if (type().componentType().isPrimitive() && !type().componentType().isReferenceType()) { 310 gen.emit(Bytecode.NEWARRAY).add(type().componentType().arrayPrimitiveTypeDescriptor()); 311 } else { 312 String n = type().componentType().arrayTypeDescriptor(); 313 int index = gen.constantPool().addClass(n); 314 gen.emit(Bytecode.ANEWARRAY).add2(index); 315 } 316 for (int i = 0; i < getNumInit(); i++) { 317 gen.emitDup(); 318 IntegerLiteral.push(gen, i); 319 getInit(i).createBCode(gen); 320 if (getInit(i) instanceof ArrayInit) { 321 gen.emit(Bytecode.AASTORE); 322 } else { 323 getInit(i).type().emitAssignConvTo(gen, expectedType()); // AssignConversion 324 gen.emit(expectedType().arrayStore()); 325 } 326 } 327 } 328 /** 329 * @attribute syn 330 * @aspect ConstantExpression 331 * @declaredat /home/jesper/git/extendj/java4/frontend/ConstantExpression.jrag:220 332 */ 333 @ASTNodeAnnotation.Attribute 334 public boolean representableIn(TypeDecl t) { 335 { 336 for (int i = 0; i < getNumInit(); i++) { 337 if (!getInit(i).representableIn(t)) { 338 return false; 339 } 340 } 341 return true; 342 } 343 } 344 /** 345 * @attribute syn 346 * @aspect DA 347 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:259 348 */ 349 @ASTNodeAnnotation.Attribute 350 public boolean isDAafter(Variable v) { 351 boolean isDAafter_Variable_value = getNumInit() == 0 ? isDAbefore(v) : getInit(getNumInit()-1).isDAafter(v); 352 353 return isDAafter_Variable_value; 354 } 355 /** 356 * @apilevel internal 357 */ 358 protected java.util.Map computeDABefore_int_Variable_values; 359 /** 360 * @apilevel internal 361 */ 362 private void computeDABefore_int_Variable_reset() { 363 computeDABefore_int_Variable_values = null; 364 } 365 /** 366 * @attribute syn 367 * @aspect DA 368 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:562 369 */ 370 @ASTNodeAnnotation.Attribute 371 public boolean computeDABefore(int childIndex, Variable v) { 372 java.util.List _parameters = new java.util.ArrayList(2); 373 _parameters.add(childIndex); 374 _parameters.add(v); 375 if (computeDABefore_int_Variable_values == null) computeDABefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 376 ASTNode$State state = state(); 377 if (computeDABefore_int_Variable_values.containsKey(_parameters)) { 378 return (Boolean) computeDABefore_int_Variable_values.get(_parameters); 379 } 380 boolean intermediate = state.INTERMEDIATE_VALUE; 381 state.INTERMEDIATE_VALUE = false; 382 int num = state.boundariesCrossed; 383 boolean isFinal = this.is$Final(); 384 boolean computeDABefore_int_Variable_value = computeDABefore_compute(childIndex, v); 385 if (isFinal && num == state().boundariesCrossed) { 386 computeDABefore_int_Variable_values.put(_parameters, computeDABefore_int_Variable_value); 387 } else { 388 } 389 state.INTERMEDIATE_VALUE |= intermediate; 390 391 return computeDABefore_int_Variable_value; 392 } 393 /** 394 * @apilevel internal 395 */ 396 private boolean computeDABefore_compute(int childIndex, Variable v) { 397 if (childIndex == 0) { 398 return isDAbefore(v); 399 } 400 int index = childIndex-1; 401 while (index > 0 && getInit(index).isConstant()) { 402 index--; 403 } 404 return getInit(childIndex-1).isDAafter(v); 405 } 406 /** 407 * @attribute syn 408 * @aspect DU 409 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:783 410 */ 411 @ASTNodeAnnotation.Attribute 412 public boolean isDUafter(Variable v) { 413 boolean isDUafter_Variable_value = getNumInit() == 0 ? isDUbefore(v) : getInit(getNumInit()-1).isDUafter(v); 414 415 return isDUafter_Variable_value; 416 } 417 /** 418 * @apilevel internal 419 */ 420 protected java.util.Map computeDUbefore_int_Variable_values; 421 /** 422 * @apilevel internal 423 */ 424 private void computeDUbefore_int_Variable_reset() { 425 computeDUbefore_int_Variable_values = null; 426 } 427 /** 428 * @attribute syn 429 * @aspect DU 430 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1007 431 */ 432 @ASTNodeAnnotation.Attribute 433 public boolean computeDUbefore(int childIndex, Variable v) { 434 java.util.List _parameters = new java.util.ArrayList(2); 435 _parameters.add(childIndex); 436 _parameters.add(v); 437 if (computeDUbefore_int_Variable_values == null) computeDUbefore_int_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 438 ASTNode$State state = state(); 439 if (computeDUbefore_int_Variable_values.containsKey(_parameters)) { 440 return (Boolean) computeDUbefore_int_Variable_values.get(_parameters); 441 } 442 boolean intermediate = state.INTERMEDIATE_VALUE; 443 state.INTERMEDIATE_VALUE = false; 444 int num = state.boundariesCrossed; 445 boolean isFinal = this.is$Final(); 446 boolean computeDUbefore_int_Variable_value = computeDUbefore_compute(childIndex, v); 447 if (isFinal && num == state().boundariesCrossed) { 448 computeDUbefore_int_Variable_values.put(_parameters, computeDUbefore_int_Variable_value); 449 } else { 450 } 451 state.INTERMEDIATE_VALUE |= intermediate; 452 453 return computeDUbefore_int_Variable_value; 454 } 455 /** 456 * @apilevel internal 457 */ 458 private boolean computeDUbefore_compute(int childIndex, Variable v) { 459 if (childIndex == 0) { 460 return isDUbefore(v); 461 } 462 int index = childIndex-1; 463 while (index > 0 && getInit(index).isConstant()) { 464 index--; 465 } 466 return getInit(childIndex-1).isDUafter(v); 467 } 468 /** 469 * @apilevel internal 470 */ 471 protected boolean type_computed = false; 472 /** 473 * @apilevel internal 474 */ 475 protected TypeDecl type_value; 476 /** 477 * @apilevel internal 478 */ 479 private void type_reset() { 480 type_computed = false; 481 type_value = null; 482 } 483 /** 484 * @attribute syn 485 * @aspect TypeAnalysis 486 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:302 487 */ 488 @ASTNodeAnnotation.Attribute 489 public TypeDecl type() { 490 ASTNode$State state = state(); 491 if (type_computed) { 492 return type_value; 493 } 494 boolean intermediate = state.INTERMEDIATE_VALUE; 495 state.INTERMEDIATE_VALUE = false; 496 int num = state.boundariesCrossed; 497 boolean isFinal = this.is$Final(); 498 type_value = declType(); 499 if (isFinal && num == state().boundariesCrossed) { 500 type_computed = true; 501 } else { 502 } 503 state.INTERMEDIATE_VALUE |= intermediate; 504 505 return type_value; 506 } 507 /** 508 * @attribute syn 509 * @aspect PreciseRethrow 510 * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:149 511 */ 512 @ASTNodeAnnotation.Attribute 513 public boolean modifiedInScope(Variable var) { 514 { 515 for (int i = 0; i < getNumInit(); ++i) { 516 if (getInit(i).modifiedInScope(var)) { 517 return true; 518 } 519 } 520 return false; 521 } 522 } 523 /** 524 * @attribute inh 525 * @aspect TypeAnalysis 526 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:281 527 */ 528 /** 529 * @attribute inh 530 * @aspect TypeAnalysis 531 * @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:281 532 */ 533 @ASTNodeAnnotation.Attribute 534 public TypeDecl declType() { 535 ASTNode$State state = state(); 536 if (declType_computed) { 537 return declType_value; 538 } 539 boolean intermediate = state.INTERMEDIATE_VALUE; 540 state.INTERMEDIATE_VALUE = false; 541 int num = state.boundariesCrossed; 542 boolean isFinal = this.is$Final(); 543 declType_value = getParent().Define_declType(this, null); 544 if (isFinal && num == state().boundariesCrossed) { 545 declType_computed = true; 546 } else { 547 } 548 state.INTERMEDIATE_VALUE |= intermediate; 549 550 return declType_value; 551 } 552 /** 553 * @apilevel internal 554 */ 555 protected boolean declType_computed = false; 556 /** 557 * @apilevel internal 558 */ 559 protected TypeDecl declType_value; 560 /** 561 * @apilevel internal 562 */ 563 private void declType_reset() { 564 declType_computed = false; 565 declType_value = null; 566 } 567 /** 568 * @attribute inh 569 * @aspect InnerClasses 570 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:93 571 */ 572 /** 573 * @attribute inh 574 * @aspect InnerClasses 575 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:93 576 */ 577 @ASTNodeAnnotation.Attribute 578 public TypeDecl expectedType() { 579 TypeDecl expectedType_value = getParent().Define_expectedType(this, null); 580 581 return expectedType_value; 582 } 583 /** 584 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47 585 * @apilevel internal 586 */ 587 public boolean Define_isSource(ASTNode caller, ASTNode child) { 588 if (caller == getInitListNoTransform()) { 589 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:64 590 int childIndex = caller.getIndexOfChild(child); 591 return true; 592 } 593 else { 594 return getParent().Define_isSource(this, caller); 595 } 596 } 597 protected boolean canDefine_isSource(ASTNode caller, ASTNode child) { 598 return true; 599 } 600 /** 601 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255 602 * @apilevel internal 603 */ 604 public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 605 if (caller == getInitListNoTransform()) { 606 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:560 607 int childIndex = caller.getIndexOfChild(child); 608 return computeDABefore(childIndex, v); 609 } 610 else { 611 return getParent().Define_isDAbefore(this, caller, v); 612 } 613 } 614 protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) { 615 return true; 616 } 617 /** 618 * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779 619 * @apilevel internal 620 */ 621 public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 622 if (caller == getInitListNoTransform()) { 623 // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1005 624 int childIndex = caller.getIndexOfChild(child); 625 return computeDUbefore(childIndex, v); 626 } 627 else { 628 return getParent().Define_isDUbefore(this, caller, v); 629 } 630 } 631 protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) { 632 return true; 633 } 634 /** 635 * @declaredat /home/jesper/git/extendj/java5/frontend/Annotations.jrag:601 636 * @apilevel internal 637 */ 638 public TypeDecl Define_declType(ASTNode caller, ASTNode child) { 639 if (caller == getInitListNoTransform()) { 640 // @declaredat /home/jesper/git/extendj/java4/frontend/TypeAnalysis.jrag:289 641 int childIndex = caller.getIndexOfChild(child); 642 return declType().componentType(); 643 } 644 else { 645 return getParent().Define_declType(this, caller); 646 } 647 } 648 protected boolean canDefine_declType(ASTNode caller, ASTNode child) { 649 return true; 650 } 651 /** 652 * @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:93 653 * @apilevel internal 654 */ 655 public TypeDecl Define_expectedType(ASTNode caller, ASTNode child) { 656 if (caller == getInitListNoTransform()) { 657 // @declaredat /home/jesper/git/extendj/java4/backend/InnerClasses.jrag:101 658 int childIndex = caller.getIndexOfChild(child); 659 return expectedType().componentType(); 660 } 661 else { 662 return getParent().Define_expectedType(this, caller); 663 } 664 } 665 protected boolean canDefine_expectedType(ASTNode caller, ASTNode child) { 666 return true; 667 } 668 /** 669 * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:58 670 * @apilevel internal 671 */ 672 public TypeDecl Define_assignConvertedType(ASTNode caller, ASTNode child) { 673 if (caller == getInitListNoTransform()) { 674 // @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethodsInference.jrag:62 675 int childIndex = caller.getIndexOfChild(child); 676 return declType().componentType(); 677 } 678 else { 679 return getParent().Define_assignConvertedType(this, caller); 680 } 681 } 682 protected boolean canDefine_assignConvertedType(ASTNode caller, ASTNode child) { 683 return true; 684 } 685 /** 686 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:30 687 * @apilevel internal 688 */ 689 public TypeDecl Define_targetType(ASTNode caller, ASTNode child) { 690 if (caller == getInitListNoTransform()) { 691 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:79 692 int childIndex = caller.getIndexOfChild(child); 693 { 694 if (!(targetType() instanceof ArrayDecl)) { 695 return targetType(); 696 } else { 697 return ((ArrayDecl) targetType()).componentType(); 698 } 699 } 700 } 701 else { 702 return getParent().Define_targetType(this, caller); 703 } 704 } 705 protected boolean canDefine_targetType(ASTNode caller, ASTNode child) { 706 return true; 707 } 708 /** 709 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:196 710 * @apilevel internal 711 */ 712 public boolean Define_assignmentContext(ASTNode caller, ASTNode child) { 713 if (caller == getInitListNoTransform()) { 714 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:343 715 int childIndex = caller.getIndexOfChild(child); 716 return true; 717 } 718 else { 719 return getParent().Define_assignmentContext(this, caller); 720 } 721 } 722 protected boolean canDefine_assignmentContext(ASTNode caller, ASTNode child) { 723 return true; 724 } 725 /** 726 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:197 727 * @apilevel internal 728 */ 729 public boolean Define_invocationContext(ASTNode caller, ASTNode child) { 730 if (caller == getInitListNoTransform()) { 731 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:344 732 int childIndex = caller.getIndexOfChild(child); 733 return false; 734 } 735 else { 736 return getParent().Define_invocationContext(this, caller); 737 } 738 } 739 protected boolean canDefine_invocationContext(ASTNode caller, ASTNode child) { 740 return true; 741 } 742 /** 743 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:198 744 * @apilevel internal 745 */ 746 public boolean Define_castContext(ASTNode caller, ASTNode child) { 747 if (caller == getInitListNoTransform()) { 748 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:345 749 int childIndex = caller.getIndexOfChild(child); 750 return false; 751 } 752 else { 753 return getParent().Define_castContext(this, caller); 754 } 755 } 756 protected boolean canDefine_castContext(ASTNode caller, ASTNode child) { 757 return true; 758 } 759 /** 760 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:199 761 * @apilevel internal 762 */ 763 public boolean Define_stringContext(ASTNode caller, ASTNode child) { 764 if (caller == getInitListNoTransform()) { 765 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:346 766 int childIndex = caller.getIndexOfChild(child); 767 return false; 768 } 769 else { 770 return getParent().Define_stringContext(this, caller); 771 } 772 } 773 protected boolean canDefine_stringContext(ASTNode caller, ASTNode child) { 774 return true; 775 } 776 /** 777 * @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:200 778 * @apilevel internal 779 */ 780 public boolean Define_numericContext(ASTNode caller, ASTNode child) { 781 if (caller == getInitListNoTransform()) { 782 // @declaredat /home/jesper/git/extendj/java8/frontend/TargetType.jrag:347 783 int childIndex = caller.getIndexOfChild(child); 784 return false; 785 } 786 else { 787 return getParent().Define_numericContext(this, caller); 788 } 789 } 790 protected boolean canDefine_numericContext(ASTNode caller, ASTNode child) { 791 return true; 792 } 793 /** 794 * @apilevel internal 795 */ 796 public ASTNode rewriteTo() { 797 return super.rewriteTo(); 798 } 799 }