From 2c5e21bc4048951f97f79142afcac16eda5c10a7 Mon Sep 17 00:00:00 2001 From: Eugene Zhuravlev Date: Fri, 14 Dec 2012 19:24:53 +0100 Subject: [PATCH] [r=nik] automatically exclude from compilation annotation processors output --- ...ilders.java.ExcludedJavaSourceRootProvider | 1 + .../src/org/jetbrains/jps/ProjectPaths.java | 20 +++----- .../java/ExcludedJavaSourceRootProvider.java | 1 + .../jps/incremental/CompileContext.java | 10 ---- .../jps/incremental/CompileContextImpl.java | 42 ---------------- .../jps/incremental/ModuleBuildTarget.java | 7 ++- .../jps/incremental/ResourcesTarget.java | 27 ---------- .../ClassProcessingBuilder.java | 6 +-- .../instrumentation/RmiStubsGenerator.java | 3 +- ...tationsExcludedJavaSourceRootProvider.java | 49 +++++++++++++++++++ .../jps/incremental/java/JavaBuilder.java | 17 ++++--- .../jps/builders/ModuleClasspathTest.groovy | 10 ++-- .../JpsJavaCompilerConfiguration.java | 16 +++++- .../JpsJavaCompilerConfigurationImpl.java | 32 +++++++++++- ...psJavaCompilerConfigurationSerializer.java | 2 +- .../JpsCompilerConfigurationTest.java | 2 +- .../AndroidLibraryPackagingBuilder.java | 3 +- .../jps/android/AndroidPackagingBuilder.java | 3 +- .../builder/AndroidPackagingBuildTarget.java | 3 +- .../jps/incremental/groovy/GroovyBuilder.java | 3 +- .../compiler/FormsInstrumenter.java | 5 +- 21 files changed, 134 insertions(+), 128 deletions(-) create mode 100644 jps/jps-builders/src/META-INF/services/org.jetbrains.jps.builders.java.ExcludedJavaSourceRootProvider create mode 100644 jps/jps-builders/src/org/jetbrains/jps/incremental/java/AnnotationsExcludedJavaSourceRootProvider.java diff --git a/jps/jps-builders/src/META-INF/services/org.jetbrains.jps.builders.java.ExcludedJavaSourceRootProvider b/jps/jps-builders/src/META-INF/services/org.jetbrains.jps.builders.java.ExcludedJavaSourceRootProvider new file mode 100644 index 000000000000..e398bfd69f5c --- /dev/null +++ b/jps/jps-builders/src/META-INF/services/org.jetbrains.jps.builders.java.ExcludedJavaSourceRootProvider @@ -0,0 +1 @@ +org.jetbrains.jps.incremental.java.AnnotationsExcludedJavaSourceRootProvider \ No newline at end of file diff --git a/jps/jps-builders/src/org/jetbrains/jps/ProjectPaths.java b/jps/jps-builders/src/org/jetbrains/jps/ProjectPaths.java index 156d9240ba6e..caa7e58a4338 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/ProjectPaths.java +++ b/jps/jps-builders/src/org/jetbrains/jps/ProjectPaths.java @@ -21,7 +21,6 @@ import com.intellij.util.Consumer; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.model.JpsDummyElement; -import org.jetbrains.jps.model.JpsProject; import org.jetbrains.jps.model.JpsSimpleElement; import org.jetbrains.jps.model.java.*; import org.jetbrains.jps.model.java.compiler.ProcessorConfigProfile; @@ -41,30 +40,25 @@ import java.util.*; * Date: 9/30/11 */ public class ProjectPaths { - @NotNull - private final JpsProject myProject; - //private final Map>> myCachedClasspath = new HashMap>>(); - - public ProjectPaths(@NotNull JpsProject project) { - myProject = project; + private ProjectPaths() { } - public Collection getCompilationClasspathFiles(ModuleChunk chunk, + public static Collection getCompilationClasspathFiles(ModuleChunk chunk, boolean includeTests, final boolean excludeMainModuleOutput, final boolean exportedOnly) { return getClasspathFiles(chunk, JpsJavaClasspathKind.compile(includeTests), excludeMainModuleOutput, ClasspathPart.WHOLE, exportedOnly); } - public Collection getPlatformCompilationClasspath(ModuleChunk chunk, boolean excludeMainModuleOutput) { + public static Collection getPlatformCompilationClasspath(ModuleChunk chunk, boolean excludeMainModuleOutput) { return getClasspathFiles(chunk, JpsJavaClasspathKind.compile(chunk.containsTests()), excludeMainModuleOutput, ClasspathPart.BEFORE_JDK, true); } - public Collection getCompilationClasspath(ModuleChunk chunk, boolean excludeMainModuleOutput) { + public static Collection getCompilationClasspath(ModuleChunk chunk, boolean excludeMainModuleOutput) { return getClasspathFiles(chunk, JpsJavaClasspathKind.compile(chunk.containsTests()), excludeMainModuleOutput, ClasspathPart.AFTER_JDK, true); } - private Collection getClasspathFiles(ModuleChunk chunk, + private static Collection getClasspathFiles(ModuleChunk chunk, JpsJavaClasspathKind kind, final boolean excludeMainModuleOutput, ClasspathPart classpathPart, final boolean exportedOnly) { @@ -159,12 +153,12 @@ public class ProjectPaths { } @Nullable - public File getModuleOutputDir(JpsModule module, boolean forTests) { + public static File getModuleOutputDir(JpsModule module, boolean forTests) { return JpsJavaExtensionService.getInstance().getOutputDirectory(module, forTests); } @Nullable - public File getAnnotationProcessorGeneratedSourcesOutputDir(JpsModule module, final boolean forTests, ProcessorConfigProfile profile) { + public static File getAnnotationProcessorGeneratedSourcesOutputDir(JpsModule module, final boolean forTests, ProcessorConfigProfile profile) { final String sourceDirName = profile.getGeneratedSourcesDirectoryName(forTests); if (profile.isOutputRelativeToContentRoot()) { List roots = module.getContentRootsList().getUrls(); diff --git a/jps/jps-builders/src/org/jetbrains/jps/builders/java/ExcludedJavaSourceRootProvider.java b/jps/jps-builders/src/org/jetbrains/jps/builders/java/ExcludedJavaSourceRootProvider.java index 64dbd190e72e..18b1a52a9ffb 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/builders/java/ExcludedJavaSourceRootProvider.java +++ b/jps/jps-builders/src/org/jetbrains/jps/builders/java/ExcludedJavaSourceRootProvider.java @@ -20,6 +20,7 @@ import org.jetbrains.jps.model.module.JpsModule; import org.jetbrains.jps.model.module.JpsModuleSourceRoot; /** + * * @author nik */ public abstract class ExcludedJavaSourceRootProvider { diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/CompileContext.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/CompileContext.java index 23d081c336d7..b878c75b3180 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/CompileContext.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/CompileContext.java @@ -16,15 +16,11 @@ package org.jetbrains.jps.incremental; import com.intellij.openapi.util.UserDataHolder; -import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.ModuleChunk; -import org.jetbrains.jps.ProjectPaths; import org.jetbrains.jps.api.CanceledStatus; import org.jetbrains.jps.builders.logging.BuildLoggingManager; import org.jetbrains.jps.cmdline.ProjectDescriptor; -import org.jetbrains.jps.model.java.compiler.ProcessorConfigProfile; -import org.jetbrains.jps.model.module.JpsModule; /** * @author Eugene Zhuravlev @@ -33,8 +29,6 @@ import org.jetbrains.jps.model.module.JpsModule; public interface CompileContext extends UserDataHolder, MessageHandler { ProjectDescriptor getProjectDescriptor(); - ProjectPaths getProjectPaths(); - CompileScope getScope(); boolean isMake(); @@ -48,10 +42,6 @@ public interface CompileContext extends UserDataHolder, MessageHandler { void removeBuildListener(BuildListener listener); - @NotNull - ProcessorConfigProfile getAnnotationProcessingProfile(JpsModule module); - - boolean shouldDifferentiate(ModuleChunk chunk); CanceledStatus getCancelStatus(); diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/CompileContextImpl.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/CompileContextImpl.java index 8b1ae2062ed7..5ccf72e73312 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/CompileContextImpl.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/CompileContextImpl.java @@ -18,10 +18,8 @@ package org.jetbrains.jps.incremental; import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.UserDataHolderBase; import com.intellij.util.EventDispatcher; -import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.ModuleChunk; -import org.jetbrains.jps.ProjectPaths; import org.jetbrains.jps.api.CanceledStatus; import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType; import org.jetbrains.jps.builders.logging.BuildLoggingManager; @@ -30,10 +28,6 @@ import org.jetbrains.jps.incremental.messages.BuildMessage; import org.jetbrains.jps.incremental.messages.FileDeletedEvent; import org.jetbrains.jps.incremental.messages.FileGeneratedEvent; import org.jetbrains.jps.incremental.messages.ProgressMessage; -import org.jetbrains.jps.model.java.JpsJavaExtensionService; -import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerConfiguration; -import org.jetbrains.jps.model.java.compiler.ProcessorConfigProfile; -import org.jetbrains.jps.model.module.JpsModule; import java.util.*; @@ -49,14 +43,12 @@ public class CompileContextImpl extends UserDataHolderBase implements CompileCon private final MessageHandler myDelegateMessageHandler; private final Set myNonIncrementalModules = new HashSet(); - private final ProjectPaths myProjectPaths; private volatile long myCompilationStartStamp; private final ProjectDescriptor myProjectDescriptor; private final Map myBuilderParams; private final CanceledStatus myCancelStatus; private volatile float myDone = -1.0f; private EventDispatcher myListeners = EventDispatcher.create(BuildListener.class); - private Map myAnnotationProcessingProfileMap; public CompileContextImpl(CompileScope scope, ProjectDescriptor pd, boolean isMake, @@ -72,7 +64,6 @@ public class CompileContextImpl extends UserDataHolderBase implements CompileCon myIsProjectRebuild = isProjectRebuild; myIsMake = !isProjectRebuild && isMake; myDelegateMessageHandler = delegateMessageHandler; - myProjectPaths = new ProjectPaths(pd.getProject()); } @Override @@ -85,11 +76,6 @@ public class CompileContextImpl extends UserDataHolderBase implements CompileCon myCompilationStartStamp = System.currentTimeMillis(); } - @Override - public ProjectPaths getProjectPaths() { - return myProjectPaths; - } - @Override public boolean isMake() { return myIsMake; @@ -121,34 +107,6 @@ public class CompileContextImpl extends UserDataHolderBase implements CompileCon myListeners.removeListener(listener); } - @Override - @NotNull - public ProcessorConfigProfile getAnnotationProcessingProfile(JpsModule module) { - final JpsJavaCompilerConfiguration compilerConfig = JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration( - getProjectDescriptor().getProject()); - Map map = myAnnotationProcessingProfileMap; - if (map == null) { - map = new HashMap(); - final Map namesMap = new HashMap(); - for (JpsModule m : getProjectDescriptor().getProject().getModules()) { - namesMap.put(m.getName(), m); - } - if (!namesMap.isEmpty()) { - for (ProcessorConfigProfile profile : compilerConfig.getAnnotationProcessingConfigurations()) { - for (String name : profile.getModuleNames()) { - final JpsModule mod = namesMap.get(name); - if (mod != null) { - map.put(mod, profile); - } - } - } - } - myAnnotationProcessingProfileMap = map; - } - final ProcessorConfigProfile profile = map.get(module); - return profile != null? profile : compilerConfig.getDefaultAnnotationProcessingConfiguration(); - } - @Override public void markNonIncremental(ModuleBuildTarget target) { if (!target.isTests()) { diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/ModuleBuildTarget.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/ModuleBuildTarget.java index 42be4576b4dd..e27534b98d40 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/ModuleBuildTarget.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/ModuleBuildTarget.java @@ -21,6 +21,7 @@ import com.intellij.util.SmartList; import gnu.trove.THashSet; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jps.ProjectPaths; import org.jetbrains.jps.builders.*; import org.jetbrains.jps.builders.java.ExcludedJavaSourceRootProvider; import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType; @@ -69,9 +70,11 @@ public final class ModuleBuildTarget extends JVMModuleBuildTarget allProfiles = - JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(model.getProject()).getAnnotationProcessingConfigurations(); - ProcessorConfigProfile profile = null; - final String moduleName = getModule().getName(); - for (ProcessorConfigProfile p : allProfiles) { - if (p.getModuleNames().contains(moduleName)) { - if (p.isEnabled()) { - profile = p; - } - break; - } - } - return profile; - } - @NotNull @Override public String getPresentableName() { diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/ClassProcessingBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/ClassProcessingBuilder.java index 475be1ed2564..8131cfd62739 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/ClassProcessingBuilder.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/ClassProcessingBuilder.java @@ -79,11 +79,9 @@ public abstract class ClassProcessingBuilder extends ModuleLevelBuilder { try { InstrumentationClassFinder finder = CLASS_FINDER.get(context); // try using shared finder if (finder == null) { - final ProjectPaths paths = context.getProjectPaths(); - final Collection platformCp = paths.getPlatformCompilationClasspath(chunk, false); - + final Collection platformCp = ProjectPaths.getPlatformCompilationClasspath(chunk, false); final Collection classpath = new ArrayList(); - classpath.addAll(paths.getCompilationClasspath(chunk, false)); + classpath.addAll(ProjectPaths.getCompilationClasspath(chunk, false)); classpath.addAll(ProjectPaths.getSourceRootsWithDependents(chunk).keySet()); finder = createInstrumentationClassFinder(platformCp, classpath, outputConsumer); diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/RmiStubsGenerator.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/RmiStubsGenerator.java index f4322364aca1..02c5cc1c1c30 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/RmiStubsGenerator.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/instrumentation/RmiStubsGenerator.java @@ -30,6 +30,7 @@ import gnu.trove.THashMap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.ModuleChunk; +import org.jetbrains.jps.ProjectPaths; import org.jetbrains.jps.incremental.*; import org.jetbrains.jps.incremental.messages.BuildMessage; import org.jetbrains.jps.incremental.messages.CompilerMessage; @@ -118,7 +119,7 @@ public class RmiStubsGenerator extends ClassProcessingBuilder { OutputConsumer outputConsumer) { ExitCode exitCode = ExitCode.NOTHING_DONE; - final Collection classpath = context.getProjectPaths().getCompilationClasspath(chunk, false); + final Collection classpath = ProjectPaths.getCompilationClasspath(chunk, false); final StringBuilder buf = new StringBuilder(); for (File file : classpath) { if (buf.length() > 0) { diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/AnnotationsExcludedJavaSourceRootProvider.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/AnnotationsExcludedJavaSourceRootProvider.java new file mode 100644 index 000000000000..4634be644d28 --- /dev/null +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/AnnotationsExcludedJavaSourceRootProvider.java @@ -0,0 +1,49 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jetbrains.jps.incremental.java; + +import com.intellij.openapi.util.io.FileUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jps.ProjectPaths; +import org.jetbrains.jps.builders.java.ExcludedJavaSourceRootProvider; +import org.jetbrains.jps.model.java.JavaSourceRootType; +import org.jetbrains.jps.model.java.JpsJavaExtensionService; +import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerConfiguration; +import org.jetbrains.jps.model.java.compiler.ProcessorConfigProfile; +import org.jetbrains.jps.model.module.JpsModule; +import org.jetbrains.jps.model.module.JpsModuleSourceRoot; + +import java.io.File; + +/** + * @author Eugene Zhuravlev + * Date: 12/14/12 + */ +public class AnnotationsExcludedJavaSourceRootProvider extends ExcludedJavaSourceRootProvider{ + @Override + public boolean isExcludedFromCompilation(@NotNull JpsModule module, @NotNull JpsModuleSourceRoot root) { + final JpsJavaCompilerConfiguration compilerConfig = JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(module.getProject()); + final ProcessorConfigProfile profile = compilerConfig.getAnnotationProcessingProfile(module); + if (!profile.isEnabled()) { + return false; + } + + final File outputDir = + ProjectPaths.getAnnotationProcessorGeneratedSourcesOutputDir(module, JavaSourceRootType.TEST_SOURCE == root.getRootType(), profile); + + return outputDir != null && FileUtil.filesEqual(outputDir, root.getFile()); + } +} diff --git a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java index fe34a7db9e2e..aa6202ce1b05 100644 --- a/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java +++ b/jps/jps-builders/src/org/jetbrains/jps/incremental/java/JavaBuilder.java @@ -207,12 +207,11 @@ public class JavaBuilder extends ModuleLevelBuilder { return exitCode; } - final ProjectPaths paths = context.getProjectPaths(); final ProjectDescriptor pd = context.getProjectDescriptor(); JavaBuilderUtil.ensureModuleHasJdk(chunk.representativeTarget().getModule(), context, BUILDER_NAME); - final Collection classpath = paths.getCompilationClasspath(chunk, false/*context.isProjectRebuild()*/); - final Collection platformCp = paths.getPlatformCompilationClasspath(chunk, false/*context.isProjectRebuild()*/); + final Collection classpath = ProjectPaths.getCompilationClasspath(chunk, false/*context.isProjectRebuild()*/); + final Collection platformCp = ProjectPaths.getPlatformCompilationClasspath(chunk, false/*context.isProjectRebuild()*/); // begin compilation round final DiagnosticSink diagnosticSink = new DiagnosticSink(context); @@ -297,14 +296,18 @@ public class JavaBuilder extends ModuleLevelBuilder { final TasksCounter counter = new TasksCounter(); COUNTER_KEY.set(context, counter); + final JpsJavaExtensionService javaExt = JpsJavaExtensionService.getInstance(); + final JpsJavaCompilerConfiguration compilerConfig = javaExt.getCompilerConfiguration(context.getProjectDescriptor().getProject()); + assert compilerConfig != null; + final Set modules = chunk.getModules(); ProcessorConfigProfile profile = null; if (modules.size() == 1) { - profile = context.getAnnotationProcessingProfile(modules.iterator().next()); + final JpsModule module = modules.iterator().next(); + profile = compilerConfig.getAnnotationProcessingProfile(module); } else { // perform cycle-related validations - final JpsJavaExtensionService javaExt = JpsJavaExtensionService.getInstance(); Pair pair = null; for (JpsModule module : modules) { final LanguageLevel moduleLevel = javaExt.getLanguageLevel(module); @@ -322,7 +325,7 @@ public class JavaBuilder extends ModuleLevelBuilder { // check that all chunk modules are excluded from annotation processing for (JpsModule module : modules) { - final ProcessorConfigProfile prof = context.getAnnotationProcessingProfile(module); + final ProcessorConfigProfile prof = compilerConfig.getAnnotationProcessingProfile(module); if (prof.isEnabled()) { final String message = "Annotation processing is not supported for module cycles. Please ensure that all modules from cycle [" + chunk.getName() + "] are excluded from annotation processing"; diagnosticSink.report(new PlainMessageDiagnostic(Diagnostic.Kind.ERROR, message)); @@ -596,7 +599,7 @@ public class JavaBuilder extends ModuleLevelBuilder { options.add("-A" + optionEntry.getKey() + "=" + optionEntry.getValue()); } - final File srcOutput = context.getProjectPaths().getAnnotationProcessorGeneratedSourcesOutputDir( + final File srcOutput = ProjectPaths.getAnnotationProcessorGeneratedSourcesOutputDir( chunk.getModules().iterator().next(), chunk.containsTests(), profile ); if (srcOutput != null) { diff --git a/jps/jps-builders/testSrc/org/jetbrains/jps/builders/ModuleClasspathTest.groovy b/jps/jps-builders/testSrc/org/jetbrains/jps/builders/ModuleClasspathTest.groovy index 55f8a86d4170..6c33c437cfd7 100644 --- a/jps/jps-builders/testSrc/org/jetbrains/jps/builders/ModuleClasspathTest.groovy +++ b/jps/jps-builders/testSrc/org/jetbrains/jps/builders/ModuleClasspathTest.groovy @@ -59,18 +59,14 @@ public class ModuleClasspathTest extends JpsRebuildTestCase { public void testCompilationClasspath() { ModuleChunk chunk = createChunk('main') assertClasspath(["util/lib/exported.jar", "out/production/util", "/jdk.jar"], - getPathsList(getProjectPaths().getPlatformCompilationClasspath(chunk, true))) + getPathsList(ProjectPaths.getPlatformCompilationClasspath(chunk, true))) assertClasspath(["main/lib/service.jar"], - getPathsList(getProjectPaths().getCompilationClasspath(chunk, true))) - } - - private ProjectPaths getProjectPaths() { - return new ProjectPaths(myProject) + getPathsList(ProjectPaths.getCompilationClasspath(chunk, true))) } private def assertClasspath(String moduleName, boolean includeTests, List expected) { ModuleChunk chunk = createChunk(moduleName) - final List classpath = getPathsList(new ProjectPaths(myProject).getCompilationClasspathFiles(chunk, includeTests, true, true)) + final List classpath = getPathsList(new ProjectPaths().getCompilationClasspathFiles(chunk, includeTests, true, true)) assertClasspath(expected, toSystemIndependentPaths(classpath)) } diff --git a/jps/model-api/src/org/jetbrains/jps/model/java/compiler/JpsJavaCompilerConfiguration.java b/jps/model-api/src/org/jetbrains/jps/model/java/compiler/JpsJavaCompilerConfiguration.java index 04c15923e086..8aaf77b1687d 100644 --- a/jps/model-api/src/org/jetbrains/jps/model/java/compiler/JpsJavaCompilerConfiguration.java +++ b/jps/model-api/src/org/jetbrains/jps/model/java/compiler/JpsJavaCompilerConfiguration.java @@ -18,6 +18,7 @@ package org.jetbrains.jps.model.java.compiler; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.model.JpsElement; +import org.jetbrains.jps.model.module.JpsModule; import java.util.Collection; import java.util.List; @@ -36,10 +37,21 @@ public interface JpsJavaCompilerConfiguration extends JpsElement { JpsCompilerExcludes getCompilerExcludes(); @NotNull - ProcessorConfigProfile getDefaultAnnotationProcessingConfiguration(); + ProcessorConfigProfile getDefaultAnnotationProcessingProfile(); ProcessorConfigProfile addAnnotationProcessingProfile(); + + /** + * @return a list of currently configured profiles excluding default one + */ @NotNull - Collection getAnnotationProcessingConfigurations(); + Collection getAnnotationProcessingProfiles(); + + /** + * @param module + * @return annotation profile with which the given module is associated + */ + @NotNull + ProcessorConfigProfile getAnnotationProcessingProfile(JpsModule module); void addResourcePattern(String pattern); List getResourcePatterns(); diff --git a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/compiler/JpsJavaCompilerConfigurationImpl.java b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/compiler/JpsJavaCompilerConfigurationImpl.java index 65851a20a549..12d01689ea0a 100644 --- a/jps/model-impl/src/org/jetbrains/jps/model/java/impl/compiler/JpsJavaCompilerConfigurationImpl.java +++ b/jps/model-impl/src/org/jetbrains/jps/model/java/impl/compiler/JpsJavaCompilerConfigurationImpl.java @@ -24,6 +24,7 @@ import org.jetbrains.jps.model.java.compiler.JpsCompilerExcludes; import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerConfiguration; import org.jetbrains.jps.model.java.compiler.JpsJavaCompilerOptions; import org.jetbrains.jps.model.java.compiler.ProcessorConfigProfile; +import org.jetbrains.jps.model.module.JpsModule; import java.util.*; @@ -42,6 +43,7 @@ public class JpsJavaCompilerConfigurationImpl extends JpsCompositeElementBase myModulesByteCodeTargetLevels = new HashMap(); private Map myCompilerOptions = new HashMap(); private String myJavaCompilerId = "Javac"; + private Map myAnnotationProcessingProfileMap; public JpsJavaCompilerConfigurationImpl() { } @@ -84,13 +86,13 @@ public class JpsJavaCompilerConfigurationImpl extends JpsCompositeElementBase getAnnotationProcessingConfigurations() { + public Collection getAnnotationProcessingProfiles() { return myAnnotationProcessingProfiles; } @@ -163,4 +165,30 @@ public class JpsJavaCompilerConfigurationImpl extends JpsCompositeElementBase map = myAnnotationProcessingProfileMap; + if (map == null) { + map = new HashMap(); + final Map namesMap = new HashMap(); + for (JpsModule m : module.getProject().getModules()) { + namesMap.put(m.getName(), m); + } + if (!namesMap.isEmpty()) { + for (ProcessorConfigProfile profile : getAnnotationProcessingProfiles()) { + for (String name : profile.getModuleNames()) { + final JpsModule mod = namesMap.get(name); + if (mod != null) { + map.put(mod, profile); + } + } + } + } + myAnnotationProcessingProfileMap = map; + } + final ProcessorConfigProfile profile = map.get(module); + return profile != null? profile : getDefaultAnnotationProcessingProfile(); + } } diff --git a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/java/compiler/JpsJavaCompilerConfigurationSerializer.java b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/java/compiler/JpsJavaCompilerConfigurationSerializer.java index 253f9434225f..b5cefb3b8b06 100644 --- a/jps/model-serialization/src/org/jetbrains/jps/model/serialization/java/compiler/JpsJavaCompilerConfigurationSerializer.java +++ b/jps/model-serialization/src/org/jetbrains/jps/model/serialization/java/compiler/JpsJavaCompilerConfigurationSerializer.java @@ -80,7 +80,7 @@ public class JpsJavaCompilerConfigurationSerializer extends JpsProjectExtensionS for (Element profileTag : profiles) { boolean isDefault = Boolean.parseBoolean(profileTag.getAttributeValue("default")); if (isDefault) { - AnnotationProcessorProfileSerializer.readExternal(configuration.getDefaultAnnotationProcessingConfiguration(), profileTag); + AnnotationProcessorProfileSerializer.readExternal(configuration.getDefaultAnnotationProcessingProfile(), profileTag); } else { AnnotationProcessorProfileSerializer.readExternal(configuration.addAnnotationProcessingProfile(), profileTag); diff --git a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsCompilerConfigurationTest.java b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsCompilerConfigurationTest.java index b39b76f536c2..654f349a96a2 100644 --- a/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsCompilerConfigurationTest.java +++ b/jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsCompilerConfigurationTest.java @@ -38,7 +38,7 @@ public class JpsCompilerConfigurationTest extends JpsSerializationTestCase { assertNotNull(configuration); assertFalse(configuration.isClearOutputDirectoryOnRebuild()); assertFalse(configuration.isAddNotNullAssertions()); - ProcessorConfigProfile defaultProfile = configuration.getDefaultAnnotationProcessingConfiguration(); + ProcessorConfigProfile defaultProfile = configuration.getDefaultAnnotationProcessingProfile(); assertTrue(defaultProfile.isEnabled()); assertFalse(defaultProfile.isObtainProcessorsFromClasspath()); assertEquals(FileUtil.toSystemDependentName(JpsPathUtil.urlToPath(getUrl("src"))), defaultProfile.getProcessorPath()); diff --git a/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidLibraryPackagingBuilder.java b/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidLibraryPackagingBuilder.java index 231b21a57767..2d46ef40efb4 100644 --- a/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidLibraryPackagingBuilder.java +++ b/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidLibraryPackagingBuilder.java @@ -60,7 +60,6 @@ public class AndroidLibraryPackagingBuilder extends ModuleLevelBuilder { continue; } - final ProjectPaths projectPaths = context.getProjectPaths(); File outputDir = AndroidJpsUtil.getDirectoryForIntermediateArtifacts(context, module); outputDir = AndroidJpsUtil.createDirIfNotExist(outputDir, context, BUILDER_NAME); if (outputDir == null) { @@ -68,7 +67,7 @@ public class AndroidLibraryPackagingBuilder extends ModuleLevelBuilder { continue; } - final File classesDir = projectPaths.getModuleOutputDir(module, false); + final File classesDir = ProjectPaths.getModuleOutputDir(module, false); if (classesDir == null || !classesDir.isDirectory()) { continue; } diff --git a/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidPackagingBuilder.java b/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidPackagingBuilder.java index 45118d7e21d3..b417740b769d 100644 --- a/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidPackagingBuilder.java +++ b/plugins/android/jps-plugin/src/org/jetbrains/jps/android/AndroidPackagingBuilder.java @@ -370,11 +370,10 @@ public class AndroidPackagingBuilder extends TargetBuilder getOutputRoots(CompileContext context) { - final File moduleOutputDir = context.getProjectPaths().getModuleOutputDir(myModule, false); + final File moduleOutputDir = ProjectPaths.getModuleOutputDir(myModule, false); final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule); if (moduleOutputDir == null || extension == null) { diff --git a/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovyBuilder.java b/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovyBuilder.java index 99060e81c62a..0ac63d6ee5b7 100644 --- a/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovyBuilder.java +++ b/plugins/groovy/jps-plugin/src/org/jetbrains/jps/incremental/groovy/GroovyBuilder.java @@ -27,6 +27,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.asm4.ClassReader; import org.jetbrains.jps.ModuleChunk; +import org.jetbrains.jps.ProjectPaths; import org.jetbrains.jps.builders.BuildRootIndex; import org.jetbrains.jps.builders.DirtyFilesHolder; import org.jetbrains.jps.builders.FileProcessor; @@ -372,7 +373,7 @@ public class GroovyBuilder extends ModuleLevelBuilder { // IMPORTANT! must be the first in classpath cp.add(getGroovyRtRoot().getPath()); - for (File file : context.getProjectPaths().getCompilationClasspathFiles(chunk, chunk.containsTests(), false, false)) { + for (File file : ProjectPaths.getCompilationClasspathFiles(chunk, chunk.containsTests(), false, false)) { cp.add(FileUtil.toCanonicalPath(file.getPath())); } diff --git a/plugins/ui-designer/jps-plugin/src/org/jetbrains/jps/uiDesigner/compiler/FormsInstrumenter.java b/plugins/ui-designer/jps-plugin/src/org/jetbrains/jps/uiDesigner/compiler/FormsInstrumenter.java index 62063da6e95e..614c4e3a7491 100644 --- a/plugins/ui-designer/jps-plugin/src/org/jetbrains/jps/uiDesigner/compiler/FormsInstrumenter.java +++ b/plugins/ui-designer/jps-plugin/src/org/jetbrains/jps/uiDesigner/compiler/FormsInstrumenter.java @@ -85,11 +85,10 @@ public class FormsInstrumenter extends FormsBuilder { } try { - final ProjectPaths paths = context.getProjectPaths(); - final Collection platformCp = paths.getPlatformCompilationClasspath(chunk, false); + final Collection platformCp = ProjectPaths.getPlatformCompilationClasspath(chunk, false); final List classpath = new ArrayList(); - classpath.addAll(paths.getCompilationClasspath(chunk, false)); + classpath.addAll(ProjectPaths.getCompilationClasspath(chunk, false)); classpath.add(getResourcePath(GridConstraints.class)); // forms_rt.jar final Map chunkSourcePath = ProjectPaths.getSourceRootsWithDependents(chunk); classpath.addAll(chunkSourcePath.keySet()); // sourcepath for loading forms resources