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 * 7.5 Import Declarations 026 * @ast node 027 * @declaredat /home/jesper/git/extendj/java5/grammar/StaticImports.ast:4 028 * @production StaticImportDecl : {@link ImportDecl}; 029 030 */ 031 public abstract class StaticImportDecl extends ImportDecl implements Cloneable { 032 /** 033 * @declaredat ASTNode:1 034 */ 035 public StaticImportDecl() { 036 super(); 037 } 038 /** 039 * Initializes the child array to the correct size. 040 * Initializes List and Opt nta children. 041 * @apilevel internal 042 * @ast method 043 * @declaredat ASTNode:10 044 */ 045 public void init$Children() { 046 children = new ASTNode[1]; 047 } 048 /** 049 * @declaredat ASTNode:13 050 */ 051 public StaticImportDecl(Access p0) { 052 setChild(p0, 0); 053 } 054 /** 055 * @apilevel low-level 056 * @declaredat ASTNode:19 057 */ 058 protected int numChildren() { 059 return 1; 060 } 061 /** 062 * @apilevel internal 063 * @declaredat ASTNode:25 064 */ 065 public boolean mayHaveRewrite() { 066 return false; 067 } 068 /** 069 * @apilevel internal 070 * @declaredat ASTNode:31 071 */ 072 public void flushAttrCache() { 073 super.flushAttrCache(); 074 importedTypes_String_reset(); 075 importedFields_String_reset(); 076 importedMethods_String_reset(); 077 } 078 /** 079 * @apilevel internal 080 * @declaredat ASTNode:40 081 */ 082 public void flushCollectionCache() { 083 super.flushCollectionCache(); 084 } 085 /** 086 * @apilevel internal 087 * @declaredat ASTNode:46 088 */ 089 public void flushRewriteCache() { 090 super.flushRewriteCache(); 091 } 092 /** 093 * @apilevel internal 094 * @declaredat ASTNode:52 095 */ 096 public StaticImportDecl clone() throws CloneNotSupportedException { 097 StaticImportDecl node = (StaticImportDecl) 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:63 107 */ 108 @Deprecated 109 public abstract StaticImportDecl 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:71 116 */ 117 public abstract StaticImportDecl 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:79 125 */ 126 public abstract StaticImportDecl 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 * @attribute syn 155 * @aspect StaticImports 156 * @declaredat /home/jesper/git/extendj/java5/frontend/StaticImports.jrag:95 157 */ 158 @ASTNodeAnnotation.Attribute 159 public abstract TypeDecl type(); 160 /** 161 * @apilevel internal 162 */ 163 protected java.util.Map importedTypes_String_values; 164 /** 165 * @apilevel internal 166 */ 167 private void importedTypes_String_reset() { 168 importedTypes_String_values = null; 169 } 170 /** 171 * @attribute syn 172 * @aspect TypeScopePropagation 173 * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:420 174 */ 175 @ASTNodeAnnotation.Attribute 176 public SimpleSet importedTypes(String name) { 177 Object _parameters = name; 178 if (importedTypes_String_values == null) importedTypes_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 179 ASTNode$State state = state(); 180 if (importedTypes_String_values.containsKey(_parameters)) { 181 return (SimpleSet) importedTypes_String_values.get(_parameters); 182 } 183 boolean intermediate = state.INTERMEDIATE_VALUE; 184 state.INTERMEDIATE_VALUE = false; 185 int num = state.boundariesCrossed; 186 boolean isFinal = this.is$Final(); 187 SimpleSet importedTypes_String_value = importedTypes_compute(name); 188 if (isFinal && num == state().boundariesCrossed) { 189 importedTypes_String_values.put(_parameters, importedTypes_String_value); 190 } else { 191 } 192 state.INTERMEDIATE_VALUE |= intermediate; 193 194 return importedTypes_String_value; 195 } 196 /** 197 * @apilevel internal 198 */ 199 private SimpleSet importedTypes_compute(String name) { 200 SimpleSet set = SimpleSet.emptySet; 201 for (Iterator iter = type().memberTypes(name).iterator(); iter.hasNext(); ) { 202 TypeDecl decl = (TypeDecl) iter.next(); 203 if (decl.isStatic() && decl.accessibleFromPackage(packageName())) { 204 set = set.add(decl); 205 } 206 } 207 return set; 208 } 209 /** 210 * @apilevel internal 211 */ 212 protected java.util.Map importedFields_String_values; 213 /** 214 * @apilevel internal 215 */ 216 private void importedFields_String_reset() { 217 importedFields_String_values = null; 218 } 219 /** 220 * @attribute syn 221 * @aspect StaticImports 222 * @declaredat /home/jesper/git/extendj/java5/frontend/StaticImports.jrag:55 223 */ 224 @ASTNodeAnnotation.Attribute 225 public SimpleSet importedFields(String name) { 226 Object _parameters = name; 227 if (importedFields_String_values == null) importedFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 228 ASTNode$State state = state(); 229 if (importedFields_String_values.containsKey(_parameters)) { 230 return (SimpleSet) importedFields_String_values.get(_parameters); 231 } 232 boolean intermediate = state.INTERMEDIATE_VALUE; 233 state.INTERMEDIATE_VALUE = false; 234 int num = state.boundariesCrossed; 235 boolean isFinal = this.is$Final(); 236 SimpleSet importedFields_String_value = importedFields_compute(name); 237 if (isFinal && num == state().boundariesCrossed) { 238 importedFields_String_values.put(_parameters, importedFields_String_value); 239 } else { 240 } 241 state.INTERMEDIATE_VALUE |= intermediate; 242 243 return importedFields_String_value; 244 } 245 /** 246 * @apilevel internal 247 */ 248 private SimpleSet importedFields_compute(String name) { 249 SimpleSet set = SimpleSet.emptySet; 250 for (Iterator iter = type().memberFields(name).iterator(); iter.hasNext(); ) { 251 FieldDeclaration decl = (FieldDeclaration) iter.next(); 252 if (decl.isStatic() && 253 (decl.isPublic() || (!decl.isPrivate() && decl.hostType().topLevelType().packageName().equals(packageName())))) 254 set = set.add(decl); 255 } 256 return set; 257 } 258 /** 259 * @apilevel internal 260 */ 261 protected java.util.Map importedMethods_String_values; 262 /** 263 * @apilevel internal 264 */ 265 private void importedMethods_String_reset() { 266 importedMethods_String_values = null; 267 } 268 /** 269 * @attribute syn 270 * @aspect StaticImports 271 * @declaredat /home/jesper/git/extendj/java5/frontend/StaticImports.jrag:75 272 */ 273 @ASTNodeAnnotation.Attribute 274 public Collection importedMethods(String name) { 275 Object _parameters = name; 276 if (importedMethods_String_values == null) importedMethods_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap()); 277 ASTNode$State state = state(); 278 if (importedMethods_String_values.containsKey(_parameters)) { 279 return (Collection) importedMethods_String_values.get(_parameters); 280 } 281 boolean intermediate = state.INTERMEDIATE_VALUE; 282 state.INTERMEDIATE_VALUE = false; 283 int num = state.boundariesCrossed; 284 boolean isFinal = this.is$Final(); 285 Collection importedMethods_String_value = importedMethods_compute(name); 286 if (isFinal && num == state().boundariesCrossed) { 287 importedMethods_String_values.put(_parameters, importedMethods_String_value); 288 } else { 289 } 290 state.INTERMEDIATE_VALUE |= intermediate; 291 292 return importedMethods_String_value; 293 } 294 /** 295 * @apilevel internal 296 */ 297 private Collection importedMethods_compute(String name) { 298 Collection set = new HashSet(); 299 for (Iterator iter = type().memberMethods(name).iterator(); iter.hasNext(); ) { 300 MethodDecl decl = (MethodDecl) iter.next(); 301 if (decl.isStatic() && 302 (decl.isPublic() || (!decl.isPrivate() && decl.hostType().topLevelType().packageName().equals(packageName())))) 303 set.add(decl); 304 } 305 return set; 306 } 307 /** 308 * @apilevel internal 309 */ 310 public ASTNode rewriteTo() { 311 return super.rewriteTo(); 312 } 313 }