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 }