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 PrimitiveType : {@link TypeDecl} ::= <span class="component">{@link Modifiers}</span> <span class="component">&lt;ID:String&gt;</span> <span class="component">[SuperClassAccess:{@link Access}]</span> <span class="component">{@link BodyDecl}*</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:45
017     */
018    public class PrimitiveType extends TypeDecl 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 PrimitiveType clone() throws CloneNotSupportedException {
034        PrimitiveType node = (PrimitiveType)super.clone();
035        node.narrowingConversionTo_TypeDecl_values = null;
036        node.instanceOf_TypeDecl_values = null;
037        node.subtype_TypeDecl_values = null;
038        node.fieldTypeSignature_computed = false;
039        node.fieldTypeSignature_value = null;
040        node.classTypeSignature_computed = false;
041        node.classTypeSignature_value = null;
042        node.in$Circle(false);
043        node.is$Final(false);
044        return node;
045      }
046    /**
047     * @apilevel internal
048     */
049      @SuppressWarnings({"unchecked", "cast"})
050    public PrimitiveType copy() {
051      
052      try {
053        PrimitiveType node = (PrimitiveType) clone();
054        node.parent = null;
055        if(children != null)
056          node.children = (ASTNode[]) children.clone();
057        
058        return node;
059      } catch (CloneNotSupportedException e) {
060        throw new Error("Error: clone not supported for " + getClass().getName());
061      }
062      
063    }/**
064     * Create a deep copy of the AST subtree at this node.
065     * The copy is dangling, i.e. has no parent.
066     * @return dangling copy of the subtree at this node
067     * @apilevel low-level
068     */
069      @SuppressWarnings({"unchecked", "cast"})
070    public PrimitiveType fullCopy() {
071      
072      PrimitiveType tree = (PrimitiveType) copy();
073      if (children != null) {
074        for (int i = 0; i < children.length; ++i) {
075          
076          ASTNode child = (ASTNode) children[i];
077          if(child != null) {
078            child = child.fullCopy();
079            tree.setChild(child, i);
080          }
081        }
082      }
083      return tree;
084      
085    }  /**
086       * @ast method 
087       * @aspect CreateQualifiedAccesses
088       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/QualifiedNames.jrag:108
089       */
090      public Access createQualifiedAccess() {
091        return new PrimitiveTypeAccess(name());
092      }
093      /**
094       * @ast method 
095       * @aspect SuperClasses
096       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:608
097       */
098      public boolean hasSuperclass() {
099        return !isObject();
100      }
101      /**
102       * @ast method 
103       * @aspect CodeGeneration
104       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:614
105       */
106      public void emitReturn(CodeGeneration gen) { gen.emit(Bytecode.IRETURN);}
107      /**
108       * @ast method 
109       * @aspect CodeGeneration
110       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:635
111       */
112      public void emitLoadLocal(CodeGeneration gen, int pos) {
113        gen.maxLocals = Math.max(gen.maxLocals, pos+1);
114        if(pos == 0) gen.emit(Bytecode.ILOAD_0);
115        else if(pos == 1) gen.emit(Bytecode.ILOAD_1);
116        else if(pos == 2) gen.emit(Bytecode.ILOAD_2);
117        else if(pos == 3) gen.emit(Bytecode.ILOAD_3);
118        else if(pos < 256) gen.emit(Bytecode.ILOAD).add(pos);
119        else gen.emit(Bytecode.WIDE).emit(Bytecode.ILOAD).add2(pos);
120      }
121      /**
122       * @ast method 
123       * @aspect CodeGeneration
124       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:748
125       */
126      public void emitStoreLocal(CodeGeneration gen, int pos) {
127        gen.maxLocals = Math.max(gen.maxLocals, pos+1);
128        if(pos == 0) gen.emit(Bytecode.ISTORE_0);
129        else if(pos == 1) gen.emit(Bytecode.ISTORE_1);
130        else if(pos == 2) gen.emit(Bytecode.ISTORE_2);
131        else if(pos == 3) gen.emit(Bytecode.ISTORE_3);
132        else if(pos < 256) gen.emit(Bytecode.ISTORE).add(pos);
133        else gen.emit(Bytecode.WIDE).emit(Bytecode.ISTORE).add2(pos);
134      }
135      /**
136       * @ast method 
137       * 
138       */
139      public PrimitiveType() {
140        super();
141    
142    
143      }
144      /**
145       * Initializes the child array to the correct size.
146       * Initializes List and Opt nta children.
147       * @apilevel internal
148       * @ast method
149       * @ast method 
150       * 
151       */
152      public void init$Children() {
153        children = new ASTNode[3];
154        setChild(new Opt(), 1);
155        setChild(new List(), 2);
156      }
157      /**
158       * @ast method 
159       * 
160       */
161      public PrimitiveType(Modifiers p0, String p1, Opt<Access> p2, List<BodyDecl> p3) {
162        setChild(p0, 0);
163        setID(p1);
164        setChild(p2, 1);
165        setChild(p3, 2);
166      }
167      /**
168       * @ast method 
169       * 
170       */
171      public PrimitiveType(Modifiers p0, beaver.Symbol p1, Opt<Access> p2, List<BodyDecl> p3) {
172        setChild(p0, 0);
173        setID(p1);
174        setChild(p2, 1);
175        setChild(p3, 2);
176      }
177      /**
178       * @apilevel low-level
179       * @ast method 
180       * 
181       */
182      protected int numChildren() {
183        return 3;
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 BodyDecl list.
321       * @param list The new list node to be used as the BodyDecl list.
322       * @apilevel high-level
323       * @ast method 
324       * 
325       */
326      public void setBodyDeclList(List<BodyDecl> list) {
327        setChild(list, 2);
328      }
329      /**
330       * Retrieves the number of children in the BodyDecl list.
331       * @return Number of children in the BodyDecl list.
332       * @apilevel high-level
333       * @ast method 
334       * 
335       */
336      public int getNumBodyDecl() {
337        return getBodyDeclList().getNumChild();
338      }
339      /**
340       * Retrieves the number of children in the BodyDecl list.
341       * Calling this method will not trigger rewrites..
342       * @return Number of children in the BodyDecl list.
343       * @apilevel low-level
344       * @ast method 
345       * 
346       */
347      public int getNumBodyDeclNoTransform() {
348        return getBodyDeclListNoTransform().getNumChildNoTransform();
349      }
350      /**
351       * Retrieves the element at index {@code i} in the BodyDecl list..
352       * @param i Index of the element to return.
353       * @return The element at position {@code i} in the BodyDecl list.
354       * @apilevel high-level
355       * @ast method 
356       * 
357       */
358      @SuppressWarnings({"unchecked", "cast"})
359      public BodyDecl getBodyDecl(int i) {
360        return (BodyDecl)getBodyDeclList().getChild(i);
361      }
362      /**
363       * Append an element to the BodyDecl list.
364       * @param node The element to append to the BodyDecl list.
365       * @apilevel high-level
366       * @ast method 
367       * 
368       */
369      public void addBodyDecl(BodyDecl node) {
370        List<BodyDecl> list = (parent == null || state == null) ? getBodyDeclListNoTransform() : getBodyDeclList();
371        list.addChild(node);
372      }
373      /**
374       * @apilevel low-level
375       * @ast method 
376       * 
377       */
378      public void addBodyDeclNoTransform(BodyDecl node) {
379        List<BodyDecl> list = getBodyDeclListNoTransform();
380        list.addChild(node);
381      }
382      /**
383       * Replaces the BodyDecl 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 setBodyDecl(BodyDecl node, int i) {
391        List<BodyDecl> list = getBodyDeclList();
392        list.setChild(node, i);
393      }
394      /**
395       * Retrieves the BodyDecl list.
396       * @return The node representing the BodyDecl list.
397       * @apilevel high-level
398       * @ast method 
399       * 
400       */
401      public List<BodyDecl> getBodyDecls() {
402        return getBodyDeclList();
403      }
404      /**
405       * Retrieves the BodyDecl list.
406       * <p><em>This method does not invoke AST transformations.</em></p>
407       * @return The node representing the BodyDecl list.
408       * @apilevel low-level
409       * @ast method 
410       * 
411       */
412      public List<BodyDecl> getBodyDeclsNoTransform() {
413        return getBodyDeclListNoTransform();
414      }
415      /**
416       * Retrieves the BodyDecl list.
417       * @return The node representing the BodyDecl list.
418       * @apilevel high-level
419       * @ast method 
420       * 
421       */
422      @SuppressWarnings({"unchecked", "cast"})
423      public List<BodyDecl> getBodyDeclList() {
424        List<BodyDecl> list = (List<BodyDecl>)getChild(2);
425        list.getNumChild();
426        return list;
427      }
428      /**
429       * Retrieves the BodyDecl list.
430       * <p><em>This method does not invoke AST transformations.</em></p>
431       * @return The node representing the BodyDecl list.
432       * @apilevel low-level
433       * @ast method 
434       * 
435       */
436      @SuppressWarnings({"unchecked", "cast"})
437      public List<BodyDecl> getBodyDeclListNoTransform() {
438        return (List<BodyDecl>)getChildNoTransform(2);
439      }
440      /**
441       * @attribute syn
442       * @aspect TypeConversion
443       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:17
444       */
445      public boolean wideningConversionTo(TypeDecl type) {
446        ASTNode$State state = state();
447        try {  return instanceOf(type);  }
448        finally {
449        }
450      }
451      protected java.util.Map narrowingConversionTo_TypeDecl_values;
452      /**
453       * @attribute syn
454       * @aspect TypeConversion
455       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:27
456       */
457      @SuppressWarnings({"unchecked", "cast"})
458      public boolean narrowingConversionTo(TypeDecl type) {
459        Object _parameters = type;
460        if(narrowingConversionTo_TypeDecl_values == null) narrowingConversionTo_TypeDecl_values = new java.util.HashMap(4);
461        if(narrowingConversionTo_TypeDecl_values.containsKey(_parameters)) {
462          return ((Boolean)narrowingConversionTo_TypeDecl_values.get(_parameters)).booleanValue();
463        }
464          ASTNode$State state = state();
465      int num = state.boundariesCrossed;
466      boolean isFinal = this.is$Final();
467        boolean narrowingConversionTo_TypeDecl_value = narrowingConversionTo_compute(type);
468      if(isFinal && num == state().boundariesCrossed){ narrowingConversionTo_TypeDecl_values.put(_parameters, Boolean.valueOf(narrowingConversionTo_TypeDecl_value)); }
469            return narrowingConversionTo_TypeDecl_value;
470      }
471      /**
472       * @apilevel internal
473       */
474      private boolean narrowingConversionTo_compute(TypeDecl type) {  return type.instanceOf(this);  }
475      /**
476       * @attribute syn
477       * @aspect TypeAnalysis
478       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:168
479       */
480      public boolean isPrimitiveType() {
481        ASTNode$State state = state();
482        try {  return true;  }
483        finally {
484        }
485      }
486      /**
487       * @attribute syn
488       * @aspect TypeAnalysis
489       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:221
490       */
491      public boolean isPrimitive() {
492        ASTNode$State state = state();
493        try {  return true;  }
494        finally {
495        }
496      }
497      protected java.util.Map instanceOf_TypeDecl_values;
498      /**
499       * @attribute syn
500       * @aspect GenericsSubtype
501       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:390
502       */
503      @SuppressWarnings({"unchecked", "cast"})
504      public boolean instanceOf(TypeDecl type) {
505        Object _parameters = type;
506        if(instanceOf_TypeDecl_values == null) instanceOf_TypeDecl_values = new java.util.HashMap(4);
507        if(instanceOf_TypeDecl_values.containsKey(_parameters)) {
508          return ((Boolean)instanceOf_TypeDecl_values.get(_parameters)).booleanValue();
509        }
510          ASTNode$State state = state();
511      int num = state.boundariesCrossed;
512      boolean isFinal = this.is$Final();
513        boolean instanceOf_TypeDecl_value = instanceOf_compute(type);
514      if(isFinal && num == state().boundariesCrossed){ instanceOf_TypeDecl_values.put(_parameters, Boolean.valueOf(instanceOf_TypeDecl_value)); }
515            return instanceOf_TypeDecl_value;
516      }
517      /**
518       * @apilevel internal
519       */
520      private boolean instanceOf_compute(TypeDecl type) { return subtype(type); }
521      /**
522       * @attribute syn
523       * @aspect TypeWideningAndIdentity
524       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:475
525       */
526      public boolean isSupertypeOfPrimitiveType(PrimitiveType type) {
527        ASTNode$State state = state();
528        try {
529        if(super.isSupertypeOfPrimitiveType(type))
530          return true;
531        return type.hasSuperclass() && type.superclass().isPrimitive() && type.superclass().instanceOf(this);
532      }
533        finally {
534        }
535      }
536      /**
537       * @attribute syn
538       * @aspect SuperClasses
539       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:612
540       */
541      public TypeDecl superclass() {
542        ASTNode$State state = state();
543        try {  return getSuperClassAccess().type();  }
544        finally {
545        }
546      }
547      /**
548       * @attribute syn
549       * @aspect LocalNum
550       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/LocalNum.jrag:124
551       */
552      public int variableSize() {
553        ASTNode$State state = state();
554        try {  return 1;  }
555        finally {
556        }
557      }
558      /* It is a compile-time error if the return type of a method declared in an
559      annotation type is any type other than one of the following: one of the
560      primitive types, String, Class and any invocation of Class, an enum type
561      (\ufffd8.9), an annotation type, or an array (\ufffd10) of one of the preceding types.* @attribute syn
562       * @aspect Annotations
563       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/Annotations.jrag:121
564       */
565      public boolean isValidAnnotationMethodReturnType() {
566        ASTNode$State state = state();
567        try {  return true;  }
568        finally {
569        }
570      }
571      /* NumericTypes, BooleanTypes
572         TypeChecking (ensure that an expression of a certain type is valid in a particular context)
573         TypeComputation (compute the type of an expression)
574         CodeGeneration (output code including implicit type conversions and promotions)
575    
576         NumericTypes:
577           binaryNumericPromotion, unaryNumericPromotion, assignmentConversion, methodInvocationConversion, castingConversion
578           numeric operations that do not use these kinds of conversions and promotions explicitly need to be refined
579         BooleanTypes:
580           assignmentConversion, methodInvocationConversion, castingConversion
581           
582      * @attribute syn
583       * @aspect AutoBoxing
584       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/AutoBoxing.jrag:31
585       */
586      public boolean boxingConversionTo(TypeDecl typeDecl) {
587        ASTNode$State state = state();
588        try {  return boxed() == typeDecl;  }
589        finally {
590        }
591      }
592      protected java.util.Map subtype_TypeDecl_values;
593      /**
594       * @attribute syn
595       * @aspect GenericsSubtype
596       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:410
597       */
598      @SuppressWarnings({"unchecked", "cast"})
599      public boolean subtype(TypeDecl type) {
600        Object _parameters = type;
601        if(subtype_TypeDecl_values == null) subtype_TypeDecl_values = new java.util.HashMap(4);
602        ASTNode$State.CircularValue _value;
603        if(subtype_TypeDecl_values.containsKey(_parameters)) {
604          Object _o = subtype_TypeDecl_values.get(_parameters);
605          if(!(_o instanceof ASTNode$State.CircularValue)) {
606            return ((Boolean)_o).booleanValue();
607          }
608          else
609            _value = (ASTNode$State.CircularValue)_o;
610        }
611        else {
612          _value = new ASTNode$State.CircularValue();
613          subtype_TypeDecl_values.put(_parameters, _value);
614          _value.value = Boolean.valueOf(true);
615        }
616        ASTNode$State state = state();
617        if (!state.IN_CIRCLE) {
618          state.IN_CIRCLE = true;
619          int num = state.boundariesCrossed;
620          boolean isFinal = this.is$Final();
621          boolean new_subtype_TypeDecl_value;
622          do {
623            _value.visited = new Integer(state.CIRCLE_INDEX);
624            state.CHANGE = false;
625            new_subtype_TypeDecl_value = subtype_compute(type);
626            if (new_subtype_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
627              state.CHANGE = true;
628              _value.value = Boolean.valueOf(new_subtype_TypeDecl_value);
629            }
630            state.CIRCLE_INDEX++;
631          } while (state.CHANGE);
632            if(isFinal && num == state().boundariesCrossed) {
633            subtype_TypeDecl_values.put(_parameters, new_subtype_TypeDecl_value);
634          }
635          else {
636            subtype_TypeDecl_values.remove(_parameters);
637          state.RESET_CYCLE = true;
638          subtype_compute(type);
639          state.RESET_CYCLE = false;
640          }
641          state.IN_CIRCLE = false; 
642          return new_subtype_TypeDecl_value;
643        }
644        if(!new Integer(state.CIRCLE_INDEX).equals(_value.visited)) {
645          _value.visited = new Integer(state.CIRCLE_INDEX);
646          boolean new_subtype_TypeDecl_value = subtype_compute(type);
647          if (state.RESET_CYCLE) {
648            subtype_TypeDecl_values.remove(_parameters);
649          }
650          else if (new_subtype_TypeDecl_value!=((Boolean)_value.value).booleanValue()) {
651            state.CHANGE = true;
652            _value.value = new_subtype_TypeDecl_value;
653          }
654          return new_subtype_TypeDecl_value;
655        }
656        return ((Boolean)_value.value).booleanValue();
657      }
658      /**
659       * @apilevel internal
660       */
661      private boolean subtype_compute(TypeDecl type) {  return type.supertypePrimitiveType(this);  }
662      /**
663       * @attribute syn
664       * @aspect GenericsSubtype
665       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericsSubtype.jrag:472
666       */
667      public boolean supertypePrimitiveType(PrimitiveType type) {
668        ASTNode$State state = state();
669        try {
670        if(super.supertypePrimitiveType(type))
671          return true;
672        return type.hasSuperclass() && type.superclass().isPrimitive() && type.superclass().subtype(this);
673      }
674        finally {
675        }
676      }
677      /**
678       * @apilevel internal
679       */
680      protected boolean fieldTypeSignature_computed = false;
681      /**
682       * @apilevel internal
683       */
684      protected String fieldTypeSignature_value;
685      /**
686       * @attribute syn
687       * @aspect GenericsCodegen
688       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:449
689       */
690      @SuppressWarnings({"unchecked", "cast"})
691      public String fieldTypeSignature() {
692        if(fieldTypeSignature_computed) {
693          return fieldTypeSignature_value;
694        }
695          ASTNode$State state = state();
696      int num = state.boundariesCrossed;
697      boolean isFinal = this.is$Final();
698        fieldTypeSignature_value = fieldTypeSignature_compute();
699      if(isFinal && num == state().boundariesCrossed){ fieldTypeSignature_computed = true; }
700            return fieldTypeSignature_value;
701      }
702      /**
703       * @apilevel internal
704       */
705      private String fieldTypeSignature_compute() {  return classTypeSignature();  }
706      /**
707       * @apilevel internal
708       */
709      protected boolean classTypeSignature_computed = false;
710      /**
711       * @apilevel internal
712       */
713      protected String classTypeSignature_value;
714      /**
715       * @attribute syn
716       * @aspect GenericsCodegen
717       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Backend/GenericsCodegen.jrag:455
718       */
719      @SuppressWarnings({"unchecked", "cast"})
720      public String classTypeSignature() {
721        if(classTypeSignature_computed) {
722          return classTypeSignature_value;
723        }
724          ASTNode$State state = state();
725      int num = state.boundariesCrossed;
726      boolean isFinal = this.is$Final();
727        classTypeSignature_value = classTypeSignature_compute();
728      if(isFinal && num == state().boundariesCrossed){ classTypeSignature_computed = true; }
729            return classTypeSignature_value;
730      }
731      /**
732       * @apilevel internal
733       */
734      private String classTypeSignature_compute() {  return typeDescriptor();  }
735      /**
736       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeAnalysis.jrag:577
737       * @apilevel internal
738       */
739      public TypeDecl Define_TypeDecl_hostType(ASTNode caller, ASTNode child) {
740        if(caller == getSuperClassAccessOptNoTransform()) {
741          return hostType();
742        }
743        else {      return super.Define_TypeDecl_hostType(caller, child);
744        }
745      }
746      /**
747       * @apilevel internal
748       */
749      public ASTNode rewriteTo() {
750        return super.rewriteTo();
751      }
752    }