public static Set<Artifact> getArtifactsToBuild(
      final Project project,
      final CompileScope compileScope,
      final boolean addIncludedArtifactsWithOutputPathsOnly) {
    final Artifact[] artifactsFromScope = getArtifacts(compileScope);
    final ArtifactManager artifactManager = ArtifactManager.getInstance(project);
    PackagingElementResolvingContext context = artifactManager.getResolvingContext();
    if (artifactsFromScope != null) {
      return addIncludedArtifacts(
          Arrays.asList(artifactsFromScope), context, addIncludedArtifactsWithOutputPathsOnly);
    }

    final Set<Artifact> cached = compileScope.getUserData(CACHED_ARTIFACTS_KEY);
    if (cached != null) {
      return cached;
    }

    Set<Artifact> artifacts = new HashSet<Artifact>();
    final Set<Module> modules =
        new HashSet<Module>(Arrays.asList(compileScope.getAffectedModules()));
    final List<Module> allModules = Arrays.asList(ModuleManager.getInstance(project).getModules());
    for (Artifact artifact : artifactManager.getArtifacts()) {
      if (artifact.isBuildOnMake()) {
        if (modules.containsAll(allModules) || containsModuleOutput(artifact, modules, context)) {
          artifacts.add(artifact);
        }
      }
    }
    Set<Artifact> result =
        addIncludedArtifacts(artifacts, context, addIncludedArtifactsWithOutputPathsOnly);
    compileScope.putUserData(CACHED_ARTIFACTS_KEY, result);
    return result;
  }
 public static List<Artifact> getArtifactWithOutputPaths(Project project) {
   final List<Artifact> result = new ArrayList<Artifact>();
   for (Artifact artifact : ArtifactManager.getInstance(project).getSortedArtifacts()) {
     if (!StringUtil.isEmpty(artifact.getOutputPath())) {
       result.add(artifact);
     }
   }
   return result;
 }
 public static Collection<Trinity<Artifact, PackagingElementPath, String>>
     findContainingArtifactsWithOutputPaths(
         @NotNull final VirtualFile file, @NotNull Project project) {
   final boolean isResourceFile = CompilerConfiguration.getInstance(project).isResourceFile(file);
   final List<Trinity<Artifact, PackagingElementPath, String>> artifacts =
       new ArrayList<Trinity<Artifact, PackagingElementPath, String>>();
   final PackagingElementResolvingContext context =
       ArtifactManager.getInstance(project).getResolvingContext();
   for (final Artifact artifact : ArtifactManager.getInstance(project).getArtifacts()) {
     processPackagingElements(
         artifact,
         null,
         new PackagingElementProcessor<PackagingElement<?>>() {
           @Override
           public boolean process(
               @NotNull PackagingElement<?> element, @NotNull PackagingElementPath path) {
             if (element instanceof FileOrDirectoryCopyPackagingElement<?>) {
               final VirtualFile root = ((FileOrDirectoryCopyPackagingElement) element).findFile();
               if (root != null && VfsUtil.isAncestor(root, file, false)) {
                 final String relativePath;
                 if (root.equals(file) && element instanceof FileCopyPackagingElement) {
                   relativePath = ((FileCopyPackagingElement) element).getOutputFileName();
                 } else {
                   relativePath = VfsUtilCore.getRelativePath(file, root, '/');
                 }
                 artifacts.add(Trinity.create(artifact, path, relativePath));
                 return false;
               }
             } else if (isResourceFile && element instanceof ModuleOutputPackagingElement) {
               final String relativePath =
                   getRelativePathInSources(file, (ModuleOutputPackagingElement) element, context);
               if (relativePath != null) {
                 artifacts.add(Trinity.create(artifact, path, relativePath));
                 return false;
               }
             }
             return true;
           }
         },
         context,
         true);
   }
   return artifacts;
 }
 @NotNull
 private static Artifact findOrCreateWebArtifact(AppEngineFacet appEngineFacet) {
   Module module = appEngineFacet.getModule();
   ArtifactType webArtifactType =
       AppEngineWebIntegration.getInstance().getAppEngineWebArtifactType();
   final Collection<Artifact> artifacts = ArtifactUtil.getArtifactsContainingModuleOutput(module);
   for (Artifact artifact : artifacts) {
     if (webArtifactType.equals(artifact.getArtifactType())) {
       return artifact;
     }
   }
   ArtifactManager artifactManager = ArtifactManager.getInstance(module.getProject());
   PackagingElementFactory elementFactory = PackagingElementFactory.getInstance();
   ArtifactRootElement<?> root = elementFactory.createArtifactRootElement();
   elementFactory
       .getOrCreateDirectory(root, "WEB-INF/classes")
       .addOrFindChild(elementFactory.createModuleOutput(module));
   return artifactManager.addArtifact(module.getName(), webArtifactType, root);
 }
 @NotNull
 @Override
 public List<DeploymentSource> createArtifactDeploymentSources(
     Project project, ArtifactType... artifactTypes) {
   if (project.isDefault()) return Collections.emptyList();
   Artifact[] artifacts = ArtifactManager.getInstance(project).getArtifacts();
   List<Artifact> supportedArtifacts = new ArrayList<>();
   Set<ArtifactType> typeSet = ContainerUtil.set(artifactTypes);
   for (Artifact artifact : artifacts) {
     if (typeSet.contains(artifact.getArtifactType())) {
       supportedArtifacts.add(artifact);
     }
   }
   return createArtifactDeploymentSources(project, supportedArtifacts);
 }
 public static Set<Module> getModulesIncludedInArtifacts(
     final @NotNull Collection<? extends Artifact> artifacts, final @NotNull Project project) {
   final Set<Module> modules = new HashSet<Module>();
   final PackagingElementResolvingContext resolvingContext =
       ArtifactManager.getInstance(project).getResolvingContext();
   for (Artifact artifact : artifacts) {
     processPackagingElements(
         artifact,
         null,
         new Processor<PackagingElement<?>>() {
           @Override
           public boolean process(PackagingElement<?> element) {
             if (element instanceof ModuleOutputPackagingElement) {
               ContainerUtil.addIfNotNull(
                   modules, ((ModuleOutputPackagingElement) element).findModule(resolvingContext));
             }
             return true;
           }
         },
         resolvingContext,
         true);
   }
   return modules;
 }
 protected ArtifactManager getArtifactManager() {
   return ArtifactManager.getInstance(myProject);
 }