import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
@Override
protected boolean isEnabled(@NotNull RootsSelection selection, @NotNull Module module) {
  if (!isJavaModule(module)) return false;

  if (selection.myHaveSelectedFilesUnderSourceRoots) {
    return false;
  }

  if (!selection.mySelectedDirectories.isEmpty()) {
    return true;
  }

  for (SourceFolder root : selection.mySelectedRoots) {
    JavaSourceRootProperties properties = root.getJpsElement().getProperties(JavaModuleSourceRootTypes.SOURCES);
    if (properties != null && !properties.isForGeneratedSources()) {
      return true;
    }
  }
  return false;
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
private static void markRootAsGenerated(ModifiableRootModel model, VirtualFile root, Ref<Boolean> modelChangedFlag) {
  final ContentEntry contentEntry = findContentEntryForRoot(model, root);

  if (contentEntry == null) {
    return;
  }
  for (SourceFolder sourceFolder : contentEntry.getSourceFolders()) {
    if (root.equals(sourceFolder.getFile())) {
      final JavaSourceRootProperties props = sourceFolder.getJpsElement().getProperties(JavaModuleSourceRootTypes.SOURCES);
      if (props != null) {
        props.setForGeneratedSources(true);
        modelChangedFlag.set(true);
        break;
      }
    }
  }
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
public void testMarkSourcesAsGeneratedOnReImport() throws IOException {
  importProject("<groupId>test</groupId>" +
                "<artifactId>project</artifactId>" +
                "<version>1</version>");
  new File(myProjectRoot.getPath(), "target/generated-sources/xxx/z").mkdirs();
  updateProjectFolders();

  assertGeneratedSources("project", "target/generated-sources/xxx");

  ModuleRootModificationUtil.updateModel(getModule("project"), new Consumer<ModifiableRootModel>() {
    @Override
    public void consume(ModifiableRootModel model) {
      for (SourceFolder folder : model.getContentEntries()[0].getSourceFolders()) {
        JavaSourceRootProperties properties = folder.getJpsElement().getProperties(JavaModuleSourceRootTypes.SOURCES);
        assertNotNull(properties);
        properties.setForGeneratedSources(false);
      }
    }
  });
  assertGeneratedSources("project");

  importProject();
  assertGeneratedSources("project", "target/generated-sources/xxx");
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
@Override
public SourceFolder setSourceFolderForLocation(
    ContentEntry contentEntry, SourceFolder parentFolder, File file, boolean isTestSource) {
  SourceFolder sourceFolder;
  if (isResource(parentFolder)) {
    JavaResourceRootType resourceRootType =
        isTestSource ? JavaResourceRootType.TEST_RESOURCE : JavaResourceRootType.RESOURCE;
    sourceFolder =
        contentEntry.addSourceFolder(UrlUtil.pathToUrl(file.getPath()), resourceRootType);
  } else {
    sourceFolder = contentEntry.addSourceFolder(UrlUtil.pathToUrl(file.getPath()), isTestSource);
  }
  sourceFolder.setPackagePrefix(derivePackagePrefix(file, parentFolder));
  JpsModuleSourceRoot sourceRoot = sourceFolder.getJpsElement();
  JpsElement properties = sourceRoot.getProperties();
  if (properties instanceof JavaSourceRootProperties) {
    ((JavaSourceRootProperties) properties).setForGeneratedSources(isGenerated(parentFolder));
  }
  return sourceFolder;
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的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.model.java.JavaSourceRootProperties; //导入依赖的package包/类
public void testPackagePrefix() {
  String file = createFile("src/a.xml");
  JpsModule m = addModule("m", PathUtil.getParentPath(file));
  JpsModuleSourceRoot sourceRoot = assertOneElement(m.getSourceRoots());
  JpsTypedModuleSourceRoot<JavaSourceRootProperties> typed = sourceRoot.asTyped(JavaSourceRootType.SOURCE);
  assertNotNull(typed);
  typed.getProperties().setPackagePrefix("xxx");
  rebuildAll();
  assertOutput(m, fs().dir("xxx").file("a.xml"));
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
@Override
protected boolean isEnabled(@NotNull RootsSelection selection, @NotNull Module module) {
  for (SourceFolder root : selection.mySelectedRoots) {
    JavaSourceRootProperties properties = root.getJpsElement().getProperties(JavaModuleSourceRootTypes.SOURCES);
    if (properties != null && properties.isForGeneratedSources()) {
      return true;
    }
  }
  return false;
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
public void testGeneratedSourceRoot() throws Exception {
  VirtualFile genRoot = getVirtualFile(createTempDir("genSrcRoot"));
  VirtualFile srcRoot = getVirtualFile(createTempDir("srcRoot"));
  JavaSourceRootProperties properties = JpsJavaExtensionService.getInstance().createSourceRootProperties("", true);
  PsiTestUtil.addSourceRoot(myModule, genRoot, JavaSourceRootType.SOURCE, properties);
  PsiTestUtil.addSourceRoot(myModule, srcRoot);
  VirtualFile genClass = VfsTestUtil.createFile(genRoot, "Gen.java", "class Gen{}");
  VirtualFile srcClass = VfsTestUtil.createFile(srcRoot, "Src.java", "class Src{}");
  AnalysisScope scope = new AnalysisScope(myModule);
  assertTrue(scope.contains(srcClass));
  assertFalse(scope.contains(genClass));
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
@Nullable
private JavaSourceRootProperties getJavaProperties() {
  if (mySourceRoot.getRootType() == JavaSourceRootType.SOURCE) {
    return mySourceRoot.getProperties(JavaSourceRootType.SOURCE);
  }
  if (mySourceRoot.getRootType() == JavaSourceRootType.TEST_SOURCE) {
    return mySourceRoot.getProperties(JavaSourceRootType.TEST_SOURCE);
  }
  return null;
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
@Override
public void setPackagePrefix(@NotNull String packagePrefix) {
  JavaSourceRootProperties properties = getJavaProperties();
  if (properties != null) {
    properties.setPackagePrefix(packagePrefix);
  }
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
private static void createSourceRootIfAbsent(
  @NotNull ContentEntry entry, @NotNull final SourceRoot root, @NotNull String moduleName,
  @NotNull JpsModuleSourceRootType<?> sourceRootType, boolean generated, boolean createEmptyContentRootDirectories) {
  List<SourceFolder> folders = entry.getSourceFolders(sourceRootType);
  for (SourceFolder folder : folders) {
    VirtualFile file = folder.getFile();
    if (file == null) {
      continue;
    }
    if (ExternalSystemApiUtil.getLocalFileSystemPath(file).equals(root.getPath())) {
      return;
    }
  }
  LOG.debug(String.format("Importing %s for content root '%s' of module '%s'", root, entry.getUrl(), moduleName));
  SourceFolder sourceFolder = entry.addSourceFolder(toVfsUrl(root.getPath()), sourceRootType);
  if (!StringUtil.isEmpty(root.getPackagePrefix())) {
    sourceFolder.setPackagePrefix(root.getPackagePrefix());
  }
  if (generated) {
    JavaSourceRootProperties properties = sourceFolder.getJpsElement().getProperties(JavaModuleSourceRootTypes.SOURCES);
    if(properties != null) {
      properties.setForGeneratedSources(true);
    }
  }
  if(createEmptyContentRootDirectories) {
    ExternalSystemApiUtil.doWriteAction(new Runnable() {
      @Override
      public void run() {
        try {
          VfsUtil.createDirectoryIfMissing(root.getPath());
        }
        catch (IOException e) {
          LOG.warn(String.format("Unable to create directory for the path: %s", root.getPath()), e);
        }
      }
    });
  }
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
private void assertGeneratedSources(String moduleName, JavaSourceRootType type, String... expectedSources) {
  ContentEntry contentRoot = getContentRoot(moduleName);
  List<ContentFolder> folders = new ArrayList<ContentFolder>();
  for (SourceFolder folder : contentRoot.getSourceFolders(type)) {
    JavaSourceRootProperties properties = folder.getJpsElement().getProperties(type);
    assertNotNull(properties);
    if (properties.isForGeneratedSources()) {
      folders.add(folder);
    }
  }
  doAssertContentFolders(contentRoot, folders, expectedSources);
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
private static String getPresentablePrefix(final ContentEntry entry, final VirtualFile file) {
  for (final SourceFolder sourceFolder : entry.getSourceFolders()) {
    if (file.equals(sourceFolder.getFile())) {
      JpsModuleSourceRoot element = sourceFolder.getJpsElement();
      JavaSourceRootProperties properties = element.getProperties(JavaModuleSourceRootTypes.SOURCES);
      if (properties != null) return properties.getPackagePrefix();
      JavaResourceRootProperties resourceRootProperties = element.getProperties(JavaModuleSourceRootTypes.RESOURCES);
      if (resourceRootProperties != null) return resourceRootProperties.getRelativeOutputPath();
    }
  }
  return "";
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
@Nullable
@Override
public String getPropertiesString(@NotNull JavaSourceRootProperties properties) {
  StringBuilder buffer = new StringBuilder();
  if (properties.isForGeneratedSources()) {
    buffer.append(" [generated]");
  }
  String packagePrefix = properties.getPackagePrefix();
  if (!packagePrefix.isEmpty()) {
    buffer.append(" (").append(packagePrefix).append(")");
  }
  return buffer.length() > 0 ? buffer.toString() : null;
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
private SourceRootPropertiesDialog(@NotNull JComponent parentComponent, @NotNull JavaSourceRootProperties properties) {
  super(parentComponent, true);
  myProperties = properties;
  setTitle(ProjectBundle.message("module.paths.edit.properties.title"));
  myPackagePrefixField = new JTextField();
  myIsGeneratedCheckBox = new JCheckBox(UIUtil.replaceMnemonicAmpersand("For &generated sources"));
  myMainPanel = FormBuilder.createFormBuilder()
    .addLabeledComponent("Package &prefix:", myPackagePrefixField)
    .addComponent(myIsGeneratedCheckBox)
    .getPanel();
  myPackagePrefixField.setText(myProperties.getPackagePrefix());
  myPackagePrefixField.setColumns(25);
  myIsGeneratedCheckBox.setSelected(myProperties.isForGeneratedSources());
  init();
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
private static void addSourceFolder(@NotNull ContentEntry contentEntry,
                                    @NotNull File folderPath,
                                    @NotNull JpsModuleSourceRootType type,
                                    boolean generated) {
  String url = pathToIdeaUrl(folderPath);
  SourceFolder sourceFolder = contentEntry.addSourceFolder(url, type);

  if (generated) {
    JpsModuleSourceRoot sourceRoot = sourceFolder.getJpsElement();
    JpsElement properties = sourceRoot.getProperties();
    if (properties instanceof JavaSourceRootProperties) {
      ((JavaSourceRootProperties)properties).setForGeneratedSources(true);
    }
  }
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
protected void assertGeneratedSources(String moduleName, String... expectedSources) {
  ContentEntry contentRoot = getContentRoot(moduleName);
  List<ContentFolder> folders = new ArrayList<ContentFolder>();
  for (SourceFolder folder : contentRoot.getSourceFolders(JavaSourceRootType.SOURCE)) {
    JavaSourceRootProperties properties = folder.getJpsElement().getProperties(JavaSourceRootType.SOURCE);
    assertNotNull(properties);
    if (properties.isForGeneratedSources()) {
      folders.add(folder);
    }
  }
  doAssertContentFolders(contentRoot, folders, expectedSources);
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
private static SourceFolder addSourceFolderToContentEntry(
    ContentEntry contentEntry, BlazeSourceDirectory sourceDirectory) {
  File sourceDir = sourceDirectory.getDirectory();

  // Create the source folder
  SourceFolder sourceFolder;
  if (sourceDirectory.getIsResource()) {
    sourceFolder =
        contentEntry.addSourceFolder(
            UrlUtil.pathToUrl(sourceDir.getPath()), JavaResourceRootType.RESOURCE);
  } else {
    sourceFolder = contentEntry.addSourceFolder(UrlUtil.pathToUrl(sourceDir.getPath()), false);
  }
  JpsModuleSourceRoot sourceRoot = sourceFolder.getJpsElement();
  JpsElement properties = sourceRoot.getProperties();
  if (properties instanceof JavaSourceRootProperties) {
    JavaSourceRootProperties rootProperties = (JavaSourceRootProperties) properties;
    if (sourceDirectory.getIsGenerated()) {
      rootProperties.setForGeneratedSources(true);
    }
  }
  String packagePrefix = sourceDirectory.getPackagePrefix();
  if (!Strings.isNullOrEmpty(packagePrefix)) {
    sourceFolder.setPackagePrefix(packagePrefix);
  }
  return sourceFolder;
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
/**
 * Computes the root descriptors for the build target.
 *
 * @param jpsModel           The JPS model.
 * @param moduleExcludeIndex The module exclude index.
 * @param ignoredFileIndex   The ignored file index.
 * @param buildDataPaths     The build data paths.
 * @return A list of source root descriptors.
 */
@Override
public final List<SpoofaxSourceRootDescriptor> computeRootDescriptors(
        final JpsModel jpsModel,
        final ModuleExcludeIndex moduleExcludeIndex,
        final IgnoredFileIndex ignoredFileIndex,
        final BuildDataPaths buildDataPaths) {
    // Default implementation.
    final List<SpoofaxSourceRootDescriptor> result = new ArrayList<>();
    final JavaSourceRootType type = isTests() ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE;
    for (final JpsTypedModuleSourceRoot<JavaSourceRootProperties> root : super.myModule.getSourceRoots(type)) {
        result.add(new SpoofaxSourceRootDescriptor(root.getFile(), this));
    }
    return result;
}
 

import org.jetbrains.jps.model.java.JavaSourceRootProperties; //导入依赖的package包/类
@NotNull
@Override
public List<HaskellSourceRootDescriptor> computeRootDescriptors(JpsModel jpsModel, ModuleExcludeIndex moduleExcludeIndex, IgnoredFileIndex ignoredFileIndex, BuildDataPaths buildDataPaths) {
    List<HaskellSourceRootDescriptor> result = new ArrayList<HaskellSourceRootDescriptor>();
    JavaSourceRootType type = isTests() ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE;
    for (JpsTypedModuleSourceRoot<JavaSourceRootProperties> root : myModule.getSourceRoots(type)) {
        result.add(new HaskellSourceRootDescriptor(root.getFile(), this));
    }
    return result;
}