private static void logStats(Collection<PsiFile> otherFiles, long start) {
long time = System.currentTimeMillis() - start;
final Multiset<String> stats = HashMultiset.create();
for (PsiFile file : otherFiles) {
stats.add(
StringUtil.notNullize(file.getViewProvider().getVirtualFile().getExtension())
.toLowerCase());
}
List<String> extensions = ContainerUtil.newArrayList(stats.elementSet());
Collections.sort(
extensions,
new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return stats.count(o2) - stats.count(o1);
}
});
String message =
"Search in "
+ otherFiles.size()
+ " files with unknown types took "
+ time
+ "ms.\n"
+ "Mapping their extensions to an existing file type (e.g. Plain Text) might speed up the search.\n"
+ "Most frequent non-indexed file extensions: ";
for (int i = 0; i < Math.min(10, extensions.size()); i++) {
String extension = extensions.get(i);
message += extension + "(" + stats.count(extension) + ") ";
}
LOG.info(message);
}
private void configEncoding() {
if (Boolean.parseBoolean(System.getProperty("maven.disable.encode.import"))) return;
String encoding = myMavenProject.getEncoding();
if (encoding != null) {
try {
EncodingProjectManager.getInstance(myModule.getProject())
.setEncoding(myMavenProject.getDirectoryFile(), Charset.forName(encoding));
} catch (UnsupportedCharsetException ignored) {
/**/
} catch (IllegalCharsetNameException ignored) {
/**/
}
}
}
public void findUsages(
@NotNull final Processor<UsageInfo> consumer,
@NotNull FindUsagesProcessPresentation processPresentation) {
try {
myProgress.setIndeterminate(true);
myProgress.setText("Scanning indexed files...");
final Set<PsiFile> filesForFastWordSearch =
ApplicationManager.getApplication()
.runReadAction(
new Computable<Set<PsiFile>>() {
@Override
public Set<PsiFile> compute() {
return getFilesForFastWordSearch();
}
});
myProgress.setIndeterminate(false);
searchInFiles(filesForFastWordSearch, processPresentation, consumer);
myProgress.setIndeterminate(true);
myProgress.setText("Scanning non-indexed files...");
boolean skipIndexed = canRelyOnIndices();
final Collection<PsiFile> otherFiles =
collectFilesInScope(filesForFastWordSearch, skipIndexed);
myProgress.setIndeterminate(false);
long start = System.currentTimeMillis();
searchInFiles(otherFiles, processPresentation, consumer);
if (skipIndexed && otherFiles.size() > 1000) {
logStats(otherFiles, start);
}
} catch (ProcessCanceledException e) {
// fine
}
if (!myLargeFiles.isEmpty()) {
processPresentation.setLargeFilesWereNotScanned(myLargeFiles);
}
if (!myProgress.isCanceled()) {
myProgress.setText(FindBundle.message("find.progress.search.completed"));
}
}
static {
System.setProperty("jbdt.test.fixture", "com.intellij.designer.dt.IJTestFixture");
}
private void configAnnotationProcessors() {
if (Boolean.parseBoolean(System.getProperty("idea.maven.keep.annotation.processors"))) return;
Sdk sdk = ModuleRootManager.getInstance(myModule).getSdk();
if (sdk != null) {
String versionString = sdk.getVersionString();
if (versionString != null) {
if (versionString.contains("1.5")
|| versionString.contains("1.4")
|| versionString.contains("1.3")
|| versionString.contains("1.2")) {
return;
}
}
}
CompilerConfigurationImpl compilerConfiguration =
(CompilerConfigurationImpl) CompilerConfiguration.getInstance(myModule.getProject());
ProcessorConfigProfile currentProfile =
compilerConfiguration.getAnnotationProcessingConfiguration(myModule);
String moduleProfileName = PROFILE_PREFIX + myModule.getName();
if (currentProfile != compilerConfiguration.getDefaultProcessorProfile()
&& !MAVEN_DEFAULT_ANNOTATION_PROFILE.equals(currentProfile.getName())
&& !moduleProfileName.equals(currentProfile.getName())) {
return;
}
ProcessorConfigProfile moduleProfile =
compilerConfiguration.findModuleProcessorProfile(moduleProfileName);
ProcessorConfigProfile defaultMavenProfile =
compilerConfiguration.findModuleProcessorProfile(MAVEN_DEFAULT_ANNOTATION_PROFILE);
if (shouldEnableAnnotationProcessors()) {
String annotationProcessorDirectory = getRelativeAnnotationProcessorDirectory(false);
if (annotationProcessorDirectory == null) {
annotationProcessorDirectory = DEFAULT_ANNOTATION_PATH_OUTPUT;
}
String testAnnotationProcessorDirectory = getRelativeAnnotationProcessorDirectory(true);
if (testAnnotationProcessorDirectory == null) {
testAnnotationProcessorDirectory = DEFAULT_TEST_ANNOTATION_OUTPUT;
}
Map<String, String> options = myMavenProject.getAnnotationProcessorOptions();
List<String> processors = myMavenProject.getDeclaredAnnotationProcessors();
if (processors == null
&& options.isEmpty()
&& DEFAULT_ANNOTATION_PATH_OUTPUT.equals(annotationProcessorDirectory.replace('\\', '/'))
&& DEFAULT_TEST_ANNOTATION_OUTPUT.equals(
testAnnotationProcessorDirectory.replace('\\', '/'))) {
if (moduleProfile != null) {
compilerConfiguration.removeModuleProcessorProfile(moduleProfile);
}
if (defaultMavenProfile == null) {
defaultMavenProfile = new ProcessorConfigProfileImpl(MAVEN_DEFAULT_ANNOTATION_PROFILE);
defaultMavenProfile.setEnabled(true);
defaultMavenProfile.setOutputRelativeToContentRoot(true);
defaultMavenProfile.setObtainProcessorsFromClasspath(true);
defaultMavenProfile.setGeneratedSourcesDirectoryName(
DEFAULT_ANNOTATION_PATH_OUTPUT, false);
defaultMavenProfile.setGeneratedSourcesDirectoryName(
DEFAULT_TEST_ANNOTATION_OUTPUT, true);
compilerConfiguration.addModuleProcessorProfile(defaultMavenProfile);
}
defaultMavenProfile.addModuleName(myModule.getName());
} else {
if (defaultMavenProfile != null) {
defaultMavenProfile.removeModuleName(myModule.getName());
if (defaultMavenProfile.getModuleNames().isEmpty()) {
compilerConfiguration.removeModuleProcessorProfile(defaultMavenProfile);
}
}
if (moduleProfile == null) {
moduleProfile = new ProcessorConfigProfileImpl(moduleProfileName);
moduleProfile.setOutputRelativeToContentRoot(true);
moduleProfile.setEnabled(true);
moduleProfile.setObtainProcessorsFromClasspath(true);
moduleProfile.addModuleName(myModule.getName());
compilerConfiguration.addModuleProcessorProfile(moduleProfile);
}
moduleProfile.setGeneratedSourcesDirectoryName(annotationProcessorDirectory, false);
moduleProfile.setGeneratedSourcesDirectoryName(testAnnotationProcessorDirectory, true);
moduleProfile.clearProcessorOptions();
for (Map.Entry<String, String> entry : options.entrySet()) {
moduleProfile.setOption(entry.getKey(), entry.getValue());
}
moduleProfile.clearProcessors();
if (processors != null) {
for (String processor : processors) {
moduleProfile.addProcessor(processor);
}
}
}
} else {
if (defaultMavenProfile != null) {
defaultMavenProfile.removeModuleName(myModule.getName());
if (defaultMavenProfile.getModuleNames().isEmpty()) {
compilerConfiguration.removeModuleProcessorProfile(defaultMavenProfile);
}
}
if (moduleProfile != null) {
compilerConfiguration.removeModuleProcessorProfile(moduleProfile);
}
}
}
private void doCompile(@NotNull final ModuleChunk chunk, @NotNull String outputDir)
throws IOException {
myCompileContext.getProgressIndicator().checkCanceled();
if (ApplicationManager.getApplication()
.runReadAction(
new Computable<Boolean>() {
public Boolean compute() {
return chunk.getFilesToCompile().isEmpty() ? Boolean.TRUE : Boolean.FALSE;
}
})
.booleanValue()) {
return; // should not invoke javac with empty sources list
}
int exitValue = 0;
try {
final Process process = myCompiler.launchProcess(chunk, outputDir, myCompileContext);
final long compilationStart = System.currentTimeMillis();
final ClassParsingThread classParsingThread =
new ClassParsingThread(isJdk6(JavaSdkUtil.getSdkForCompilation(chunk)), outputDir);
final Future<?> classParsingThreadFuture =
ApplicationManager.getApplication().executeOnPooledThread(classParsingThread);
OutputParser errorParser = myCompiler.createErrorParser(outputDir, process);
CompilerParsingThread errorParsingThread =
errorParser == null
? null
: new SynchedCompilerParsing(
process,
myCompileContext,
errorParser,
classParsingThread,
true,
errorParser.isTrimLines());
Future<?> errorParsingThreadFuture = null;
if (errorParsingThread != null) {
errorParsingThreadFuture =
ApplicationManager.getApplication().executeOnPooledThread(errorParsingThread);
}
OutputParser outputParser = myCompiler.createOutputParser(outputDir);
CompilerParsingThread outputParsingThread =
outputParser == null
? null
: new SynchedCompilerParsing(
process,
myCompileContext,
outputParser,
classParsingThread,
false,
outputParser.isTrimLines());
Future<?> outputParsingThreadFuture = null;
if (outputParsingThread != null) {
outputParsingThreadFuture =
ApplicationManager.getApplication().executeOnPooledThread(outputParsingThread);
}
try {
exitValue = process.waitFor();
} catch (InterruptedException e) {
process.destroy();
exitValue = process.exitValue();
} catch (Error e) {
process.destroy();
exitValue = process.exitValue();
throw e;
} finally {
if (CompileDriver.ourDebugMode) {
System.out.println("Compiler exit code is " + exitValue);
}
if (errorParsingThread != null) {
errorParsingThread.setProcessTerminated(true);
}
if (outputParsingThread != null) {
outputParsingThread.setProcessTerminated(true);
}
joinThread(errorParsingThreadFuture);
joinThread(outputParsingThreadFuture);
classParsingThread.stopParsing();
joinThread(classParsingThreadFuture);
registerParsingException(outputParsingThread);
registerParsingException(errorParsingThread);
assert outputParsingThread == null || !outputParsingThread.processing;
assert errorParsingThread == null || !errorParsingThread.processing;
assert classParsingThread == null || !classParsingThread.processing;
}
} finally {
compileFinished(exitValue, chunk, outputDir);
myModuleName = null;
}
}