import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
public List<JavaSourceRootDescriptor> computeRootDescriptors(JpsModel model, ModuleExcludeIndex index, IgnoredFileIndex ignoredFileIndex, BuildDataPaths dataPaths) {
  List<JavaSourceRootDescriptor> roots = new ArrayList<JavaSourceRootDescriptor>();
  JavaSourceRootType type = isTests() ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE;
  Iterable<ExcludedJavaSourceRootProvider> excludedRootProviders = JpsServiceManager.getInstance().getExtensions(ExcludedJavaSourceRootProvider.class);
  final Set<File> moduleExcludes = new THashSet<File>(FileUtil.FILE_HASHING_STRATEGY);
  moduleExcludes.addAll(index.getModuleExcludes(myModule));

  roots_loop:
  for (JpsTypedModuleSourceRoot<JavaSourceRootProperties> sourceRoot : myModule.getSourceRoots(type)) {
    if (JpsPathUtil.isUnder(moduleExcludes, sourceRoot.getFile())) {
      continue;
    }
    for (ExcludedJavaSourceRootProvider provider : excludedRootProviders) {
      if (provider.isExcludedFromCompilation(myModule, sourceRoot)) {
        continue roots_loop;
      }
    }
    final String packagePrefix = sourceRoot.getProperties().getPackagePrefix();
    roots.add(new JavaSourceRootDescriptor(sourceRoot.getFile(), this, false, false, packagePrefix,
                                           computeRootExcludes(sourceRoot.getFile(), index)));
  }
  return roots;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
private <R extends BuildRootDescriptor> void addRoots(BuildDataPaths dataPaths, Iterable<AdditionalRootsProviderService> rootsProviders,
                                                      BuildTarget<R> target,
                                                      JpsModel model,
                                                      ModuleExcludeIndex index,
                                                      IgnoredFileIndex ignoredFileIndex) {
  List<R> descriptors = target.computeRootDescriptors(model, index, ignoredFileIndex, dataPaths);
  for (AdditionalRootsProviderService<?> provider : rootsProviders) {
    if (provider.getTargetTypes().contains(target.getTargetType())) {
      //noinspection unchecked
      AdditionalRootsProviderService<R> providerService = (AdditionalRootsProviderService<R>)provider;
      final List<R> additionalRoots = providerService.getAdditionalRoots(target, dataPaths);
      if (!additionalRoots.isEmpty()) {
        descriptors = new ArrayList<R>(descriptors);
        descriptors.addAll(additionalRoots);
      }
    }
  }
  for (BuildRootDescriptor descriptor : descriptors) {
    registerDescriptor(descriptor);
  }
  if (descriptors instanceof ArrayList<?>) {
    ((ArrayList)descriptors).trimToSize();
  }
  myRootsByTarget.put(target, descriptors);
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
protected ProjectDescriptor createProjectDescriptor(final BuildLoggingManager buildLoggingManager) {
  try {
    BuildTargetRegistryImpl targetRegistry = new BuildTargetRegistryImpl(myModel);
    ModuleExcludeIndex index = new ModuleExcludeIndexImpl(myModel);
    IgnoredFileIndexImpl ignoredFileIndex = new IgnoredFileIndexImpl(myModel);
    BuildDataPaths dataPaths = new BuildDataPathsImpl(myDataStorageRoot);
    BuildRootIndexImpl buildRootIndex = new BuildRootIndexImpl(targetRegistry, myModel, index, dataPaths, ignoredFileIndex);
    BuildTargetIndexImpl targetIndex = new BuildTargetIndexImpl(targetRegistry, buildRootIndex);
    BuildTargetsState targetsState = new BuildTargetsState(dataPaths, myModel, buildRootIndex);
    ProjectTimestamps timestamps = new ProjectTimestamps(myDataStorageRoot, targetsState);
    BuildDataManager dataManager = new BuildDataManager(dataPaths, targetsState, true);
    return new ProjectDescriptor(myModel, new BuildFSState(true), timestamps, dataManager, buildLoggingManager, index, targetsState,
                                 targetIndex, buildRootIndex, ignoredFileIndex);
  }
  catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
public List<MyRootDescriptor> computeRootDescriptors(JpsModel model,
                                                        ModuleExcludeIndex index,
                                                        IgnoredFileIndex ignoredFileIndex,
                                                        BuildDataPaths dataPaths) {
  final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(myModule);
  assert extension != null;
  final List<MyRootDescriptor> result = new ArrayList<MyRootDescriptor>();

  final File manifestFile = AndroidJpsUtil.getManifestFileForCompilationPath(extension);

  if (manifestFile != null) {
    result.add(new MyRootDescriptor(this, manifestFile, false));
  }

  for (JpsAndroidModuleExtension libExtension : AndroidJpsUtil.getAllAndroidDependencies(myModule, true)) {
    final File libManifest = AndroidJpsUtil.getManifestFileForCompilationPath(libExtension);

    if (libManifest != null && libManifest.exists()) {
      result.add(new MyRootDescriptor(this, libManifest, true));
    }
  }
  return result;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
protected List<BuildRootDescriptor> doComputeRootDescriptors(JpsModel model,
                                                             ModuleExcludeIndex index,
                                                             IgnoredFileIndex ignoredFileIndex,
                                                             BuildDataPaths dataPaths) {
  final File moduleOutputDir = ProjectPaths.getModuleOutputDir(myModule, false);

  if (moduleOutputDir != null) {
    return Collections.<BuildRootDescriptor>singletonList(
      new AndroidClassesDirBuildRootDescriptor(this, moduleOutputDir));
  }
  else {
    return Collections.emptyList();
  }
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
protected List<BuildRootDescriptor> doComputeRootDescriptors(JpsModel model,
                                                             ModuleExcludeIndex index,
                                                             IgnoredFileIndex ignoredFileIndex,
                                                             BuildDataPaths dataPaths) {
  final Set<JpsLibrary> libraries = JpsJavaExtensionService.getInstance().enumerateDependencies(
    Collections.singleton(myModule)).runtimeOnly().productionOnly().getLibraries();
  final List<BuildRootDescriptor> result = new ArrayList<BuildRootDescriptor>();

  for (JpsLibrary library : libraries) {
    final Pair<File, List<File>> pair = AndroidJpsUtil.getResDirAndJarsIfAar(library);
    final List<File> jars = pair != null ? pair.getSecond() : null;

    if (jars != null) {
      for (File jar : jars) {
        result.add(new BuildRootDescriptorImpl(this, jar));
      }
    }
  }
  return result;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
public List<GradleResourceRootDescriptor> computeRootDescriptors(JpsModel model, ModuleExcludeIndex index, IgnoredFileIndex ignoredFileIndex, BuildDataPaths dataPaths) {
  final List<GradleResourceRootDescriptor> result = new ArrayList<GradleResourceRootDescriptor>();

  GradleProjectConfiguration projectConfig = JpsGradleExtensionService.getInstance().getGradleProjectConfiguration(dataPaths);
  GradleModuleResourceConfiguration moduleConfig = projectConfig.moduleConfigurations.get(myModule.getName());
  if (moduleConfig == null) return Collections.emptyList();

  int i = 0;

  for (ResourceRootConfiguration resource : getRootConfigurations(moduleConfig)) {
    result.add(new GradleResourceRootDescriptor(this, resource, i++, moduleConfig.overwrite));
  }
  return result;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
public List<MavenResourceRootDescriptor> computeRootDescriptors(JpsModel model, ModuleExcludeIndex index, IgnoredFileIndex ignoredFileIndex, BuildDataPaths dataPaths) {
  // todo: should we honor ignored and excluded roots here?
  final List<MavenResourceRootDescriptor> result = new ArrayList<MavenResourceRootDescriptor>();

  MavenModuleResourceConfiguration moduleConfig = getModuleResourcesConfiguration(dataPaths);
  if (moduleConfig == null) return Collections.emptyList();

  int i = 0;

  for (ResourceRootConfiguration resource : getRootConfigurations(moduleConfig)) {
    result.add(new MavenResourceRootDescriptor(this, resource, i++, moduleConfig.overwrite));
  }
  return result;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
public List<JavaSourceRootDescriptor> computeRootDescriptors(JpsModel model, ModuleExcludeIndex index, IgnoredFileIndex ignoredFileIndex, BuildDataPaths dataPaths) {
  List<JavaSourceRootDescriptor> roots = new ArrayList<JavaSourceRootDescriptor>();
  JavaSourceRootType type = isTests() ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE;
  Iterable<ExcludedJavaSourceRootProvider> excludedRootProviders = JpsServiceManager.getInstance().getExtensions(ExcludedJavaSourceRootProvider.class);
  final Set<File> moduleExcludes = new THashSet<File>(FileUtil.FILE_HASHING_STRATEGY);
  moduleExcludes.addAll(index.getModuleExcludes(myModule));

  roots_loop:
  for (JpsTypedModuleSourceRoot<JpsSimpleElement<JavaSourceRootProperties>> sourceRoot : myModule.getSourceRoots(type)) {
    if (JpsPathUtil.isUnder(moduleExcludes, sourceRoot.getFile())) {
      continue;
    }
    for (ExcludedJavaSourceRootProvider provider : excludedRootProviders) {
      if (provider.isExcludedFromCompilation(myModule, sourceRoot)) {
        continue roots_loop;
      }
    }
    final String packagePrefix = sourceRoot.getProperties().getData().getPackagePrefix();
    roots.add(new JavaSourceRootDescriptor(sourceRoot.getFile(), this, false, false, packagePrefix,
                                           computeRootExcludes(sourceRoot.getFile(), index)));
  }
  return roots;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
public List<ResourceRootDescriptor> computeRootDescriptors(JpsModel model, ModuleExcludeIndex index, IgnoredFileIndex ignoredFileIndex, BuildDataPaths dataPaths) {
  List<ResourceRootDescriptor> roots = new ArrayList<ResourceRootDescriptor>();
  JavaSourceRootType type = isTests() ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE;
  Iterable<ExcludedJavaSourceRootProvider> excludedRootProviders = JpsServiceManager.getInstance().getExtensions(ExcludedJavaSourceRootProvider.class);

  roots_loop:
  for (JpsTypedModuleSourceRoot<JpsSimpleElement<JavaSourceRootProperties>> sourceRoot : myModule.getSourceRoots(type)) {
    for (ExcludedJavaSourceRootProvider provider : excludedRootProviders) {
      if (provider.isExcludedFromCompilation(myModule, sourceRoot)) {
        continue roots_loop;
      }
    }
    final String packagePrefix = sourceRoot.getProperties().getData().getPackagePrefix();
    final File rootFile = sourceRoot.getFile();
    roots.add(new ResourceRootDescriptor(rootFile, this, false, packagePrefix, computeRootExcludes(rootFile, index)));
  }

  return roots;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
private <R extends BuildRootDescriptor> void addRoots(BuildDataPaths dataPaths, Iterable<AdditionalRootsProviderService> rootsProviders,
                                                      BuildTarget<R> target,
                                                      JpsModel model,
                                                      ModuleExcludeIndex index,
                                                      IgnoredFileIndex ignoredFileIndex) {
  List<R> descriptors = target.computeRootDescriptors(model, index, ignoredFileIndex, dataPaths);
  for (AdditionalRootsProviderService<?> provider : rootsProviders) {
    if (provider.getTargetTypes().contains(target.getTargetType())) {
      //noinspection unchecked
      AdditionalRootsProviderService<R> providerService = (AdditionalRootsProviderService<R>)provider;
      final List<R> additionalRoots = providerService.getAdditionalRoots(target, dataPaths);
      if (!additionalRoots.isEmpty()) {
        descriptors = new ArrayList<R>(descriptors);
        descriptors.addAll(additionalRoots);
      }
    }
  }
  for (BuildRootDescriptor descriptor : descriptors) {
    registerDescriptor(descriptor);
  }
  myRootsByTarget.put(target, descriptors);
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
protected ProjectDescriptor createProjectDescriptor(final BuildLoggingManager buildLoggingManager) {
  try {
    BuildTargetIndexImpl targetIndex = new BuildTargetIndexImpl(myModel);
    ModuleExcludeIndex index = new ModuleExcludeIndexImpl(myModel);
    IgnoredFileIndexImpl ignoredFileIndex = new IgnoredFileIndexImpl(myModel);
    BuildDataPaths dataPaths = new BuildDataPathsImpl(myDataStorageRoot);
    BuildRootIndexImpl buildRootIndex = new BuildRootIndexImpl(targetIndex, myModel, index, dataPaths, ignoredFileIndex);
    BuildTargetsState targetsState = new BuildTargetsState(dataPaths, myModel, buildRootIndex);
    ProjectTimestamps timestamps = new ProjectTimestamps(myDataStorageRoot, targetsState);
    BuildDataManager dataManager = new BuildDataManager(dataPaths, targetsState, true);
    return new ProjectDescriptor(myModel, new BuildFSState(true), timestamps, dataManager, buildLoggingManager, index, targetsState,
                                 targetIndex, buildRootIndex, ignoredFileIndex);
  }
  catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
public List<ArtifactRootDescriptor> computeRootDescriptors(JpsModel model,
                                                           ModuleExcludeIndex index,
                                                           IgnoredFileIndex ignoredFileIndex,
                                                           BuildDataPaths dataPaths) {
  ArtifactInstructionsBuilderImpl builder = new ArtifactInstructionsBuilderImpl(index, ignoredFileIndex, this, model, dataPaths);
  ArtifactInstructionsBuilderContext context = new ArtifactInstructionsBuilderContextImpl(model, dataPaths);
  String outputPath = StringUtil.notNullize(myArtifact.getOutputPath());
  final CopyToDirectoryInstructionCreator instructionCreator = new CopyToDirectoryInstructionCreator(builder, outputPath);
  LayoutElementBuildersRegistry.getInstance().generateInstructions(myArtifact, instructionCreator, context);
  return builder.getDescriptors();
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
public ArtifactInstructionsBuilderImpl(@NotNull ModuleExcludeIndex rootsIndex,
                                       @NotNull IgnoredFileIndex ignoredFileIndex,
                                       @NotNull ArtifactBuildTarget target,
                                       @NotNull JpsModel model, @NotNull BuildDataPaths dataPaths) {
  myRootsIndex = rootsIndex;
  myIgnoredFileIndex = ignoredFileIndex;
  myBuildTarget = target;
  myModel = model;
  myBuildDataPaths = dataPaths;
  myJarByPath = new HashMap<String, JarInfo>();
  myDescriptors = new ArrayList<ArtifactRootDescriptor>();
  myCopyingHandlerProviders = JpsServiceManager.getInstance().getExtensions(ArtifactRootCopyingHandlerProvider.class);
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
private SourceFileFilterImpl(@Nullable SourceFileFilter baseFilter,
                             @NotNull ModuleExcludeIndex rootsIndex,
                             IgnoredFileIndex patterns,
                             boolean includeExcluded) {
  myBaseFilter = baseFilter;
  myRootsIndex = rootsIndex;
  myIgnoredFileIndex = patterns;
  myIncludeExcluded = includeExcluded;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
protected Set<File> computeRootExcludes(File root, ModuleExcludeIndex index) {
  final Collection<File> moduleExcludes = index.getModuleExcludes(getModule());
  if (moduleExcludes.isEmpty()) {
    return Collections.emptySet();
  }
  final Set<File> excludes = new THashSet<File>(FileUtil.FILE_HASHING_STRATEGY);
  for (File excluded : moduleExcludes) {
    if (FileUtil.isAncestor(root, excluded, true)) {
      excludes.add(excluded);
    }
  }
  return excludes;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
public BuildRootIndexImpl(BuildTargetRegistry targetRegistry, JpsModel model, ModuleExcludeIndex index,
                          BuildDataPaths dataPaths, final IgnoredFileIndex ignoredFileIndex) {
  myIgnoredFileIndex = ignoredFileIndex;
  myRootsByTarget = new HashMap<BuildTarget<?>, List<? extends BuildRootDescriptor>>();
  myRootToDescriptors = new THashMap<File, List<BuildRootDescriptor>>(FileUtil.FILE_HASHING_STRATEGY);
  myFileFilters = new ConcurrentHashMap<BuildRootDescriptor, FileFilter>(16, 0.75f, 1);
  final Iterable<AdditionalRootsProviderService> rootsProviders = JpsServiceManager.getInstance().getExtensions(AdditionalRootsProviderService.class);
  for (BuildTargetType<?> targetType : TargetTypeRegistry.getInstance().getTargetTypes()) {
    for (BuildTarget<?> target : targetRegistry.getAllTargets(targetType)) {
      addRoots(dataPaths, rootsProviders, target, model, index, ignoredFileIndex);
    }
  }
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
public ProjectDescriptor(JpsModel model,
                         BuildFSState fsState,
                         ProjectTimestamps timestamps,
                         BuildDataManager dataManager,
                         BuildLoggingManager loggingManager,
                         final ModuleExcludeIndex moduleExcludeIndex,
                         final BuildTargetsState targetsState,
                         final BuildTargetIndex buildTargetIndex, final BuildRootIndex buildRootIndex, IgnoredFileIndex ignoredFileIndex) {
  myModel = model;
  myIgnoredFileIndex = ignoredFileIndex;
  myProject = model.getProject();
  this.fsState = fsState;
  this.timestamps = timestamps;
  this.dataManager = dataManager;
  myBuildTargetIndex = buildTargetIndex;
  myBuildRootIndex = buildRootIndex;
  myLoggingManager = loggingManager;
  myModuleExcludeIndex = moduleExcludeIndex;
  myProjectJavaSdks = new HashSet<JpsSdk<?>>();
  myEncodingConfiguration = new CompilerEncodingConfiguration(model, buildRootIndex);
  for (JpsModule module : myProject.getModules()) {
    final JpsSdk<?> sdk = module.getSdk(JpsJavaSdkType.INSTANCE);
    if (sdk != null && !myProjectJavaSdks.contains(sdk) && sdk.getVersionString() != null && sdk.getHomePath() != null) {
      myProjectJavaSdks.add(sdk);
    }
  }
  myTargetsState = targetsState;
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@Override
@NotNull
public List<RootDescriptor> computeRootDescriptors(JpsModel model,
                                                   ModuleExcludeIndex index,
                                                   IgnoredFileIndex ignoredFileIndex,
                                                   BuildDataPaths dataPaths) {
  return Collections.emptyList();
}
 

import org.jetbrains.jps.indices.ModuleExcludeIndex; //导入依赖的package包/类
@NotNull
@Override
public List<AndroidPreDexBuildTarget.MyRootDescriptor> computeRootDescriptors(JpsModel model,
                                                        ModuleExcludeIndex index,
                                                        IgnoredFileIndex ignoredFileIndex,
                                                        BuildDataPaths dataPaths) {
  final List<AndroidPreDexBuildTarget.MyRootDescriptor> result =
    new ArrayList<AndroidPreDexBuildTarget.MyRootDescriptor>();
  final Set<JpsModule> libModules = new HashSet<JpsModule>();
  final Set<String> externalJars = new HashSet<String>();

  for (JpsModule module : myProject.getModules()) {
    final JpsAndroidModuleExtension extension = AndroidJpsUtil.getExtension(module);

    if (extension != null && !extension.isLibrary() && extension.isPreDexingEnabled()) {
      final AndroidPlatform platform = AndroidJpsUtil.getAndroidPlatform(module, null, null);

      if (platform != null) {
        fillDepsRecursively(module, libModules, externalJars, dataPaths, platform);
      }
    }
  }

  for (JpsModule libModule : libModules) {
    final File classesJarFile = new AndroidLibraryPackagingTarget(libModule).getOutputFile(dataPaths);
    result.add(new MyRootDescriptor(this, classesJarFile, libModule.getName()));
  }

  for (String externalJarPath : externalJars) {
    result.add(new MyRootDescriptor(this, new File(externalJarPath), null));
  }
  return result;
}