Explain the javax.lang.model element and type model: Element vs TypeMirror, the main Element kinds, and the role of the Elements/Types utilities and the visitor pattern.
answer
- Element = declaration; TypeMirror = type; bridge via asType()/asElement()
- TypeElement(class) / ExecutableElement(method) / VariableElement(field,param)
- Never == or equals on TypeMirror — use Types.isSameType/isSubtype/erasure
- Elements util: getTypeElement, getAllMembers, getPackageOf
- Visitor pattern (Simple*Visitor) instead of getKind() if/else
basics
~20 sElement represents a declaration (a class, method, field), while TypeMirror represents a type (like List<String>). TypeElement is a class/interface, ExecutableElement a method, VariableElement a field/parameter. The Elements and Types helper objects answer questions about them, and visitors traverse them safely.
solid answer
~50 sDuring processing you never see the JDK's reflection Class objects — the source may not even be compiled yet — so you work with the abstract javax.lang.model. An Element is a static declaration: TypeElement (a class or interface), ExecutableElement (a method or constructor), VariableElement (a field, parameter, or enum constant), PackageElement, and TypeParameterElement. A TypeMirror is a use of a type, like List<String>, int, or void; you get it via element.asType() or return types. Because a TypeMirror can't be compared with == reliably, you use the injected Types utility (isSameType, isSubtype, erasure, asElement) and the Elements utility (getTypeElement by name, getPackageOf, getAllMembers, docs). To branch on element or type kind without long if/else on getKind(), you use the visitor pattern via ElementVisitor/TypeVisitor (typically SimpleElementVisitor/TypeKindVisitor). This model is deliberately lazy and partial because it must describe code that is still being compiled.
go deeper
Knows there is a special model for inspecting code at compile time and can name Element vs type.
Distinguishes Element from TypeMirror, names the main Element kinds, and uses getElementsAnnotatedWith results correctly.
Uses Elements/Types utilities correctly (no == on mirrors), bridges asType/asElement, and applies visitors for kind dispatch.
Reasons about the model's laziness/partiality for not-yet-compiled code, erasure pitfalls, generic type resolution, and designing robust visitors that survive new language constructs.
## Why a special model at all? When your processor runs, the program is *being compiled* — some classes may not exist as `.class` files yet, and types may reference still-ungenerated code. The familiar runtime **reflection** API (`java.lang.Class`, `Method`, `Field`) needs loaded classes, so it can't be used. Instead, javac exposes a compile-time, abstract description of the program in the **`javax.lang.model`** packages. Two orthogonal hierarchies live there: **Elements** and **TypeMirrors**. ## Element = a declaration (the 'what is written') An **`Element`** is a node representing something *declared* in source. Subtypes: - **`TypeElement`** — a class, interface, enum, or annotation type declaration. e.g. `com.example.User`. - **`ExecutableElement`** — a method, constructor, or annotation attribute. Exposes parameters, return type, thrown types, default value. - **`VariableElement`** — a field, method/constructor parameter, exception parameter, local variable, or enum constant. - **`PackageElement`** — a package. - **`TypeParameterElement`** — a generic type variable like `T`. - (Java 9+) **`ModuleElement`** — a module. Every element answers `getSimpleName()`, `getModifiers()` (public/abstract/static…), `getAnnotationMirrors()`, `getEnclosingElement()` (the class containing a method), and `getEnclosedElements()` (the members of a class). You navigate the program by walking enclosed/enclosing elements. ## TypeMirror = a type (the 'what type is it') A **`TypeMirror`** represents a *type*, which is a different thing from a declaration. `List<String>`, `int`, `String[]`, `void`, a wildcard `? extends Number`, the null type, and `T` are all TypeMirrors. Key subtypes/kinds: `DeclaredType` (class/interface uses, carries the type arguments), `PrimitiveType`, `ArrayType`, `TypeVariable`, `WildcardType`, `NoType` (e.g. `void`). **Element ↔ TypeMirror bridge**: `someElement.asType()` gives the type of a declaration; `((DeclaredType) typeMirror).asElement()` (or `Types.asElement`) goes back to the declaration. One `TypeElement` (`List`) can back many `TypeMirror`s (`List<String>`, `List<Integer>`). ## The two utility objects (from ProcessingEnvironment) Because Elements/TypeMirrors are abstract and **must not be compared with `==`/`equals`**, javac gives you helpers: - **`Elements`** (`elementUtils`): `getTypeElement("java.util.List")` (look up by name), `getPackageOf(e)`, `getAllMembers(typeElement)` (incl. inherited), `getDocComment(e)`, `getConstantExpression(...)`, `overrides(...)`. - **`Types`** (`typeUtils`): `isSameType(a, b)`, `isSubtype(a, b)`, `isAssignable(a, b)`, `erasure(t)` (strip generics), `asElement(t)`, `getDeclaredType(elem, args...)`, `boxedClass/unboxedType`. Example: to test whether a field's type is a `List`, you do not call `equals` — you compare with `types.isSameType(types.erasure(field.asType()), types.erasure(elements.getTypeElement("java.util.List").asType()))`. ## The visitor pattern Elements and TypeMirrors come in many kinds, and switching on `getKind()` with long if/else chains is fragile. The model ships the **visitor pattern**: `ElementVisitor<R,P>` / `TypeVisitor<R,P>`, with convenience bases `SimpleElementVisitor`, `ElementKindVisitor`, `SimpleTypeVisitor`, `TypeKindVisitor`. You call `element.accept(myVisitor, param)`; the right `visitType`/`visitExecutable`/`visitVariable` method fires. This is type-safe, exhaustive-by-default (the base classes have a `defaultAction`), and resilient when new kinds (records, sealed types, modules) are added — the base supplies sensible fallbacks. ## Mental model summary - **Element = the declaration** (what you wrote). **TypeMirror = the type** (how it's used). Bridge with `asType()`/`asElement()`. - Never `==`/`equals` on mirrors — use **Types/Elements** utilities. - Walk structure via `getEnclosed/EnclosingElement`; branch via **visitors**, not `getKind()` chains. This abstract, lazy model is what makes processors able to reason about code that doesn't fully exist yet.
- Why can't you compare two TypeMirror instances with equals()?TypeMirror equality is not defined by Object.equals for type-system semantics; two different instances can denote the same type. Use Types.isSameType (often after erasure) for a correct semantic comparison.
- How do you go from a method's VariableElement parameter back to information about its type's class?Call param.asType() to get the TypeMirror, then Types.asElement(typeMirror) (or cast to DeclaredType and asElement()) to get the TypeElement, whose members you can inspect.
- Why use the visitor pattern instead of switching on getKind()?Visitors are type-safe, give you the correctly-typed subinterface in each visit method, and the Simple*/Kind* base classes provide a defaultAction so new element/type kinds (records, modules) degrade gracefully instead of falling through unhandled.
saying these in an interview costs you the question
- Comparing TypeMirrors with == or .equals() instead of Types.isSameType
- Confusing Element (declaration) with TypeMirror (type use)
- Trying to use java.lang.reflect.Class during processing
- Assuming one TypeElement maps to exactly one TypeMirror (List backs List<String>, List<Integer>, ...)
- Casting blindly instead of using visitors / checking getKind()