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    }