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 }