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 ReturnStmt : {@link Stmt} ::= <span class="component">[Result:{@link Expr}]</span>;
015     * @ast node
016     * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/java.ast:214
017     */
018    public class ReturnStmt extends Stmt 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 ReturnStmt clone() throws CloneNotSupportedException {
034        ReturnStmt node = (ReturnStmt)super.clone();
035        node.finallyList_computed = false;
036        node.finallyList_value = null;
037        node.isDAafter_Variable_values = null;
038        node.isDUafterReachedFinallyBlocks_Variable_values = null;
039        node.isDAafterReachedFinallyBlocks_Variable_values = null;
040        node.isDUafter_Variable_values = null;
041        node.canCompleteNormally_computed = false;
042        node.resultSaveLocalNum_computed = false;
043        node.in$Circle(false);
044        node.is$Final(false);
045        return node;
046      }
047    /**
048     * @apilevel internal
049     */
050      @SuppressWarnings({"unchecked", "cast"})
051    public ReturnStmt copy() {
052      
053      try {
054        ReturnStmt node = (ReturnStmt) clone();
055        node.parent = null;
056        if(children != null)
057          node.children = (ASTNode[]) children.clone();
058        
059        return node;
060      } catch (CloneNotSupportedException e) {
061        throw new Error("Error: clone not supported for " + getClass().getName());
062      }
063      
064    }/**
065     * Create a deep copy of the AST subtree at this node.
066     * The copy is dangling, i.e. has no parent.
067     * @return dangling copy of the subtree at this node
068     * @apilevel low-level
069     */
070      @SuppressWarnings({"unchecked", "cast"})
071    public ReturnStmt fullCopy() {
072      
073      ReturnStmt tree = (ReturnStmt) copy();
074      if (children != null) {
075        for (int i = 0; i < children.length; ++i) {
076          
077          ASTNode child = (ASTNode) children[i];
078          if(child != null) {
079            child = child.fullCopy();
080            tree.setChild(child, i);
081          }
082        }
083      }
084      return tree;
085      
086    }  /**
087       * @ast method 
088       * @aspect BranchTarget
089       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:54
090       */
091      public void collectBranches(Collection c) {
092        c.add(this);
093      }
094      /**
095       * @ast method 
096       * @aspect NodeConstructors
097       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/NodeConstructors.jrag:62
098       */
099      public ReturnStmt(Expr expr) {
100        this(new Opt(expr));
101      }
102      /**
103       * @ast method 
104       * @aspect PrettyPrint
105       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/PrettyPrint.jadd:683
106       */
107      public void toString(StringBuffer s) {
108        s.append(indent());
109        s.append("return ");
110        if(hasResult()) {
111          getResult().toString(s);
112        }
113        s.append(";");
114      }
115      /**
116       * @ast method 
117       * @aspect TypeCheck
118       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:408
119       */
120      public void typeCheck() {
121        if(hasResult() && !returnType().isVoid()) {
122          if(!getResult().type().assignConversionTo(returnType(), getResult()))
123            error("return value must be an instance of " + returnType().typeName() + " which " + getResult().type().typeName() + " is not");
124        }
125        // 8.4.5 8.8.5
126        if(returnType().isVoid() && hasResult())
127          error("return stmt may not have an expression in void methods");
128        // 8.4.5
129        if(!returnType().isVoid() && !hasResult())
130          error("return stmt must have an expression in non void methods");
131        if(enclosingBodyDecl() instanceof InstanceInitializer || enclosingBodyDecl() instanceof StaticInitializer)
132          error("Initializers may not return");
133    
134      }
135      /**
136       * @ast method 
137       * @aspect CreateBCode
138       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CreateBCode.jrag:1435
139       */
140      public void createBCode(CodeGeneration gen) {
141        super.createBCode(gen);
142        if(hasResult()) {
143          TypeDecl type = null;
144          BodyDecl b = enclosingBodyDecl();
145          if(b instanceof MethodDecl) {
146            type = ((MethodDecl)b).type();
147          }
148          else {
149            throw new Error("Can not create code that returns value within non method");
150          }
151          getResult().createBCode(gen);
152          getResult().type().emitCastTo(gen, type);
153          if(!finallyList().isEmpty()) {
154            type.emitStoreLocal(gen, resultSaveLocalNum());
155          }
156          for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
157            FinallyHost stmt = (FinallyHost)iter.next();
158            gen.emitJsr(stmt.label_finally_block());
159          }
160          if(!finallyList().isEmpty()) {
161            type.emitLoadLocal(gen, resultSaveLocalNum());
162          }
163          type.emitReturn(gen);
164        }
165        else {
166          for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
167            FinallyHost stmt = (FinallyHost)iter.next();
168            gen.emitJsr(stmt.label_finally_block());
169          }
170          gen.emitReturn();
171        }
172      }
173      /**
174       * @ast method 
175       * 
176       */
177      public ReturnStmt() {
178        super();
179    
180    
181      }
182      /**
183       * Initializes the child array to the correct size.
184       * Initializes List and Opt nta children.
185       * @apilevel internal
186       * @ast method
187       * @ast method 
188       * 
189       */
190      public void init$Children() {
191        children = new ASTNode[1];
192        setChild(new Opt(), 0);
193      }
194      /**
195       * @ast method 
196       * 
197       */
198      public ReturnStmt(Opt<Expr> p0) {
199        setChild(p0, 0);
200      }
201      /**
202       * @apilevel low-level
203       * @ast method 
204       * 
205       */
206      protected int numChildren() {
207        return 1;
208      }
209      /**
210       * @apilevel internal
211       * @ast method 
212       * 
213       */
214      public boolean mayHaveRewrite() {
215        return false;
216      }
217      /**
218       * Replaces the optional node for the Result child. This is the {@code Opt} node containing the child Result, not the actual child!
219       * @param opt The new node to be used as the optional node for the Result child.
220       * @apilevel low-level
221       * @ast method 
222       * 
223       */
224      public void setResultOpt(Opt<Expr> opt) {
225        setChild(opt, 0);
226      }
227      /**
228       * Check whether the optional Result child exists.
229       * @return {@code true} if the optional Result child exists, {@code false} if it does not.
230       * @apilevel high-level
231       * @ast method 
232       * 
233       */
234      public boolean hasResult() {
235        return getResultOpt().getNumChild() != 0;
236      }
237      /**
238       * Retrieves the (optional) Result child.
239       * @return The Result child, if it exists. Returns {@code null} otherwise.
240       * @apilevel low-level
241       * @ast method 
242       * 
243       */
244      @SuppressWarnings({"unchecked", "cast"})
245      public Expr getResult() {
246        return (Expr)getResultOpt().getChild(0);
247      }
248      /**
249       * Replaces the (optional) Result child.
250       * @param node The new node to be used as the Result child.
251       * @apilevel high-level
252       * @ast method 
253       * 
254       */
255      public void setResult(Expr node) {
256        getResultOpt().setChild(node, 0);
257      }
258      /**
259       * @apilevel low-level
260       * @ast method 
261       * 
262       */
263      @SuppressWarnings({"unchecked", "cast"})
264      public Opt<Expr> getResultOpt() {
265        return (Opt<Expr>)getChild(0);
266      }
267      /**
268       * Retrieves the optional node for child Result. This is the {@code Opt} node containing the child Result, not the actual child!
269       * <p><em>This method does not invoke AST transformations.</em></p>
270       * @return The optional node for child Result.
271       * @apilevel low-level
272       * @ast method 
273       * 
274       */
275      @SuppressWarnings({"unchecked", "cast"})
276      public Opt<Expr> getResultOptNoTransform() {
277        return (Opt<Expr>)getChildNoTransform(0);
278      }
279      /**
280       * @apilevel internal
281       */
282      protected boolean finallyList_computed = false;
283      /**
284       * @apilevel internal
285       */
286      protected ArrayList finallyList_value;
287      /**
288       * @attribute syn
289       * @aspect BranchTarget
290       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/BranchTarget.jrag:185
291       */
292      @SuppressWarnings({"unchecked", "cast"})
293      public ArrayList finallyList() {
294        if(finallyList_computed) {
295          return finallyList_value;
296        }
297          ASTNode$State state = state();
298      int num = state.boundariesCrossed;
299      boolean isFinal = this.is$Final();
300        finallyList_value = finallyList_compute();
301      if(isFinal && num == state().boundariesCrossed){ finallyList_computed = true; }
302            return finallyList_value;
303      }
304      /**
305       * @apilevel internal
306       */
307      private ArrayList finallyList_compute() {
308        ArrayList list = new ArrayList();
309        collectFinally(this, list);
310        return list;
311      }
312      protected java.util.Map isDAafter_Variable_values;
313      /**
314       * @attribute syn
315       * @aspect DA
316       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:649
317       */
318      @SuppressWarnings({"unchecked", "cast"})
319      public boolean isDAafter(Variable v) {
320        Object _parameters = v;
321        if(isDAafter_Variable_values == null) isDAafter_Variable_values = new java.util.HashMap(4);
322        if(isDAafter_Variable_values.containsKey(_parameters)) {
323          return ((Boolean)isDAafter_Variable_values.get(_parameters)).booleanValue();
324        }
325          ASTNode$State state = state();
326      int num = state.boundariesCrossed;
327      boolean isFinal = this.is$Final();
328        boolean isDAafter_Variable_value = isDAafter_compute(v);
329      if(isFinal && num == state().boundariesCrossed){ isDAafter_Variable_values.put(_parameters, Boolean.valueOf(isDAafter_Variable_value)); }
330            return isDAafter_Variable_value;
331      }
332      /**
333       * @apilevel internal
334       */
335      private boolean isDAafter_compute(Variable v) {  return true;  }
336      protected java.util.Map isDUafterReachedFinallyBlocks_Variable_values;
337      /**
338       * @attribute syn
339       * @aspect DU
340       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:942
341       */
342      @SuppressWarnings({"unchecked", "cast"})
343      public boolean isDUafterReachedFinallyBlocks(Variable v) {
344        Object _parameters = v;
345        if(isDUafterReachedFinallyBlocks_Variable_values == null) isDUafterReachedFinallyBlocks_Variable_values = new java.util.HashMap(4);
346        if(isDUafterReachedFinallyBlocks_Variable_values.containsKey(_parameters)) {
347          return ((Boolean)isDUafterReachedFinallyBlocks_Variable_values.get(_parameters)).booleanValue();
348        }
349          ASTNode$State state = state();
350      int num = state.boundariesCrossed;
351      boolean isFinal = this.is$Final();
352        boolean isDUafterReachedFinallyBlocks_Variable_value = isDUafterReachedFinallyBlocks_compute(v);
353      if(isFinal && num == state().boundariesCrossed){ isDUafterReachedFinallyBlocks_Variable_values.put(_parameters, Boolean.valueOf(isDUafterReachedFinallyBlocks_Variable_value)); }
354            return isDUafterReachedFinallyBlocks_Variable_value;
355      }
356      /**
357       * @apilevel internal
358       */
359      private boolean isDUafterReachedFinallyBlocks_compute(Variable v) {
360        if(!isDUbefore(v) && finallyList().isEmpty())
361          return false;
362        for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
363          FinallyHost f = (FinallyHost)iter.next();
364          if(!f.isDUafterFinally(v))
365            return false;
366        }
367        return true;
368      }
369      protected java.util.Map isDAafterReachedFinallyBlocks_Variable_values;
370      /**
371       * @attribute syn
372       * @aspect DU
373       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:978
374       */
375      @SuppressWarnings({"unchecked", "cast"})
376      public boolean isDAafterReachedFinallyBlocks(Variable v) {
377        Object _parameters = v;
378        if(isDAafterReachedFinallyBlocks_Variable_values == null) isDAafterReachedFinallyBlocks_Variable_values = new java.util.HashMap(4);
379        if(isDAafterReachedFinallyBlocks_Variable_values.containsKey(_parameters)) {
380          return ((Boolean)isDAafterReachedFinallyBlocks_Variable_values.get(_parameters)).booleanValue();
381        }
382          ASTNode$State state = state();
383      int num = state.boundariesCrossed;
384      boolean isFinal = this.is$Final();
385        boolean isDAafterReachedFinallyBlocks_Variable_value = isDAafterReachedFinallyBlocks_compute(v);
386      if(isFinal && num == state().boundariesCrossed){ isDAafterReachedFinallyBlocks_Variable_values.put(_parameters, Boolean.valueOf(isDAafterReachedFinallyBlocks_Variable_value)); }
387            return isDAafterReachedFinallyBlocks_Variable_value;
388      }
389      /**
390       * @apilevel internal
391       */
392      private boolean isDAafterReachedFinallyBlocks_compute(Variable v) {
393        if(hasResult() ? getResult().isDAafter(v) : isDAbefore(v))
394          return true;
395        if(finallyList().isEmpty())
396          return false;
397        for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
398          FinallyHost f = (FinallyHost)iter.next();
399          if(!f.isDAafterFinally(v))
400            return false;
401        }
402        return true;
403      }
404      protected java.util.Map isDUafter_Variable_values;
405      /**
406       * @attribute syn
407       * @aspect DU
408       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1172
409       */
410      @SuppressWarnings({"unchecked", "cast"})
411      public boolean isDUafter(Variable v) {
412        Object _parameters = v;
413        if(isDUafter_Variable_values == null) isDUafter_Variable_values = new java.util.HashMap(4);
414        if(isDUafter_Variable_values.containsKey(_parameters)) {
415          return ((Boolean)isDUafter_Variable_values.get(_parameters)).booleanValue();
416        }
417          ASTNode$State state = state();
418      int num = state.boundariesCrossed;
419      boolean isFinal = this.is$Final();
420        boolean isDUafter_Variable_value = isDUafter_compute(v);
421      if(isFinal && num == state().boundariesCrossed){ isDUafter_Variable_values.put(_parameters, Boolean.valueOf(isDUafter_Variable_value)); }
422            return isDUafter_Variable_value;
423      }
424      /**
425       * @apilevel internal
426       */
427      private boolean isDUafter_compute(Variable v) {  return true;  }
428      /**
429       * @apilevel internal
430       */
431      protected boolean canCompleteNormally_computed = false;
432      /**
433       * @apilevel internal
434       */
435      protected boolean canCompleteNormally_value;
436      /**
437       * @attribute syn
438       * @aspect UnreachableStatements
439       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/UnreachableStatements.jrag:107
440       */
441      @SuppressWarnings({"unchecked", "cast"})
442      public boolean canCompleteNormally() {
443        if(canCompleteNormally_computed) {
444          return canCompleteNormally_value;
445        }
446          ASTNode$State state = state();
447      int num = state.boundariesCrossed;
448      boolean isFinal = this.is$Final();
449        canCompleteNormally_value = canCompleteNormally_compute();
450      if(isFinal && num == state().boundariesCrossed){ canCompleteNormally_computed = true; }
451            return canCompleteNormally_value;
452      }
453      /**
454       * @apilevel internal
455       */
456      private boolean canCompleteNormally_compute() {  return false;  }
457      /**
458       * @attribute syn
459       * @aspect CodeGeneration
460       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/CodeGeneration.jrag:15
461       */
462      public int sourceLineNumber() {
463        ASTNode$State state = state();
464        try {
465        int num = super.sourceLineNumber();
466        if(num != -1)
467          return num;
468        if(hasResult()) {
469          num = getResult().findFirstSourceLineNumber();
470          if(num != -1)
471            return num;
472        }
473        return getLine(getParent().getParent().getEnd());
474      }
475        finally {
476        }
477      }
478      /**
479       * @attribute syn
480       * @aspect PreciseRethrow
481       * @declaredat /home/jesper/svn/JastAddJ/Java7Frontend/PreciseRethrow.jrag:55
482       */
483      public boolean modifiedInScope(Variable var) {
484        ASTNode$State state = state();
485        try {  return false;  }
486        finally {
487        }
488      }
489      /**
490       * @attribute inh
491       * @aspect TypeCheck
492       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/TypeCheck.jrag:403
493       */
494      @SuppressWarnings({"unchecked", "cast"})
495      public TypeDecl returnType() {
496          ASTNode$State state = state();
497        TypeDecl returnType_value = getParent().Define_TypeDecl_returnType(this, null);
498            return returnType_value;
499      }
500      /**
501       * @apilevel internal
502       */
503      protected boolean resultSaveLocalNum_computed = false;
504      /**
505       * @apilevel internal
506       */
507      protected int resultSaveLocalNum_value;
508      /**
509       * @attribute inh
510       * @aspect LocalNum
511       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Backend/LocalNum.jrag:44
512       */
513      @SuppressWarnings({"unchecked", "cast"})
514      public int resultSaveLocalNum() {
515        if(resultSaveLocalNum_computed) {
516          return resultSaveLocalNum_value;
517        }
518          ASTNode$State state = state();
519      int num = state.boundariesCrossed;
520      boolean isFinal = this.is$Final();
521        resultSaveLocalNum_value = getParent().Define_int_resultSaveLocalNum(this, null);
522      if(isFinal && num == state().boundariesCrossed){ resultSaveLocalNum_computed = true; }
523            return resultSaveLocalNum_value;
524      }
525      /**
526       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:652
527       * @apilevel internal
528       */
529      public boolean Define_boolean_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
530        if(caller == getResultOptNoTransform()) {
531          return isDAbefore(v);
532        }
533        else {      return getParent().Define_boolean_isDAbefore(this, caller, v);
534        }
535      }
536      /**
537       * @declaredat /home/jesper/svn/JastAddJ/Java1.4Frontend/DefiniteAssignment.jrag:1175
538       * @apilevel internal
539       */
540      public boolean Define_boolean_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
541        if(caller == getResultOptNoTransform()) {
542          return isDUbefore(v);
543        }
544        else {      return getParent().Define_boolean_isDUbefore(this, caller, v);
545        }
546      }
547      /**
548       * @declaredat /home/jesper/svn/JastAddJ/Java1.5Frontend/GenericMethodsInference.jrag:38
549       * @apilevel internal
550       */
551      public TypeDecl Define_TypeDecl_assignConvertedType(ASTNode caller, ASTNode child) {
552        if(caller == getResultOptNoTransform()) {
553          return returnType();
554        }
555        else {      return getParent().Define_TypeDecl_assignConvertedType(this, caller);
556        }
557      }
558      /**
559       * @apilevel internal
560       */
561      public ASTNode rewriteTo() {
562        return super.rewriteTo();
563      }
564    }