001    /* This file was generated with JastAdd2 (http://jastadd.org) version R20130213 */
002    package AST;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.*;
007    import beaver.*;
008    import java.util.ArrayList;
009    import java.util.zip.*;
010    import java.io.*;
011    import java.io.FileNotFoundException;
012    import java.util.Collection;
013    /**
014     * @production ArrayDecl : {@link ClassDecl};
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:68
017     */
018    public class ArrayDecl extends ClassDecl implements Cloneable {
019      /**
020       * @apilevel low-level
021       */
022      public void flushCache() {
023      }
024      /**
025       * @apilevel internal
026       */
027      public void flushCollectionCache() {
028      }
029      /**
030       * @apilevel internal
031       */
032      @SuppressWarnings({"unchecked", "cast"})
033      public ArrayDecl clone() throws CloneNotSupportedException {
034        ArrayDecl node = (ArrayDecl)super.clone();
035        node.accessibleFrom_TypeDecl_values = null;
036        node.dimension_computed = false;
037        node.elementType_computed = false;
038        node.elementType_value = null;
039        node.fullName_computed = false;
040        node.fullName_value = null;
041        node.typeName_computed = false;
042        node.typeName_value = null;
043        node.castingConversionTo_TypeDecl_values = null;
044        node.instanceOf_TypeDecl_values = null;
045        node.constantPoolName_computed = false;
046        node.constantPoolName_value = null;
047        node.typeDescriptor_computed = false;
048        node.typeDescriptor_value = null;
049        node.jvmName_computed = false;
050        node.jvmName_value = null;
051        node.involvesTypeParameters_visited = -1;
052        node.involvesTypeParameters_computed = false;
053        node.involvesTypeParameters_initialized = false;
054        node.erasure_computed = false;
055        node.erasure_value = null;
056        node.usesTypeVariable_visited = -1;
057        node.usesTypeVariable_computed = false;
058        node.usesTypeVariable_initialized = false;
059        node.subtype_TypeDecl_values = null;
060        node.needsSignatureAttribute_computed = false;
061        node.fieldTypeSignature_computed = false;
062        node.fieldTypeSignature_value = null;
063        node.classTypeSignature_computed = false;
064        node.classTypeSignature_value = null;
065        node.in$Circle(false);
066        node.is$Final(false);
067        return node;
068      }
069    /**
070     * @apilevel internal
071     */
072      @SuppressWarnings({"unchecked", "cast"})
073    public ArrayDecl copy() {
074      
075      try {
076        ArrayDecl node = (ArrayDecl) clone();
077        node.parent = null;
078        if(children != null)
079          node.children = (ASTNode[]) children.clone();
080        
081        return node;
082      } catch (CloneNotSupportedException e) {
083        throw new Error("Error: clone not supported for " + getClass().getName());
084      }
085      
086    }/**
087     * Create a deep copy of the AST subtree at this node.
088     * The copy is dangling, i.e. has no parent.
089     * @return dangling copy of the subtree at this node
090     * @apilevel low-level
091     */
092      @SuppressWarnings({"unchecked", "cast"})
093    public ArrayDecl fullCopy() {
094      
095      ArrayDecl tree = (ArrayDecl) copy();
096      if (children != null) {
097        for (int i = 0; i < children.length; ++i) {
098          
099          ASTNode child = (ASTNode) children[i];
100          if(child != null) {
101            child = child.fullCopy();
102            tree.setChild(child, i);
103          }
104        }
105      }
106      return tree;
107      
108    }  /**
109       * @ast method 
110       * @aspect Arrays
111       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Arrays.jrag:59
112       */
113      public Access createQualifiedAccess() {
114        return new ArrayTypeAccess(componentType().createQualifiedAccess());
115      }
116      /**
117       * @ast method 
118       * @aspect LookupParTypeDecl
119       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:880
120       */
121      public Access substitute(Parameterization parTypeDecl) {
122        return new ArrayTypeAccess(componentType().substitute(parTypeDecl));
123      }
124      /**
125       * @ast method 
126       * @aspect LookupParTypeDecl
127       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:916
128       */
129      public Access substituteReturnType(Parameterization parTypeDecl) {
130        return new ArrayTypeAccess(componentType().substituteReturnType(parTypeDecl));
131      }
132      /**
133       * @ast method 
134       * 
135       */
136      public ArrayDecl() {
137        super();
138    
139    
140      }
141      /**
142       * Initializes the child array to the correct size.
143       * Initializes List and Opt nta children.
144       * @apilevel internal
145       * @ast method
146       * @ast method 
147       * 
148       */
149      public void init$Children() {
150        children = new ASTNode[4];
151        setChild(new Opt(), 1);
152        setChild(new List(), 2);
153        setChild(new List(), 3);
154      }
155      /**
156       * @ast method 
157       * 
158       */
159      public ArrayDecl(Modifiers p0, String p1, Opt<Access> p2, List<Access> p3, List<BodyDecl> p4) {
160        setChild(p0, 0);
161        setID(p1);
162        setChild(p2, 1);
163        setChild(p3, 2);
164        setChild(p4, 3);
165      }
166      /**
167       * @ast method 
168       * 
169       */
170      public ArrayDecl(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<Access> p3, List<BodyDecl> p4) {
171        setChild(p0, 0);
172        setID(p1);
173        setChild(p2, 1);
174        setChild(p3, 2);
175        setChild(p4, 3);
176      }
177      /**
178       * @apilevel low-level
179       * @ast method 
180       * 
181       */
182      protected int numChildren() {
183        return 4;
184      }
185      /**
186       * @apilevel internal
187       * @ast method 
188       * 
189       */
190      public boolean mayHaveRewrite() {
191        return false;
192      }
193      /**
194       * Replaces the Modifiers child.
195       * @param node The new node to replace the Modifiers child.
196       * @apilevel high-level
197       * @ast method 
198       * 
199       */
200      public void setModifiers(Modifiers node) {
201        setChild(node, 0);
202      }
203      /**
204       * Retrieves the Modifiers child.
205       * @return The current node used as the Modifiers child.
206       * @apilevel high-level
207       * @ast method 
208       * 
209       */
210      public Modifiers getModifiers() {
211        return (Modifiers)getChild(0);
212      }
213      /**
214       * Retrieves the Modifiers child.
215       * <p><em>This method does not invoke AST transformations.</em></p>
216       * @return The current node used as the Modifiers child.
217       * @apilevel low-level
218       * @ast method 
219       * 
220       */
221      public Modifiers getModifiersNoTransform() {
222        return (Modifiers)getChildNoTransform(0);
223      }
224      /**
225       * Replaces the lexeme ID.
226       * @param value The new value for the lexeme ID.
227       * @apilevel high-level
228       * @ast method 
229       * 
230       */
231      public void setID(String value) {
232        tokenString_ID = value;
233      }
234      /**
235       * JastAdd-internal setter for lexeme ID using the Beaver parser.
236       * @apilevel internal
237       * @ast method 
238       * 
239       */
240      public void setID(beaver.Symbol symbol) {
241        if(symbol.value != null && !(symbol.value instanceof String))
242          throw new UnsupportedOperationException("setID is only valid for String lexemes");
243        tokenString_ID = (String)symbol.value;
244        IDstart = symbol.getStart();
245        IDend = symbol.getEnd();
246      }
247      /**
248       * Retrieves the value for the lexeme ID.
249       * @return The value for the lexeme ID.
250       * @apilevel high-level
251       * @ast method 
252       * 
253       */
254      public String getID() {
255        return tokenString_ID != null ? tokenString_ID : "";
256      }
257      /**
258       * Replaces the optional node for the SuperClassAccess child. This is the {@code Opt} node containing the child SuperClassAccess, not the actual child!
259       * @param opt The new node to be used as the optional node for the SuperClassAccess child.
260       * @apilevel low-level
261       * @ast method 
262       * 
263       */
264      public void setSuperClassAccessOpt(Opt<Access> opt) {
265        setChild(opt, 1);
266      }
267      /**
268       * Check whether the optional SuperClassAccess child exists.
269       * @return {@code true} if the optional SuperClassAccess child exists, {@code false} if it does not.
270       * @apilevel high-level
271       * @ast method 
272       * 
273       */
274      public boolean hasSuperClassAccess() {
275        return getSuperClassAccessOpt().getNumChild() != 0;
276      }
277      /**
278       * Retrieves the (optional) SuperClassAccess child.
279       * @return The SuperClassAccess child, if it exists. Returns {@code null} otherwise.
280       * @apilevel low-level
281       * @ast method 
282       * 
283       */
284      @SuppressWarnings({"unchecked", "cast"})
285      public Access getSuperClassAccess() {
286        return (Access)getSuperClassAccessOpt().getChild(0);
287      }
288      /**
289       * Replaces the (optional) SuperClassAccess child.
290       * @param node The new node to be used as the SuperClassAccess child.
291       * @apilevel high-level
292       * @ast method 
293       * 
294       */
295      public void setSuperClassAccess(Access node) {
296        getSuperClassAccessOpt().setChild(node, 0);
297      }
298      /**
299       * @apilevel low-level
300       * @ast method 
301       * 
302       */
303      @SuppressWarnings({"unchecked", "cast"})
304      public Opt<Access> getSuperClassAccessOpt() {
305        return (Opt<Access>)getChild(1);
306      }
307      /**
308       * Retrieves the optional node for child SuperClassAccess. This is the {@code Opt} node containing the child SuperClassAccess, not the actual child!
309       * <p><em>This method does not invoke AST transformations.</em></p>
310       * @return The optional node for child SuperClassAccess.
311       * @apilevel low-level
312       * @ast method 
313       * 
314       */
315      @SuppressWarnings({"unchecked", "cast"})
316      public Opt<Access> getSuperClassAccessOptNoTransform() {
317        return (Opt<Access>)getChildNoTransform(1);
318      }
319      /**
320       * Replaces the Implements list.
321       * @param list The new list node to be used as the Implements list.
322       * @apilevel high-level
323       * @ast method 
324       * 
325       */
326      public void setImplementsList(List<Access> list) {
327        setChild(list, 2);
328      }
329      /**
330       * Retrieves the number of children in the Implements list.
331       * @return Number of children in the Implements list.
332       * @apilevel high-level
333       * @ast method 
334       * 
335       */
336      public int getNumImplements() {
337        return getImplementsList().getNumChild();
338      }
339      /**
340       * Retrieves the number of children in the Implements list.
341       * Calling this method will not trigger rewrites..
342       * @return Number of children in the Implements list.
343       * @apilevel low-level
344       * @ast method 
345       * 
346       */
347      public int getNumImplementsNoTransform() {
348        return getImplementsListNoTransform().getNumChildNoTransform();
349      }
350      /**
351       * Retrieves the element at index {@code i} in the Implements list..
352       * @param i Index of the element to return.
353       * @return The element at position {@code i} in the Implements list.
354       * @apilevel high-level
355       * @ast method 
356       * 
357       */
358      @SuppressWarnings({"unchecked", "cast"})
359      public Access getImplements(int i) {
360        return (Access)getImplementsList().getChild(i);
361      }
362      /**
363       * Append an element to the Implements list.
364       * @param node The element to append to the Implements list.
365       * @apilevel high-level
366       * @ast method 
367       * 
368       */
369      public void addImplements(Access node) {
370        List<Access> list = (parent == null || state == null) ? getImplementsListNoTransform() : getImplementsList();
371        list.addChild(node);
372      }
373      /**
374       * @apilevel low-level
375       * @ast method 
376       * 
377       */
378      public void addImplementsNoTransform(Access node) {
379        List<Access> list = getImplementsListNoTransform();
380        list.addChild(node);
381      }
382      /**
383       * Replaces the Implements list element at index {@code i} with the new node {@code node}.
384       * @param node The new node to replace the old list element.
385       * @param i The list index of the node to be replaced.
386       * @apilevel high-level
387       * @ast method 
388       * 
389       */
390      public void setImplements(Access node, int i) {
391        List<Access> list = getImplementsList();
392        list.setChild(node, i);
393      }
394      /**
395       * Retrieves the Implements list.
396       * @return The node representing the Implements list.
397       * @apilevel high-level
398       * @ast method 
399       * 
400       */
401      public List<Access> getImplementss() {
402        return getImplementsList();
403      }
404      /**
405       * Retrieves the Implements list.
406       * <p><em>This method does not invoke AST transformations.</em></p>
407       * @return The node representing the Implements list.
408       * @apilevel low-level
409       * @ast method 
410       * 
411       */
412      public List<Access> getImplementssNoTransform() {
413        return getImplementsListNoTransform();
414      }
415      /**
416       * Retrieves the Implements list.
417       * @return The node representing the Implements list.
418       * @apilevel high-level
419       * @ast method 
420       * 
421       */
422      @SuppressWarnings({"unchecked", "cast"})
423      public List<Access> getImplementsList() {
424        List<Access> list = (List<Access>)getChild(2);
425        list.getNumChild();
426        return list;
427      }
428      /**
429       * Retrieves the Implements list.
430       * <p><em>This method does not invoke AST transformations.</em></p>
431       * @return The node representing the Implements list.
432       * @apilevel low-level
433       * @ast method 
434       * 
435       */
436      @SuppressWarnings({"unchecked", "cast"})
437      public List<Access> getImplementsListNoTransform() {
438        return (List<Access>)getChildNoTransform(2);
439      }
440      /**
441       * Replaces the BodyDecl list.
442       * @param list The new list node to be used as the BodyDecl list.
443       * @apilevel high-level
444       * @ast method 
445       * 
446       */
447      public void setBodyDeclList(List<BodyDecl> list) {
448        setChild(list, 3);
449      }
450      /**
451       * Retrieves the number of children in the BodyDecl list.
452       * @return Number of children in the BodyDecl list.
453       * @apilevel high-level
454       * @ast method 
455       * 
456       */
457      public int getNumBodyDecl() {
458        return getBodyDeclList().getNumChild();
459      }
460      /**
461       * Retrieves the number of children in the BodyDecl list.
462       * Calling this method will not trigger rewrites..
463       * @return Number of children in the BodyDecl list.
464       * @apilevel low-level
465       * @ast method 
466       * 
467       */
468      public int getNumBodyDeclNoTransform() {
469        return getBodyDeclListNoTransform().getNumChildNoTransform();
470      }
471      /**
472       * Retrieves the element at index {@code i} in the BodyDecl list..
473       * @param i Index of the element to return.
474       * @return The element at position {@code i} in the BodyDecl list.
475       * @apilevel high-level
476       * @ast method 
477       * 
478       */
479      @SuppressWarnings({"unchecked", "cast"})
480      public BodyDecl getBodyDecl(int i) {
481        return (BodyDecl)getBodyDeclList().getChild(i);
482      }
483      /**
484       * Append an element to the BodyDecl list.
485       * @param node The element to append to the BodyDecl list.
486       * @apilevel high-level
487       * @ast method 
488       * 
489       */
490      public void addBodyDecl(BodyDecl node) {
491        List<BodyDecl> list = (parent == null || state == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
492        list.addChild(node);
493      }
494      /**
495       * @apilevel low-level
496       * @ast method 
497       * 
498       */
499      public void addBodyDeclNoTransform(BodyDecl node) {
500        List<BodyDecl> list = getBodyDeclListNoTransform();
501        list.addChild(node);
502      }
503      /**
504       * Replaces the BodyDecl list element at index {@code i} with the new node {@code node}.
505       * @param node The new node to replace the old list element.
506       * @param i The list index of the node to be replaced.
507       * @apilevel high-level
508       * @ast method 
509       * 
510       */
511      public void setBodyDecl(BodyDecl node, int i) {
512        List<BodyDecl> list = getBodyDeclList();
513        list.setChild(node, i);
514      }
515      /**
516       * Retrieves the BodyDecl list.
517       * @return The node representing the BodyDecl list.
518       * @apilevel high-level
519       * @ast method 
520       * 
521       */
522      public List<BodyDecl> getBodyDecls() {
523        return getBodyDeclList();
524      }
525      /**
526       * Retrieves the BodyDecl list.
527       * <p><em>This method does not invoke AST transformations.</em></p>
528       * @return The node representing the BodyDecl list.
529       * @apilevel low-level
530       * @ast method 
531       * 
532       */
533      public List<BodyDecl> getBodyDeclsNoTransform() {
534        return getBodyDeclListNoTransform();
535      }
536      /**
537       * Retrieves the BodyDecl list.
538       * @return The node representing the BodyDecl list.
539       * @apilevel high-level
540       * @ast method 
541       * 
542       */
543      @SuppressWarnings({"unchecked", "cast"})
544      public List<BodyDecl> getBodyDeclList() {
545        List<BodyDecl> list = (List<BodyDecl>)getChild(3);
546        list.getNumChild();
547        return list;
548      }
549      /**
550       * Retrieves the BodyDecl list.
551       * <p><em>This method does not invoke AST transformations.</em></p>
552       * @return The node representing the BodyDecl list.
553       * @apilevel low-level
554       * @ast method 
555       * 
556       */
557      @SuppressWarnings({"unchecked", "cast"})
558      public List<BodyDecl> getBodyDeclListNoTransform() {
559        return (List<BodyDecl>)getChildNoTransform(3);
560      }
561      /**
562       * @ast method 
563       * @aspect TypeConversion
564       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:120
565       */
566      private boolean refined_TypeConversion_ArrayDecl_castingConversionTo_TypeDecl(TypeDecl type)
567    {
568        if(type.isArrayDecl()) {
569          TypeDecl SC = componentType();
570          TypeDecl TC = type.componentType();
571          if(SC.isPrimitiveType() && TC.isPrimitiveType() && SC == TC)
572            return true;
573          if(SC.isReferenceType() && TC.isReferenceType()) {
574            return SC.castingConversionTo(TC);
575          }
576          return false;
577        }
578        else if(type.isClassDecl()) {
579          return type.isObject();
580        }
581        else if(type.isInterfaceDecl()) {
582          return type == typeSerializable() || type == typeCloneable();
583        }
584        else return super.castingConversionTo(type);
585      }
586      protected java.util.Map accessibleFrom_TypeDecl_values;
587      /**
588       * @attribute syn
589       * @aspect AccessControl
590       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/AccessControl.jrag:13
591       */
592      @SuppressWarnings({"unchecked", "cast"})
593      public boolean accessibleFrom(TypeDecl type) {
594        Object _parameters = type;
595        if(accessibleFrom_TypeDecl_values == null) accessibleFrom_TypeDecl_values = new java.util.HashMap(4);
596        if(accessibleFrom_TypeDecl_values.containsKey(_parameters)) {
597          return ((Boolean)accessibleFrom_TypeDecl_values.get(_parameters)).booleanValue();
598        }
599          ASTNode$State state = state();
600      int num = state.boundariesCrossed;
601      boolean isFinal = this.is$Final();
602        boolean accessibleFrom_TypeDecl_value = accessibleFrom_compute(type);
603      if(isFinal && num == state().boundariesCrossed){ accessibleFrom_TypeDecl_values.put(_parameters, Boolean.valueOf(accessibleFrom_TypeDecl_value)); }
604            return accessibleFrom_TypeDecl_value;
605      }
606      /**
607       * @apilevel internal
608       */
609      private boolean accessibleFrom_compute(TypeDecl type) {  return elementType().accessibleFrom(type);  }
610      /**
611       * @apilevel internal
612       */
613      protected boolean dimension_computed = false;
614      /**
615       * @apilevel internal
616       */
617      protected int dimension_value;
618      /**
619       * @attribute syn
620       * @aspect Arrays
621       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Arrays.jrag:12
622       */
623      @SuppressWarnings({"unchecked", "cast"})
624      public int dimension() {
625        if(dimension_computed) {
626          return dimension_value;
627        }
628          ASTNode$State state = state();
629      int num = state.boundariesCrossed;
630      boolean isFinal = this.is$Final();
631        dimension_value = dimension_compute();
632      if(isFinal && num == state().boundariesCrossed){ dimension_computed = true; }
633            return dimension_value;
634      }
635      /**
636       * @apilevel internal
637       */
638      private int dimension_compute() {  return componentType().dimension() + 1;  }
639      /**
640       * @apilevel internal
641       */
642      protected boolean elementType_computed = false;
643      /**
644       * @apilevel internal
645       */
646      protected TypeDecl elementType_value;
647      /**
648       * @attribute syn
649       * @aspect Arrays
650       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Arrays.jrag:16
651       */
652      @SuppressWarnings({"unchecked", "cast"})
653      public TypeDecl elementType() {
654        if(elementType_computed) {
655          return elementType_value;
656        }
657          ASTNode$State state = state();
658      int num = state.boundariesCrossed;
659      boolean isFinal = this.is$Final();
660        elementType_value = elementType_compute();
661      if(isFinal && num == state().boundariesCrossed){ elementType_computed = true; }
662            return elementType_value;
663      }
664      /**
665       * @apilevel internal
666       */
667      private TypeDecl elementType_compute() {  return componentType().elementType();  }
668      /**
669       * @attribute syn
670       * @aspect TypeName
671       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/QualifiedNames.jrag:68
672       */
673      public String name() {
674        ASTNode$State state = state();
675        try {  return fullName();  }
676        finally {
677        }
678      }
679      /**
680       * @apilevel internal
681       */
682      protected boolean fullName_computed = false;
683      /**
684       * @apilevel internal
685       */
686      protected String fullName_value;
687      /**
688       * @attribute syn
689       * @aspect Arrays
690       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/Arrays.jrag:54
691       */
692      @SuppressWarnings({"unchecked", "cast"})
693      public String fullName() {
694        if(fullName_computed) {
695          return fullName_value;
696        }
697          ASTNode$State state = state();
698      int num = state.boundariesCrossed;
699      boolean isFinal = this.is$Final();
700        fullName_value = fullName_compute();
701      if(isFinal && num == state().boundariesCrossed){ fullName_computed = true; }
702            return fullName_value;
703      }
704      /**
705       * @apilevel internal
706       */
707      private String fullName_compute() {  return getID();  }
708      /**
709       * @apilevel internal
710       */
711      protected boolean typeName_computed = false;
712      /**
713       * @apilevel internal
714       */
715      protected String typeName_value;
716      /**
717       * @attribute syn
718       * @aspect TypeName
719       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/QualifiedNames.jrag:87
720       */
721      @SuppressWarnings({"unchecked", "cast"})
722      public String typeName() {
723        if(typeName_computed) {
724          return typeName_value;
725        }
726          ASTNode$State state = state();
727      int num = state.boundariesCrossed;
728      boolean isFinal = this.is$Final();
729        typeName_value = typeName_compute();
730      if(isFinal && num == state().boundariesCrossed){ typeName_computed = true; }
731            return typeName_value;
732      }
733      /**
734       * @apilevel internal
735       */
736      private String typeName_compute() {  return componentType().typeName() + "[]";  }
737      protected java.util.Map castingConversionTo_TypeDecl_values;
738      /**
739       * @attribute syn
740       * @aspect Generics
741       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:96
742       */
743      @SuppressWarnings({"unchecked", "cast"})
744      public boolean castingConversionTo(TypeDecl type) {
745        Object _parameters = type;
746        if(castingConversionTo_TypeDecl_values == null) castingConversionTo_TypeDecl_values = new java.util.HashMap(4);
747        if(castingConversionTo_TypeDecl_values.containsKey(_parameters)) {
748          return ((Boolean)castingConversionTo_TypeDecl_values.get(_parameters)).booleanValue();
749        }
750          ASTNode$State state = state();
751      int num = state.boundariesCrossed;
752      boolean isFinal = this.is$Final();
753        boolean castingConversionTo_TypeDecl_value = castingConversionTo_compute(type);
754      if(isFinal && num == state().boundariesCrossed){ castingConversionTo_TypeDecl_values.put(_parameters, Boolean.valueOf(castingConversionTo_TypeDecl_value)); }
755            return castingConversionTo_TypeDecl_value;
756      }
757      /**
758       * @apilevel internal
759       */
760      private boolean castingConversionTo_compute(TypeDecl type) {
761        TypeDecl S = this;
762        TypeDecl T = type;
763        if(T instanceof TypeVariable) {
764          TypeVariable t = (TypeVariable)T;
765          if(!type.isReferenceType())
766            return false;
767          if(t.getNumTypeBound() == 0) return true;
768          for(int i = 0; i < t.getNumTypeBound(); i++) {
769            TypeDecl bound = t.getTypeBound(i).type();
770            if(bound.isObject() || bound == typeSerializable() || bound == typeCloneable())
771              return true;
772            if(bound.isTypeVariable() && castingConversionTo(bound))
773              return true;
774            if(bound.isArrayDecl() && castingConversionTo(bound))
775              return true;
776          }
777          return false;
778        }
779        else
780          return refined_TypeConversion_ArrayDecl_castingConversionTo_TypeDecl(type);
781      }
782      /**
783       * @attribute syn
784       * @aspect TypeAnalysis
785       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:213
786       */
787      public boolean isArrayDecl() {
788        ASTNode$State state = state();
789        try {  return true;  }
790        finally {
791        }
792      }
793      protected java.util.Map instanceOf_TypeDecl_values;
794      /**
795       * @attribute syn
796       * @aspect GenericsSubtype
797       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:389
798       */
799      @SuppressWarnings({"unchecked", "cast"})
800      public boolean instanceOf(TypeDecl type) {
801        Object _parameters = type;
802        if(instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new java.util.HashMap(4);
803        if(instanceOf_TypeDecl_values.containsKey(_parameters)) {
804          return ((Boolean)instanceOf_TypeDecl_values.get(_parameters)).booleanValue();
805        }
806          ASTNode$State state = state();
807      int num = state.boundariesCrossed;
808      boolean isFinal = this.is$Final();
809        boolean instanceOf_TypeDecl_value = instanceOf_compute(type);
810      if(isFinal && num == state().boundariesCrossed){ instanceOf_TypeDecl_values.put(_parameters, Boolean.valueOf(instanceOf_TypeDecl_value)); }
811            return instanceOf_TypeDecl_value;
812      }
813      /**
814       * @apilevel internal
815       */
816      private boolean instanceOf_compute(TypeDecl type) { return subtype(type); }
817      /**
818       * @attribute syn
819       * @aspect TypeWideningAndIdentity
820       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:453
821       */
822      public boolean isSupertypeOfArrayDecl(ArrayDecl type) {
823        ASTNode$State state = state();
824        try {
825        if(type.elementType().isPrimitive() && elementType().isPrimitive())
826          return type.dimension() == dimension() && type.elementType() == elementType();
827        return type.componentType().instanceOf(componentType());
828      }
829        finally {
830        }
831      }
832      /**
833       * @apilevel internal
834       */
835      protected boolean constantPoolName_computed = false;
836      /**
837       * @apilevel internal
838       */
839      protected String constantPoolName_value;
840      /**
841       * @attribute syn
842       * @aspect ConstantPool
843       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/ConstantPool.jrag:36
844       */
845      @SuppressWarnings({"unchecked", "cast"})
846      public String constantPoolName() {
847        if(constantPoolName_computed) {
848          return constantPoolName_value;
849        }
850          ASTNode$State state = state();
851      int num = state.boundariesCrossed;
852      boolean isFinal = this.is$Final();
853        constantPoolName_value = constantPoolName_compute();
854      if(isFinal && num == state().boundariesCrossed){ constantPoolName_computed = true; }
855            return constantPoolName_value;
856      }
857      /**
858       * @apilevel internal
859       */
860      private String constantPoolName_compute() {  return typeDescriptor();  }
861      /**
862       * @apilevel internal
863       */
864      protected boolean typeDescriptor_computed = false;
865      /**
866       * @apilevel internal
867       */
868      protected String typeDescriptor_value;
869      /**
870       * @attribute syn
871       * @aspect ConstantPoolNames
872       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/ConstantPoolNames.jrag:26
873       */
874      @SuppressWarnings({"unchecked", "cast"})
875      public String typeDescriptor() {
876        if(typeDescriptor_computed) {
877          return typeDescriptor_value;
878        }
879          ASTNode$State state = state();
880      int num = state.boundariesCrossed;
881      boolean isFinal = this.is$Final();
882        typeDescriptor_value = typeDescriptor_compute();
883      if(isFinal && num == state().boundariesCrossed){ typeDescriptor_computed = true; }
884            return typeDescriptor_value;
885      }
886      /**
887       * @apilevel internal
888       */
889      private String typeDescriptor_compute() { 
890        StringBuffer dim = new StringBuffer();
891        for(int i = 0; i < dimension(); i++)
892          dim.append("[");
893        return dim.toString() + elementType().typeDescriptor(); 
894      }
895      /**
896       * @attribute syn
897       * @aspect CreateBCode
898       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:820
899       */
900      public String arrayTypeDescriptor() {
901        ASTNode$State state = state();
902        try {  return typeDescriptor();  }
903        finally {
904        }
905      }
906      /**
907       * @apilevel internal
908       */
909      protected boolean jvmName_computed = false;
910      /**
911       * @apilevel internal
912       */
913      protected String jvmName_value;
914      /**
915       * @attribute syn
916       * @aspect Java2Rewrites
917       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Java2Rewrites.jrag:26
918       */
919      @SuppressWarnings({"unchecked", "cast"})
920      public String jvmName() {
921        if(jvmName_computed) {
922          return jvmName_value;
923        }
924          ASTNode$State state = state();
925      int num = state.boundariesCrossed;
926      boolean isFinal = this.is$Final();
927        jvmName_value = jvmName_compute();
928      if(isFinal && num == state().boundariesCrossed){ jvmName_computed = true; }
929            return jvmName_value;
930      }
931      /**
932       * @apilevel internal
933       */
934      private String jvmName_compute() {
935        StringBuffer dim = new StringBuffer();
936        for(int i = 0; i < dimension(); i++)
937          dim.append("[");
938        if(elementType().isReferenceType())
939          return dim.toString() + "L" + elementType().jvmName() + ";";
940        else
941          return dim.toString() + elementType().jvmName(); 
942      }
943      /**
944       * @attribute syn
945       * @aspect Java2Rewrites
946       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/Java2Rewrites.jrag:57
947       */
948      public String referenceClassFieldName() {
949        ASTNode$State state = state();
950        try {  return "array" + jvmName().replace('[', '$').replace('.', '$').replace(';', ' ').trim();  }
951        finally {
952        }
953      }
954      /* It is a compile-time error if the return type of a method declared in an
955      annotation type is any type other than one of the following: one of the
956      primitive types, String, Class and any invocation of Class, an enum type
957      (\ufffd8.9), an annotation type, or an array (\ufffd10) of one of the preceding types.* @attribute syn
958       * @aspect Annotations
959       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Annotations.jrag:121
960       */
961      public boolean isValidAnnotationMethodReturnType() {
962        ASTNode$State state = state();
963        try {  return componentType().isValidAnnotationMethodReturnType();  }
964        finally {
965        }
966      }
967      /* An element type T is commensurate with an element value V if and only if one of the following conditions is true:
968        * T is an array type E[] and either:
969              o V is an ElementValueArrayInitializer and each ElementValueInitializer (analogous to a variable initializer in an array initializer) in V is commensurate with E. Or
970              o V is an ElementValue that is commensurate with T. 
971        * The type of V is assignment compatible (\ufffd5.2) with T and, furthermore:
972              o If T is a primitive type or String, V is a constant expression (\ufffd15.28).
973              o V is not null.
974              o if T is Class, or an invocation of Class, and V is a class literal (\ufffd15.8.2).
975              o If T is an enum type, and V is an enum constant. * @attribute syn
976       * @aspect Annotations
977       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Annotations.jrag:474
978       */
979      public boolean commensurateWith(ElementValue value) {
980        ASTNode$State state = state();
981        try {  return value.commensurateWithArrayDecl(this);  }
982        finally {
983        }
984      }
985      /**
986       * @apilevel internal
987       */
988      protected int involvesTypeParameters_visited = -1;
989      /**
990       * @apilevel internal
991       */
992      protected boolean involvesTypeParameters_computed = false;
993      /**
994       * @apilevel internal
995       */
996      protected boolean involvesTypeParameters_initialized = false;
997      /**
998       * @apilevel internal
999       */
1000      protected boolean involvesTypeParameters_value;
1001      /**
1002       * @attribute syn
1003       * @aspect GenericMethodsInference
1004       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericMethodsInference.jrag:17
1005       */
1006      @SuppressWarnings({"unchecked", "cast"})
1007      public boolean involvesTypeParameters() {
1008        if(involvesTypeParameters_computed) {
1009          return involvesTypeParameters_value;
1010        }
1011        ASTNode$State state = state();
1012        if (!involvesTypeParameters_initialized) {
1013          involvesTypeParameters_initialized = true;
1014          involvesTypeParameters_value = false;
1015        }
1016        if (!state.IN_CIRCLE) {
1017          state.IN_CIRCLE = true;
1018        int num = state.boundariesCrossed;
1019        boolean isFinal = this.is$Final();
1020          do {
1021            involvesTypeParameters_visited = state.CIRCLE_INDEX;
1022            state.CHANGE = false;
1023            boolean new_involvesTypeParameters_value = involvesTypeParameters_compute();
1024            if (new_involvesTypeParameters_value!=involvesTypeParameters_value)
1025              state.CHANGE = true;
1026            involvesTypeParameters_value = new_involvesTypeParameters_value; 
1027            state.CIRCLE_INDEX++;
1028          } while (state.CHANGE);
1029            if(isFinal && num == state().boundariesCrossed) {
1030          involvesTypeParameters_computed = true;
1031          }
1032          else {
1033          state.RESET_CYCLE = true;
1034          involvesTypeParameters_compute();
1035          state.RESET_CYCLE = false;
1036            involvesTypeParameters_computed = false;
1037            involvesTypeParameters_initialized = false;
1038          }
1039          state.IN_CIRCLE = false; 
1040              return involvesTypeParameters_value;
1041        }
1042        if(involvesTypeParameters_visited != state.CIRCLE_INDEX) {
1043          involvesTypeParameters_visited = state.CIRCLE_INDEX;
1044          if (state.RESET_CYCLE) {
1045            involvesTypeParameters_computed = false;
1046            involvesTypeParameters_initialized = false;
1047            involvesTypeParameters_visited = -1;
1048                return involvesTypeParameters_value;
1049          }
1050          boolean new_involvesTypeParameters_value = involvesTypeParameters_compute();
1051          if (new_involvesTypeParameters_value!=involvesTypeParameters_value)
1052            state.CHANGE = true;
1053          involvesTypeParameters_value = new_involvesTypeParameters_value; 
1054              return involvesTypeParameters_value;
1055        }
1056            return involvesTypeParameters_value;
1057      }
1058      /**
1059       * @apilevel internal
1060       */
1061      private boolean involvesTypeParameters_compute() {  return componentType().involvesTypeParameters();  }
1062      /**
1063       * @apilevel internal
1064       */
1065      protected boolean erasure_computed = false;
1066      /**
1067       * @apilevel internal
1068       */
1069      protected TypeDecl erasure_value;
1070      /**
1071       * @attribute syn
1072       * @aspect GenericsErasure
1073       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:353
1074       */
1075      @SuppressWarnings({"unchecked", "cast"})
1076      public TypeDecl erasure() {
1077        if(erasure_computed) {
1078          return erasure_value;
1079        }
1080          ASTNode$State state = state();
1081      int num = state.boundariesCrossed;
1082      boolean isFinal = this.is$Final();
1083        erasure_value = erasure_compute();
1084      if(isFinal && num == state().boundariesCrossed){ erasure_computed = true; }
1085            return erasure_value;
1086      }
1087      /**
1088       * @apilevel internal
1089       */
1090      private TypeDecl erasure_compute() {  return componentType().erasure().arrayType();  }
1091      /**
1092       * @apilevel internal
1093       */
1094      protected int usesTypeVariable_visited = -1;
1095      /**
1096       * @apilevel internal
1097       */
1098      protected boolean usesTypeVariable_computed = false;
1099      /**
1100       * @apilevel internal
1101       */
1102      protected boolean usesTypeVariable_initialized = false;
1103      /**
1104       * @apilevel internal
1105       */
1106      protected boolean usesTypeVariable_value;
1107      /**
1108       * @attribute syn
1109       * @aspect LookupParTypeDecl
1110       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Generics.jrag:1082
1111       */
1112      @SuppressWarnings({"unchecked", "cast"})
1113      public boolean usesTypeVariable() {
1114        if(usesTypeVariable_computed) {
1115          return usesTypeVariable_value;
1116        }
1117        ASTNode$State state = state();
1118        if (!usesTypeVariable_initialized) {
1119          usesTypeVariable_initialized = true;
1120          usesTypeVariable_value = false;
1121        }
1122        if (!state.IN_CIRCLE) {
1123          state.IN_CIRCLE = true;
1124        int num = state.boundariesCrossed;
1125        boolean isFinal = this.is$Final();
1126          do {
1127            usesTypeVariable_visited = state.CIRCLE_INDEX;
1128            state.CHANGE = false;
1129            boolean new_usesTypeVariable_value = usesTypeVariable_compute();
1130            if (new_usesTypeVariable_value!=usesTypeVariable_value)
1131              state.CHANGE = true;
1132            usesTypeVariable_value = new_usesTypeVariable_value; 
1133            state.CIRCLE_INDEX++;
1134          } while (state.CHANGE);
1135            if(isFinal && num == state().boundariesCrossed) {
1136          usesTypeVariable_computed = true;
1137          }
1138          else {
1139          state.RESET_CYCLE = true;
1140          usesTypeVariable_compute();
1141          state.RESET_CYCLE = false;
1142            usesTypeVariable_computed = false;
1143            usesTypeVariable_initialized = false;
1144          }
1145          state.IN_CIRCLE = false; 
1146              return usesTypeVariable_value;
1147        }
1148        if(usesTypeVariable_visited != state.CIRCLE_INDEX) {
1149          usesTypeVariable_visited = state.CIRCLE_INDEX;
1150          if (state.RESET_CYCLE) {
1151            usesTypeVariable_computed = false;
1152            usesTypeVariable_initialized = false;
1153            usesTypeVariable_visited = -1;
1154                return usesTypeVariable_value;
1155          }
1156          boolean new_usesTypeVariable_value = usesTypeVariable_compute();
1157          if (new_usesTypeVariable_value!=usesTypeVariable_value)
1158            state.CHANGE = true;
1159          usesTypeVariable_value = new_usesTypeVariable_value; 
1160              return usesTypeVariable_value;
1161        }
1162            return usesTypeVariable_value;
1163      }
1164      /**
1165       * @apilevel internal
1166       */
1167      private boolean usesTypeVariable_compute() {  return elementType().usesTypeVariable();  }
1168      protected java.util.Map subtype_TypeDecl_values;
1169      /**
1170       * @attribute syn
1171       * @aspect GenericsSubtype
1172       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:409
1173       */
1174      @SuppressWarnings({"unchecked", "cast"})
1175      public boolean subtype(TypeDecl type) {
1176        Object _parameters = type;
1177        if(subtype_TypeDecl_values == null) subtype_TypeDecl_values = new java.util.HashMap(4);
1178        ASTNode$State.CircularValue _value;
1179        if(subtype_TypeDecl_values.containsKey(_parameters)) {
1180          Object _o = subtype_TypeDecl_values.get(_parameters);
1181          if(!(_o instanceof ASTNode$State.CircularValue)) {
1182            return ((Boolean)_o).booleanValue();
1183          }
1184          else
1185            _value = (ASTNode$State.CircularValue)_o;
1186        }
1187        else {
1188          _value = new ASTNode$State.CircularValue();
1189          subtype_TypeDecl_values.put(_parameters, _value);
1190          _value.value = Boolean.valueOf(true);
1191        }
1192        ASTNode$State state = state();
1193        if (!state.IN_CIRCLE) {
1194          state.IN_CIRCLE = true;
1195          int num = state.boundariesCrossed;
1196          boolean isFinal = this.is$Final();
1197          boolean new_subtype_TypeDecl_value;
1198          do {
1199            _value.visited = new Integer(state.CIRCLE_INDEX);
1200            state.CHANGE = false;
1201            new_subtype_TypeDecl_value = subtype_compute(type);
1202            if (new_subtype_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
1203              state.CHANGE = true;
1204              _value.value = Boolean.valueOf(new_subtype_TypeDecl_value);
1205            }
1206            state.CIRCLE_INDEX++;
1207          } while (state.CHANGE);
1208            if(isFinal && num == state().boundariesCrossed) {
1209            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
1210          }
1211          else {
1212            subtype_TypeDecl_values.remove(_parameters);
1213          state.RESET_CYCLE = true;
1214          subtype_compute(type);
1215          state.RESET_CYCLE = false;
1216          }
1217          state.IN_CIRCLE = false; 
1218          return new_subtype_TypeDecl_value;
1219        }
1220        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
1221          _value.visited = new Integer(state.CIRCLE_INDEX);
1222          boolean new_subtype_TypeDecl_value = subtype_compute(type);
1223          if (state.RESET_CYCLE) {
1224            subtype_TypeDecl_values.remove(_parameters);
1225          }
1226          else if (new_subtype_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
1227            state.CHANGE = true;
1228            _value.value = new_subtype_TypeDecl_value;
1229          }
1230          return new_subtype_TypeDecl_value;
1231        }
1232        return ((Boolean)_value.value).booleanValue();
1233      }
1234      /**
1235       * @apilevel internal
1236       */
1237      private boolean subtype_compute(TypeDecl type) {  return type.supertypeArrayDecl(this);  }
1238      /**
1239       * @attribute syn
1240       * @aspect GenericsSubtype
1241       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:450
1242       */
1243      public boolean supertypeArrayDecl(ArrayDecl type) {
1244        ASTNode$State state = state();
1245        try {
1246        if(type.elementType().isPrimitive() && elementType().isPrimitive())
1247          return type.dimension() == dimension() && type.elementType() == elementType();
1248        return type.componentType().subtype(componentType());
1249      }
1250        finally {
1251        }
1252      }
1253      /**
1254       * @apilevel internal
1255       */
1256      protected boolean needsSignatureAttribute_computed = false;
1257      /**
1258       * @apilevel internal
1259       */
1260      protected boolean needsSignatureAttribute_value;
1261      /**
1262       * @attribute syn
1263       * @aspect GenericsCodegen
1264       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:346
1265       */
1266      @SuppressWarnings({"unchecked", "cast"})
1267      public boolean needsSignatureAttribute() {
1268        if(needsSignatureAttribute_computed) {
1269          return needsSignatureAttribute_value;
1270        }
1271          ASTNode$State state = state();
1272      int num = state.boundariesCrossed;
1273      boolean isFinal = this.is$Final();
1274        needsSignatureAttribute_value = needsSignatureAttribute_compute();
1275      if(isFinal && num == state().boundariesCrossed){ needsSignatureAttribute_computed = true; }
1276            return needsSignatureAttribute_value;
1277      }
1278      /**
1279       * @apilevel internal
1280       */
1281      private boolean needsSignatureAttribute_compute() {  return elementType().needsSignatureAttribute();  }
1282      /**
1283       * @apilevel internal
1284       */
1285      protected boolean fieldTypeSignature_computed = false;
1286      /**
1287       * @apilevel internal
1288       */
1289      protected String fieldTypeSignature_value;
1290      /**
1291       * @attribute syn
1292       * @aspect GenericsCodegen
1293       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:444
1294       */
1295      @SuppressWarnings({"unchecked", "cast"})
1296      public String fieldTypeSignature() {
1297        if(fieldTypeSignature_computed) {
1298          return fieldTypeSignature_value;
1299        }
1300          ASTNode$State state = state();
1301      int num = state.boundariesCrossed;
1302      boolean isFinal = this.is$Final();
1303        fieldTypeSignature_value = fieldTypeSignature_compute();
1304      if(isFinal && num == state().boundariesCrossed){ fieldTypeSignature_computed = true; }
1305            return fieldTypeSignature_value;
1306      }
1307      /**
1308       * @apilevel internal
1309       */
1310      private String fieldTypeSignature_compute() {  return "[" + componentType().fieldTypeSignature();  }
1311      /**
1312       * @apilevel internal
1313       */
1314      protected boolean classTypeSignature_computed = false;
1315      /**
1316       * @apilevel internal
1317       */
1318      protected String classTypeSignature_value;
1319      /**
1320       * @attribute syn
1321       * @aspect GenericsCodegen
1322       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:453
1323       */
1324      @SuppressWarnings({"unchecked", "cast"})
1325      public String classTypeSignature() {
1326        if(classTypeSignature_computed) {
1327          return classTypeSignature_value;
1328        }
1329          ASTNode$State state = state();
1330      int num = state.boundariesCrossed;
1331      boolean isFinal = this.is$Final();
1332        classTypeSignature_value = classTypeSignature_compute();
1333      if(isFinal && num == state().boundariesCrossed){ classTypeSignature_computed = true; }
1334            return classTypeSignature_value;
1335      }
1336      /**
1337       * @apilevel internal
1338       */
1339      private String classTypeSignature_compute() {  return "[" + componentType().classTypeSignature();  }
1340      /**
1341      * A type is reifiable if it either refers to a non-parameterized type,
1342      * is a raw type, is a parameterized type with only unbound wildcard
1343      * parameters or is an array type with a reifiable type parameter.
1344      *
1345      * @see "JLSv3 &sect;4.7"
1346      * @attribute syn
1347       * @aspect SafeVarargs
1348       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/SafeVarargs.jrag:106
1349       */
1350      public boolean isReifiable() {
1351        ASTNode$State state = state();
1352        try {  return elementType().isReifiable();  }
1353        finally {
1354        }
1355      }
1356      /**
1357       * @attribute inh
1358       * @aspect TypeConversion
1359       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:140
1360       */
1361      @SuppressWarnings({"unchecked", "cast"})
1362      public TypeDecl typeSerializable() {
1363          ASTNode$State state = state();
1364        TypeDecl typeSerializable_value = getParent().Define_TypeDecl_typeSerializable(this, null);
1365            return typeSerializable_value;
1366      }
1367      /**
1368       * @attribute inh
1369       * @aspect TypeConversion
1370       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:141
1371       */
1372      @SuppressWarnings({"unchecked", "cast"})
1373      public TypeDecl typeCloneable() {
1374          ASTNode$State state = state();
1375        TypeDecl typeCloneable_value = getParent().Define_TypeDecl_typeCloneable(this, null);
1376            return typeCloneable_value;
1377      }
1378      /**
1379       * @apilevel internal
1380       */
1381      public ASTNode rewriteTo() {
1382        return super.rewriteTo();
1383      }
1384    }