1 /* 2 * Copyright 2005-2006 Sun Microsystems, Inc. All Rights Reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Sun designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Sun in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 22 * CA 95054 USA or visit www.sun.com if you need additional information or 23 * have any questions. 24 */ 25 26 package javax.lang.model.util; 27 28 import javax.lang.model.element.*; 29 import static javax.lang.model.element.ElementKind.*; 30 import javax.annotation.processing.SupportedSourceVersion; 31 import static javax.lang.model.SourceVersion.*; 32 import javax.lang.model.SourceVersion; 33 34 35 /** 36 * A visitor of program elements based on their {@linkplain 37 * ElementKind kind} with default behavior appropriate for the {@link 38 * SourceVersion#RELEASE_6 RELEASE_6} source version. For {@linkplain 39 * Element elements} <tt><i>XYZ</i></tt> that may have more than one 40 * kind, the <tt>visit<i>XYZ</i></tt> methods in this class delegate 41 * to the <tt>visit<i>XYZKind</i></tt> method corresponding to the 42 * first argument's kind. The <tt>visit<i>XYZKind</i></tt> methods 43 * call {@link #defaultAction defaultAction}, passing their arguments 44 * to {@code defaultAction}'s corresponding parameters. 45 * 46 * <p> Methods in this class may be overridden subject to their 47 * general contract. Note that annotating methods in concrete 48 * subclasses with {@link java.lang.Override @Override} will help 49 * ensure that methods are overridden as intended. 50 * 51 * <p> <b>WARNING:</b> The {@code ElementVisitor} interface 52 * implemented by this class may have methods added to it or the 53 * {@code ElementKind} {@code enum} used in this case may have 54 * constants added to it in the future to accommodate new, currently 55 * unknown, language structures added to future versions of the 56 * Java™ programming language. Therefore, methods whose names 57 * begin with {@code "visit"} may be added to this class in the 58 * future; to avoid incompatibilities, classes which extend this class 59 * should not declare any instance methods with names beginning with 60 * {@code "visit"}. 61 * 62 * <p>When such a new visit method is added, the default 63 * implementation in this class will be to call the {@link 64 * #visitUnknown visitUnknown} method. A new abstract element kind 65 * visitor class will also be introduced to correspond to the new 66 * language level; this visitor will have different default behavior 67 * for the visit method in question. When the new visitor is 68 * introduced, all or portions of this visitor may be deprecated. 69 * 70 * @param <R> the return type of this visitor's methods. Use {@link 71 * Void} for visitors that do not need to return results. 72 * @param <P> the type of the additional parameter to this visitor's 73 * methods. Use {@code Void} for visitors that do not need an 74 * additional parameter. 75 * 76 * @author Joseph D. Darcy 77 * @author Scott Seligman 78 * @author Peter von der Ahé 79 * @since 1.6 80 */ 81 @SupportedSourceVersion(RELEASE_6) 82 public class ElementKindVisitor6<R, P> 83 extends SimpleElementVisitor6<R, P> { 84 /** 85 * Constructor for concrete subclasses; uses {@code null} for the 86 * default value. 87 */ 88 protected ElementKindVisitor6() { 89 super(null); 90 } 91 92 /** 93 * Constructor for concrete subclasses; uses the argument for the 94 * default value. 95 * 96 * @param defaultValue the value to assign to {@link #DEFAULT_VALUE} 97 */ 98 protected ElementKindVisitor6(R defaultValue) { 99 super(defaultValue); 100 } 101 102 /** 103 * {@inheritDoc} 104 * 105 * The element argument has kind {@code PACKAGE}. 106 * 107 * @param e {@inheritDoc} 108 * @param p {@inheritDoc} 109 * @return {@inheritDoc} 110 */ 111 @Override 112 public R visitPackage(PackageElement e, P p) { 113 assert e.getKind() == PACKAGE: "Bad kind on PackageElement"; 114 return defaultAction(e, p); 115 } 116 117 /** 118 * Visits a type element, dispatching to the visit method for the 119 * specific {@linkplain ElementKind kind} of type, {@code 120 * ANNOTATION_TYPE}, {@code CLASS}, {@code ENUM}, or {@code 121 * INTERFACE}. 122 * 123 * @param e {@inheritDoc} 124 * @param p {@inheritDoc} 125 * @return the result of the kind-specific visit method 126 */ 127 @Override 128 public R visitType(TypeElement e, P p) { 129 ElementKind k = e.getKind(); 130 switch(k) { 131 case ANNOTATION_TYPE: 132 return visitTypeAsAnnotationType(e, p); 133 134 case CLASS: 135 return visitTypeAsClass(e, p); 136 137 case ENUM: 138 return visitTypeAsEnum(e, p); 139 140 case INTERFACE: 141 return visitTypeAsInterface(e, p); 142 143 default: 144 throw new AssertionError("Bad kind " + k + " for TypeElement" + e); 145 } 146 } 147 148 /** 149 * Visits an {@code ANNOTATION_TYPE} type element by calling 150 * {@code defaultAction}. 151 * 152 * @param e the element to visit 153 * @param p a visitor-specified parameter 154 * @return the result of {@code defaultAction} 155 */ 156 public R visitTypeAsAnnotationType(TypeElement e, P p) { 157 return defaultAction(e, p); 158 } 159 160 /** 161 * Visits a {@code CLASS} type element by calling {@code 162 * defaultAction}. 163 * 164 * @param e the element to visit 165 * @param p a visitor-specified parameter 166 * @return the result of {@code defaultAction} 167 */ 168 public R visitTypeAsClass(TypeElement e, P p) { 169 return defaultAction(e, p); 170 } 171 172 /** 173 * Visits an {@code ENUM} type element by calling {@code 174 * defaultAction}. 175 * 176 * @param e the element to visit 177 * @param p a visitor-specified parameter 178 * @return the result of {@code defaultAction} 179 */ 180 public R visitTypeAsEnum(TypeElement e, P p) { 181 return defaultAction(e, p); 182 } 183 184 /** 185 * Visits an {@code INTERFACE} type element by calling {@code 186 * defaultAction}. 187 *. 188 * @param e the element to visit 189 * @param p a visitor-specified parameter 190 * @return the result of {@code defaultAction} 191 */ 192 public R visitTypeAsInterface(TypeElement e, P p) { 193 return defaultAction(e, p); 194 } 195 196 /** 197 * Visits a variable element, dispatching to the visit method for 198 * the specific {@linkplain ElementKind kind} of variable, {@code 199 * ENUM_CONSTANT}, {@code EXCEPTION_PARAMETER}, {@code FIELD}, 200 * {@code LOCAL_VARIABLE}, or {@code PARAMETER}. 201 * @param e {@inheritDoc} 202 * @param p {@inheritDoc} 203 * @return the result of the kind-specific visit method 204 */ 205 @Override 206 public R visitVariable(VariableElement e, P p) { 207 ElementKind k = e.getKind(); 208 switch(k) { 209 case ENUM_CONSTANT: 210 return visitVariableAsEnumConstant(e, p); 211 212 case EXCEPTION_PARAMETER: 213 return visitVariableAsExceptionParameter(e, p); 214 215 case FIELD: 216 return visitVariableAsField(e, p); 217 218 case LOCAL_VARIABLE: 219 return visitVariableAsLocalVariable(e, p); 220 221 case PARAMETER: 222 return visitVariableAsParameter(e, p); 223 224 default: 225 throw new AssertionError("Bad kind " + k + " for VariableElement" + e); 226 } 227 228 } 229 230 /** 231 * Visits an {@code ENUM_CONSTANT} variable element by calling 232 * {@code defaultAction}. 233 * 234 * @param e the element to visit 235 * @param p a visitor-specified parameter 236 * @return the result of {@code defaultAction} 237 */ 238 public R visitVariableAsEnumConstant(VariableElement e, P p) { 239 return defaultAction(e, p); 240 } 241 242 /** 243 * Visits an {@code EXCEPTION_PARAMETER} variable element by calling 244 * {@code defaultAction}. 245 * 246 * @param e the element to visit 247 * @param p a visitor-specified parameter 248 * @return the result of {@code defaultAction} 249 */ 250 public R visitVariableAsExceptionParameter(VariableElement e, P p) { 251 return defaultAction(e, p); 252 } 253 254 /** 255 * Visits a {@code FIELD} variable element by calling 256 * {@code defaultAction}. 257 * 258 * @param e the element to visit 259 * @param p a visitor-specified parameter 260 * @return the result of {@code defaultAction} 261 */ 262 public R visitVariableAsField(VariableElement e, P p) { 263 return defaultAction(e, p); 264 } 265 266 /** 267 * Visits a {@code LOCAL_VARIABLE} variable element by calling 268 * {@code defaultAction}. 269 * 270 * @param e the element to visit 271 * @param p a visitor-specified parameter 272 * @return the result of {@code defaultAction} 273 */ 274 public R visitVariableAsLocalVariable(VariableElement e, P p) { 275 return defaultAction(e, p); 276 } 277 278 /** 279 * Visits a {@code PARAMETER} variable element by calling 280 * {@code defaultAction}. 281 * 282 * @param e the element to visit 283 * @param p a visitor-specified parameter 284 * @return the result of {@code defaultAction} 285 */ 286 public R visitVariableAsParameter(VariableElement e, P p) { 287 return defaultAction(e, p); 288 } 289 290 /** 291 * Visits an executable element, dispatching to the visit method 292 * for the specific {@linkplain ElementKind kind} of executable, 293 * {@code CONSTRUCTOR}, {@code INSTANCE_INIT}, {@code METHOD}, or 294 * {@code STATIC_INIT}. 295 * 296 * @param e {@inheritDoc} 297 * @param p {@inheritDoc} 298 * @return the result of the kind-specific visit method 299 */ 300 @Override 301 public R visitExecutable(ExecutableElement e, P p) { 302 ElementKind k = e.getKind(); 303 switch(k) { 304 case CONSTRUCTOR: 305 return visitExecutableAsConstructor(e, p); 306 307 case INSTANCE_INIT: 308 return visitExecutableAsInstanceInit(e, p); 309 310 case METHOD: 311 return visitExecutableAsMethod(e, p); 312 313 case STATIC_INIT: 314 return visitExecutableAsStaticInit(e, p); 315 316 default: 317 throw new AssertionError("Bad kind " + k + " for ExecutableElement" + e); 318 } 319 } 320 321 /** 322 * Visits a {@code CONSTRUCTOR} executable element by calling 323 * {@code defaultAction}. 324 * 325 * @param e the element to visit 326 * @param p a visitor-specified parameter 327 * @return the result of {@code defaultAction} 328 */ 329 public R visitExecutableAsConstructor(ExecutableElement e, P p) { 330 return defaultAction(e, p); 331 } 332 333 /** 334 * Visits an {@code INSTANCE_INIT} executable element by calling 335 * {@code defaultAction}. 336 * 337 * @param e the element to visit 338 * @param p a visitor-specified parameter 339 * @return the result of {@code defaultAction} 340 */ 341 public R visitExecutableAsInstanceInit(ExecutableElement e, P p) { 342 return defaultAction(e, p); 343 } 344 345 /** 346 * Visits a {@code METHOD} executable element by calling 347 * {@code defaultAction}. 348 * 349 * @param e the element to visit 350 * @param p a visitor-specified parameter 351 * @return the result of {@code defaultAction} 352 */ 353 public R visitExecutableAsMethod(ExecutableElement e, P p) { 354 return defaultAction(e, p); 355 } 356 357 /** 358 * Visits a {@code STATIC_INIT} executable element by calling 359 * {@code defaultAction}. 360 * 361 * @param e the element to visit 362 * @param p a visitor-specified parameter 363 * @return the result of {@code defaultAction} 364 */ 365 public R visitExecutableAsStaticInit(ExecutableElement e, P p) { 366 return defaultAction(e, p); 367 } 368 369 370 /** 371 * {@inheritDoc} 372 * 373 * The element argument has kind {@code TYPE_PARAMETER}. 374 * 375 * @param e {@inheritDoc} 376 * @param p {@inheritDoc} 377 * @return {@inheritDoc} 378 */ 379 @Override 380 public R visitTypeParameter(TypeParameterElement e, P p) { 381 assert e.getKind() == TYPE_PARAMETER: "Bad kind on TypeParameterElement"; 382 return defaultAction(e, p); 383 } 384 }