1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*******************************************************************************
* Copyright (c) 2006, 2018 BEA Systems, Inc.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* wharley@bea.com - initial API and implementation
* IBM Corporation - fix for 342598
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.apt.model;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.TypeVisitor;
import org.eclipse.jdt.internal.compiler.apt.dispatch.BaseProcessingEnvImpl;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
/**
* Implementation of DeclaredType, which refers to a particular usage or instance of a type.
* Contrast with {@link javax.lang.model.element.TypeElement}, which is an element that potentially defines a family
* of DeclaredTypes.
*/
public class DeclaredTypeImpl extends TypeMirrorImpl implements DeclaredType {
private final ElementKind _elementKindHint;
/* package */ DeclaredTypeImpl(BaseProcessingEnvImpl env, ReferenceBinding binding) {
super(env, binding);
_elementKindHint = null;
}
/**
* Create a DeclaredType that knows in advance what kind of element to produce from asElement().
* This is useful in the case where the type binding is to an unresolved type, but we know
* from context what type it is - e.g., an annotation type.
*/
/* package */ DeclaredTypeImpl(BaseProcessingEnvImpl env, ReferenceBinding binding, ElementKind elementKindHint) {
super(env, binding);
_elementKindHint = elementKindHint;
}
@Override
public Element asElement() {
TypeBinding prototype = null;
if (_binding instanceof TypeBinding) {
prototype = ((TypeBinding) _binding).prototype();
}
if (prototype != null) {
return _env.getFactory().newElement(prototype, _elementKindHint);
}
// The JDT compiler does not distinguish between type elements and declared types
return _env.getFactory().newElement((ReferenceBinding)_binding, _elementKindHint);
}
@Override
public TypeMirror getEnclosingType() {
ReferenceBinding binding = (ReferenceBinding)_binding;
ReferenceBinding enclosingType = binding.enclosingType();
if (enclosingType != null) {
return _env.getFactory().newTypeMirror(enclosingType);
}
return _env.getFactory().getNoType(TypeKind.NONE);
}
/*
* (non-Javadoc)
* @see javax.lang.model.type.DeclaredType#getTypeArguments()
* @see javax.lang.model.element.TypeElement#getTypeParameters().
*/
@Override
public List<? extends TypeMirror> getTypeArguments() {
ReferenceBinding binding = (ReferenceBinding)_binding;
if (binding.isParameterizedType()) {
ParameterizedTypeBinding ptb = (ParameterizedTypeBinding)_binding;
TypeBinding[] arguments = ptb.arguments;
int length = arguments == null ? 0 : arguments.length;
if (length == 0) return Collections.emptyList();
List<TypeMirror> args = new ArrayList<>(length);
for (TypeBinding arg : arguments) {
args.add(_env.getFactory().newTypeMirror(arg));
}
return Collections.unmodifiableList(args);
}
if (binding.isGenericType()) {
TypeVariableBinding[] typeVariables = binding.typeVariables();
List<TypeMirror> args = new ArrayList<>(typeVariables.length);
for (TypeBinding arg : typeVariables) {
args.add(_env.getFactory().newTypeMirror(arg));
}
return Collections.unmodifiableList(args);
}
return Collections.emptyList();
}
/* (non-Javadoc)
* @see javax.lang.model.type.TypeMirror#accept(javax.lang.model.type.TypeVisitor, java.lang.Object)
*/
@Override
public <R, P> R accept(TypeVisitor<R, P> v, P p) {
return v.visitDeclared(this, p);
}
@Override
public TypeKind getKind() {
return TypeKind.DECLARED;
}
@Override
public String toString() {
return new String(_binding.readableName());
}
}
|
