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:9
027     * @production ImportDecl : {@link ASTNode} ::= <span class="component">{@link Access}</span>;
028    
029     */
030    public abstract class ImportDecl extends ASTNode<ASTNode> implements Cloneable {
031      /**
032       * @declaredat ASTNode:1
033       */
034      public ImportDecl() {
035        super();
036      }
037      /**
038       * Initializes the child array to the correct size.
039       * Initializes List and Opt nta children.
040       * @apilevel internal
041       * @ast method
042       * @declaredat ASTNode:10
043       */
044      public void init$Children() {
045        children = new ASTNode[1];
046      }
047      /**
048       * @declaredat ASTNode:13
049       */
050      public ImportDecl(Access p0) {
051        setChild(p0, 0);
052      }
053      /**
054       * @apilevel low-level
055       * @declaredat ASTNode:19
056       */
057      protected int numChildren() {
058        return 1;
059      }
060      /**
061       * @apilevel internal
062       * @declaredat ASTNode:25
063       */
064      public boolean mayHaveRewrite() {
065        return false;
066      }
067      /**
068       * @apilevel internal
069       * @declaredat ASTNode:31
070       */
071      public void flushAttrCache() {
072        super.flushAttrCache();
073        importedTypes_String_reset();
074        importedTypes_reset();
075        importedFields_String_reset();
076        importedMethods_String_reset();
077      }
078      /**
079       * @apilevel internal
080       * @declaredat ASTNode:41
081       */
082      public void flushCollectionCache() {
083        super.flushCollectionCache();
084      }
085      /**
086       * @apilevel internal
087       * @declaredat ASTNode:47
088       */
089      public void flushRewriteCache() {
090        super.flushRewriteCache();
091      }
092      /**
093       * @apilevel internal
094       * @declaredat ASTNode:53
095       */
096      public ImportDecl clone() throws CloneNotSupportedException {
097        ImportDecl node = (ImportDecl) super.clone();
098        return node;
099      }
100      /**
101       * Create a deep copy of the AST subtree at this node.
102       * The copy is dangling, i.e. has no parent.
103       * @return dangling copy of the subtree at this node
104       * @apilevel low-level
105       * @deprecated Please use treeCopy or treeCopyNoTransform instead
106       * @declaredat ASTNode:64
107       */
108      @Deprecated
109      public abstract ImportDecl fullCopy();
110      /**
111       * Create a deep copy of the AST subtree at this node.
112       * The copy is dangling, i.e. has no parent.
113       * @return dangling copy of the subtree at this node
114       * @apilevel low-level
115       * @declaredat ASTNode:72
116       */
117      public abstract ImportDecl treeCopyNoTransform();
118      /**
119       * Create a deep copy of the AST subtree at this node.
120       * The subtree of this node is traversed to trigger rewrites before copy.
121       * The copy is dangling, i.e. has no parent.
122       * @return dangling copy of the subtree at this node
123       * @apilevel low-level
124       * @declaredat ASTNode:80
125       */
126      public abstract ImportDecl treeCopy();
127      /**
128       * Replaces the Access child.
129       * @param node The new node to replace the Access child.
130       * @apilevel high-level
131       */
132      public void setAccess(Access node) {
133        setChild(node, 0);
134      }
135      /**
136       * Retrieves the Access child.
137       * @return The current node used as the Access child.
138       * @apilevel high-level
139       */
140      @ASTNodeAnnotation.Child(name="Access")
141      public Access getAccess() {
142        return (Access) getChild(0);
143      }
144      /**
145       * Retrieves the Access child.
146       * <p><em>This method does not invoke AST transformations.</em></p>
147       * @return The current node used as the Access child.
148       * @apilevel low-level
149       */
150      public Access getAccessNoTransform() {
151        return (Access) getChildNoTransform(0);
152      }
153      /**
154       * @apilevel internal
155       */
156      protected java.util.Map importedTypes_String_values;
157      /**
158       * @apilevel internal
159       */
160      private void importedTypes_String_reset() {
161        importedTypes_String_values = null;
162      }
163      /**
164       * @attribute syn
165       * @aspect TypeScopePropagation
166       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:420
167       */
168      @ASTNodeAnnotation.Attribute
169      public SimpleSet importedTypes(String name) {
170        Object _parameters = name;
171        if (importedTypes_String_values == null) importedTypes_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
172        ASTNode$State state = state();
173        if (importedTypes_String_values.containsKey(_parameters)) {
174          return (SimpleSet) importedTypes_String_values.get(_parameters);
175        }
176        boolean intermediate = state.INTERMEDIATE_VALUE;
177        state.INTERMEDIATE_VALUE = false;
178        int num = state.boundariesCrossed;
179        boolean isFinal = this.is$Final();
180        SimpleSet importedTypes_String_value = SimpleSet.emptySet;
181        if (isFinal && num == state().boundariesCrossed) {
182          importedTypes_String_values.put(_parameters, importedTypes_String_value);
183        } else {
184        }
185        state.INTERMEDIATE_VALUE |= intermediate;
186    
187        return importedTypes_String_value;
188      }
189      /**
190       * @apilevel internal
191       */
192      protected boolean importedTypes_computed = false;
193      /**
194       * @apilevel internal
195       */
196      protected SimpleSet importedTypes_value;
197      /**
198       * @apilevel internal
199       */
200      private void importedTypes_reset() {
201        importedTypes_computed = false;
202        importedTypes_value = null;
203      }
204      /**
205       * For a single-import declaration this will return a SimpleSet
206       * containing the TypeDecl for the imported type. For dynamic
207       * import declarations this returns the empty set.
208       * @return TypeDecl of imported type wrapped in SimpleSet
209       * @attribute syn
210       * @aspect TypeScopePropagation
211       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:437
212       */
213      @ASTNodeAnnotation.Attribute
214      public SimpleSet importedTypes() {
215        ASTNode$State state = state();
216        if (importedTypes_computed) {
217          return importedTypes_value;
218        }
219        boolean intermediate = state.INTERMEDIATE_VALUE;
220        state.INTERMEDIATE_VALUE = false;
221        int num = state.boundariesCrossed;
222        boolean isFinal = this.is$Final();
223        importedTypes_value = SimpleSet.emptySet;
224        if (isFinal && num == state().boundariesCrossed) {
225          importedTypes_computed = true;
226        } else {
227        }
228        state.INTERMEDIATE_VALUE |= intermediate;
229    
230        return importedTypes_value;
231      }
232      /**
233       * @attribute syn
234       * @aspect TypeScopePropagation
235       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:466
236       */
237      @ASTNodeAnnotation.Attribute
238      public boolean isOnDemand() {
239        boolean isOnDemand_value = false;
240    
241        return isOnDemand_value;
242      }
243      /**
244       * @attribute syn
245       * @aspect Names
246       * @declaredat /home/jesper/git/extendj/java4/frontend/QualifiedNames.jrag:60
247       */
248      @ASTNodeAnnotation.Attribute
249      public String typeName() {
250        {
251            Access a = getAccess().lastAccess();
252            String name = a.isTypeAccess() ? ((TypeAccess) a).nameWithPackage() : "";
253            while (a.hasPrevExpr() && a.prevExpr() instanceof Access) {
254              Access pred = (Access) a.prevExpr();
255              if (pred.isTypeAccess()) {
256                name = ((TypeAccess) pred).nameWithPackage() + "." + name;
257              }
258              a = pred;
259            }
260            return name;
261          }
262      }
263      /**
264       * @apilevel internal
265       */
266      protected java.util.Map importedFields_String_values;
267      /**
268       * @apilevel internal
269       */
270      private void importedFields_String_reset() {
271        importedFields_String_values = null;
272      }
273      /**
274       * @attribute syn
275       * @aspect StaticImports
276       * @declaredat /home/jesper/git/extendj/java5/frontend/StaticImports.jrag:55
277       */
278      @ASTNodeAnnotation.Attribute
279      public SimpleSet importedFields(String name) {
280        Object _parameters = name;
281        if (importedFields_String_values == null) importedFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
282        ASTNode$State state = state();
283        if (importedFields_String_values.containsKey(_parameters)) {
284          return (SimpleSet) importedFields_String_values.get(_parameters);
285        }
286        boolean intermediate = state.INTERMEDIATE_VALUE;
287        state.INTERMEDIATE_VALUE = false;
288        int num = state.boundariesCrossed;
289        boolean isFinal = this.is$Final();
290        SimpleSet importedFields_String_value = SimpleSet.emptySet;
291        if (isFinal && num == state().boundariesCrossed) {
292          importedFields_String_values.put(_parameters, importedFields_String_value);
293        } else {
294        }
295        state.INTERMEDIATE_VALUE |= intermediate;
296    
297        return importedFields_String_value;
298      }
299      /**
300       * @apilevel internal
301       */
302      protected java.util.Map importedMethods_String_values;
303      /**
304       * @apilevel internal
305       */
306      private void importedMethods_String_reset() {
307        importedMethods_String_values = null;
308      }
309      /**
310       * @attribute syn
311       * @aspect StaticImports
312       * @declaredat /home/jesper/git/extendj/java5/frontend/StaticImports.jrag:75
313       */
314      @ASTNodeAnnotation.Attribute
315      public Collection importedMethods(String name) {
316        Object _parameters = name;
317        if (importedMethods_String_values == null) importedMethods_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
318        ASTNode$State state = state();
319        if (importedMethods_String_values.containsKey(_parameters)) {
320          return (Collection) importedMethods_String_values.get(_parameters);
321        }
322        boolean intermediate = state.INTERMEDIATE_VALUE;
323        state.INTERMEDIATE_VALUE = false;
324        int num = state.boundariesCrossed;
325        boolean isFinal = this.is$Final();
326        Collection importedMethods_String_value = Collections.EMPTY_LIST;
327        if (isFinal && num == state().boundariesCrossed) {
328          importedMethods_String_values.put(_parameters, importedMethods_String_value);
329        } else {
330        }
331        state.INTERMEDIATE_VALUE |= intermediate;
332    
333        return importedMethods_String_value;
334      }
335      /**
336       * @attribute inh
337       * @aspect TypeScopePropagation
338       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:464
339       */
340      /**
341       * @attribute inh
342       * @aspect TypeScopePropagation
343       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:464
344       */
345      @ASTNodeAnnotation.Attribute
346      public String packageName() {
347        String packageName_value = getParent().Define_packageName(this, null);
348    
349        return packageName_value;
350      }
351      /**
352       * @attribute inh
353       * @aspect NameCheck
354       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:52
355       */
356      /**
357       * @attribute inh
358       * @aspect NameCheck
359       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:52
360       */
361      @ASTNodeAnnotation.Attribute
362      public SimpleSet allImportedTypes(String name) {
363        SimpleSet allImportedTypes_String_value = getParent().Define_allImportedTypes(this, null, name);
364    
365        return allImportedTypes_String_value;
366      }
367      /**
368       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:37
369       * @apilevel internal
370       */
371      public boolean Define_isDest(ASTNode caller, ASTNode child) {
372        if (caller == getAccessNoTransform()) {
373          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:45
374          return false;
375        }
376        else {
377          return getParent().Define_isDest(this, caller);
378        }
379      }
380      protected boolean canDefine_isDest(ASTNode caller, ASTNode child) {
381        return true;
382      }
383      /**
384       * @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:47
385       * @apilevel internal
386       */
387      public boolean Define_isSource(ASTNode caller, ASTNode child) {
388        if (caller == getAccessNoTransform()) {
389          // @declaredat /home/jesper/git/extendj/java4/frontend/DefiniteAssignment.jrag:54
390          return true;
391        }
392        else {
393          return getParent().Define_isSource(this, caller);
394        }
395      }
396      protected boolean canDefine_isSource(ASTNode caller, ASTNode child) {
397        return true;
398      }
399      /**
400       * @apilevel internal
401       */
402      public ASTNode rewriteTo() {
403        return super.rewriteTo();
404      }
405    }