1 /*
   2  * Copyright (c) 2005, 2019, Oracle and/or its affiliates. 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.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package javax.lang.model.element;
  27 
  28 
  29 import java.lang.annotation.Annotation;
  30 import java.lang.annotation.AnnotationTypeMismatchException;
  31 import java.lang.annotation.IncompleteAnnotationException;
  32 import java.util.List;
  33 import java.util.Set;
  34 
  35 import javax.lang.model.type.*;
  36 import javax.lang.model.util.*;
  37 
  38 
  39 /**
  40  * Represents a program element such as a module, package, class, or method.
  41  * Each element represents a static, language-level construct
  42  * (and not, for example, a runtime construct of the virtual machine).
  43  *
  44  * <p> Elements should be compared using the {@link #equals(Object)}
  45  * method.  There is no guarantee that any particular element will
  46  * always be represented by the same object.
  47  *
  48  * <p> To implement operations based on the class of an {@code
  49  * Element} object, either use a {@linkplain ElementVisitor visitor} or
  50  * use the result of the {@link #getKind} method.  Using {@code
  51  * instanceof} is <em>not</em> necessarily a reliable idiom for
  52  * determining the effective class of an object in this modeling
  53  * hierarchy since an implementation may choose to have a single object
  54  * implement multiple {@code Element} subinterfaces.
  55  *
  56  * @author Joseph D. Darcy
  57  * @author Scott Seligman
  58  * @author Peter von der Ah&eacute;
  59  * @see Elements
  60  * @see TypeMirror
  61  * @since 1.6
  62  */
  63 public interface Element extends javax.lang.model.AnnotatedConstruct {
  64     /**
  65      * Returns the type defined by this element.
  66      * @return the type defined by this element
  67      *
  68      * @see Types
  69      * @see ExecutableElement#asType
  70      * @see ModuleElement#asType
  71      * @see PackageElement#asType
  72      * @see TypeElement#asType
  73      * @see TypeParameterElement#asType
  74      * @see VariableElement#asType
  75      */
  76     TypeMirror asType();
  77 
  78     /**
  79      * Returns the {@code kind} of this element.
  80      *
  81      * @return the kind of this element
  82      */
  83     ElementKind getKind();
  84 
  85     /**
  86      * Returns the modifiers of this element, excluding annotations.
  87      * Implicit modifiers, such as the {@code public} and {@code static}
  88      * modifiers of interface members, are included.
  89      *
  90      * @return the modifiers of this element, or an empty set if there are none
  91      */
  92     Set<Modifier> getModifiers();
  93 
  94     /**
  95      * Returns the simple (unqualified) name of this element.  The
  96      * name of a generic type does not include any reference to its
  97      * formal type parameters.
  98      *
  99      * For example, the simple name of the type element {@code
 100      * java.util.Set<E>} is {@code "Set"}.
 101      *
 102      * If this element represents an unnamed {@linkplain
 103      * PackageElement#getSimpleName package} or unnamed {@linkplain
 104      * ModuleElement#getSimpleName module}, an empty name is returned.
 105      *
 106      * If it represents a {@linkplain ExecutableElement#getSimpleName
 107      * constructor}, the name "{@code <init>}" is returned.  If it
 108      * represents a {@linkplain ExecutableElement#getSimpleName static
 109      * initializer}, the name "{@code <clinit>}" is returned.
 110      *
 111      * If it represents an {@linkplain TypeElement#getSimpleName
 112      * anonymous class} or {@linkplain ExecutableElement#getSimpleName
 113      * instance initializer}, an empty name is returned.
 114      *
 115      * @return the simple name of this element
 116      * @see PackageElement#getSimpleName
 117      * @see ExecutableElement#getSimpleName
 118      * @see TypeElement#getSimpleName
 119      * @see VariableElement#getSimpleName
 120      * @see ModuleElement#getSimpleName
 121      * @revised 9
 122      * @spec JPMS
 123      */
 124     Name getSimpleName();
 125 
 126     /**
 127      * Returns the innermost element
 128      * within which this element is, loosely speaking, enclosed.
 129      * <ul>
 130      * <li> If this element is one whose declaration is lexically enclosed
 131      * immediately within the declaration of another element, that other
 132      * element is returned.
 133      *
 134      * <li> If this is a {@linkplain TypeElement#getEnclosingElement
 135      * top-level type}, its package is returned.
 136      *
 137      * <li> If this is a {@linkplain
 138      * PackageElement#getEnclosingElement package}, its module is
 139      * returned if such a module exists. Otherwise, {@code null} is returned.
 140      *
 141      * <li> If this is a {@linkplain
 142      * TypeParameterElement#getEnclosingElement type parameter},
 143      * {@linkplain TypeParameterElement#getGenericElement the
 144      * generic element} of the type parameter is returned.
 145      *
 146      * <li> If this is a {@linkplain
 147      * VariableElement#getEnclosingElement method or constructor
 148      * parameter}, {@linkplain ExecutableElement the executable
 149      * element} which declares the parameter is returned.
 150      *
 151      * <li> If this is a {@linkplain ModuleElement#getEnclosingElement
 152      * module}, {@code null} is returned.
 153      *
 154      * </ul>
 155      *
 156      * @return the enclosing element, or {@code null} if there is none
 157      * @see Elements#getPackageOf
 158      * @revised 9
 159      * @spec JPMS
 160      */
 161     Element getEnclosingElement();
 162 
 163     /**
 164      * Returns the elements that are, loosely speaking, directly
 165      * enclosed by this element.
 166      *
 167      * A {@linkplain TypeElement#getEnclosedElements class or
 168      * interface} is considered to enclose the fields, methods,
 169      * constructors, and member types that it directly declares.
 170      *
 171      * A {@linkplain PackageElement#getEnclosedElements package}
 172      * encloses the top-level classes and interfaces within it, but is
 173      * not considered to enclose subpackages.
 174      *
 175      * A {@linkplain ModuleElement#getEnclosedElements module}
 176      * encloses packages within it.
 177      *
 178      * Enclosed elements may include implicitly declared {@linkplain
 179      * Elements.Origin#MANDATED mandated} elements.
 180      *
 181      * Other kinds of elements are not currently considered to enclose
 182      * any elements; however, that may change as this API or the
 183      * programming language evolves.
 184      *
 185      * @apiNote Elements of certain kinds can be isolated using
 186      * methods in {@link ElementFilter}.
 187      *
 188      * @return the enclosed elements, or an empty list if none
 189      * @see TypeElement#getEnclosedElements
 190      * @see PackageElement#getEnclosedElements
 191      * @see ModuleElement#getEnclosedElements
 192      * @see Elements#getAllMembers
 193      * @jls 8.8.9 Default Constructor
 194      * @jls 8.9 Enum Types
 195      * @revised 9
 196      * @spec JPMS
 197      */
 198     List<? extends Element> getEnclosedElements();
 199 
 200     /**
 201      * Returns {@code true} if the argument represents the same
 202      * element as {@code this}, or {@code false} otherwise.
 203      *
 204      * @apiNote The identity of an element involves implicit state
 205      * not directly accessible from the element's methods, including
 206      * state about the presence of unrelated types.  Element objects
 207      * created by different implementations of these interfaces should
 208      * <i>not</i> be expected to be equal even if &quot;the same&quot;
 209      * element is being modeled; this is analogous to the inequality
 210      * of {@code Class} objects for the same class file loaded through
 211      * different class loaders.
 212      *
 213      * @param obj  the object to be compared with this element
 214      * @return {@code true} if the specified object represents the same
 215      *          element as this
 216      */
 217     @Override
 218     boolean equals(Object obj);
 219 
 220     /**
 221      * Obeys the general contract of {@link Object#hashCode Object.hashCode}.
 222      *
 223      * @see #equals
 224      */
 225     @Override
 226     int hashCode();
 227 
 228 
 229     /**
 230      * {@inheritDoc}
 231      *
 232      * <p> To get inherited annotations as well, use {@link
 233      * Elements#getAllAnnotationMirrors(Element)
 234      * getAllAnnotationMirrors}.
 235      *
 236      * @since 1.6
 237      */
 238     @Override
 239     List<? extends AnnotationMirror> getAnnotationMirrors();
 240 
 241     /**
 242      * {@inheritDoc}
 243      * @since 1.6
 244      */
 245     @Override
 246     <A extends Annotation> A getAnnotation(Class<A> annotationType);
 247 
 248     /**
 249      * Applies a visitor to this element.
 250      *
 251      * @param <R> the return type of the visitor's methods
 252      * @param <P> the type of the additional parameter to the visitor's methods
 253      * @param v   the visitor operating on this element
 254      * @param p   additional parameter to the visitor
 255      * @return a visitor-specified result
 256      */
 257     <R, P> R accept(ElementVisitor<R, P> v, P p);
 258 }