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/java5/grammar/GenericMethods.ast:10
027     * @production ParConstructorDecl : {@link ConstructorDecl} ::= <span class="component">TypeArgument:{@link Access}*</span> <span class="component">&lt;GenericConstructorDecl:GenericConstructorDecl&gt;</span>;
028    
029     */
030    public class ParConstructorDecl extends ConstructorDecl implements Cloneable, Parameterization {
031      /**
032       * @aspect LookupParTypeDecl
033       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:977
034       */
035      public boolean isRawType() {
036        return false;
037      }
038      /**
039       * @aspect LookupParTypeDecl
040       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:981
041       */
042      public TypeDecl substitute(TypeVariable typeVariable) {
043        for (int i = 0; i < numTypeParameter(); i++) {
044          if (typeParameter(i) == typeVariable) {
045            return getTypeArgument(i).type();
046          }
047        }
048        return genericConstructorDecl().hostType().substitute(typeVariable);
049      }
050      /**
051       * @aspect LookupParTypeDecl
052       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1013
053       */
054      public int numTypeParameter() {
055        return genericConstructorDecl().original().getNumTypeParameter();
056      }
057      /**
058       * @aspect LookupParTypeDecl
059       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1021
060       */
061      public TypeVariable typeParameter(int index) {
062        return genericConstructorDecl().original().getTypeParameter(index);
063      }
064      /**
065       * @aspect GenericsCodegen
066       * @declaredat /home/jesper/git/extendj/java5/backend/GenericsCodegen.jrag:203
067       */
068      public void emitInvokeConstructor(CodeGeneration gen) {
069        genericConstructorDecl().emitInvokeConstructor(gen);
070      }
071      /**
072       * A raw type parameterization. Performs no substitutions.
073       * @aspect MethodSignature15
074       * @declaredat /home/jesper/git/extendj/java5/frontend/MethodSignature.jrag:240
075       */
076      public static final Parameterization RAW = new Parameterization() {
077        @Override
078        public boolean isRawType() {
079          return true;
080        }
081        @Override
082        public TypeDecl substitute(TypeVariable typeVariable) {
083          return typeVariable;
084        }
085      };
086      /**
087       * @declaredat ASTNode:1
088       */
089      public ParConstructorDecl() {
090        super();
091      }
092      /**
093       * Initializes the child array to the correct size.
094       * Initializes List and Opt nta children.
095       * @apilevel internal
096       * @ast method
097       * @declaredat ASTNode:10
098       */
099      public void init$Children() {
100        children = new ASTNode[7];
101        setChild(new List(), 1);
102        setChild(new List(), 2);
103        setChild(new Opt(), 3);
104        setChild(new List(), 5);
105      }
106      /**
107       * @declaredat ASTNode:17
108       */
109      public ParConstructorDecl(Modifiers p0, String p1, List<ParameterDeclaration> p2, List<Access> p3, Opt<Stmt> p4, Block p5, List<Access> p6, GenericConstructorDecl p7) {
110        setChild(p0, 0);
111        setID(p1);
112        setChild(p2, 1);
113        setChild(p3, 2);
114        setChild(p4, 3);
115        setChild(p5, 4);
116        setChild(p6, 5);
117        setGenericConstructorDecl(p7);
118      }
119      /**
120       * @declaredat ASTNode:27
121       */
122      public ParConstructorDecl(Modifiers p0, beaver.Symbol p1, List<ParameterDeclaration> p2, List<Access> p3, Opt<Stmt> p4, Block p5, List<Access> p6, GenericConstructorDecl p7) {
123        setChild(p0, 0);
124        setID(p1);
125        setChild(p2, 1);
126        setChild(p3, 2);
127        setChild(p4, 3);
128        setChild(p5, 4);
129        setChild(p6, 5);
130        setGenericConstructorDecl(p7);
131      }
132      /**
133       * @apilevel low-level
134       * @declaredat ASTNode:40
135       */
136      protected int numChildren() {
137        return 6;
138      }
139      /**
140       * @apilevel internal
141       * @declaredat ASTNode:46
142       */
143      public boolean mayHaveRewrite() {
144        return false;
145      }
146      /**
147       * @apilevel internal
148       * @declaredat ASTNode:52
149       */
150      public void flushAttrCache() {
151        super.flushAttrCache();
152        genericConstructorDecl_reset();
153        sourceConstructorDecl_reset();
154      }
155      /**
156       * @apilevel internal
157       * @declaredat ASTNode:60
158       */
159      public void flushCollectionCache() {
160        super.flushCollectionCache();
161      }
162      /**
163       * @apilevel internal
164       * @declaredat ASTNode:66
165       */
166      public void flushRewriteCache() {
167        super.flushRewriteCache();
168      }
169      /**
170       * @apilevel internal
171       * @declaredat ASTNode:72
172       */
173      public ParConstructorDecl clone() throws CloneNotSupportedException {
174        ParConstructorDecl node = (ParConstructorDecl) super.clone();
175        return node;
176      }
177      /**
178       * @apilevel internal
179       * @declaredat ASTNode:79
180       */
181      public ParConstructorDecl copy() {
182        try {
183          ParConstructorDecl node = (ParConstructorDecl) clone();
184          node.parent = null;
185          if (children != null) {
186            node.children = (ASTNode[]) children.clone();
187          }
188          return node;
189        } catch (CloneNotSupportedException e) {
190          throw new Error("Error: clone not supported for " + getClass().getName());
191        }
192      }
193      /**
194       * Create a deep copy of the AST subtree at this node.
195       * The copy is dangling, i.e. has no parent.
196       * @return dangling copy of the subtree at this node
197       * @apilevel low-level
198       * @deprecated Please use treeCopy or treeCopyNoTransform instead
199       * @declaredat ASTNode:98
200       */
201      @Deprecated
202      public ParConstructorDecl fullCopy() {
203        return treeCopyNoTransform();
204      }
205      /**
206       * Create a deep copy of the AST subtree at this node.
207       * The copy is dangling, i.e. has no parent.
208       * @return dangling copy of the subtree at this node
209       * @apilevel low-level
210       * @declaredat ASTNode:108
211       */
212      public ParConstructorDecl treeCopyNoTransform() {
213        ParConstructorDecl tree = (ParConstructorDecl) copy();
214        if (children != null) {
215          for (int i = 0; i < children.length; ++i) {
216            switch (i) {
217            case 6:
218              tree.children[i] = null;
219              continue;
220            }
221            ASTNode child = (ASTNode) children[i];
222            if (child != null) {
223              child = child.treeCopyNoTransform();
224              tree.setChild(child, i);
225            }
226          }
227        }
228        return tree;
229      }
230      /**
231       * Create a deep copy of the AST subtree at this node.
232       * The subtree of this node is traversed to trigger rewrites before copy.
233       * The copy is dangling, i.e. has no parent.
234       * @return dangling copy of the subtree at this node
235       * @apilevel low-level
236       * @declaredat ASTNode:133
237       */
238      public ParConstructorDecl treeCopy() {
239        doFullTraversal();
240        return treeCopyNoTransform();
241      }
242      /**
243       * @apilevel internal
244       * @declaredat ASTNode:140
245       */
246      protected boolean is$Equal(ASTNode node) {
247        return super.is$Equal(node) && (tokenString_ID == ((ParConstructorDecl)node).tokenString_ID) && (tokenGenericConstructorDecl_GenericConstructorDecl == ((ParConstructorDecl)node).tokenGenericConstructorDecl_GenericConstructorDecl);    
248      }
249      /**
250       * Replaces the Modifiers child.
251       * @param node The new node to replace the Modifiers child.
252       * @apilevel high-level
253       */
254      public void setModifiers(Modifiers node) {
255        setChild(node, 0);
256      }
257      /**
258       * Retrieves the Modifiers child.
259       * @return The current node used as the Modifiers child.
260       * @apilevel high-level
261       */
262      @ASTNodeAnnotation.Child(name="Modifiers")
263      public Modifiers getModifiers() {
264        return (Modifiers) getChild(0);
265      }
266      /**
267       * Retrieves the Modifiers child.
268       * <p><em>This method does not invoke AST transformations.</em></p>
269       * @return The current node used as the Modifiers child.
270       * @apilevel low-level
271       */
272      public Modifiers getModifiersNoTransform() {
273        return (Modifiers) getChildNoTransform(0);
274      }
275      /**
276       * Replaces the lexeme ID.
277       * @param value The new value for the lexeme ID.
278       * @apilevel high-level
279       */
280      public void setID(String value) {
281        tokenString_ID = value;
282      }
283      /**
284       * JastAdd-internal setter for lexeme ID using the Beaver parser.
285       * @param symbol Symbol containing the new value for the lexeme ID
286       * @apilevel internal
287       */
288      public void setID(beaver.Symbol symbol) {
289        if (symbol.value != null && !(symbol.value instanceof String))
290        throw new UnsupportedOperationException("setID is only valid for String lexemes");
291        tokenString_ID = (String)symbol.value;
292        IDstart = symbol.getStart();
293        IDend = symbol.getEnd();
294      }
295      /**
296       * Retrieves the value for the lexeme ID.
297       * @return The value for the lexeme ID.
298       * @apilevel high-level
299       */
300      @ASTNodeAnnotation.Token(name="ID")
301      public String getID() {
302        return tokenString_ID != null ? tokenString_ID : "";
303      }
304      /**
305       * Replaces the Parameter list.
306       * @param list The new list node to be used as the Parameter list.
307       * @apilevel high-level
308       */
309      public void setParameterList(List<ParameterDeclaration> list) {
310        setChild(list, 1);
311      }
312      /**
313       * Retrieves the number of children in the Parameter list.
314       * @return Number of children in the Parameter list.
315       * @apilevel high-level
316       */
317      public int getNumParameter() {
318        return getParameterList().getNumChild();
319      }
320      /**
321       * Retrieves the number of children in the Parameter list.
322       * Calling this method will not trigger rewrites.
323       * @return Number of children in the Parameter list.
324       * @apilevel low-level
325       */
326      public int getNumParameterNoTransform() {
327        return getParameterListNoTransform().getNumChildNoTransform();
328      }
329      /**
330       * Retrieves the element at index {@code i} in the Parameter list.
331       * @param i Index of the element to return.
332       * @return The element at position {@code i} in the Parameter list.
333       * @apilevel high-level
334       */
335      public ParameterDeclaration getParameter(int i) {
336        return (ParameterDeclaration) getParameterList().getChild(i);
337      }
338      /**
339       * Check whether the Parameter list has any children.
340       * @return {@code true} if it has at least one child, {@code false} otherwise.
341       * @apilevel high-level
342       */
343      public boolean hasParameter() {
344        return getParameterList().getNumChild() != 0;
345      }
346      /**
347       * Append an element to the Parameter list.
348       * @param node The element to append to the Parameter list.
349       * @apilevel high-level
350       */
351      public void addParameter(ParameterDeclaration node) {
352        List<ParameterDeclaration> list = (parent == null) ? getParameterListNoTransform() : getParameterList();
353        list.addChild(node);
354      }
355      /**
356       * @apilevel low-level
357       */
358      public void addParameterNoTransform(ParameterDeclaration node) {
359        List<ParameterDeclaration> list = getParameterListNoTransform();
360        list.addChild(node);
361      }
362      /**
363       * Replaces the Parameter list element at index {@code i} with the new node {@code node}.
364       * @param node The new node to replace the old list element.
365       * @param i The list index of the node to be replaced.
366       * @apilevel high-level
367       */
368      public void setParameter(ParameterDeclaration node, int i) {
369        List<ParameterDeclaration> list = getParameterList();
370        list.setChild(node, i);
371      }
372      /**
373       * Retrieves the Parameter list.
374       * @return The node representing the Parameter list.
375       * @apilevel high-level
376       */
377      @ASTNodeAnnotation.ListChild(name="Parameter")
378      public List<ParameterDeclaration> getParameterList() {
379        List<ParameterDeclaration> list = (List<ParameterDeclaration>) getChild(1);
380        return list;
381      }
382      /**
383       * Retrieves the Parameter list.
384       * <p><em>This method does not invoke AST transformations.</em></p>
385       * @return The node representing the Parameter list.
386       * @apilevel low-level
387       */
388      public List<ParameterDeclaration> getParameterListNoTransform() {
389        return (List<ParameterDeclaration>) getChildNoTransform(1);
390      }
391      /**
392       * Retrieves the Parameter list.
393       * @return The node representing the Parameter list.
394       * @apilevel high-level
395       */
396      public List<ParameterDeclaration> getParameters() {
397        return getParameterList();
398      }
399      /**
400       * Retrieves the Parameter list.
401       * <p><em>This method does not invoke AST transformations.</em></p>
402       * @return The node representing the Parameter list.
403       * @apilevel low-level
404       */
405      public List<ParameterDeclaration> getParametersNoTransform() {
406        return getParameterListNoTransform();
407      }
408      /**
409       * Replaces the Exception list.
410       * @param list The new list node to be used as the Exception list.
411       * @apilevel high-level
412       */
413      public void setExceptionList(List<Access> list) {
414        setChild(list, 2);
415      }
416      /**
417       * Retrieves the number of children in the Exception list.
418       * @return Number of children in the Exception list.
419       * @apilevel high-level
420       */
421      public int getNumException() {
422        return getExceptionList().getNumChild();
423      }
424      /**
425       * Retrieves the number of children in the Exception list.
426       * Calling this method will not trigger rewrites.
427       * @return Number of children in the Exception list.
428       * @apilevel low-level
429       */
430      public int getNumExceptionNoTransform() {
431        return getExceptionListNoTransform().getNumChildNoTransform();
432      }
433      /**
434       * Retrieves the element at index {@code i} in the Exception list.
435       * @param i Index of the element to return.
436       * @return The element at position {@code i} in the Exception list.
437       * @apilevel high-level
438       */
439      public Access getException(int i) {
440        return (Access) getExceptionList().getChild(i);
441      }
442      /**
443       * Check whether the Exception list has any children.
444       * @return {@code true} if it has at least one child, {@code false} otherwise.
445       * @apilevel high-level
446       */
447      public boolean hasException() {
448        return getExceptionList().getNumChild() != 0;
449      }
450      /**
451       * Append an element to the Exception list.
452       * @param node The element to append to the Exception list.
453       * @apilevel high-level
454       */
455      public void addException(Access node) {
456        List<Access> list = (parent == null) ? getExceptionListNoTransform() : getExceptionList();
457        list.addChild(node);
458      }
459      /**
460       * @apilevel low-level
461       */
462      public void addExceptionNoTransform(Access node) {
463        List<Access> list = getExceptionListNoTransform();
464        list.addChild(node);
465      }
466      /**
467       * Replaces the Exception list element at index {@code i} with the new node {@code node}.
468       * @param node The new node to replace the old list element.
469       * @param i The list index of the node to be replaced.
470       * @apilevel high-level
471       */
472      public void setException(Access node, int i) {
473        List<Access> list = getExceptionList();
474        list.setChild(node, i);
475      }
476      /**
477       * Retrieves the Exception list.
478       * @return The node representing the Exception list.
479       * @apilevel high-level
480       */
481      @ASTNodeAnnotation.ListChild(name="Exception")
482      public List<Access> getExceptionList() {
483        List<Access> list = (List<Access>) getChild(2);
484        return list;
485      }
486      /**
487       * Retrieves the Exception list.
488       * <p><em>This method does not invoke AST transformations.</em></p>
489       * @return The node representing the Exception list.
490       * @apilevel low-level
491       */
492      public List<Access> getExceptionListNoTransform() {
493        return (List<Access>) getChildNoTransform(2);
494      }
495      /**
496       * Retrieves the Exception list.
497       * @return The node representing the Exception list.
498       * @apilevel high-level
499       */
500      public List<Access> getExceptions() {
501        return getExceptionList();
502      }
503      /**
504       * Retrieves the Exception list.
505       * <p><em>This method does not invoke AST transformations.</em></p>
506       * @return The node representing the Exception list.
507       * @apilevel low-level
508       */
509      public List<Access> getExceptionsNoTransform() {
510        return getExceptionListNoTransform();
511      }
512      /**
513       * Replaces the optional node for the ParsedConstructorInvocation child. This is the <code>Opt</code>
514       * node containing the child ParsedConstructorInvocation, not the actual child!
515       * @param opt The new node to be used as the optional node for the ParsedConstructorInvocation child.
516       * @apilevel low-level
517       */
518      public void setParsedConstructorInvocationOpt(Opt<Stmt> opt) {
519        setChild(opt, 3);
520      }
521      /**
522       * Replaces the (optional) ParsedConstructorInvocation child.
523       * @param node The new node to be used as the ParsedConstructorInvocation child.
524       * @apilevel high-level
525       */
526      public void setParsedConstructorInvocation(Stmt node) {
527        getParsedConstructorInvocationOpt().setChild(node, 0);
528      }
529      /**
530       * Check whether the optional ParsedConstructorInvocation child exists.
531       * @return {@code true} if the optional ParsedConstructorInvocation child exists, {@code false} if it does not.
532       * @apilevel high-level
533       */
534      public boolean hasParsedConstructorInvocation() {
535        return getParsedConstructorInvocationOpt().getNumChild() != 0;
536      }
537      /**
538       * Retrieves the (optional) ParsedConstructorInvocation child.
539       * @return The ParsedConstructorInvocation child, if it exists. Returns {@code null} otherwise.
540       * @apilevel low-level
541       */
542      public Stmt getParsedConstructorInvocation() {
543        return (Stmt) getParsedConstructorInvocationOpt().getChild(0);
544      }
545      /**
546       * Retrieves the optional node for the ParsedConstructorInvocation child. This is the <code>Opt</code> node containing the child ParsedConstructorInvocation, not the actual child!
547       * @return The optional node for child the ParsedConstructorInvocation child.
548       * @apilevel low-level
549       */
550      @ASTNodeAnnotation.OptChild(name="ParsedConstructorInvocation")
551      public Opt<Stmt> getParsedConstructorInvocationOpt() {
552        return (Opt<Stmt>) getChild(3);
553      }
554      /**
555       * Retrieves the optional node for child ParsedConstructorInvocation. This is the <code>Opt</code> node containing the child ParsedConstructorInvocation, not the actual child!
556       * <p><em>This method does not invoke AST transformations.</em></p>
557       * @return The optional node for child ParsedConstructorInvocation.
558       * @apilevel low-level
559       */
560      public Opt<Stmt> getParsedConstructorInvocationOptNoTransform() {
561        return (Opt<Stmt>) getChildNoTransform(3);
562      }
563      /**
564       * Replaces the Block child.
565       * @param node The new node to replace the Block child.
566       * @apilevel high-level
567       */
568      public void setBlock(Block node) {
569        setChild(node, 4);
570      }
571      /**
572       * Retrieves the Block child.
573       * @return The current node used as the Block child.
574       * @apilevel high-level
575       */
576      @ASTNodeAnnotation.Child(name="Block")
577      public Block getBlock() {
578        return (Block) getChild(4);
579      }
580      /**
581       * Retrieves the Block child.
582       * <p><em>This method does not invoke AST transformations.</em></p>
583       * @return The current node used as the Block child.
584       * @apilevel low-level
585       */
586      public Block getBlockNoTransform() {
587        return (Block) getChildNoTransform(4);
588      }
589      /**
590       * Replaces the TypeArgument list.
591       * @param list The new list node to be used as the TypeArgument list.
592       * @apilevel high-level
593       */
594      public void setTypeArgumentList(List<Access> list) {
595        setChild(list, 5);
596      }
597      /**
598       * Retrieves the number of children in the TypeArgument list.
599       * @return Number of children in the TypeArgument list.
600       * @apilevel high-level
601       */
602      public int getNumTypeArgument() {
603        return getTypeArgumentList().getNumChild();
604      }
605      /**
606       * Retrieves the number of children in the TypeArgument list.
607       * Calling this method will not trigger rewrites.
608       * @return Number of children in the TypeArgument list.
609       * @apilevel low-level
610       */
611      public int getNumTypeArgumentNoTransform() {
612        return getTypeArgumentListNoTransform().getNumChildNoTransform();
613      }
614      /**
615       * Retrieves the element at index {@code i} in the TypeArgument list.
616       * @param i Index of the element to return.
617       * @return The element at position {@code i} in the TypeArgument list.
618       * @apilevel high-level
619       */
620      public Access getTypeArgument(int i) {
621        return (Access) getTypeArgumentList().getChild(i);
622      }
623      /**
624       * Check whether the TypeArgument list has any children.
625       * @return {@code true} if it has at least one child, {@code false} otherwise.
626       * @apilevel high-level
627       */
628      public boolean hasTypeArgument() {
629        return getTypeArgumentList().getNumChild() != 0;
630      }
631      /**
632       * Append an element to the TypeArgument list.
633       * @param node The element to append to the TypeArgument list.
634       * @apilevel high-level
635       */
636      public void addTypeArgument(Access node) {
637        List<Access> list = (parent == null) ? getTypeArgumentListNoTransform() : getTypeArgumentList();
638        list.addChild(node);
639      }
640      /**
641       * @apilevel low-level
642       */
643      public void addTypeArgumentNoTransform(Access node) {
644        List<Access> list = getTypeArgumentListNoTransform();
645        list.addChild(node);
646      }
647      /**
648       * Replaces the TypeArgument list element at index {@code i} with the new node {@code node}.
649       * @param node The new node to replace the old list element.
650       * @param i The list index of the node to be replaced.
651       * @apilevel high-level
652       */
653      public void setTypeArgument(Access node, int i) {
654        List<Access> list = getTypeArgumentList();
655        list.setChild(node, i);
656      }
657      /**
658       * Retrieves the TypeArgument list.
659       * @return The node representing the TypeArgument list.
660       * @apilevel high-level
661       */
662      @ASTNodeAnnotation.ListChild(name="TypeArgument")
663      public List<Access> getTypeArgumentList() {
664        List<Access> list = (List<Access>) getChild(5);
665        return list;
666      }
667      /**
668       * Retrieves the TypeArgument list.
669       * <p><em>This method does not invoke AST transformations.</em></p>
670       * @return The node representing the TypeArgument list.
671       * @apilevel low-level
672       */
673      public List<Access> getTypeArgumentListNoTransform() {
674        return (List<Access>) getChildNoTransform(5);
675      }
676      /**
677       * Retrieves the TypeArgument list.
678       * @return The node representing the TypeArgument list.
679       * @apilevel high-level
680       */
681      public List<Access> getTypeArguments() {
682        return getTypeArgumentList();
683      }
684      /**
685       * Retrieves the TypeArgument list.
686       * <p><em>This method does not invoke AST transformations.</em></p>
687       * @return The node representing the TypeArgument list.
688       * @apilevel low-level
689       */
690      public List<Access> getTypeArgumentsNoTransform() {
691        return getTypeArgumentListNoTransform();
692      }
693      /**
694       * Replaces the lexeme GenericConstructorDecl.
695       * @param value The new value for the lexeme GenericConstructorDecl.
696       * @apilevel high-level
697       */
698      public void setGenericConstructorDecl(GenericConstructorDecl value) {
699        tokenGenericConstructorDecl_GenericConstructorDecl = value;
700      }
701      /**
702       * @apilevel internal
703       */
704      protected GenericConstructorDecl tokenGenericConstructorDecl_GenericConstructorDecl;
705      /**
706       * Retrieves the value for the lexeme GenericConstructorDecl.
707       * @return The value for the lexeme GenericConstructorDecl.
708       * @apilevel high-level
709       */
710      @ASTNodeAnnotation.Token(name="GenericConstructorDecl")
711      public GenericConstructorDecl getGenericConstructorDecl() {
712        return tokenGenericConstructorDecl_GenericConstructorDecl;
713      }
714      /**
715       * Retrieves the ImplicitConstructorInvocation child.
716       * <p><em>This method does not invoke AST transformations.</em></p>
717       * @return The current node used as the ImplicitConstructorInvocation child.
718       * @apilevel low-level
719       */
720      public Stmt getImplicitConstructorInvocationNoTransform() {
721        return (Stmt) getChildNoTransform(6);
722      }
723      /**
724       * Retrieves the child position of the optional child ImplicitConstructorInvocation.
725       * @return The the child position of the optional child ImplicitConstructorInvocation.
726       * @apilevel low-level
727       */
728      protected int getImplicitConstructorInvocationChildPosition() {
729        return 6;
730      }
731      /**
732       * @apilevel internal
733       */
734      protected boolean genericConstructorDecl_computed = false;
735      /**
736       * @apilevel internal
737       */
738      protected GenericConstructorDecl genericConstructorDecl_value;
739      /**
740       * @apilevel internal
741       */
742      private void genericConstructorDecl_reset() {
743        genericConstructorDecl_computed = false;
744        genericConstructorDecl_value = null;
745      }
746      /**
747       * @attribute syn
748       * @aspect GenericMethods
749       * @declaredat /home/jesper/git/extendj/java5/frontend/GenericMethods.jrag:53
750       */
751      @ASTNodeAnnotation.Attribute
752      public GenericConstructorDecl genericConstructorDecl() {
753        ASTNode$State state = state();
754        if (genericConstructorDecl_computed) {
755          return genericConstructorDecl_value;
756        }
757        boolean intermediate = state.INTERMEDIATE_VALUE;
758        state.INTERMEDIATE_VALUE = false;
759        int num = state.boundariesCrossed;
760        boolean isFinal = this.is$Final();
761        genericConstructorDecl_value = getGenericConstructorDecl();
762        if (isFinal && num == state().boundariesCrossed) {
763          genericConstructorDecl_computed = true;
764        } else {
765        }
766        state.INTERMEDIATE_VALUE |= intermediate;
767    
768        return genericConstructorDecl_value;
769      }
770      /**
771       * @apilevel internal
772       */
773      protected boolean sourceConstructorDecl_computed = false;
774      /**
775       * @apilevel internal
776       */
777      protected ConstructorDecl sourceConstructorDecl_value;
778      /**
779       * @apilevel internal
780       */
781      private void sourceConstructorDecl_reset() {
782        sourceConstructorDecl_computed = false;
783        sourceConstructorDecl_value = null;
784      }
785      /**
786       * @attribute syn
787       * @aspect SourceDeclarations
788       * @declaredat /home/jesper/git/extendj/java5/frontend/Generics.jrag:1629
789       */
790      @ASTNodeAnnotation.Attribute
791      public ConstructorDecl sourceConstructorDecl() {
792        ASTNode$State state = state();
793        if (sourceConstructorDecl_computed) {
794          return sourceConstructorDecl_value;
795        }
796        boolean intermediate = state.INTERMEDIATE_VALUE;
797        state.INTERMEDIATE_VALUE = false;
798        int num = state.boundariesCrossed;
799        boolean isFinal = this.is$Final();
800        sourceConstructorDecl_value = genericConstructorDecl().original().sourceConstructorDecl();
801        if (isFinal && num == state().boundariesCrossed) {
802          sourceConstructorDecl_computed = true;
803        } else {
804        }
805        state.INTERMEDIATE_VALUE |= intermediate;
806    
807        return sourceConstructorDecl_value;
808      }
809      /**
810       * @apilevel internal
811       */
812      public ASTNode rewriteTo() {
813        return super.rewriteTo();
814      }
815    }