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:11
027     * @production TypeImportOnDemandDecl : {@link ImportDecl};
028    
029     */
030    public class TypeImportOnDemandDecl extends ImportDecl implements Cloneable {
031      /**
032       * @aspect NameCheck
033       * @declaredat /home/jesper/git/extendj/java4/frontend/NameCheck.jrag:55
034       */
035      public void nameCheck() {
036        if (getAccess().lastAccess().isTypeAccess()
037            && !getAccess().type().typeName().equals(typeName())) {
038          errorf("On demand type import %s.* is not the canonical name of type %s",
039              typeName(), getAccess().type().typeName());
040        }
041      }
042      /**
043       * @aspect Java4PrettyPrint
044       * @declaredat /home/jesper/git/extendj/java4/frontend/PrettyPrint.jadd:620
045       */
046      public void prettyPrint(PrettyPrinter out) {
047        out.print("import ");
048        out.print(getAccess());
049        out.print(".*;");
050        out.println();
051      }
052      /**
053       * @declaredat ASTNode:1
054       */
055      public TypeImportOnDemandDecl() {
056        super();
057      }
058      /**
059       * Initializes the child array to the correct size.
060       * Initializes List and Opt nta children.
061       * @apilevel internal
062       * @ast method
063       * @declaredat ASTNode:10
064       */
065      public void init$Children() {
066        children = new ASTNode[1];
067      }
068      /**
069       * @declaredat ASTNode:13
070       */
071      public TypeImportOnDemandDecl(Access p0) {
072        setChild(p0, 0);
073      }
074      /**
075       * @apilevel low-level
076       * @declaredat ASTNode:19
077       */
078      protected int numChildren() {
079        return 1;
080      }
081      /**
082       * @apilevel internal
083       * @declaredat ASTNode:25
084       */
085      public boolean mayHaveRewrite() {
086        return false;
087      }
088      /**
089       * @apilevel internal
090       * @declaredat ASTNode:31
091       */
092      public void flushAttrCache() {
093        super.flushAttrCache();
094        importedTypes_String_reset();
095      }
096      /**
097       * @apilevel internal
098       * @declaredat ASTNode:38
099       */
100      public void flushCollectionCache() {
101        super.flushCollectionCache();
102      }
103      /**
104       * @apilevel internal
105       * @declaredat ASTNode:44
106       */
107      public void flushRewriteCache() {
108        super.flushRewriteCache();
109      }
110      /**
111       * @apilevel internal
112       * @declaredat ASTNode:50
113       */
114      public TypeImportOnDemandDecl clone() throws CloneNotSupportedException {
115        TypeImportOnDemandDecl node = (TypeImportOnDemandDecl) super.clone();
116        return node;
117      }
118      /**
119       * @apilevel internal
120       * @declaredat ASTNode:57
121       */
122      public TypeImportOnDemandDecl copy() {
123        try {
124          TypeImportOnDemandDecl node = (TypeImportOnDemandDecl) 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:76
141       */
142      @Deprecated
143      public TypeImportOnDemandDecl 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:86
152       */
153      public TypeImportOnDemandDecl treeCopyNoTransform() {
154        TypeImportOnDemandDecl tree = (TypeImportOnDemandDecl) 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:106
173       */
174      public TypeImportOnDemandDecl treeCopy() {
175        doFullTraversal();
176        return treeCopyNoTransform();
177      }
178      /**
179       * @apilevel internal
180       * @declaredat ASTNode:113
181       */
182      protected boolean is$Equal(ASTNode node) {
183        return super.is$Equal(node);    
184      }
185      /**
186       * Replaces the Access child.
187       * @param node The new node to replace the Access child.
188       * @apilevel high-level
189       */
190      public void setAccess(Access node) {
191        setChild(node, 0);
192      }
193      /**
194       * Retrieves the Access child.
195       * @return The current node used as the Access child.
196       * @apilevel high-level
197       */
198      @ASTNodeAnnotation.Child(name="Access")
199      public Access getAccess() {
200        return (Access) getChild(0);
201      }
202      /**
203       * Retrieves the Access child.
204       * <p><em>This method does not invoke AST transformations.</em></p>
205       * @return The current node used as the Access child.
206       * @apilevel low-level
207       */
208      public Access getAccessNoTransform() {
209        return (Access) getChildNoTransform(0);
210      }
211      /**
212       * @apilevel internal
213       */
214      protected java.util.Map importedTypes_String_values;
215      /**
216       * @apilevel internal
217       */
218      private void importedTypes_String_reset() {
219        importedTypes_String_values = null;
220      }
221      /**
222       * @attribute syn
223       * @aspect TypeScopePropagation
224       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:420
225       */
226      @ASTNodeAnnotation.Attribute
227      public SimpleSet importedTypes(String name) {
228        Object _parameters = name;
229        if (importedTypes_String_values == null) importedTypes_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
230        ASTNode$State state = state();
231        if (importedTypes_String_values.containsKey(_parameters)) {
232          return (SimpleSet) importedTypes_String_values.get(_parameters);
233        }
234        boolean intermediate = state.INTERMEDIATE_VALUE;
235        state.INTERMEDIATE_VALUE = false;
236        int num = state.boundariesCrossed;
237        boolean isFinal = this.is$Final();
238        SimpleSet importedTypes_String_value = importedTypes_compute(name);
239        if (isFinal && num == state().boundariesCrossed) {
240          importedTypes_String_values.put(_parameters, importedTypes_String_value);
241        } else {
242        }
243        state.INTERMEDIATE_VALUE |= intermediate;
244    
245        return importedTypes_String_value;
246      }
247      /**
248       * @apilevel internal
249       */
250      private SimpleSet importedTypes_compute(String name) {
251          SimpleSet set = SimpleSet.emptySet;
252          if (getAccess() instanceof PackageAccess) {
253            String packageName = ((PackageAccess) getAccess()).getPackage();
254            TypeDecl typeDecl = lookupType(packageName, name);
255            if (typeDecl.accessibleFromPackage(packageName()) &&
256               typeDecl.typeName().equals(packageName + "." + name)) {
257              // Canonical names match.
258              set = set.add(typeDecl);
259            }
260          } else {
261            for (Iterator iter = getAccess().type().memberTypes(name).iterator(); iter.hasNext(); ) {
262              TypeDecl decl = (TypeDecl) iter.next();
263              if (decl.accessibleFromPackage(packageName()) &&
264                 decl.typeName().equals(getAccess().typeName() + "." + name)) {
265                // Canonical names match.
266                set = set.add(decl);
267              }
268            }
269          }
270          return set;
271        }
272      /**
273       * @attribute syn
274       * @aspect TypeScopePropagation
275       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:466
276       */
277      @ASTNodeAnnotation.Attribute
278      public boolean isOnDemand() {
279        boolean isOnDemand_value = true;
280    
281        return isOnDemand_value;
282      }
283      /**
284       * @attribute inh
285       * @aspect TypeScopePropagation
286       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:463
287       */
288      /**
289       * @attribute inh
290       * @aspect TypeScopePropagation
291       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:463
292       */
293      @ASTNodeAnnotation.Attribute
294      public TypeDecl lookupType(String packageName, String typeName) {
295        TypeDecl lookupType_String_String_value = getParent().Define_lookupType(this, null, packageName, typeName);
296    
297        return lookupType_String_String_value;
298      }
299      /**
300       * @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:36
301       * @apilevel internal
302       */
303      public NameType Define_nameType(ASTNode caller, ASTNode child) {
304        if (caller == getAccessNoTransform()) {
305          // @declaredat /home/jesper/git/extendj/java4/frontend/SyntacticClassification.jrag:131
306          return NameType.PACKAGE_OR_TYPE_NAME;
307        }
308        else {
309          return getParent().Define_nameType(this, caller);
310        }
311      }
312      protected boolean canDefine_nameType(ASTNode caller, ASTNode child) {
313        return true;
314      }
315      /**
316       * @apilevel internal
317       */
318      public ASTNode rewriteTo() {
319        return super.rewriteTo();
320      }
321    }