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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
/*******************************************************************************
* Copyright (c) 2000, 2018 IBM Corporation and others.
*
* 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:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.core;
import java.util.ArrayList;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jdt.core.IAnnotation;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaModelStatusConstants;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.env.IBinaryAnnotation;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.core.util.Util;
/**
* Common functionality for Binary member handles.
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public abstract class BinaryMember extends NamedMember {
/*
* Constructs a binary member.
*/
protected BinaryMember(JavaElement parent, String name) {
super(parent, name);
}
/*
* @see ISourceManipulation
*/
@Override
public void copy(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor) throws JavaModelException {
throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));
}
protected IAnnotation[] getAnnotations(IBinaryAnnotation[] binaryAnnotations, long tagBits) {
IAnnotation[] standardAnnotations = getStandardAnnotations(tagBits);
if (binaryAnnotations == null)
return standardAnnotations;
int length = binaryAnnotations.length;
int standardLength = standardAnnotations.length;
int fullLength = length + standardLength;
if (fullLength == 0) {
return Annotation.NO_ANNOTATIONS;
}
IAnnotation[] annotations = new IAnnotation[fullLength];
for (int i = 0; i < length; i++) {
annotations[i] = Util.getAnnotation(this, binaryAnnotations[i], null);
}
System.arraycopy(standardAnnotations, 0, annotations, length, standardLength);
return annotations;
}
private IAnnotation getAnnotation(char[][] annotationName) {
return new Annotation(this, new String(CharOperation.concatWith(annotationName, '.')));
}
protected IAnnotation[] getStandardAnnotations(long tagBits) {
if ((tagBits & TagBits.AllStandardAnnotationsMask) == 0)
return Annotation.NO_ANNOTATIONS;
ArrayList annotations = new ArrayList();
if ((tagBits & TagBits.AnnotationTargetMASK) != 0) {
annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_TARGET));
}
if ((tagBits & TagBits.AnnotationRetentionMASK) != 0) {
annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_RETENTION));
}
if ((tagBits & TagBits.AnnotationDeprecated) != 0) {
annotations.add(getAnnotation(TypeConstants.JAVA_LANG_DEPRECATED));
}
if ((tagBits & TagBits.AnnotationDocumented) != 0) {
annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_DOCUMENTED));
}
if ((tagBits & TagBits.AnnotationInherited) != 0) {
annotations.add(getAnnotation(TypeConstants.JAVA_LANG_ANNOTATION_INHERITED));
}
if ((tagBits & TagBits.AnnotationPolymorphicSignature) != 0) {
annotations.add(getAnnotation(TypeConstants.JAVA_LANG_INVOKE_METHODHANDLE_$_POLYMORPHICSIGNATURE));
}
if ((tagBits & TagBits.AnnotationSafeVarargs) != 0) {
annotations.add(getAnnotation(TypeConstants.JAVA_LANG_SAFEVARARGS));
}
// note that JAVA_LANG_SUPPRESSWARNINGS and JAVA_LANG_OVERRIDE cannot appear in binaries
return (IAnnotation[]) annotations.toArray(new IAnnotation[annotations.size()]);
}
@Override
public String[] getCategories() throws JavaModelException {
SourceMapper mapper= getSourceMapper();
if (mapper != null) {
// ensure the class file's buffer is open so that categories are computed
getClassFile().getBuffer();
if (mapper.categories != null) {
String[] categories = (String[]) mapper.categories.get(this);
if (categories != null)
return categories;
}
}
return CharOperation.NO_STRINGS;
}
public String getKey() {
try {
return getKey(false/*don't open*/);
} catch (JavaModelException e) {
// happen only if force open is true
return null;
}
}
/**
* @see org.eclipse.jdt.internal.compiler.lookup.Binding#computeUniqueKey()
*/
public abstract String getKey(boolean forceOpen) throws JavaModelException;
/*
* @see ISourceReference
*/
@Override
public ISourceRange getNameRange() throws JavaModelException {
SourceMapper mapper= getSourceMapper();
if (mapper != null) {
// ensure the class file's buffer is open so that source ranges are computed
((AbstractClassFile)getClassFile()).getBuffer();
return mapper.getNameRange(this);
} else {
return SourceMapper.UNKNOWN_RANGE;
}
}
/*
* @see ISourceReference
*/
@Override
public ISourceRange getSourceRange() throws JavaModelException {
SourceMapper mapper= getSourceMapper();
if (mapper != null) {
// ensure the class file's buffer is open so that source ranges are computed
getClassFile().getBuffer();
return mapper.getSourceRange(this);
} else {
return SourceMapper.UNKNOWN_RANGE;
}
}
/*
* @see IMember
*/
@Override
public boolean isBinary() {
return true;
}
/*
* @see IJavaElement
*/
@Override
public boolean isStructureKnown() throws JavaModelException {
return ((IJavaElement)getOpenableParent()).isStructureKnown();
}
/*
* @see ISourceManipulation
*/
@Override
public void move(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor) throws JavaModelException {
throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));
}
/*
* @see ISourceManipulation
*/
@Override
public void rename(String newName, boolean force, IProgressMonitor monitor) throws JavaModelException {
throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));
}
/*
* Sets the contents of this element.
* Throws an exception as this element is read only.
*/
public void setContents(String contents, IProgressMonitor monitor) throws JavaModelException {
throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.READ_ONLY, this));
}
}
|
