1/* 2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 3 * 4 * This code is free software; you can redistribute it and/or modify it 5 * under the terms of the GNU General Public License version 2 only, as 6 * published by the Free Software Foundation. Oracle designates this 7 * particular file as subject to the "Classpath" exception as provided 8 * by Oracle in the LICENSE file that accompanied this code. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 */ 24 25/* 26 * This file is available under and governed by the GNU General Public 27 * License version 2 only, as published by the Free Software Foundation. 28 * However, the following notice accompanied the original version of this 29 * file: 30 * 31 * ASM: a very small and fast Java bytecode manipulation framework 32 * Copyright (c) 2000-2013 INRIA, France Telecom 33 * All rights reserved. 34 * 35 * Redistribution and use in source and binary forms, with or without 36 * modification, are permitted provided that the following conditions 37 * are met: 38 * 1. Redistributions of source code must retain the above copyright 39 * notice, this list of conditions and the following disclaimer. 40 * 2. Redistributions in binary form must reproduce the above copyright 41 * notice, this list of conditions and the following disclaimer in the 42 * documentation and/or other materials provided with the distribution. 43 * 3. Neither the name of the copyright holders nor the names of its 44 * contributors may be used to endorse or promote products derived from 45 * this software without specific prior written permission. 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 48 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 50 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 51 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 52 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 53 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 54 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 55 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 56 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 57 * THE POSSIBILITY OF SUCH DAMAGE. 58 */ 59 60package jdk.internal.org.objectweb.asm; 61 62/** 63 * A reference to a type appearing in a class, field or method declaration, or 64 * on an instruction. Such a reference designates the part of the class where 65 * the referenced type is appearing (e.g. an 'extends', 'implements' or 'throws' 66 * clause, a 'new' instruction, a 'catch' clause, a type cast, a local variable 67 * declaration, etc). 68 * 69 * @author Eric Bruneton 70 */ 71public class TypeReference { 72 73 /** 74 * The sort of type references that target a type parameter of a generic 75 * class. See {@link #getSort getSort}. 76 */ 77 public final static int CLASS_TYPE_PARAMETER = 0x00; 78 79 /** 80 * The sort of type references that target a type parameter of a generic 81 * method. See {@link #getSort getSort}. 82 */ 83 public final static int METHOD_TYPE_PARAMETER = 0x01; 84 85 /** 86 * The sort of type references that target the super class of a class or one 87 * of the interfaces it implements. See {@link #getSort getSort}. 88 */ 89 public final static int CLASS_EXTENDS = 0x10; 90 91 /** 92 * The sort of type references that target a bound of a type parameter of a 93 * generic class. See {@link #getSort getSort}. 94 */ 95 public final static int CLASS_TYPE_PARAMETER_BOUND = 0x11; 96 97 /** 98 * The sort of type references that target a bound of a type parameter of a 99 * generic method. See {@link #getSort getSort}. 100 */ 101 public final static int METHOD_TYPE_PARAMETER_BOUND = 0x12; 102 103 /** 104 * The sort of type references that target the type of a field. See 105 * {@link #getSort getSort}. 106 */ 107 public final static int FIELD = 0x13; 108 109 /** 110 * The sort of type references that target the return type of a method. See 111 * {@link #getSort getSort}. 112 */ 113 public final static int METHOD_RETURN = 0x14; 114 115 /** 116 * The sort of type references that target the receiver type of a method. 117 * See {@link #getSort getSort}. 118 */ 119 public final static int METHOD_RECEIVER = 0x15; 120 121 /** 122 * The sort of type references that target the type of a formal parameter of 123 * a method. See {@link #getSort getSort}. 124 */ 125 public final static int METHOD_FORMAL_PARAMETER = 0x16; 126 127 /** 128 * The sort of type references that target the type of an exception declared 129 * in the throws clause of a method. See {@link #getSort getSort}. 130 */ 131 public final static int THROWS = 0x17; 132 133 /** 134 * The sort of type references that target the type of a local variable in a 135 * method. See {@link #getSort getSort}. 136 */ 137 public final static int LOCAL_VARIABLE = 0x40; 138 139 /** 140 * The sort of type references that target the type of a resource variable 141 * in a method. See {@link #getSort getSort}. 142 */ 143 public final static int RESOURCE_VARIABLE = 0x41; 144 145 /** 146 * The sort of type references that target the type of the exception of a 147 * 'catch' clause in a method. See {@link #getSort getSort}. 148 */ 149 public final static int EXCEPTION_PARAMETER = 0x42; 150 151 /** 152 * The sort of type references that target the type declared in an 153 * 'instanceof' instruction. See {@link #getSort getSort}. 154 */ 155 public final static int INSTANCEOF = 0x43; 156 157 /** 158 * The sort of type references that target the type of the object created by 159 * a 'new' instruction. See {@link #getSort getSort}. 160 */ 161 public final static int NEW = 0x44; 162 163 /** 164 * The sort of type references that target the receiver type of a 165 * constructor reference. See {@link #getSort getSort}. 166 */ 167 public final static int CONSTRUCTOR_REFERENCE = 0x45; 168 169 /** 170 * The sort of type references that target the receiver type of a method 171 * reference. See {@link #getSort getSort}. 172 */ 173 public final static int METHOD_REFERENCE = 0x46; 174 175 /** 176 * The sort of type references that target the type declared in an explicit 177 * or implicit cast instruction. See {@link #getSort getSort}. 178 */ 179 public final static int CAST = 0x47; 180 181 /** 182 * The sort of type references that target a type parameter of a generic 183 * constructor in a constructor call. See {@link #getSort getSort}. 184 */ 185 public final static int CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT = 0x48; 186 187 /** 188 * The sort of type references that target a type parameter of a generic 189 * method in a method call. See {@link #getSort getSort}. 190 */ 191 public final static int METHOD_INVOCATION_TYPE_ARGUMENT = 0x49; 192 193 /** 194 * The sort of type references that target a type parameter of a generic 195 * constructor in a constructor reference. See {@link #getSort getSort}. 196 */ 197 public final static int CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT = 0x4A; 198 199 /** 200 * The sort of type references that target a type parameter of a generic 201 * method in a method reference. See {@link #getSort getSort}. 202 */ 203 public final static int METHOD_REFERENCE_TYPE_ARGUMENT = 0x4B; 204 205 /** 206 * The type reference value in Java class file format. 207 */ 208 private int value; 209 210 /** 211 * Creates a new TypeReference. 212 * 213 * @param typeRef 214 * the int encoded value of the type reference, as received in a 215 * visit method related to type annotations, like 216 * visitTypeAnnotation. 217 */ 218 public TypeReference(int typeRef) { 219 this.value = typeRef; 220 } 221 222 /** 223 * Returns a type reference of the given sort. 224 * 225 * @param sort 226 * {@link #FIELD FIELD}, {@link #METHOD_RETURN METHOD_RETURN}, 227 * {@link #METHOD_RECEIVER METHOD_RECEIVER}, 228 * {@link #LOCAL_VARIABLE LOCAL_VARIABLE}, 229 * {@link #RESOURCE_VARIABLE RESOURCE_VARIABLE}, 230 * {@link #INSTANCEOF INSTANCEOF}, {@link #NEW NEW}, 231 * {@link #CONSTRUCTOR_REFERENCE CONSTRUCTOR_REFERENCE}, or 232 * {@link #METHOD_REFERENCE METHOD_REFERENCE}. 233 * @return a type reference of the given sort. 234 */ 235 public static TypeReference newTypeReference(int sort) { 236 return new TypeReference(sort << 24); 237 } 238 239 /** 240 * Returns a reference to a type parameter of a generic class or method. 241 * 242 * @param sort 243 * {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER} or 244 * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}. 245 * @param paramIndex 246 * the type parameter index. 247 * @return a reference to the given generic class or method type parameter. 248 */ 249 public static TypeReference newTypeParameterReference(int sort, 250 int paramIndex) { 251 return new TypeReference((sort << 24) | (paramIndex << 16)); 252 } 253 254 /** 255 * Returns a reference to a type parameter bound of a generic class or 256 * method. 257 * 258 * @param sort 259 * {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER} or 260 * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}. 261 * @param paramIndex 262 * the type parameter index. 263 * @param boundIndex 264 * the type bound index within the above type parameters. 265 * @return a reference to the given generic class or method type parameter 266 * bound. 267 */ 268 public static TypeReference newTypeParameterBoundReference(int sort, 269 int paramIndex, int boundIndex) { 270 return new TypeReference((sort << 24) | (paramIndex << 16) 271 | (boundIndex << 8)); 272 } 273 274 /** 275 * Returns a reference to the super class or to an interface of the 276 * 'implements' clause of a class. 277 * 278 * @param itfIndex 279 * the index of an interface in the 'implements' clause of a 280 * class, or -1 to reference the super class of the class. 281 * @return a reference to the given super type of a class. 282 */ 283 public static TypeReference newSuperTypeReference(int itfIndex) { 284 itfIndex &= 0xFFFF; 285 return new TypeReference((CLASS_EXTENDS << 24) | (itfIndex << 8)); 286 } 287 288 /** 289 * Returns a reference to the type of a formal parameter of a method. 290 * 291 * @param paramIndex 292 * the formal parameter index. 293 * 294 * @return a reference to the type of the given method formal parameter. 295 */ 296 public static TypeReference newFormalParameterReference(int paramIndex) { 297 return new TypeReference((METHOD_FORMAL_PARAMETER << 24) 298 | (paramIndex << 16)); 299 } 300 301 /** 302 * Returns a reference to the type of an exception, in a 'throws' clause of 303 * a method. 304 * 305 * @param exceptionIndex 306 * the index of an exception in a 'throws' clause of a method. 307 * 308 * @return a reference to the type of the given exception. 309 */ 310 public static TypeReference newExceptionReference(int exceptionIndex) { 311 return new TypeReference((THROWS << 24) | (exceptionIndex << 8)); 312 } 313 314 /** 315 * Returns a reference to the type of the exception declared in a 'catch' 316 * clause of a method. 317 * 318 * @param tryCatchBlockIndex 319 * the index of a try catch block (using the order in which they 320 * are visited with visitTryCatchBlock). 321 * 322 * @return a reference to the type of the given exception. 323 */ 324 public static TypeReference newTryCatchReference(int tryCatchBlockIndex) { 325 return new TypeReference((EXCEPTION_PARAMETER << 24) 326 | (tryCatchBlockIndex << 8)); 327 } 328 329 /** 330 * Returns a reference to the type of a type argument in a constructor or 331 * method call or reference. 332 * 333 * @param sort 334 * {@link #CAST CAST}, 335 * {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT 336 * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT}, 337 * {@link #METHOD_INVOCATION_TYPE_ARGUMENT 338 * METHOD_INVOCATION_TYPE_ARGUMENT}, 339 * {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT 340 * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or 341 * {@link #METHOD_REFERENCE_TYPE_ARGUMENT 342 * METHOD_REFERENCE_TYPE_ARGUMENT}. 343 * @param argIndex 344 * the type argument index. 345 * 346 * @return a reference to the type of the given type argument. 347 */ 348 public static TypeReference newTypeArgumentReference(int sort, int argIndex) { 349 return new TypeReference((sort << 24) | argIndex); 350 } 351 352 /** 353 * Returns the sort of this type reference. 354 * 355 * @return {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER}, 356 * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}, 357 * {@link #CLASS_EXTENDS CLASS_EXTENDS}, 358 * {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND}, 359 * {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND}, 360 * {@link #FIELD FIELD}, {@link #METHOD_RETURN METHOD_RETURN}, 361 * {@link #METHOD_RECEIVER METHOD_RECEIVER}, 362 * {@link #METHOD_FORMAL_PARAMETER METHOD_FORMAL_PARAMETER}, 363 * {@link #THROWS THROWS}, {@link #LOCAL_VARIABLE LOCAL_VARIABLE}, 364 * {@link #RESOURCE_VARIABLE RESOURCE_VARIABLE}, 365 * {@link #EXCEPTION_PARAMETER EXCEPTION_PARAMETER}, 366 * {@link #INSTANCEOF INSTANCEOF}, {@link #NEW NEW}, 367 * {@link #CONSTRUCTOR_REFERENCE CONSTRUCTOR_REFERENCE}, 368 * {@link #METHOD_REFERENCE METHOD_REFERENCE}, {@link #CAST CAST}, 369 * {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT 370 * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT}, 371 * {@link #METHOD_INVOCATION_TYPE_ARGUMENT 372 * METHOD_INVOCATION_TYPE_ARGUMENT}, 373 * {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT 374 * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or 375 * {@link #METHOD_REFERENCE_TYPE_ARGUMENT 376 * METHOD_REFERENCE_TYPE_ARGUMENT}. 377 */ 378 public int getSort() { 379 return value >>> 24; 380 } 381 382 /** 383 * Returns the index of the type parameter referenced by this type 384 * reference. This method must only be used for type references whose sort 385 * is {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER}, 386 * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}, 387 * {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND} or 388 * {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND}. 389 * 390 * @return a type parameter index. 391 */ 392 public int getTypeParameterIndex() { 393 return (value & 0x00FF0000) >> 16; 394 } 395 396 /** 397 * Returns the index of the type parameter bound, within the type parameter 398 * {@link #getTypeParameterIndex}, referenced by this type reference. This 399 * method must only be used for type references whose sort is 400 * {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND} or 401 * {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND}. 402 * 403 * @return a type parameter bound index. 404 */ 405 public int getTypeParameterBoundIndex() { 406 return (value & 0x0000FF00) >> 8; 407 } 408 409 /** 410 * Returns the index of the "super type" of a class that is referenced by 411 * this type reference. This method must only be used for type references 412 * whose sort is {@link #CLASS_EXTENDS CLASS_EXTENDS}. 413 * 414 * @return the index of an interface in the 'implements' clause of a class, 415 * or -1 if this type reference references the type of the super 416 * class. 417 */ 418 public int getSuperTypeIndex() { 419 return (short) ((value & 0x00FFFF00) >> 8); 420 } 421 422 /** 423 * Returns the index of the formal parameter whose type is referenced by 424 * this type reference. This method must only be used for type references 425 * whose sort is {@link #METHOD_FORMAL_PARAMETER METHOD_FORMAL_PARAMETER}. 426 * 427 * @return a formal parameter index. 428 */ 429 public int getFormalParameterIndex() { 430 return (value & 0x00FF0000) >> 16; 431 } 432 433 /** 434 * Returns the index of the exception, in a 'throws' clause of a method, 435 * whose type is referenced by this type reference. This method must only be 436 * used for type references whose sort is {@link #THROWS THROWS}. 437 * 438 * @return the index of an exception in the 'throws' clause of a method. 439 */ 440 public int getExceptionIndex() { 441 return (value & 0x00FFFF00) >> 8; 442 } 443 444 /** 445 * Returns the index of the try catch block (using the order in which they 446 * are visited with visitTryCatchBlock), whose 'catch' type is referenced by 447 * this type reference. This method must only be used for type references 448 * whose sort is {@link #EXCEPTION_PARAMETER EXCEPTION_PARAMETER} . 449 * 450 * @return the index of an exception in the 'throws' clause of a method. 451 */ 452 public int getTryCatchBlockIndex() { 453 return (value & 0x00FFFF00) >> 8; 454 } 455 456 /** 457 * Returns the index of the type argument referenced by this type reference. 458 * This method must only be used for type references whose sort is 459 * {@link #CAST CAST}, {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT 460 * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT}, 461 * {@link #METHOD_INVOCATION_TYPE_ARGUMENT METHOD_INVOCATION_TYPE_ARGUMENT}, 462 * {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT 463 * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or 464 * {@link #METHOD_REFERENCE_TYPE_ARGUMENT METHOD_REFERENCE_TYPE_ARGUMENT}. 465 * 466 * @return a type parameter index. 467 */ 468 public int getTypeArgumentIndex() { 469 return value & 0xFF; 470 } 471 472 /** 473 * Returns the int encoded value of this type reference, suitable for use in 474 * visit methods related to type annotations, like visitTypeAnnotation. 475 * 476 * @return the int encoded value of this type reference. 477 */ 478 public int getValue() { 479 return value; 480 } 481} 482