introducing ModuleBasedBuildTargetType for differentiating module-based targets and splitting BuilderRegistry into BuilderRegistry and TargetTypeRegistry for better functionality separation

jps/jps-builders/src/org/jetbrains/jps/builders/ModuleBasedBuildTargetType.java

@@ -0,0 +1,7 @@
+package org.jetbrains.jps.builders;
+
+public abstract class ModuleBasedBuildTargetType<T extends ModuleBasedTarget<?>> extends BuildTargetType<T>{
+  protected ModuleBasedBuildTargetType(String typeId) {
+    super(typeId);
+  }
+}

jps/jps-builders/src/org/jetbrains/jps/builders/ModuleBasedTarget.java

@@ -25,7 +25,7 @@ import org.jetbrains.jps.model.module.JpsModule;
 public abstract class ModuleBasedTarget<R extends BuildRootDescriptor> extends BuildTarget<R> {
   protected final JpsModule myModule;
 
-  public ModuleBasedTarget(BuildTargetType<?> targetType, @NotNull JpsModule module) {
+  public ModuleBasedTarget(ModuleBasedBuildTargetType<?> targetType, @NotNull JpsModule module) {
     super(targetType);
     myModule = module;
   }

jps/jps-builders/src/org/jetbrains/jps/builders/impl/BuildRootIndexImpl.java

@@ -27,8 +27,8 @@ import org.jetbrains.jps.builders.*;
 import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType;
 import org.jetbrains.jps.builders.java.JavaSourceRootDescriptor;
 import org.jetbrains.jps.builders.storage.BuildDataPaths;
-import org.jetbrains.jps.incremental.BuilderRegistry;
 import org.jetbrains.jps.incremental.CompileContext;
+import org.jetbrains.jps.incremental.TargetTypeRegistry;
 import org.jetbrains.jps.indices.IgnoredFileIndex;
 import org.jetbrains.jps.indices.ModuleExcludeIndex;
 import org.jetbrains.jps.model.JpsModel;
@@ -57,7 +57,7 @@ public class BuildRootIndexImpl implements BuildRootIndex {
     myRootToDescriptors = new THashMap<File, List<BuildRootDescriptor>>(FileUtil.FILE_HASHING_STRATEGY);
     myFileFilters = new ConcurrentHashMap<BuildRootDescriptor, FileFilter>();
     final Iterable<AdditionalRootsProviderService> rootsProviders = JpsServiceManager.getInstance().getExtensions(AdditionalRootsProviderService.class);
-    for (BuildTargetType<?> targetType : BuilderRegistry.getInstance().getTargetTypes()) {
+    for (BuildTargetType<?> targetType : TargetTypeRegistry.getInstance().getTargetTypes()) {
       for (BuildTarget<?> target : targetIndex.getAllTargets(targetType)) {
         addRoots(dataPaths, rootsProviders, target, model, index, ignoredFileIndex);
       }

jps/jps-builders/src/org/jetbrains/jps/builders/impl/BuildTargetIndexImpl.java

@@ -25,8 +25,8 @@ import gnu.trove.TIntArrayList;
 import gnu.trove.TIntProcedure;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jps.builders.*;
-import org.jetbrains.jps.incremental.BuilderRegistry;
 import org.jetbrains.jps.incremental.CompileContext;
+import org.jetbrains.jps.incremental.TargetTypeRegistry;
 import org.jetbrains.jps.model.JpsModel;
 import org.jetbrains.jps.model.module.JpsModule;
 
@@ -46,7 +46,7 @@ public class BuildTargetIndexImpl implements BuildTargetIndex {
     myTargets = new THashMap<BuildTargetType<?>, List<? extends BuildTarget<?>>>();
     myModuleBasedTargets = new THashMap<JpsModule, List<ModuleBasedTarget>>();
     List<List<? extends BuildTarget<?>>> targetsByType = new ArrayList<List<? extends BuildTarget<?>>>();
-    for (BuildTargetType<?> type : BuilderRegistry.getInstance().getTargetTypes()) {
+    for (BuildTargetType<?> type : TargetTypeRegistry.getInstance().getTargetTypes()) {
       List<? extends BuildTarget<?>> targets = type.computeAllTargets(model);
       myTargets.put(type, targets);
       targetsByType.add(targets);

jps/jps-builders/src/org/jetbrains/jps/builders/java/JavaModuleBuildTargetType.java

@@ -18,7 +18,7 @@ package org.jetbrains.jps.builders.java;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.builders.BuildTargetLoader;
-import org.jetbrains.jps.builders.BuildTargetType;
+import org.jetbrains.jps.builders.ModuleBasedBuildTargetType;
 import org.jetbrains.jps.incremental.ModuleBuildTarget;
 import org.jetbrains.jps.model.JpsModel;
 import org.jetbrains.jps.model.module.JpsModule;
@@ -28,7 +28,7 @@ import java.util.*;
 /**
  * @author nik
  */
-public class JavaModuleBuildTargetType extends BuildTargetType<ModuleBuildTarget> {
+public class JavaModuleBuildTargetType extends ModuleBasedBuildTargetType<ModuleBuildTarget> {
   public static final JavaModuleBuildTargetType PRODUCTION = new JavaModuleBuildTargetType("java-production", false);
   public static final JavaModuleBuildTargetType TEST = new JavaModuleBuildTargetType("java-test", true);
   public static final List<JavaModuleBuildTargetType> ALL_TYPES = Arrays.asList(PRODUCTION, TEST);

jps/jps-builders/src/org/jetbrains/jps/builders/java/ResourcesTargetType.java

@@ -18,7 +18,7 @@ package org.jetbrains.jps.builders.java;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.builders.BuildTargetLoader;
-import org.jetbrains.jps.builders.BuildTargetType;
+import org.jetbrains.jps.builders.ModuleBasedBuildTargetType;
 import org.jetbrains.jps.incremental.ResourcesTarget;
 import org.jetbrains.jps.model.JpsModel;
 import org.jetbrains.jps.model.module.JpsModule;
@@ -28,7 +28,7 @@ import java.util.*;
 /**
  * @author nik
  */
-public class ResourcesTargetType extends BuildTargetType<ResourcesTarget> {
+public class ResourcesTargetType extends ModuleBasedBuildTargetType<ResourcesTarget> {
   public static final ResourcesTargetType PRODUCTION = new ResourcesTargetType("resources-production", false);
   public static final ResourcesTargetType TEST = new ResourcesTargetType("resources-test", true);
   public static final List<ResourcesTargetType> ALL_TYPES = Arrays.asList(PRODUCTION, TEST);

jps/jps-builders/src/org/jetbrains/jps/cmdline/BuildRunner.java

@@ -165,8 +165,9 @@ public class BuildRunner {
     Set<BuildTarget<?>> targets = new HashSet<BuildTarget<?>>();
     Map<BuildTarget<?>, Set<File>> files;
 
+    final TargetTypeRegistry typeRegistry = TargetTypeRegistry.getInstance();
     for (TargetTypeBuildScope scope : scopes) {
-      BuildTargetType<?> targetType = BuilderRegistry.getInstance().getTargetType(scope.getTypeId());
+      final BuildTargetType<?> targetType = typeRegistry.getTargetType(scope.getTypeId());
       if (targetType == null) {
         LOG.info("Unknown target type: " + scope.getTypeId());
         continue;

jps/jps-builders/src/org/jetbrains/jps/cmdline/BuildSession.java

@@ -24,7 +24,6 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.concurrency.SequentialTaskExecutor;
 import com.intellij.util.io.DataOutputStream;
-import gnu.trove.THashMap;
 import org.jboss.netty.channel.Channel;
 import org.jboss.netty.channel.Channels;
 import org.jetbrains.annotations.Nullable;
@@ -32,20 +31,17 @@ import org.jetbrains.jps.api.*;
 import org.jetbrains.jps.builders.*;
 import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType;
 import org.jetbrains.jps.builders.java.dependencyView.Callbacks;
-import org.jetbrains.jps.incremental.BuilderService;
 import org.jetbrains.jps.incremental.MessageHandler;
+import org.jetbrains.jps.incremental.TargetTypeRegistry;
 import org.jetbrains.jps.incremental.Utils;
 import org.jetbrains.jps.incremental.fs.BuildFSState;
 import org.jetbrains.jps.incremental.fs.FSState;
 import org.jetbrains.jps.incremental.messages.*;
 import org.jetbrains.jps.incremental.storage.Timestamps;
 import org.jetbrains.jps.model.module.JpsModule;
-import org.jetbrains.jps.service.JpsServiceManager;
 import org.jetbrains.jps.service.SharedThreadPool;
 
 import java.io.*;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
 import java.util.*;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
@@ -231,23 +227,18 @@ final class BuildSession implements Runnable, CanceledStatus {
   }
 
   private static boolean scopeContainsModulesOnly(List<TargetTypeBuildScope> scopes) {
-    Map<String, BuildTargetType<?>> allTypes = null;
+    TargetTypeRegistry typeRegistry = null;
     for (TargetTypeBuildScope scope : scopes) {
       final String typeId = scope.getTypeId();
       if (isJavaModuleBuildType(typeId)) { // fast check
         continue;
       }
-      if (allTypes == null) {
+      if (typeRegistry == null) {
         // lazy init
-        allTypes = new THashMap<String, BuildTargetType<?>>();
-        for (BuilderService builderService : JpsServiceManager.getInstance().getExtensions(BuilderService.class)) {
-          for (BuildTargetType<?> targetType : builderService.getTargetTypes()) {
-            allTypes.put(targetType.getTypeId(), targetType);
-          }
-        }
+        typeRegistry = TargetTypeRegistry.getInstance();
       }
-      final BuildTargetType<?> targetType = allTypes.get(typeId);
-      if (targetType != null && !isModuleBasedTargetType(targetType)) {
+      final BuildTargetType<?> targetType = typeRegistry.getTargetType(typeId);
+      if (targetType != null && !(targetType instanceof ModuleBasedBuildTargetType)) {
         return false;
       }
     }
@@ -263,20 +254,6 @@ final class BuildSession implements Runnable, CanceledStatus {
     return false;
   }
 
-  private static boolean isModuleBasedTargetType(final BuildTargetType targetType) {
-    Class<?> aClass = targetType.getClass();
-    while (!BuildTargetType.class.equals(aClass.getSuperclass())) {
-      aClass = aClass.getSuperclass();
-    }
-    final ParameterizedType generic = (ParameterizedType)aClass.getGenericSuperclass();
-    for (Type type : generic.getActualTypeArguments()) {
-      if (type instanceof Class && ModuleBasedTarget.class.isAssignableFrom((Class)type)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
   private void saveData(final BuildFSState fsState, File dataStorageRoot) {
     final boolean wasInterrupted = Thread.interrupted();
     try {

jps/jps-builders/src/org/jetbrains/jps/incremental/BuilderRegistry.java

@@ -20,8 +20,6 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.io.FileUtilRt;
 import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jps.builders.BuildTargetType;
 import org.jetbrains.jps.service.JpsServiceManager;
 
 import java.io.File;
@@ -39,7 +37,6 @@ public class BuilderRegistry {
   }
   private final Map<BuilderCategory, List<ModuleLevelBuilder>> myModuleLevelBuilders = new HashMap<BuilderCategory, List<ModuleLevelBuilder>>();
   private final List<TargetBuilder<?,?>> myTargetBuilders = new ArrayList<TargetBuilder<?,?>>();
-  private final Map<String, BuildTargetType<?>> myTargetTypes = new LinkedHashMap<String, BuildTargetType<?>>();
   private final FileFilter myModuleBuilderFileFilter;
 
   public static BuilderRegistry getInstance() {
@@ -66,13 +63,6 @@ public class BuilderRegistry {
         }
         myModuleLevelBuilders.get(builder.getCategory()).add(builder);
       }
-      for (BuildTargetType<?> type : service.getTargetTypes()) {
-        String id = type.getTypeId();
-        BuildTargetType<?> old = myTargetTypes.put(id, type);
-        if (old != null) {
-          LOG.error("Two build target types (" + type + ", " + old + ") use same id (" + id + ")");
-        }
-      }
     }
     if (compilableFileExtensions == null) {
       myModuleBuilderFileFilter = FileUtilRt.ALL_FILES;
@@ -88,20 +78,11 @@ public class BuilderRegistry {
     }
   }
 
-  @Nullable
-  public BuildTargetType<?> getTargetType(String typeId) {
-    return myTargetTypes.get(typeId);
-  }
-
   @NotNull
   public FileFilter getModuleBuilderFileFilter() {
     return myModuleBuilderFileFilter;
   }
 
-  public Collection<BuildTargetType<?>> getTargetTypes() {
-    return myTargetTypes.values();
-  }
-
   public int getModuleLevelBuilderCount() {
     int count = 0;
     for (BuilderCategory category : BuilderCategory.values()) {

jps/jps-builders/src/org/jetbrains/jps/incremental/JVMModuleBuildTarget.java

@@ -19,10 +19,7 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.containers.ContainerUtil;
 import gnu.trove.THashSet;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jps.builders.BuildRootDescriptor;
-import org.jetbrains.jps.builders.BuildRootIndex;
-import org.jetbrains.jps.builders.BuildTargetType;
-import org.jetbrains.jps.builders.ModuleBasedTarget;
+import org.jetbrains.jps.builders.*;
 import org.jetbrains.jps.indices.ModuleExcludeIndex;
 import org.jetbrains.jps.model.module.JpsModule;
 
@@ -38,7 +35,7 @@ import java.util.Set;
  */
 public abstract class JVMModuleBuildTarget<R extends BuildRootDescriptor> extends ModuleBasedTarget<R> {
 
-  public JVMModuleBuildTarget(BuildTargetType<? extends JVMModuleBuildTarget<R>> targetType, JpsModule module) {
+  public JVMModuleBuildTarget(ModuleBasedBuildTargetType<? extends JVMModuleBuildTarget<R>> targetType, JpsModule module) {
     super(targetType, module);
   }
 

jps/jps-builders/src/org/jetbrains/jps/incremental/TargetTypeRegistry.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2000-2013 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;
+
+import com.intellij.openapi.diagnostic.Logger;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jps.builders.BuildTargetType;
+import org.jetbrains.jps.service.JpsServiceManager;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class TargetTypeRegistry {
+  private static final Logger LOG = Logger.getInstance("#org.jetbrains.jps.incremental.TargetTypeRegistry");
+  private static class Holder {
+    static final TargetTypeRegistry ourInstance = new TargetTypeRegistry();
+  }
+  private final Map<String, BuildTargetType<?>> myTargetTypes = new LinkedHashMap<String, BuildTargetType<?>>();
+
+  public static TargetTypeRegistry getInstance() {
+    return Holder.ourInstance;
+  }
+
+  private TargetTypeRegistry() {
+    for (BuilderService service : JpsServiceManager.getInstance().getExtensions(BuilderService.class)) {
+      for (BuildTargetType<?> type : service.getTargetTypes()) {
+        String id = type.getTypeId();
+        BuildTargetType<?> old = myTargetTypes.put(id, type);
+        if (old != null) {
+          LOG.error("Two build target types (" + type + ", " + old + ") use same id (" + id + ")");
+        }
+      }
+    }
+  }
+
+  @Nullable
+  public BuildTargetType<?> getTargetType(String typeId) {
+    return myTargetTypes.get(typeId);
+  }
+
+
+  public Collection<BuildTargetType<?>> getTargetTypes() {
+    return myTargetTypes.values();
+  }
+
+}

jps/jps-builders/src/org/jetbrains/jps/incremental/fs/FSState.java

@@ -23,8 +23,8 @@ import gnu.trove.TObjectLongHashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.builders.*;
-import org.jetbrains.jps.incremental.BuilderRegistry;
 import org.jetbrains.jps.incremental.CompileContext;
+import org.jetbrains.jps.incremental.TargetTypeRegistry;
 import org.jetbrains.jps.incremental.storage.Timestamps;
 import org.jetbrains.jps.model.JpsModel;
 
@@ -63,7 +63,7 @@ public class FSState {
   }
 
   public void load(DataInputStream in, JpsModel model, final BuildRootIndex buildRootIndex) throws IOException {
-    BuilderRegistry registry = BuilderRegistry.getInstance();
+    final TargetTypeRegistry registry = TargetTypeRegistry.getInstance();
     int typeCount = in.readInt();
     while (typeCount-- > 0) {
       final String typeId = IOUtil.readString(in);

jps/jps-builders/src/org/jetbrains/jps/incremental/storage/BuildTargetsState.java

@@ -23,7 +23,7 @@ import org.jetbrains.jps.builders.BuildTarget;
 import org.jetbrains.jps.builders.BuildTargetType;
 import org.jetbrains.jps.builders.impl.BuildRootIndexImpl;
 import org.jetbrains.jps.builders.storage.BuildDataPaths;
-import org.jetbrains.jps.incremental.BuilderRegistry;
+import org.jetbrains.jps.incremental.TargetTypeRegistry;
 import org.jetbrains.jps.model.JpsModel;
 
 import java.io.*;
@@ -58,7 +58,7 @@ public class BuildTargetsState {
     catch (IOException e) {
       LOG.debug("Cannot load " + targetTypesFile + ":" + e.getMessage(), e);
       LOG.debug("Loading all target types to calculate max target id");
-      for (BuildTargetType<?> type : BuilderRegistry.getInstance().getTargetTypes()) {
+      for (BuildTargetType<?> type : TargetTypeRegistry.getInstance().getTargetTypes()) {
         getTypeState(type);
       }
     }

jps/jps-builders/testSrc/org/jetbrains/jps/builders/CompileScopeTestBuilder.java

@@ -17,10 +17,10 @@ package org.jetbrains.jps.builders;
 
 import org.jetbrains.jps.api.BuildType;
 import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType;
-import org.jetbrains.jps.incremental.BuilderRegistry;
 import org.jetbrains.jps.incremental.CompileScope;
 import org.jetbrains.jps.incremental.CompileScopeImpl;
 import org.jetbrains.jps.incremental.ModuleBuildTarget;
+import org.jetbrains.jps.incremental.TargetTypeRegistry;
 import org.jetbrains.jps.incremental.artifacts.ArtifactBuildTarget;
 import org.jetbrains.jps.incremental.artifacts.ArtifactBuildTargetType;
 import org.jetbrains.jps.model.artifact.JpsArtifact;
@@ -85,7 +85,7 @@ public class CompileScopeTestBuilder {
   }
 
   public CompileScopeTestBuilder all() {
-    myTargetTypes.addAll(BuilderRegistry.getInstance().getTargetTypes());
+    myTargetTypes.addAll(TargetTypeRegistry.getInstance().getTargetTypes());
     return this;
   }
 

plugins/maven/jps-plugin/src/org/jetbrains/jps/maven/model/impl/MavenResourcesTargetType.java

@@ -18,7 +18,7 @@ package org.jetbrains.jps.maven.model.impl;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jps.builders.BuildTargetLoader;
-import org.jetbrains.jps.builders.BuildTargetType;
+import org.jetbrains.jps.builders.ModuleBasedBuildTargetType;
 import org.jetbrains.jps.maven.model.JpsMavenExtensionService;
 import org.jetbrains.jps.model.JpsModel;
 import org.jetbrains.jps.model.module.JpsModule;
@@ -32,7 +32,7 @@ import java.util.Map;
 * @author Eugene Zhuravlev
 *         Date: 10/24/12
 */
-public class MavenResourcesTargetType extends BuildTargetType<MavenResourcesTarget> {
+public class MavenResourcesTargetType extends ModuleBasedBuildTargetType<MavenResourcesTarget> {
   public static final MavenResourcesTargetType PRODUCTION = new MavenResourcesTargetType("maven-resources-production", false);
   public static final MavenResourcesTargetType TEST = new MavenResourcesTargetType("maven-resources-test", true);