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 
  60 package 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  */
  71 public 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 static final 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 }