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:70
027     * @production InstanceInitializer : {@link BodyDecl} ::= <span class="component">{@link Block}</span>;
028    
029     */
030    public class InstanceInitializer extends BodyDecl implements Cloneable {
031      /**
032       * @aspect Java4PrettyPrint
033       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:264
034       */
035      public void prettyPrint(PrettyPrinter out) {
036        if (!blockIsEmpty()) {
037          out.print(getBlock());
038        }
039      }
040      /**
041       * @aspect UnreachableStatements
042       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:45
043       */
044      void checkUnreachableStmt() {
045        if (!getBlock().canCompleteNormally()) {
046          errorf("instance initializer in %s can not complete normally", hostType().fullName());
047        }
048      }
049      /**
050       * @declaredat ASTNode:1
051       */
052      public InstanceInitializer() {
053        super();
054      }
055      /**
056       * Initializes the child array to the correct size.
057       * Initializes List and Opt nta children.
058       * @apilevel internal
059       * @ast method
060       * @declaredat ASTNode:10
061       */
062      public void init$Children() {
063        children = new ASTNode[1];
064      }
065      /**
066       * @declaredat ASTNode:13
067       */
068      public InstanceInitializer(Block p0) {
069        setChild(p0, 0);
070      }
071      /**
072       * @apilevel low-level
073       * @declaredat ASTNode:19
074       */
075      protected int numChildren() {
076        return 1;
077      }
078      /**
079       * @apilevel internal
080       * @declaredat ASTNode:25
081       */
082      public boolean mayHaveRewrite() {
083        return false;
084      }
085      /**
086       * @apilevel internal
087       * @declaredat ASTNode:31
088       */
089      public void flushAttrCache() {
090        super.flushAttrCache();
091        exceptions_reset();
092        isDAafter_Variable_reset();
093        isDUafter_Variable_reset();
094        handlesException_TypeDecl_reset();
095      }
096      /**
097       * @apilevel internal
098       * @declaredat ASTNode:41
099       */
100      public void flushCollectionCache() {
101        super.flushCollectionCache();
102      }
103      /**
104       * @apilevel internal
105       * @declaredat ASTNode:47
106       */
107      public void flushRewriteCache() {
108        super.flushRewriteCache();
109      }
110      /**
111       * @apilevel internal
112       * @declaredat ASTNode:53
113       */
114      public InstanceInitializer clone() throws CloneNotSupportedException {
115        InstanceInitializer node = (InstanceInitializer) super.clone();
116        return node;
117      }
118      /**
119       * @apilevel internal
120       * @declaredat ASTNode:60
121       */
122      public InstanceInitializer copy() {
123        try {
124          InstanceInitializer node = (InstanceInitializer) clone();
125          node.parent = null;
126          if (children != null) {
127            node.children = (ASTNode[]) children.clone();
128          }
129          return node;
130        } catch (CloneNotSupportedException e) {
131          throw new Error("Error: clone not supported for " + getClass().getName());
132        }
133      }
134      /**
135       * Create a deep copy of the AST subtree at this node.
136       * The copy is dangling, i.e. has no parent.
137       * @return dangling copy of the subtree at this node
138       * @apilevel low-level
139       * @deprecated Please use treeCopy or treeCopyNoTransform instead
140       * @declaredat ASTNode:79
141       */
142      @Deprecated
143      public InstanceInitializer fullCopy() {
144        return treeCopyNoTransform();
145      }
146      /**
147       * Create a deep copy of the AST subtree at this node.
148       * The copy is dangling, i.e. has no parent.
149       * @return dangling copy of the subtree at this node
150       * @apilevel low-level
151       * @declaredat ASTNode:89
152       */
153      public InstanceInitializer treeCopyNoTransform() {
154        InstanceInitializer tree = (InstanceInitializer) copy();
155        if (children != null) {
156          for (int i = 0; i < children.length; ++i) {
157            ASTNode child = (ASTNode) children[i];
158            if (child != null) {
159              child = child.treeCopyNoTransform();
160              tree.setChild(child, i);
161            }
162          }
163        }
164        return tree;
165      }
166      /**
167       * Create a deep copy of the AST subtree at this node.
168       * The subtree of this node is traversed to trigger rewrites before copy.
169       * The copy is dangling, i.e. has no parent.
170       * @return dangling copy of the subtree at this node
171       * @apilevel low-level
172       * @declaredat ASTNode:109
173       */
174      public InstanceInitializer treeCopy() {
175        doFullTraversal();
176        return treeCopyNoTransform();
177      }
178      /**
179       * @apilevel internal
180       * @declaredat ASTNode:116
181       */
182      protected boolean is$Equal(ASTNode node) {
183        return super.is$Equal(node);    
184      }
185      /**
186       * Replaces the Block child.
187       * @param node The new node to replace the Block child.
188       * @apilevel high-level
189       */
190      public void setBlock(Block node) {
191        setChild(node, 0);
192      }
193      /**
194       * Retrieves the Block child.
195       * @return The current node used as the Block child.
196       * @apilevel high-level
197       */
198      @ASTNodeAnnotation.Child(name="Block")
199      public Block getBlock() {
200        return (Block) getChild(0);
201      }
202      /**
203       * Retrieves the Block child.
204       * <p><em>This method does not invoke AST transformations.</em></p>
205       * @return The current node used as the Block child.
206       * @apilevel low-level
207       */
208      public Block getBlockNoTransform() {
209        return (Block) getChildNoTransform(0);
210      }
211      /**
212       * @apilevel internal
213       */
214      protected boolean exceptions_computed = false;
215      /**
216       * @apilevel internal
217       */
218      protected Collection exceptions_value;
219      /**
220       * @apilevel internal
221       */
222      private void exceptions_reset() {
223        exceptions_computed = false;
224        exceptions_value = null;
225      }
226      /**
227       * @attribute syn
228       * @aspect AnonymousClasses
229       * @declaredat /home/jesper/git/extendj/java4/frontend/AnonymousClasses.jrag:111
230       */
231      @ASTNodeAnnotation.Attribute
232      public Collection exceptions() {
233        ASTNode$State state = state();
234        if (exceptions_computed) {
235          return exceptions_value;
236        }
237        boolean intermediate = state.INTERMEDIATE_VALUE;
238        state.INTERMEDIATE_VALUE = false;
239        int num = state.boundariesCrossed;
240        boolean isFinal = this.is$Final();
241        exceptions_value = exceptions_compute();
242        if (isFinal && num == state().boundariesCrossed) {
243          exceptions_computed = true;
244        } else {
245        }
246        state.INTERMEDIATE_VALUE |= intermediate;
247    
248        return exceptions_value;
249      }
250      /**
251       * @apilevel internal
252       */
253      private Collection exceptions_compute() {
254          HashSet set = new HashSet();
255          collectExceptions(set, this);
256          for (Iterator iter = set.iterator(); iter.hasNext(); ) {
257            TypeDecl typeDecl = (TypeDecl) iter.next();
258            if (!getBlock().reachedException(typeDecl)) {
259              iter.remove();
260            }
261          }
262          return set;
263        }
264      /**
265       * @apilevel internal
266       */
267      protected java.util.Map isDAafter_Variable_values;
268      /**
269       * @apilevel internal
270       */
271      private void isDAafter_Variable_reset() {
272        isDAafter_Variable_values = null;
273      }
274      /**
275       * @attribute syn
276       * @aspect DA
277       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:266
278       */
279      @ASTNodeAnnotation.Attribute
280      public boolean isDAafter(Variable v) {
281        Object _parameters = v;
282        if (isDAafter_Variable_values == null) isDAafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
283        ASTNode$State state = state();
284        if (isDAafter_Variable_values.containsKey(_parameters)) {
285          return (Boolean) isDAafter_Variable_values.get(_parameters);
286        }
287        boolean intermediate = state.INTERMEDIATE_VALUE;
288        state.INTERMEDIATE_VALUE = false;
289        int num = state.boundariesCrossed;
290        boolean isFinal = this.is$Final();
291        boolean isDAafter_Variable_value = getBlock().isDAafter(v);
292        if (isFinal && num == state().boundariesCrossed) {
293          isDAafter_Variable_values.put(_parameters, isDAafter_Variable_value);
294        } else {
295        }
296        state.INTERMEDIATE_VALUE |= intermediate;
297    
298        return isDAafter_Variable_value;
299      }
300      /**
301       * @apilevel internal
302       */
303      protected java.util.Map isDUafter_Variable_values;
304      /**
305       * @apilevel internal
306       */
307      private void isDUafter_Variable_reset() {
308        isDUafter_Variable_values = null;
309      }
310      /**
311       * @attribute syn
312       * @aspect DU
313       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:796
314       */
315      @ASTNodeAnnotation.Attribute
316      public boolean isDUafter(Variable v) {
317        Object _parameters = v;
318        if (isDUafter_Variable_values == null) isDUafter_Variable_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
319        ASTNode$State state = state();
320        if (isDUafter_Variable_values.containsKey(_parameters)) {
321          return (Boolean) isDUafter_Variable_values.get(_parameters);
322        }
323        boolean intermediate = state.INTERMEDIATE_VALUE;
324        state.INTERMEDIATE_VALUE = false;
325        int num = state.boundariesCrossed;
326        boolean isFinal = this.is$Final();
327        boolean isDUafter_Variable_value = getBlock().isDUafter(v);
328        if (isFinal && num == state().boundariesCrossed) {
329          isDUafter_Variable_values.put(_parameters, isDUafter_Variable_value);
330        } else {
331        }
332        state.INTERMEDIATE_VALUE |= intermediate;
333    
334        return isDUafter_Variable_value;
335      }
336      /**
337       * @attribute syn
338       * @aspect PrettyPrintUtil
339       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrintUtil.jrag:215
340       */
341      @ASTNodeAnnotation.Attribute
342      public boolean blockIsEmpty() {
343        boolean blockIsEmpty_value = getBlock().getNumStmt() == 0;
344    
345        return blockIsEmpty_value;
346      }
347      /**
348       * @attribute syn
349       * @aspect PreciseRethrow
350       * @declaredat /home/jesper/git/extendj/java8/frontend/EffectivelyFinal.jrag:40
351       */
352      @ASTNodeAnnotation.Attribute
353      public boolean modifiedInScope(Variable var) {
354        boolean modifiedInScope_Variable_value = getBlock().modifiedInScope(var);
355    
356        return modifiedInScope_Variable_value;
357      }
358      /**
359       * @attribute inh
360       * @aspect ExceptionHandling
361       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:79
362       */
363      /**
364       * @attribute inh
365       * @aspect ExceptionHandling
366       * @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:79
367       */
368      @ASTNodeAnnotation.Attribute
369      public boolean handlesException(TypeDecl exceptionType) {
370        Object _parameters = exceptionType;
371        if (handlesException_TypeDecl_values == null) handlesException_TypeDecl_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
372        ASTNode$State state = state();
373        if (handlesException_TypeDecl_values.containsKey(_parameters)) {
374          return (Boolean) handlesException_TypeDecl_values.get(_parameters);
375        }
376        boolean intermediate = state.INTERMEDIATE_VALUE;
377        state.INTERMEDIATE_VALUE = false;
378        int num = state.boundariesCrossed;
379        boolean isFinal = this.is$Final();
380        boolean handlesException_TypeDecl_value = getParent().Define_handlesException(this, null, exceptionType);
381        if (isFinal && num == state().boundariesCrossed) {
382          handlesException_TypeDecl_values.put(_parameters, handlesException_TypeDecl_value);
383        } else {
384        }
385        state.INTERMEDIATE_VALUE |= intermediate;
386    
387        return handlesException_TypeDecl_value;
388      }
389      /**
390       * @apilevel internal
391       */
392      protected java.util.Map handlesException_TypeDecl_values;
393      /**
394       * @apilevel internal
395       */
396      private void handlesException_TypeDecl_reset() {
397        handlesException_TypeDecl_values = null;
398      }
399      /**
400       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:255
401       * @apilevel internal
402       */
403      public boolean Define_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
404        if (caller == getBlockNoTransform()) {
405          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:480
406          return isDAbefore(v);
407        }
408        else {
409          return super.Define_isDAbefore(caller, child, v);
410        }
411      }
412      protected boolean canDefine_isDAbefore(ASTNode caller, ASTNode child, Variable v) {
413        return true;
414      }
415      /**
416       * @declaredat /home/jesper/git/extendj/java7/frontend/TryWithResources.jrag:113
417       * @apilevel internal
418       */
419      public boolean Define_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
420        if (caller == getBlockNoTransform()) {
421          // @declaredat /home/jesper/git/extendj/java4/frontend/ExceptionHandling.jrag:223
422          {
423              if (hostType().isAnonymous()) {
424                return true;
425              }
426              for (Iterator iter = hostType().constructors().iterator(); iter.hasNext(); ) {
427                ConstructorDecl decl = (ConstructorDecl) iter.next();
428                if (!decl.throwsException(exceptionType)) {
429                  return false;
430                }
431              }
432              return true;
433            }
434        }
435        else {
436          return getParent().Define_handlesException(this, caller, exceptionType);
437        }
438      }
439      protected boolean canDefine_handlesException(ASTNode caller, ASTNode child, TypeDecl exceptionType) {
440        return true;
441      }
442      /**
443       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:310
444       * @apilevel internal
445       */
446      public ASTNode Define_enclosingBlock(ASTNode caller, ASTNode child) {
447        if (caller == getBlockNoTransform()) {
448          // @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:313
449          return this;
450        }
451        else {
452          return getParent().Define_enclosingBlock(this, caller);
453        }
454      }
455      protected boolean canDefine_enclosingBlock(ASTNode caller, ASTNode child) {
456        return true;
457      }
458      /**
459       * @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:182
460       * @apilevel internal
461       */
462      public boolean Define_inStaticContext(ASTNode caller, ASTNode child) {
463        if (caller == getBlockNoTransform()) {
464          // @declaredat /home/jesper/git/extendj/java4/frontend/TypeHierarchyCheck.jrag:188
465          return false;
466        }
467        else {
468          return getParent().Define_inStaticContext(this, caller);
469        }
470      }
471      protected boolean canDefine_inStaticContext(ASTNode caller, ASTNode child) {
472        return true;
473      }
474      /**
475       * @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:52
476       * @apilevel internal
477       */
478      public boolean Define_reachable(ASTNode caller, ASTNode child) {
479        if (caller == getBlockNoTransform()) {
480          // @declaredat /home/jesper/git/extendj/java4/frontend/UnreachableStatements.jrag:66
481          return true;
482        }
483        else {
484          return getParent().Define_reachable(this, caller);
485        }
486      }
487      protected boolean canDefine_reachable(ASTNode caller, ASTNode child) {
488        return true;
489      }
490      /**
491       * @declaredat /home/jesper/git/extendj/java7/backend/MultiCatch.jrag:64
492       * @apilevel internal
493       */
494      public int Define_localNum(ASTNode caller, ASTNode child) {
495        if (caller == getBlockNoTransform()) {
496          // @declaredat /home/jesper/git/extendj/java4/backend/LocalNum.jrag:89
497          {
498              int localNum = 1;
499              for (Iterator iter = hostType().constructors().iterator(); iter.hasNext(); ) {
500                ConstructorDecl c = (ConstructorDecl)iter.next();
501                int num = c.offsetAfterParameters();
502                if (num > localNum) {
503                  localNum = num;
504                }
505              }
506              return localNum;
507            }
508        }
509        else {
510          return getParent().Define_localNum(this, caller);
511        }
512      }
513      protected boolean canDefine_localNum(ASTNode caller, ASTNode child) {
514        return true;
515      }
516      /**
517       * @apilevel internal
518       */
519      public ASTNode rewriteTo() {
520        return super.rewriteTo();
521      }
522    }