001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * @ast node
026     * @declaredat /home/jesper/git/extendj/java4/grammar/Java.ast:211
027     * @production ThrowStmt : {@link Stmt} ::= <span class="component">{@link Expr}</span>;
028    
029     */
030    public class ThrowStmt extends Stmt implements Cloneable {
031      /**
032       * @aspect AnonymousClasses
033       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:129
034       */
035      protected void collectExceptions(Collection c, ASTNode target) {
036        super.collectExceptions(c, target);
037        TypeDecl exceptionType = getExpr().type();
038        if (exceptionType == typeNull()) {
039          exceptionType = typeNullPointerException();
040        }
041        c.add(exceptionType);
042      }
043      /**
044       * @aspect Java4PrettyPrint
045       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:283
046       */
047      public void prettyPrint(PrettyPrinter out) {
048        out.print("throw ");
049        out.print(getExpr());
050        out.print(";");
051      }
052      /**
053       * @aspect TypeCheck
054       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeCheck.jrag:437
055       */
056      public void typeCheck() {
057        if (!getExpr().type().instanceOf(typeThrowable())) {
058          error("*** The thrown expression must extend Throwable");
059        }
060      }
061      /**
062       * @aspect CreateBCode
063       * @declaredat /home/jesper/git/extendj/java4/backend/CreateBCode.jrag:1705
064       */
065      public void createBCode(CodeGeneration gen) {
066        super.createBCode(gen);
067        getExpr().createBCode(gen);
068        gen.emitThrow();
069      }
070      /**
071       * @declaredat ASTNode:1
072       */
073      public ThrowStmt() {
074        super();
075      }
076      /**
077       * Initializes the child array to the correct size.
078       * Initializes List and Opt nta children.
079       * @apilevel internal
080       * @ast method
081       * @declaredat ASTNode:10
082       */
083      public void init$Children() {
084        children = new ASTNode[1];
085      }
086      /**
087       * @declaredat ASTNode:13
088       */
089      public ThrowStmt(Expr p0) {
090        setChild(p0, 0);
091      }
092      /**
093       * @apilevel low-level
094       * @declaredat ASTNode:19
095       */
096      protected int numChildren() {
097        return 1;
098      }
099      /**
100       * @apilevel internal
101       * @declaredat ASTNode:25
102       */
103      public boolean mayHaveRewrite() {
104        return false;
105      }
106      /**
107       * @apilevel internal
108       * @declaredat ASTNode:31
109       */
110      public void flushAttrCache() {
111        super.flushAttrCache();
112        isDAafter_Variable_reset();
113        isDUafter_Variable_reset();
114        canCompleteNormally_reset();
115        typeNullPointerException_reset();
116        handlesException_TypeDecl_reset();
117        typeThrowable_reset();
118        typeNull_reset();
119      }
120      /**
121       * @apilevel internal
122       * @declaredat ASTNode:44
123       */
124      public void flushCollectionCache() {
125        super.flushCollectionCache();
126      }
127      /**
128       * @apilevel internal
129       * @declaredat ASTNode:50
130       */
131      public void flushRewriteCache() {
132        super.flushRewriteCache();
133      }
134      /**
135       * @apilevel internal
136       * @declaredat ASTNode:56
137       */
138      public ThrowStmt clone() throws CloneNotSupportedException {
139        ThrowStmt node = (ThrowStmt) super.clone();
140        return node;
141      }
142      /**
143       * @apilevel internal
144       * @declaredat ASTNode:63
145       */
146      public ThrowStmt copy() {
147        try {
148          ThrowStmt node = (ThrowStmt) clone();
149          node.parent = null;
150          if (children != null) {
151            node.children = (ASTNode[]) children.clone();
152          }
153          return node;
154        } catch (CloneNotSupportedException e) {
155          throw new Error("Error: clone not supported for " + getClass().getName());
156        }
157      }
158      /**
159       * Create a deep copy of the AST subtree at this node.
160       * The copy is dangling, i.e. has no parent.
161       * @return dangling copy of the subtree at this node
162       * @apilevel low-level
163       * @deprecated Please use treeCopy or treeCopyNoTransform instead
164       * @declaredat ASTNode:82
165       */
166      @Deprecated
167      public ThrowStmt fullCopy() {
168        return treeCopyNoTransform();
169      }
170      /**
171       * Create a deep copy of the AST subtree at this node.
172       * The copy is dangling, i.e. has no parent.
173       * @return dangling copy of the subtree at this node
174       * @apilevel low-level
175       * @declaredat ASTNode:92
176       */
177      public ThrowStmt treeCopyNoTransform() {
178        ThrowStmt tree = (ThrowStmt) copy();
179        if (children != null) {
180          for (int i = 0; i < children.length; ++i) {
181            ASTNode child = (ASTNode) children[i];
182            if (child != null) {
183              child = child.treeCopyNoTransform();
184              tree.setChild(child, i);
185            }
186          }
187        }
188        return tree;
189      }
190      /**
191       * Create a deep copy of the AST subtree at this node.
192       * The subtree of this node is traversed to trigger rewrites before copy.
193       * The copy is dangling, i.e. has no parent.
194       * @return dangling copy of the subtree at this node
195       * @apilevel low-level
196       * @declaredat ASTNode:112
197       */
198      public ThrowStmt treeCopy() {
199        doFullTraversal();
200        return treeCopyNoTransform();
201      }
202      /**
203       * @apilevel internal
204       * @declaredat ASTNode:119
205       */
206      protected boolean is$Equal(ASTNode node) {
207        return super.is$Equal(node);    
208      }
209      /**
210       * Replaces the Expr child.
211       * @param node The new node to replace the Expr child.
212       * @apilevel high-level
213       */
214      public void setExpr(Expr node) {
215        setChild(node, 0);
216      }
217      /**
218       * Retrieves the Expr child.
219       * @return The current node used as the Expr child.
220       * @apilevel high-level
221       */
222      @ASTNodeAnnotation.Child(name="Expr")
223      public Expr getExpr() {
224        return (Expr) getChild(0);
225      }
226      /**
227       * Retrieves the Expr child.
228       * <p><em>This method does not invoke AST transformations.</em></p>
229       * @return The current node used as the Expr child.
230       * @apilevel low-level
231       */
232      public Expr getExprNoTransform() {
233        return (Expr) getChildNoTransform(0);
234      }
235      /**
236       * @aspect PreciseRethrow
237       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:249
238       */
239       
240      public void exceptionHandling() {
241        Collection<TypeDecl> exceptionTypes = getExpr().throwTypes();
242        for (TypeDecl exceptionType : exceptionTypes) {
243          if (exceptionType == typeNull()) {
244            exceptionType = typeNullPointerException();
245          }
246          // 8.4.4
247          if (exceptionType.isCheckedException() && !handlesException(exceptionType)) {
248            errorf("%s throws uncaught exception %s", this.prettyPrint(), exceptionType.fullName());
249          }
250        }
251      }
252      /**
253       * @aspect PreciseRethrow
254       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:263
255       */
256       
257      protected boolean reachedException(TypeDecl catchType) {
258        Collection<TypeDecl> exceptionTypes = getExpr().throwTypes();
259        boolean reached = false;
260        for (TypeDecl exceptionType : exceptionTypes) {
261          if (exceptionType == typeNull()) {
262            exceptionType = typeNullPointerException();
263          }
264          if (catchType.mayCatch(exceptionType)) {
265            reached = true;
266            break;
267          }
268          if (super.reachedException(catchType)) {
269            reached = true;
270            break;
271          }
272        }
273        return reached;
274      }
275      /**
276       * @apilevel internal
277       */
278      protected java.util.Map isDAafter_Variable_values;
279      /**
280       * @apilevel internal
281       */
282      private void isDAafter_Variable_reset() {
283        isDAafter_Variable_values = null;
284      }
285      /**
286       * @attribute syn
287       * @aspect DA
288       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:257
289       */
290      @ASTNodeAnnotation.Attribute
291      public boolean isDAafter(Variable v) {
292        Object _parameters = v;
293        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
294        ASTNode$State state = state();
295        if (isDAafter_Variable_values.containsKey(_parameters)) {
296          return (Boolean) isDAafter_Variable_values.get(_parameters);
297        }
298        boolean intermediate = state.INTERMEDIATE_VALUE;
299        state.INTERMEDIATE_VALUE = false;
300        int num = state.boundariesCrossed;
301        boolean isFinal = this.is$Final();
302        boolean isDAafter_Variable_value = true;
303        if (isFinal && num == state().boundariesCrossed) {
304          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
305        } else {
306        }
307        state.INTERMEDIATE_VALUE |= intermediate;
308    
309        return isDAafter_Variable_value;
310      }
311      /**
312       * @apilevel internal
313       */
314      protected java.util.Map isDUafter_Variable_values;
315      /**
316       * @apilevel internal
317       */
318      private void isDUafter_Variable_reset() {
319        isDUafter_Variable_values = null;
320      }
321      /**
322       * @attribute syn
323       * @aspect DU
324       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:781
325       */
326      @ASTNodeAnnotation.Attribute
327      public boolean isDUafter(Variable v) {
328        Object _parameters = v;
329        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
330        ASTNode$State state = state();
331        if (isDUafter_Variable_values.containsKey(_parameters)) {
332          return (Boolean) isDUafter_Variable_values.get(_parameters);
333        }
334        boolean intermediate = state.INTERMEDIATE_VALUE;
335        state.INTERMEDIATE_VALUE = false;
336        int num = state.boundariesCrossed;
337        boolean isFinal = this.is$Final();
338        boolean isDUafter_Variable_value = true;
339        if (isFinal && num == state().boundariesCrossed) {
340          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
341        } else {
342        }
343        state.INTERMEDIATE_VALUE |= intermediate;
344    
345        return isDUafter_Variable_value;
346      }
347      /**
348       * @apilevel internal
349       */
350      protected boolean canCompleteNormally_computed = false;
351      /**
352       * @apilevel internal
353       */
354      protected boolean canCompleteNormally_value;
355      /**
356       * @apilevel internal
357       */
358      private void canCompleteNormally_reset() {
359        canCompleteNormally_computed = false;
360      }
361      /**
362       * @attribute syn
363       * @aspect UnreachableStatements
364       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:53
365       */
366      @ASTNodeAnnotation.Attribute
367      public boolean canCompleteNormally() {
368        ASTNode$State state = state();
369        if (canCompleteNormally_computed) {
370          return canCompleteNormally_value;
371        }
372        boolean intermediate = state.INTERMEDIATE_VALUE;
373        state.INTERMEDIATE_VALUE = false;
374        int num = state.boundariesCrossed;
375        boolean isFinal = this.is$Final();
376        canCompleteNormally_value = false;
377        if (isFinal && num == state().boundariesCrossed) {
378          canCompleteNormally_computed = true;
379        } else {
380        }
381        state.INTERMEDIATE_VALUE |= intermediate;
382    
383        return canCompleteNormally_value;
384      }
385      /**
386       * @attribute syn
387       * @aspect PreciseRethrow
388       * @declaredat /home/jesper/git/extendj/java7/frontend/PreciseRethrow.jrag:84
389       */
390      @ASTNodeAnnotation.Attribute
391      public boolean modifiedInScope(Variable var) {
392        boolean modifiedInScope_Variable_value = false;
393    
394        return modifiedInScope_Variable_value;
395      }
396      /**
397       * @attribute inh
398       * @aspect ExceptionHandling
399       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:47
400       */
401      /**
402       * @attribute inh
403       * @aspect ExceptionHandling
404       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:47
405       */
406      @ASTNodeAnnotation.Attribute
407      public TypeDecl typeNullPointerException() {
408        ASTNode$State state = state();
409        if (typeNullPointerException_computed) {
410          return typeNullPointerException_value;
411        }
412        boolean intermediate = state.INTERMEDIATE_VALUE;
413        state.INTERMEDIATE_VALUE = false;
414        int num = state.boundariesCrossed;
415        boolean isFinal = this.is$Final();
416        typeNullPointerException_value = getParent().Define_typeNullPointerException(this, null);
417        if (isFinal && num == state().boundariesCrossed) {
418          typeNullPointerException_computed = true;
419        } else {
420        }
421        state.INTERMEDIATE_VALUE |= intermediate;
422    
423        return typeNullPointerException_value;
424      }
425      /**
426       * @apilevel internal
427       */
428      protected boolean typeNullPointerException_computed = false;
429      /**
430       * @apilevel internal
431       */
432      protected TypeDecl typeNullPointerException_value;
433      /**
434       * @apilevel internal
435       */
436      private void typeNullPointerException_reset() {
437        typeNullPointerException_computed = false;
438        typeNullPointerException_value = null;
439      }
440      /**
441       * @attribute inh
442       * @aspect ExceptionHandling
443       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:78
444       */
445      /**
446       * @attribute inh
447       * @aspect ExceptionHandling
448       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:78
449       */
450      @ASTNodeAnnotation.Attribute
451      public boolean handlesException(TypeDecl exceptionType) {
452        Object _parameters = exceptionType;
453        if (handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
454        ASTNode$State state = state();
455        if (handlesException_TypeDecl_values.containsKey(_parameters)) {
456          return (Boolean) handlesException_TypeDecl_values.get(_parameters);
457        }
458        boolean intermediate = state.INTERMEDIATE_VALUE;
459        state.INTERMEDIATE_VALUE = false;
460        int num = state.boundariesCrossed;
461        boolean isFinal = this.is$Final();
462        boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType);
463        if (isFinal && num == state().boundariesCrossed) {
464          handlesException_TypeDecl_values.put(_parameters, handlesException_TypeDecl_value);
465        } else {
466        }
467        state.INTERMEDIATE_VALUE |= intermediate;
468    
469        return handlesException_TypeDecl_value;
470      }
471      /**
472       * @apilevel internal
473       */
474      protected java.util.Map handlesException_TypeDecl_values;
475      /**
476       * @apilevel internal
477       */
478      private void handlesException_TypeDecl_reset() {
479        handlesException_TypeDecl_values = null;
480      }
481      /**
482       * @attribute inh
483       * @aspect SpecialClasses
484       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:92
485       */
486      /**
487       * @attribute inh
488       * @aspect SpecialClasses
489       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:92
490       */
491      @ASTNodeAnnotation.Attribute
492      public TypeDecl typeThrowable() {
493        ASTNode$State state = state();
494        if (typeThrowable_computed) {
495          return typeThrowable_value;
496        }
497        boolean intermediate = state.INTERMEDIATE_VALUE;
498        state.INTERMEDIATE_VALUE = false;
499        int num = state.boundariesCrossed;
500        boolean isFinal = this.is$Final();
501        typeThrowable_value = getParent().Define_typeThrowable(this, null);
502        if (isFinal && num == state().boundariesCrossed) {
503          typeThrowable_computed = true;
504        } else {
505        }
506        state.INTERMEDIATE_VALUE |= intermediate;
507    
508        return typeThrowable_value;
509      }
510      /**
511       * @apilevel internal
512       */
513      protected boolean typeThrowable_computed = false;
514      /**
515       * @apilevel internal
516       */
517      protected TypeDecl typeThrowable_value;
518      /**
519       * @apilevel internal
520       */
521      private void typeThrowable_reset() {
522        typeThrowable_computed = false;
523        typeThrowable_value = null;
524      }
525      /**
526       * @attribute inh
527       * @aspect SpecialClasses
528       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:95
529       */
530      /**
531       * @attribute inh
532       * @aspect SpecialClasses
533       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:95
534       */
535      @ASTNodeAnnotation.Attribute
536      public TypeDecl typeNull() {
537        ASTNode$State state = state();
538        if (typeNull_computed) {
539          return typeNull_value;
540        }
541        boolean intermediate = state.INTERMEDIATE_VALUE;
542        state.INTERMEDIATE_VALUE = false;
543        int num = state.boundariesCrossed;
544        boolean isFinal = this.is$Final();
545        typeNull_value = getParent().Define_typeNull(this, null);
546        if (isFinal && num == state().boundariesCrossed) {
547          typeNull_computed = true;
548        } else {
549        }
550        state.INTERMEDIATE_VALUE |= intermediate;
551    
552        return typeNull_value;
553      }
554      /**
555       * @apilevel internal
556       */
557      protected boolean typeNull_computed = false;
558      /**
559       * @apilevel internal
560       */
561      protected TypeDecl typeNull_value;
562      /**
563       * @apilevel internal
564       */
565      private void typeNull_reset() {
566        typeNull_computed = false;
567        typeNull_value = null;
568      }
569      /**
570       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
571       * @apilevel internal
572       */
573      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
574        if (caller == getExprNoTransform()) {
575          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:735
576          return isDAbefore(v);
577        }
578        else {
579          return getParent().Define_isDAbefore(this, caller, v);
580        }
581      }
582      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
583        return true;
584      }
585      /**
586       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:779
587       * @apilevel internal
588       */
589      public boolean Define_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
590        if (caller == getExprNoTransform()) {
591          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:1354
592          return isDUbefore(v);
593        }
594        else {
595          return getParent().Define_isDUbefore(this, caller, v);
596        }
597      }
598      protected boolean canDefine_isDUbefore(ASTNode caller, ASTNode child, Variable v) {
599        return true;
600      }
601      /**
602       * @apilevel internal
603       */
604      public ASTNode rewriteTo() {
605        return super.rewriteTo();
606      }
607    }