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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
|
/*******************************************************************************
* Copyright (c) 2015, 2016 Google, Inc and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Stefan Xenos (Google) - Initial implementation
*******************************************************************************/
package org.eclipse.jdt.internal.core.nd.java.model;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IJavaModelStatusConstants;
import org.eclipse.jdt.core.IOrdinaryClassFile;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
import org.eclipse.jdt.internal.compiler.env.IBinaryType;
import org.eclipse.jdt.internal.compiler.env.IDependent;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.core.ClassFile;
import org.eclipse.jdt.internal.core.JarPackageFragmentRoot;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.PackageFragment;
import org.eclipse.jdt.internal.core.PackageFragmentRoot;
import org.eclipse.jdt.internal.core.nd.IReader;
import org.eclipse.jdt.internal.core.nd.Nd;
import org.eclipse.jdt.internal.core.nd.db.IndexException;
import org.eclipse.jdt.internal.core.nd.indexer.Indexer;
import org.eclipse.jdt.internal.core.nd.java.JavaIndex;
import org.eclipse.jdt.internal.core.nd.java.JavaNames;
import org.eclipse.jdt.internal.core.nd.java.NdResourceFile;
import org.eclipse.jdt.internal.core.nd.java.NdType;
import org.eclipse.jdt.internal.core.nd.java.TypeRef;
import org.eclipse.jdt.internal.core.nd.util.CharArrayUtils;
import org.eclipse.jdt.internal.core.util.Util;
public class BinaryTypeFactory {
public static final class NotInIndexException extends Exception {
private static final long serialVersionUID = 2859848007651528256L;
public NotInIndexException() {
}
}
/**
* Returns a descriptor for the given class within the given package fragment, or null if the fragment doesn't have
* a location on the filesystem.
*/
private static BinaryTypeDescriptor createDescriptor(PackageFragment pkg, ClassFile classFile) {
String name = classFile.getName();
PackageFragmentRoot root = (PackageFragmentRoot) pkg.getParent();
IPath location = JavaIndex.getLocationForElement(root);
if (location == null) {
return null;
}
name = root.getClassFilePath(Util.concatWith(pkg.names, name, '/'));
String entryName = Util.concatWith(pkg.names, classFile.getElementName(), '/');
char[] fieldDescriptor = CharArrayUtils.concat(new char[] { 'L' },
name.toCharArray(), new char[] { ';' });
IPath workspacePath = root.getPath();
String indexPath;
if (root instanceof JarPackageFragmentRoot) {
entryName = ((JarPackageFragmentRoot) root).getClassFilePath(entryName);
// The old version returned this, but it doesn't conform to the spec on IBinaryType.getFileName():
indexPath = root.getHandleIdentifier() + IDependent.JAR_FILE_ENTRY_SEPARATOR + entryName;
// Version that conforms to the JavaDoc spec on IBinaryType.getFileName() -- note that this breaks
// InlineMethodTests in the JDT UI project. Need to investigate why before using it.
//indexPath = workspacePath.toString() + IDependent.JAR_FILE_ENTRY_SEPARATOR + entryName;
} else {
location = location.append(entryName);
indexPath = workspacePath.append(entryName).toString();
workspacePath = classFile.resource().getFullPath();
}
return new BinaryTypeDescriptor(location.toString().toCharArray(), fieldDescriptor,
workspacePath.toString().toCharArray(), indexPath.toCharArray());
}
public static BinaryTypeDescriptor createDescriptor(IOrdinaryClassFile classFile) {
ClassFile concreteClass = (ClassFile)classFile;
PackageFragment parent = (PackageFragment) classFile.getParent();
return createDescriptor(parent, concreteClass);
}
public static BinaryTypeDescriptor createDescriptor(IType type) {
return createDescriptor(type.getClassFile());
}
public static IBinaryType create(IOrdinaryClassFile classFile, IProgressMonitor monitor) throws JavaModelException, ClassFormatException {
BinaryTypeDescriptor descriptor = createDescriptor(classFile);
return readType(descriptor, monitor);
}
/**
* Reads the given binary type. If the type can be found in the index with a fingerprint that exactly matches
* the file on disk, the type is read from the index. Otherwise the type is read from disk. Returns null if
* no such type exists.
* @throws ClassFormatException
*/
public static IBinaryType readType(BinaryTypeDescriptor descriptor, IProgressMonitor monitor) throws JavaModelException, ClassFormatException {
if (JavaIndex.isEnabled()) {
try {
return readFromIndex(JavaIndex.getIndex(), descriptor, monitor);
} catch (NotInIndexException e) {
// fall back to reading the zip file, below
}
}
return rawReadType(descriptor, true);
}
public static ClassFileReader rawReadType(BinaryTypeDescriptor descriptor, boolean fullyInitialize) throws JavaModelException, ClassFormatException {
try {
return rawReadTypeTestForExists(descriptor, fullyInitialize, true);
} catch (FileNotFoundException e) {
throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
}
}
/**
* Read the class file from disk, circumventing the index's cache. This should only be used by callers
* that need to read information from the class file which aren't present in the index (such as method bodies).
*
* @return the newly-created ClassFileReader or null if the given class file does not exist.
* @throws ClassFormatException if the class file existed but was corrupt
* @throws JavaModelException if unable to read the class file due to a transient failure
* @throws FileNotFoundException if the file does not exist
*/
public static ClassFileReader rawReadTypeTestForExists(BinaryTypeDescriptor descriptor, boolean fullyInitialize,
boolean useInvalidArchiveCache) throws JavaModelException, ClassFormatException, FileNotFoundException {
if (descriptor == null) {
return null;
}
if (descriptor.isInJarFile()) {
if (CharOperation.indexOf("jrt-fs.jar".toCharArray(), descriptor.location, false) == -1) { //$NON-NLS-1$
ZipFile zip = null;
try {
zip = JavaModelManager.getJavaModelManager().getZipFile(new Path(new String(descriptor.workspacePath)),
useInvalidArchiveCache);
char[] entryNameCharArray = CharArrayUtils.concat(
JavaNames.fieldDescriptorToBinaryName(descriptor.fieldDescriptor), SuffixConstants.SUFFIX_class);
String entryName = new String(entryNameCharArray);
ZipEntry ze = zip.getEntry(entryName);
if (ze != null) {
byte contents[];
try {
contents = org.eclipse.jdt.internal.compiler.util.Util.getZipEntryByteContent(ze, zip);
} catch (IOException ioe) {
throw new JavaModelException(ioe, IJavaModelStatusConstants.IO_EXCEPTION);
}
return new ClassFileReader(contents, descriptor.indexPath, fullyInitialize);
}
} catch (CoreException e) {
throw new JavaModelException(e);
} finally {
JavaModelManager.getJavaModelManager().closeZipFile(zip);
}
}
} else {
IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(new String(descriptor.workspacePath)));
byte[] contents;
try (InputStream stream = file.getContents(true)) {
contents = org.eclipse.jdt.internal.compiler.util.Util.getInputStreamAsByteArray(stream, -1);
} catch (CoreException e) {
IStatus status = e.getStatus();
if (status.getCode() == IResourceStatus.RESOURCE_NOT_FOUND) {
throw new FileNotFoundException();
}
throw new JavaModelException(e);
} catch (IOException e) {
throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
}
return new ClassFileReader(contents, file.getFullPath().toString().toCharArray(), fullyInitialize);
}
return null;
}
/**
* Tries to read the given IBinaryType from the index. The return value is lightweight and may be cached
* with minimal memory cost. Returns an IBinaryType if the type was found in the index and the index
* was up-to-date. Throws a NotInIndexException if the index does not contain an up-to-date cache of the
* requested file. Returns null if the index contains an up-to-date cache of the requested file and it was
* able to determine that the requested class does not exist in that file.
*/
public static IBinaryType readFromIndex(JavaIndex index, BinaryTypeDescriptor descriptor, IProgressMonitor monitor) throws JavaModelException, NotInIndexException {
// If the new index is enabled, check if we have this class file cached in the index already
char[] fieldDescriptor = descriptor.fieldDescriptor;
Nd nd = index.getNd();
if (descriptor.location != null) {
// Acquire a read lock on the index
try (IReader lock = nd.acquireReadLock()) {
try {
TypeRef typeRef = TypeRef.create(nd, descriptor.location, fieldDescriptor);
NdType type = typeRef.get();
if (type == null) {
// If we couldn't find the type in the index, determine whether the cause is
// that the type is known not to exist or whether the resource just hasn't
// been indexed yet
NdResourceFile resourceFile = index.getResourceFile(descriptor.location);
if (index.isUpToDate(resourceFile)) {
return null;
}
throw new NotInIndexException();
}
NdResourceFile resourceFile = type.getResourceFile();
if (index.isUpToDate(resourceFile)) {
IndexBinaryType result = new IndexBinaryType(typeRef, descriptor.indexPath);
// We already have the database lock open and have located the element, so we may as
// well prefetch the inexpensive attributes.
result.initSimpleAttributes();
return result;
}
throw new NotInIndexException();
} catch (CoreException e) {
throw new JavaModelException(e);
}
} catch (IndexException e) {
Package.log("Index corruption detected. Rebuilding index.", e); //$NON-NLS-1$
Indexer.getInstance().requestRebuildIndex();
}
}
throw new NotInIndexException();
}
}
|
