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