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
|
/*******************************************************************************
* Copyright (c) 2000, 2019 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
* Stephan Herrmann - Contribution for
* Bug 440477 - [null] Infrastructure for feeding external annotations into compilation
*******************************************************************************/
package org.eclipse.jdt.internal.core.builder;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.zip.ZipFile;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.AccessRuleSet;
import org.eclipse.jdt.internal.compiler.env.IModule;
import org.eclipse.jdt.internal.compiler.env.IUpdatableModule;
import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
import org.eclipse.jdt.internal.compiler.env.IUpdatableModule.UpdateKind;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.lookup.ModuleBinding;
import org.eclipse.jdt.internal.compiler.util.Util;
public abstract class ClasspathLocation {
protected boolean isOnModulePath;
protected IModule module;
protected IUpdatableModule.UpdatesByKind updates;
protected Set<String> limitModuleNames = null;
protected String patchModuleName = null;
// In the following signatures, passing a null moduleName signals "don't care":
abstract public NameEnvironmentAnswer findClass(String typeName, String qualifiedPackageName, String moduleName, String qualifiedBinaryFileName);
abstract public NameEnvironmentAnswer findClass(String typeName, String qualifiedPackageName, String moduleName, String qualifiedBinaryFileName,
boolean asBinaryOnly, Predicate<String> moduleNameFilter);
abstract public boolean isPackage(String qualifiedPackageName, String moduleName);
public char[][] getModulesDeclaringPackage(String qualifiedPackageName, String moduleName) {
return singletonModuleNameIf(isPackage(qualifiedPackageName, moduleName));
}
public boolean hasModule() { return getModule() != null; }
abstract public boolean hasCompilationUnit(String pkgName, String moduleName);
public NameEnvironmentAnswer findClass(char[] typeName, String qualifiedPackageName, String moduleName, String qualifiedBinaryFileName,
boolean asBinaryOnly, Predicate<String> moduleNameFilter) {
String fileName = new String(typeName);
return findClass(fileName, qualifiedPackageName, moduleName, qualifiedBinaryFileName, asBinaryOnly, moduleNameFilter);
}
public void setModule (IModule mod) {
this.module = mod;
}
public IModule getModule() {
return this.module;
}
protected boolean areAllModuleOptionsEqual(ClasspathLocation other) {
if (this.patchModuleName != null) {
if (other.patchModuleName == null)
return false;
if (!this.patchModuleName.equals(other.patchModuleName))
return false;
} else {
if (other.patchModuleName != null)
return false;
}
if (this.limitModuleNames != null) {
if (other.limitModuleNames == null)
return false;
if (other.limitModuleNames.size() != this.limitModuleNames.size())
return false;
if (!this.limitModuleNames.containsAll(other.limitModuleNames))
return false;
} else {
if (other.limitModuleNames != null)
return false;
}
if (this.updates != null) {
if (other.updates == null)
return false;
List<Consumer<IUpdatableModule>> packageUpdates = this.updates.getList(UpdateKind.PACKAGE, false);
List<Consumer<IUpdatableModule>> otherPackageUpdates = other.updates.getList(UpdateKind.PACKAGE, false);
if (packageUpdates != null) {
if (otherPackageUpdates == null)
return false;
if (packageUpdates.size() != otherPackageUpdates.size())
return false;
if (!packageUpdates.containsAll(otherPackageUpdates))
return false;
} else {
if (otherPackageUpdates != null)
return false;
}
List<Consumer<IUpdatableModule>> moduleUpdates = this.updates.getList(UpdateKind.MODULE, false);
List<Consumer<IUpdatableModule>> otherModuleUpdates = other.updates.getList(UpdateKind.MODULE, false);
if (moduleUpdates != null) {
if (otherModuleUpdates == null)
return false;
if (moduleUpdates.size() != otherModuleUpdates.size())
return false;
if (!moduleUpdates.containsAll(otherModuleUpdates))
return false;
} else {
if (otherModuleUpdates != null)
return false;
}
} else {
if (other.updates != null)
return false;
}
return true;
}
static ClasspathLocation forSourceFolder(IContainer sourceFolder, IContainer outputFolder,
char[][] inclusionPatterns, char[][] exclusionPatterns, boolean ignoreOptionalProblems) {
return new ClasspathMultiDirectory(sourceFolder, outputFolder, inclusionPatterns, exclusionPatterns,
ignoreOptionalProblems);
}
public static ClasspathLocation forBinaryFolder(IContainer binaryFolder, boolean isOutputFolder, AccessRuleSet accessRuleSet, IPath externalAnnotationPath, boolean autoModule) {
return new ClasspathDirectory(binaryFolder, isOutputFolder, accessRuleSet, externalAnnotationPath, autoModule);
}
static ClasspathLocation forLibrary(String libraryPathname,
long lastModified,
AccessRuleSet accessRuleSet,
IPath annotationsPath,
boolean autoModule,
String compliance) {
return Util.archiveFormat(libraryPathname) == Util.JMOD_FILE ?
new ClasspathJMod(libraryPathname, lastModified, accessRuleSet, annotationsPath) :
(compliance == null || (CompilerOptions.versionToJdkLevel(compliance) < ClassFileConstants.JDK9) ?
new ClasspathJar(libraryPathname, lastModified, accessRuleSet, annotationsPath, autoModule) :
new ClasspathMultiReleaseJar(libraryPathname, lastModified, accessRuleSet, annotationsPath, autoModule, compliance));
}
public static ClasspathJrt forJrtSystem(String jrtPath, AccessRuleSet accessRuleSet, IPath annotationsPath, String release) throws CoreException {
return (release == null || release.equals("")) ? new ClasspathJrt(jrtPath, accessRuleSet, annotationsPath) : //$NON-NLS-1$
new ClasspathJrtWithReleaseOption(jrtPath, accessRuleSet, annotationsPath, release);
}
public static ClasspathLocation forLibrary(String libraryPathname, AccessRuleSet accessRuleSet, IPath annotationsPath,
boolean autoModule, String compliance) {
return forLibrary(libraryPathname, 0, accessRuleSet, annotationsPath, autoModule, compliance);
}
static ClasspathLocation forLibrary(IFile library, AccessRuleSet accessRuleSet, IPath annotationsPath,
boolean autoModule, String compliance) {
return (CompilerOptions.versionToJdkLevel(compliance) < ClassFileConstants.JDK9) ?
new ClasspathJar(library, accessRuleSet, annotationsPath, autoModule) :
new ClasspathMultiReleaseJar(library, accessRuleSet, annotationsPath, autoModule, compliance);
}
public static ClasspathLocation forLibrary(ZipFile zipFile, AccessRuleSet accessRuleSet, IPath externalAnnotationPath, boolean isOnModulePath, String compliance) {
return (CompilerOptions.versionToJdkLevel(compliance) < ClassFileConstants.JDK9) ?
new ClasspathJar(zipFile, accessRuleSet, externalAnnotationPath, isOnModulePath) :
new ClasspathMultiReleaseJar(zipFile, accessRuleSet, externalAnnotationPath, isOnModulePath, compliance);
}
public abstract IPath getProjectRelativePath();
public boolean isOutputFolder() {
return false;
}
public void cleanup() {
// free anything which is not required when the state is saved
}
public void reset() {
// reset any internal caches before another compile loop starts
}
public abstract String debugPathString();
public char[][] singletonModuleNameIf(boolean condition) {
if (!condition)
return null;
if (this.module != null)
return new char[][] { this.module.name() };
return new char[][] { ModuleBinding.UNNAMED };
}
public char[][] listPackages() {
return CharOperation.NO_CHAR_CHAR;
}
}
|
