org.aspectj.ajdt.internal.core.builder.AjBuildConfig Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aspectjtools Show documentation
Show all versions of aspectjtools Show documentation
AspectJ tools most notably contains the AspectJ compiler (AJC). AJC applies aspects to Java classes during
compilation, fully replacing Javac for plain Java classes and also compiling native AspectJ or annotation-based
@AspectJ syntax. Furthermore, AJC can weave aspects into existing class files in a post-compile binary weaving step.
This library is a superset of AspectJ weaver and hence also of AspectJ runtime.
/* *******************************************************************
* Copyright (c) 2002 - 2018 Contributors
* All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v 2.0
* which accompanies this distribution and is available at
* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
*
* Contributors:
* PARC initial implementation
* Adrian Colyer added constructor to populate javaOptions with
* default settings - 01.20.2003
* Bugzilla #29768, 29769
* Andy Clement
* ******************************************************************/
package org.aspectj.ajdt.internal.core.builder;
import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.stream.Collectors;
import org.aspectj.ajdt.ajc.BuildArgParser;
import org.aspectj.ajdt.internal.compiler.CompilationResultDestinationManager;
import org.aspectj.org.eclipse.jdt.internal.compiler.batch.ClasspathJep247;
import org.aspectj.org.eclipse.jdt.internal.compiler.batch.ClasspathLocation;
import org.aspectj.org.eclipse.jdt.internal.compiler.batch.FileSystem;
import org.aspectj.org.eclipse.jdt.internal.compiler.batch.FileSystem.Classpath;
import org.aspectj.org.eclipse.jdt.internal.compiler.env.IModule;
import org.aspectj.util.FileUtil;
/**
* All configuration information needed to run the AspectJ compiler. Compiler options (as opposed to path information) are held in
* an AjCompilerOptions instance
*/
public class AjBuildConfig implements CompilerConfigurationChangeFlags {
public static final Classpath[] NO_CHECKED_CLASSPATHS = new Classpath[0];
private boolean shouldProceed = true;
public static final String AJLINT_IGNORE = "ignore";
public static final String AJLINT_WARN = "warn";
public static final String AJLINT_ERROR = "error";
public static final String AJLINT_DEFAULT = "default";
private File outputDir;
private File outputJar;
private String outxmlName;
private CompilationResultDestinationManager compilationResultDestinationManager = null;
private List sourceRoots = new ArrayList<>();
private List changedFiles;
private List files = new ArrayList<>();
private List xmlfiles = new ArrayList<>();
private String processor;
private String processorPath;
private List binaryFiles = new ArrayList<>(); // .class files in indirs...
private List inJars = new ArrayList<>();
private List inPath = new ArrayList<>();
private Map sourcePathResources = new HashMap<>();
private List aspectpath = new ArrayList<>();
private List classpath = new ArrayList<>();
private List modulepath = new ArrayList<>();
// Expensive to compute (searching modules, parsing module-info)
private Collection modulepathClasspathEntries = null;
private List modulesourcepath = new ArrayList<>();
// Expensive to compute (searching modules, parsing module-info)
private Collection modulesourcepathClasspathEntries = null;
private Classpath[] checkedClasspaths = null;
private List bootclasspath = new ArrayList<>();
private List cpElementsWithModifiedContents = new ArrayList<>();
private IModule moduleDesc;
private File configFile;
private String lintMode = AJLINT_DEFAULT;
private Map lintOptionsMap = null;
private File lintSpecFile = null;
private int changes = EVERYTHING; // bitflags, see CompilerConfigurationChangeFlags
private final AjCompilerOptions options;
private final BuildArgParser buildArgParser;
// incremental variants handled by the compiler client, but parsed here
private boolean incrementalMode;
private File incrementalFile;
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("BuildConfig[" + (configFile == null ? "null" : configFile.getAbsoluteFile().toString()) + "] #Files="
+ files.size() + " AopXmls=#" + xmlfiles.size());
return sb.toString();
}
public static class BinarySourceFile {
public BinarySourceFile(File dir, File src) {
this.fromInPathDirectory = dir;
this.binSrc = src;
}
public File fromInPathDirectory;
public File binSrc;
@Override
public boolean equals(Object obj) {
if (obj instanceof BinarySourceFile) {
BinarySourceFile other = (BinarySourceFile) obj;
return (binSrc.equals(other.binSrc));
}
return false;
}
@Override
public int hashCode() {
return binSrc != null ? binSrc.hashCode() : 0;
}
}
/**
* Intialises the javaOptions Map to hold the default JDT Compiler settings. Added by AMC 01.20.2003 in reponse to bug #29768
* and enh. 29769. The settings here are duplicated from those set in org.eclipse.jdt.internal.compiler.batch.Main, but I've
* elected to copy them rather than refactor the JDT class since this keeps integration with future JDT releases easier (?).
*/
public AjBuildConfig(BuildArgParser buildArgParser) {
this.buildArgParser = buildArgParser;
options = new AjCompilerOptions();
}
public BuildArgParser getBuildArgParser() {
return buildArgParser;
}
/**
* returned files includes
*
* - files explicitly listed on command-line
* - files listed by reference in argument list files
* - files contained in sourceRootDir if that exists
*
*
* @return all source files that should be compiled.
*/
public List getFiles() {
return files;
}
public List getXmlFiles() {
return xmlfiles;
}
public void setProcessor(String processor) {
this.processor = processor;
}
/**
* @return the list of processor classes to execute
*/
public String getProcessor() {
return this.processor;
}
public void setProcessorPath(String processorPath) {
this.processorPath = processorPath;
}
/**
* @return the processor path which can be searched for processors (via META-INF/services)
*/
public String getProcessorPath() {
return this.processorPath;
}
/**
* returned files includes all .class files found in a directory on the inpath, but does not include .class files contained
* within jars.
*/
public List getBinaryFiles() {
return binaryFiles;
}
public File getOutputDir() {
return outputDir;
}
public CompilationResultDestinationManager getCompilationResultDestinationManager() {
return this.compilationResultDestinationManager;
}
public void setCompilationResultDestinationManager(CompilationResultDestinationManager mgr) {
this.compilationResultDestinationManager = mgr;
}
public void setFiles(List files) {
this.files = files;
}
public void setXmlFiles(List xmlfiles) {
this.xmlfiles = xmlfiles;
}
public void setOutputDir(File outputDir) {
this.outputDir = outputDir;
}
public AjCompilerOptions getOptions() {
return options;
}
/**
* This does not include -bootclasspath but includes -extdirs and -classpath
*/
public List getClasspath() {
return classpath;
}
public void setClasspath(List classpath) {
this.classpath = classpath;
checkedClasspaths = null;
}
public List getModulepath() {
return modulepath;
}
public List getModulesourcepath() {
return modulesourcepath;
}
public void setModulepath(List modulepath) {
this.modulepath = modulepath;
checkedClasspaths = null;
}
public void setModulesourcepath(List modulesourcepath) {
this.modulesourcepath = modulesourcepath;
checkedClasspaths = null;
}
public void setCheckedClasspaths(Classpath[] checkedClasspaths) {
this.checkedClasspaths = checkedClasspaths;
checkedClasspaths = null;
}
private List processFilePath(List path, java.lang.String encoding) {
List entries = new ArrayList<>();
for (File file: path) {
entries.add(FileSystem.getClasspath(file.getAbsolutePath(), encoding, null, ClasspathLocation.BINARY, null));
}
return entries;
}
private List processStringPath(List path, java.lang.String encoding) {
List entries = new ArrayList<>();
for (String file: path) {
entries.add(FileSystem.getClasspath(file, encoding, null, ClasspathLocation.BINARY, null));
}
return entries;
}
public Classpath[] getCheckedClasspaths() {
if (checkedClasspaths == null) {
computeCheckedClasspath();
}
return checkedClasspaths;
}
public List getBootclasspath() {
return bootclasspath;
}
public void setBootclasspath(List bootclasspath) {
this.bootclasspath = bootclasspath;
}
public File getOutputJar() {
return outputJar;
}
public String getOutxmlName() {
return outxmlName;
}
public List getInpath() {
// Elements of the list are either archives (jars/zips) or directories
return Collections.unmodifiableList(inPath);
}
public List getInJars() {
return inJars;
}
public Map getSourcePathResources() {
return sourcePathResources;
}
public void setOutputJar(File outputJar) {
this.outputJar = outputJar;
}
public void setOutxmlName(String name) {
this.outxmlName = name;
}
public void setInJars(List sourceJars) {
this.inJars = sourceJars;
checkedClasspaths = null;
}
public void processInPath() {
// remember all the class files in directories on the inpath
binaryFiles = new ArrayList<>();
FileFilter filter = new FileFilter() {
@Override
public boolean accept(File pathname) {
return pathname.getPath().endsWith(".class");
}
};
for (File inpathElement : inPath) {
if (inpathElement.isDirectory()) {
File[] files = FileUtil.listFiles(inpathElement, filter);
for (File file : files) {
binaryFiles.add(new BinarySourceFile(inpathElement, file));
}
}
}
}
public void setInPath(List dirsOrJars) {
inPath = dirsOrJars;
checkedClasspaths = null;
processInPath();
}
public List getSourceRoots() {
return sourceRoots;
}
public void setSourceRoots(List sourceRootDir) {
this.sourceRoots = sourceRootDir;
}
public File getConfigFile() {
return configFile;
}
public void setConfigFile(File configFile) {
this.configFile = configFile;
}
public void setIncrementalMode(boolean incrementalMode) {
this.incrementalMode = incrementalMode;
}
public boolean isIncrementalMode() {
return incrementalMode;
}
public void setIncrementalFile(File incrementalFile) {
this.incrementalFile = incrementalFile;
}
public boolean isIncrementalFileMode() {
return (null != incrementalFile);
}
/**
* @return List (String) classpath of bootclasspath, injars, inpath, aspectpath entries, specified classpath (extdirs, and
* classpath), and output dir or jar
*/
public List getFullClasspath() {
List full = new ArrayList<>(getBootclasspath()); // XXX Is it OK that boot classpath overrides inpath/injars/aspectpath?
for (File file: inJars) {
full.add(file.getAbsolutePath());
}
for (File file: inPath) {
full.add(file.getAbsolutePath());
}
for (File file: aspectpath) {
full.add(file.getAbsolutePath());
}
full.addAll(getClasspath());
// full.addAll(getModulepath());
// full.addAll(getModulesourcepath());
// if (null != outputDir) {
// full.add(outputDir.getAbsolutePath());
// } else if (null != outputJar) {
// full.add(outputJar.getAbsolutePath());
// }
return full;
}
public File getLintSpecFile() {
return lintSpecFile;
}
public void setLintSpecFile(File lintSpecFile) {
this.lintSpecFile = lintSpecFile;
}
public List getAspectpath() {
return Collections.unmodifiableList(aspectpath);
}
public void setAspectpath(List aspectpath) {
this.aspectpath = aspectpath;
checkedClasspaths = null;
}
public void addToAspectpath(File file) {
this.aspectpath.add(file);
checkedClasspaths = null;
}
public void addToInjars(File file) {
this.inJars.add(file);
checkedClasspaths = null;
}
/** @return true if any config file, sourceroots, sourcefiles, injars or inpath */
public boolean hasSources() {
return ((null != configFile) || (0 < sourceRoots.size()) || (0 < files.size()) || (0 < inJars.size()) || (0 < inPath.size()));
}
// /** @return null if no errors, String errors otherwise */
// public String configErrors() {
// StringBuffer result = new StringBuffer();
// // ok, permit both. sigh.
// // if ((null != outputDir) && (null != outputJar)) {
// // result.append("specified both outputDir and outputJar");
// // }
// // incremental => only sourceroots
// //
// return (0 == result.length() ? null : result.toString());
// }
/**
* Install global values into local config unless values conflict:
*
* - Collections are unioned
* - values takes local value unless default and global set
* - this only sets one of outputDir and outputJar as needed
*
* This also configures super if javaOptions change.
*
* @param global the AjBuildConfig to read globals from
*/
public void installGlobals(AjBuildConfig global) { // XXX relies on default values
// don't join the options - they already have defaults taken care of.
// Map optionsMap = options.getMap();
// join(optionsMap,global.getOptions().getMap());
// options.set(optionsMap);
options.defaultEncoding = global.options.defaultEncoding;// pr244321
join(aspectpath, global.aspectpath);
join(classpath, global.classpath);
if (null == configFile) {
configFile = global.configFile; // XXX correct?
}
if (!isEmacsSymMode() && global.isEmacsSymMode()) {
setEmacsSymMode(true);
}
join(files, global.files);
join(xmlfiles, global.xmlfiles);
if (!isGenerateModelMode() && global.isGenerateModelMode()) {
setGenerateModelMode(true);
}
if (null == incrementalFile) {
incrementalFile = global.incrementalFile;
}
if (!incrementalMode && global.incrementalMode) {
incrementalMode = true;
}
if (isCheckRuntimeVersion() && !global.isCheckRuntimeVersion()) {
setCheckRuntimeVersion(false);
}
join(inJars, global.inJars);
join(inPath, global.inPath);
if ((null == lintMode) || (AJLINT_DEFAULT.equals(lintMode))) {
setLintMode(global.lintMode);
}
if (null == lintSpecFile) {
lintSpecFile = global.lintSpecFile;
}
if (!isTerminateAfterCompilation() && global.isTerminateAfterCompilation()) {
setTerminateAfterCompilation(true);
}
if ((null == outputDir) && (null == outputJar)) {
if (null != global.outputDir) {
outputDir = global.outputDir;
}
if (null != global.outputJar) {
outputJar = global.outputJar;
}
}
join(sourceRoots, global.sourceRoots);
if (!isXnoInline() && global.isXnoInline()) {
setXnoInline(true);
}
if (!isXserializableAspects() && global.isXserializableAspects()) {
setXserializableAspects(true);
}
if (!isXlazyTjp() && global.isXlazyTjp()) {
setXlazyTjp(true);
}
if (!getProceedOnError() && global.getProceedOnError()) {
setProceedOnError(true);
}
setTargetAspectjRuntimeLevel(global.getTargetAspectjRuntimeLevel());
setXJoinpoints(global.getXJoinpoints());
if (!isXHasMemberEnabled() && global.isXHasMemberEnabled()) {
setXHasMemberSupport(true);
}
if (!isXNotReweavable() && global.isXNotReweavable()) {
setXnotReweavable(true);
}
setOutxmlName(global.getOutxmlName());
setXconfigurationInfo(global.getXconfigurationInfo());
setAddSerialVerUID(global.isAddSerialVerUID());
if (!isXmlConfigured() && global.isXmlConfigured()) {
setXmlConfigured(global.isXmlConfigured());
}
setTiming(global.isTiming());
setMakeReflectable(global.isMakeReflectable());
}
void join(Collection local, Collection global) {
for (T next : global) {
if (!local.contains(next)) {
local.add(next);
}
}
}
public void setSourcePathResources(Map map) {
sourcePathResources = map;
}
/**
* used to indicate whether to proceed after parsing config
*/
public boolean shouldProceed() {
return shouldProceed;
}
public void doNotProceed() {
shouldProceed = false;
}
public String getLintMode() {
return lintMode;
}
public Map getLintOptionsMap() {
return lintOptionsMap;
}
// options...
public void setLintMode(String lintMode) {
String lintValue = null;
this.lintMode = lintMode;
if (AJLINT_IGNORE.equals(lintMode)) {
lintValue = AjCompilerOptions.IGNORE;
} else if (AJLINT_WARN.equals(lintMode)) {
lintValue = AjCompilerOptions.WARNING;
} else if (AJLINT_ERROR.equals(lintMode)) {
lintValue = AjCompilerOptions.ERROR;
} else {
// Possibly a name=value comma separated list of configurations
if (lintMode.contains("=")) {
this.lintMode = AJLINT_DEFAULT;
lintOptionsMap = new HashMap<>();
StringTokenizer tokenizer = new StringTokenizer(lintMode,",");
while (tokenizer.hasMoreElements()) {
String option = tokenizer.nextToken();
int equals = option.indexOf("=");
if (equals!=-1) {
String key = option.substring(0,equals);
String value = option.substring(equals+1);
lintOptionsMap.put(key,value);
}
}
}
}
if (lintValue != null || lintOptionsMap != null ) {
Map lintOptions = new HashMap<>();
setOption(AjCompilerOptions.OPTION_ReportInvalidAbsoluteTypeName, lintValue, lintOptions);
setOption(AjCompilerOptions.OPTION_ReportInvalidWildcardTypeName, lintValue, lintOptions);
setOption(AjCompilerOptions.OPTION_ReportUnresolvableMember, lintValue, lintOptions);
setOption(AjCompilerOptions.OPTION_ReportTypeNotExposedToWeaver, lintValue, lintOptions);
setOption(AjCompilerOptions.OPTION_ReportShadowNotInStructure, lintValue, lintOptions);
setOption(AjCompilerOptions.OPTION_ReportUnmatchedSuperTypeInCall, lintValue, lintOptions);
setOption(AjCompilerOptions.OPTION_ReportCannotImplementLazyTJP, lintValue, lintOptions);
setOption(AjCompilerOptions.OPTION_ReportNeedSerialVersionUIDField, lintValue, lintOptions);
setOption(AjCompilerOptions.OPTION_ReportIncompatibleSerialVersion, lintValue, lintOptions);
options.set(lintOptions);
}
}
private void setOption(String optionKey, String lintValue, Map lintOptionsAccumulator) {
if (lintOptionsMap!=null && lintOptionsMap.containsKey(optionKey)) {
String v = lintOptionsMap.get(optionKey);
if (AJLINT_IGNORE.equals(v)) {
lintValue = AjCompilerOptions.IGNORE;
} else if (AJLINT_WARN.equals(v)) {
lintValue = AjCompilerOptions.WARNING;
} else if (AJLINT_ERROR.equals(v)) {
lintValue = AjCompilerOptions.ERROR;
}
}
if (lintValue != null) {
lintOptionsAccumulator.put(optionKey,lintValue);
}
}
public boolean isTerminateAfterCompilation() {
return options.terminateAfterCompilation;
}
public void setTerminateAfterCompilation(boolean b) {
options.terminateAfterCompilation = b;
}
public boolean isXserializableAspects() {
return options.xSerializableAspects;
}
public void setXserializableAspects(boolean xserializableAspects) {
options.xSerializableAspects = xserializableAspects;
}
public void setXJoinpoints(String jps) {
options.xOptionalJoinpoints = jps;
}
public String getXJoinpoints() {
return options.xOptionalJoinpoints;
}
public boolean isXnoInline() {
return options.xNoInline;
}
public void setXnoInline(boolean xnoInline) {
options.xNoInline = xnoInline;
}
public boolean isXlazyTjp() {
return options.xLazyThisJoinPoint;
}
public void setXlazyTjp(boolean b) {
options.xLazyThisJoinPoint = b;
}
public void setXnotReweavable(boolean b) {
options.xNotReweavable = b;
}
public void setXconfigurationInfo(String info) {
options.xConfigurationInfo = info;
}
public String getXconfigurationInfo() {
return options.xConfigurationInfo;
}
public void setXHasMemberSupport(boolean enabled) {
options.xHasMember = enabled;
}
public boolean isXHasMemberEnabled() {
return options.xHasMember;
}
public void setXdevPinpointMode(boolean enabled) {
options.xdevPinpoint = enabled;
}
public boolean isXdevPinpoint() {
return options.xdevPinpoint;
}
public void setAddSerialVerUID(boolean b) {
options.addSerialVerUID = b;
}
public boolean isAddSerialVerUID() {
return options.addSerialVerUID;
}
public void setXmlConfigured(boolean b) {
options.xmlConfigured = b;
}
public void setMakeReflectable(boolean b) {
options.makeReflectable = b;
}
public boolean isXmlConfigured() {
return options.xmlConfigured;
}
public boolean isMakeReflectable() {
return options.makeReflectable;
}
public boolean isXNotReweavable() {
return options.xNotReweavable;
}
public boolean isGenerateJavadocsInModelMode() {
return options.generateJavaDocsInModel;
}
public void setGenerateJavadocsInModelMode(boolean generateJavadocsInModelMode) {
options.generateJavaDocsInModel = generateJavadocsInModelMode;
}
public boolean isGenerateCrossRefsMode() {
return options.generateCrossRefs;
}
public void setGenerateCrossRefsMode(boolean on) {
options.generateCrossRefs = on;
}
public boolean isCheckRuntimeVersion() {
return options.checkRuntimeVersion;
}
public void setCheckRuntimeVersion(boolean on) {
options.checkRuntimeVersion = on;
}
public boolean isEmacsSymMode() {
return options.generateEmacsSymFiles;
}
public void setEmacsSymMode(boolean emacsSymMode) {
options.generateEmacsSymFiles = emacsSymMode;
}
public boolean isGenerateModelMode() {
return options.generateModel;
}
public void setGenerateModelMode(boolean structureModelMode) {
options.generateModel = structureModelMode;
}
public boolean isNoAtAspectJAnnotationProcessing() {
return options.noAtAspectJProcessing;
}
public void setNoAtAspectJAnnotationProcessing(boolean noProcess) {
options.noAtAspectJProcessing = noProcess;
}
public void setShowWeavingInformation(boolean b) {
options.showWeavingInformation = true;
}
public boolean getShowWeavingInformation() {
return options.showWeavingInformation;
}
public void setProceedOnError(boolean b) {
options.proceedOnError = b;
}
public boolean getProceedOnError() {
return options.proceedOnError;
}
public void setBehaveInJava5Way(boolean b) {
options.behaveInJava5Way = b;
}
public boolean getBehaveInJava5Way() {
return options.behaveInJava5Way;
}
public void setTiming(boolean b) {
options.timing = b;
}
public boolean isTiming() {
return options.timing;
}
public void setTargetAspectjRuntimeLevel(String level) {
options.targetAspectjRuntimeLevel = level;
}
public String getTargetAspectjRuntimeLevel() {
return options.targetAspectjRuntimeLevel;
}
/**
* Indicates what has changed in this configuration compared to the last time it was used, allowing the state management logic
* to make intelligent optimizations and skip unnecessary work.
*
* @param changes set of bitflags, see {@link CompilerConfigurationChangeFlags} for flags
*/
public void setChanged(int changes) {
this.changes = changes;
}
/**
* Return the bit flags indicating what has changed since the last time this config was used.
*
* @return the bitflags according too {@link CompilerConfigurationChangeFlags}
*/
public int getChanged() {
return this.changes;
}
public void setModifiedFiles(List projectSourceFilesChanged) {
this.changedFiles = projectSourceFilesChanged;
}
public List getModifiedFiles() {
return this.changedFiles;
}
public void setClasspathElementsWithModifiedContents(List cpElementsWithModifiedContents) {
this.cpElementsWithModifiedContents = cpElementsWithModifiedContents;
}
public List getClasspathElementsWithModifiedContents() {
return this.cpElementsWithModifiedContents;
}
public void setProjectEncoding(String projectEncoding) {
options.defaultEncoding = projectEncoding;
}
public String getProjectEncoding() {
return options.defaultEncoding;
}
public void setModuleDesc(IModule moduleDesc) {
this.moduleDesc = moduleDesc;
}
public IModule getModuleDesc() {
return moduleDesc;
}
public void addToInpath(Set newInpathEntries) {
if (newInpathEntries != null && newInpathEntries.size() != 0) {
for (File newInpathEntry: newInpathEntries) {
if (!inPath.contains(newInpathEntry)) {
inPath.add(newInpathEntry);
}
}
checkedClasspaths = null;
}
}
public void addToInpath(File newInpathEntry) {
// if (!inPath.contains(newInpathEntry)) {
inPath.add(newInpathEntry);
// }
checkedClasspaths = null;
}
public void addToAspectpath(Set newAspectpathEntries) {
if (newAspectpathEntries != null && newAspectpathEntries.size() != 0) {
for (File newAspectpathEntry: newAspectpathEntries) {
if (!aspectpath.contains(newAspectpathEntry)) {
aspectpath.add(newAspectpathEntry);
}
}
checkedClasspaths = null;
}
}
public void setModulepathClasspathEntries(ArrayList modulepathClasspathEntries) {
this.modulepathClasspathEntries = modulepathClasspathEntries;
}
public void setModulesourcepathClasspathEntries(ArrayList modulesourcepathClasspathEntries) {
this.modulesourcepathClasspathEntries = modulesourcepathClasspathEntries;
}
public File removeAspectPathEntry(int i) {
checkedClasspaths = null;
return aspectpath.remove(i);
}
public String removeClasspathEntry(int i) {
checkedClasspaths = null;
return classpath.remove(i);
}
public File removeInpathEntry(int i) {
checkedClasspaths = null;
return inPath.remove(i);
}
public File removeInjarsEntry(int i) {
checkedClasspaths = null;
return inJars.remove(0);
}
// This is similar to the calculation done in Main.setPaths() but it isn't as sophisticated
// as that one (doesn't need to be) and it also considers the additional paths for an
// AspectJ project (aspectpath/inpath/injars)
private void computeCheckedClasspath() {
// Follow what we do in getFullClasspath():
// bootclasspath, injars, inpath, aspectpath, classpath, modulepath
String encoding = getProjectEncoding();
// What to do about bootclasspath on java 9?
// ArrayList allPaths = handleBootclasspath(bootclasspaths, customEncoding);
ArrayList allPaths = new ArrayList<>();
if (
Arrays.stream(buildArgParser.getCheckedClasspaths())
.anyMatch(cp -> cp instanceof ClasspathJep247)
) {
allPaths.addAll(
Arrays.stream(buildArgParser.getCheckedClasspaths())
.filter(cp -> cp instanceof ClasspathJep247)
.collect(Collectors.toList())
);
}
else
allPaths.addAll(processStringPath(bootclasspath, encoding));
allPaths.addAll(processFilePath(inJars, encoding));
allPaths.addAll(processFilePath(inPath, encoding));
allPaths.addAll(processFilePath(aspectpath, encoding));
if (modulepathClasspathEntries != null) {
allPaths.addAll(modulepathClasspathEntries);
}
if (modulesourcepathClasspathEntries != null) {
allPaths.addAll(modulesourcepathClasspathEntries);
}
// The classpath is done after modules to give precedence to modules that share the
// same paths as classpath elements (the upcoming normalize will remove later dups)
allPaths.addAll(processStringPath(classpath, encoding));
allPaths.removeIf(Objects::isNull);
allPaths = FileSystem.ClasspathNormalizer.normalize(allPaths);
this.checkedClasspaths = new FileSystem.Classpath[allPaths.size()];
allPaths.toArray(this.checkedClasspaths);
for (Classpath checkedClasspath : checkedClasspaths) {
if (checkedClasspath == null) {
throw new IllegalStateException();
}
}
}
}