Java CompilerConfiguration.getInstance方法代码示例

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
public boolean isModified() {
  final CompilerConfigurationImpl config = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(myProject);

  if (!config.getDefaultProcessorProfile().equals(myMainPanel.getDefaultProfile())) {
    return true;
  }

  final Map<String, ProcessorConfigProfile> configProfiles = new java.util.HashMap<String, ProcessorConfigProfile>();
  for (ProcessorConfigProfile profile : config.getModuleProcessorProfiles()) {
    configProfiles.put(profile.getName(), profile);
  }
  final List<ProcessorConfigProfile> panelProfiles = myMainPanel.getModuleProfiles();
  if (configProfiles.size() != panelProfiles.size()) {
    return true;
  }
  for (ProcessorConfigProfile panelProfile : panelProfiles) {
    final ProcessorConfigProfile configProfile = configProfiles.get(panelProfile.getName());
    if (configProfile == null || !configProfile.equals(panelProfile)) {
      return true;
    }
  }

  return false;
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
public CompilerExcludes(Project project, GenerationOptions genOptions) {
  final CompilerConfigurationImpl compilerConfiguration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(project);
  final ExcludeEntryDescription[] excludeEntryDescriptions =
    compilerConfiguration.getExcludedEntriesConfiguration().getExcludeEntryDescriptions();
  myPatternSet = new PatternSet(BuildProperties.PROPERTY_COMPILER_EXCLUDES);
  for (final ExcludeEntryDescription entry : excludeEntryDescriptions) {
    final String path = GenerationUtils
      .toRelativePath(entry.getVirtualFile(), BuildProperties.getProjectBaseDir(project), BuildProperties.getProjectBaseDirProperty(),
                      genOptions);
    if (path == null) {
      // entry is invalid, skip it
      continue;
    }
    if (entry.isFile()) {
      myPatternSet.add(new Exclude(path));
    }
    else {
      if (entry.isIncludeSubdirectories()) {
        myPatternSet.add(new Exclude(path + "/**"));
      }
      else {
        myPatternSet.add(new Exclude(path + "/*"));
      }
    }
  }
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
@Override
public void configure(@NotNull MavenProject mavenProject, @NotNull Project project, @Nullable Module module) {
  if (module == null) return;

  CompilerConfiguration configuration = CompilerConfiguration.getInstance(project);
  if (!Boolean.TRUE.equals(module.getUserData(IGNORE_MAVEN_COMPILER_TARGET_KEY))) {
    String targetLevel = mavenProject.getTargetLevel();
    // default source and target settings of maven-compiler-plugin is 1.5, see details at http://maven.apache.org/plugins/maven-compiler-plugin
    configuration.setBytecodeTargetLevel(module, ObjectUtils.notNull(targetLevel, "1.5"));
  }
  module.putUserData(IGNORE_MAVEN_COMPILER_TARGET_KEY, Boolean.FALSE);

  // Exclude src/main/archetype-resources
  VirtualFile dir = VfsUtil.findRelativeFile(mavenProject.getDirectoryFile(), "src", "main", "resources", "archetype-resources");
  if (dir != null && !configuration.isExcludedFromCompilation(dir)) {
    ExcludesConfiguration cfg = configuration.getExcludedEntriesConfiguration();
    cfg.addExcludeEntryDescription(new ExcludeEntryDescription(dir, true, false, project));
  }
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
public GenerationItem[] compute() {
    ProjectFileIndex fileIndex = ProjectRootManager.getInstance(context.getProject()).getFileIndex();
    CompileScope compileScope = context.getCompileScope();
    VirtualFile[] files = compileScope.getFiles(JFlexFileType.FILE_TYPE, false);
    List<GenerationItem> items = new ArrayList<GenerationItem>(files.length);
    CompilerConfiguration compilerConfiguration = CompilerConfiguration.getInstance(context.getProject());
    for (VirtualFile file : files) {
        if (context.isMake() && compilerConfiguration.isExcludedFromCompilation(file)) {
            continue;
        }
        JFlexGenerationItem generationItem = new JFlexGenerationItem(context.getModuleByFile(file), file, fileIndex.isInTestSourceContent(file));
        if (context.isMake()) {
            File generatedFile = generationItem.getGeneratedFile();
            if (!generatedFile.exists() || generatedFile.lastModified() <= file.getTimeStamp()) {
                items.add(generationItem);
            }
        } else {
            items.add(generationItem);
        }
    }
    return items.toArray(new GenerationItem[items.size()]);
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
public void reset() {

    final CompilerConfigurationImpl configuration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(myProject);
    final CompilerWorkspaceConfiguration workspaceConfiguration = CompilerWorkspaceConfiguration.getInstance(myProject);
    myCbAutoShowFirstError.setSelected(workspaceConfiguration.AUTO_SHOW_ERRORS_IN_EDITOR);
    myCbClearOutputDirectory.setSelected(workspaceConfiguration.CLEAR_OUTPUT_DIRECTORY);
    myCbAssertNotNull.setSelected(configuration.isAddNotNullAssertions());
    myCbUseExternalBuild.setSelected(workspaceConfiguration.USE_COMPILE_SERVER);
    myCbEnableAutomake.setSelected(workspaceConfiguration.MAKE_PROJECT_ON_SAVE);
    myCbParallelCompilation.setSelected(workspaceConfiguration.PARALLEL_COMPILATION);
    myCbRebuildOnDependencyChange.setSelected(workspaceConfiguration.REBUILD_ON_DEPENDENCY_CHANGE);
    myHeapSizeField.setText(String.valueOf(workspaceConfiguration.COMPILER_PROCESS_HEAP_SIZE));
    final String options = workspaceConfiguration.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS;
    myVMOptionsField.setText(options == null ? "" : options.trim());
    updateExternalMakeOptionControls(myCbUseExternalBuild.isSelected());

    configuration.convertPatterns();

    myResourcePatternsField.setText(patternsToString(configuration.getResourceFilePatterns()));
  }
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
private VirtualFile[] filterRoots(VirtualFile[] roots, Project project, final int sourcesFilter) {
  final List<VirtualFile> filteredRoots = new ArrayList<VirtualFile>(roots.length);
  final CompilerConfigurationImpl compilerConfiguration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(project);
  for (final VirtualFile root : roots) {
    if (sourcesFilter != ALL_SOURCES) {
      if (myContext.isInTestSourceContent(root)) {
        if ((sourcesFilter & TEST_SOURCES) == 0) {
          continue;
        }
      }
      else {
        if ((sourcesFilter & SOURCES) == 0) {
          continue;
        }
      }
    }
    if (compilerConfiguration.isExcludedFromCompilation(root)) {
      continue;
    }
    filteredRoots.add(root);
  }
  return VfsUtil.toVirtualFileArray(filteredRoots);
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
public static void addTargetCommandLineSwitch(final ModuleChunk chunk, final List<String> commandLine) {
  String optionValue = null;
  CompilerConfiguration config = null;
  final Module[] modules = chunk.getModules();
  for (Module module : modules) {
    if (config == null) {
      config = CompilerConfiguration.getInstance(module.getProject());
    }
    final String moduleTarget = config.getBytecodeTargetLevel(module);
    if (moduleTarget == null) {
      continue;
    }
    if (optionValue == null) {
      optionValue = moduleTarget;
    }
    else {
      if (moduleTarget.compareTo(optionValue) < 0) {
        optionValue = moduleTarget; // use the lower possible target among modules that form the chunk
      }
    }
  }
  if (optionValue != null) {
    commandLine.add("-target");
    commandLine.add(optionValue);
  }
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
@Override
public void configure(@NotNull MavenProject mavenProject, @NotNull Project project, @Nullable Module module) {
  if (module == null) return;

  String targetLevel = mavenProject.getTargetLevel();
  if (targetLevel != null) {
    CompilerConfigurationImpl configuration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(project);
    configuration.setBytecodeTargetLevel(module, targetLevel);
  }

  VirtualFile directoryFile = mavenProject.getDirectoryFile();

  // Exclude src/main/archetype-resources
  VirtualFile archetypeResourcesDir = VfsUtil.findRelativeFile(directoryFile, "src", "main", "resources", "archetype-resources");

  if (archetypeResourcesDir != null) {
    CompilerConfigurationImpl compilerConfiguration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(project);

    if (!compilerConfiguration.isExcludedFromCompilation(archetypeResourcesDir)) {
      ExcludedEntriesConfiguration cfg = compilerConfiguration.getExcludedEntriesConfiguration();

      cfg.addExcludeEntryDescription(new ExcludeEntryDescription(archetypeResourcesDir, true, false, project));
    }
  }
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
public void reset() {

    final CompilerConfigurationImpl configuration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(myProject);
    final CompilerWorkspaceConfiguration workspaceConfiguration = CompilerWorkspaceConfiguration.getInstance(myProject);
    myCbAutoShowFirstError.setSelected(workspaceConfiguration.AUTO_SHOW_ERRORS_IN_EDITOR);
    myCbDisplayNotificationPopup.setSelected(workspaceConfiguration.DISPLAY_NOTIFICATION_POPUP);
    myCbClearOutputDirectory.setSelected(workspaceConfiguration.CLEAR_OUTPUT_DIRECTORY);
    myCbAssertNotNull.setSelected(configuration.isAddNotNullAssertions());
    myCbEnableAutomake.setSelected(workspaceConfiguration.MAKE_PROJECT_ON_SAVE);
    myCbParallelCompilation.setSelected(workspaceConfiguration.PARALLEL_COMPILATION);
    myCbRebuildOnDependencyChange.setSelected(workspaceConfiguration.REBUILD_ON_DEPENDENCY_CHANGE);
    final int javacPreferred = JavacConfiguration.getOptions(myProject, JavacConfiguration.class).MAXIMUM_HEAP_SIZE; // for compatibility with older projects
    myHeapSizeField.setText(String.valueOf(configuration.getBuildProcessHeapSize(javacPreferred)));
    final String options = workspaceConfiguration.COMPILER_PROCESS_ADDITIONAL_VM_OPTIONS;
    myVMOptionsField.setText(options == null ? "" : options.trim());
    mySharedVMOptionsField.setText(configuration.getBuildProcessVMOptions());

    configuration.convertPatterns();

    myResourcePatternsField.setText(patternsToString(configuration.getResourceFilePatterns()));

    if (PowerSaveMode.isEnabled()) {
      myEnableAutomakeLegendLabel.setText("(disabled in Power Save mode)");
      myEnableAutomakeLegendLabel.setFont(myEnableAutomakeLegendLabel.getFont().deriveFont(Font.BOLD));
    } else {
      myEnableAutomakeLegendLabel.setText("(only works while not running / debugging)");
      myEnableAutomakeLegendLabel.setFont(myEnableAutomakeLegendLabel.getFont().deriveFont(Font.PLAIN));
    }
  }
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
public CompilerResourcePatterns(Project project) {
  final CompilerConfigurationImpl compilerConfiguration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(project);
  final String[] patterns = compilerConfiguration.getResourceFilePatterns();
  myPatternSet = new PatternSet(BuildProperties.PROPERTY_COMPILER_RESOURCE_PATTERNS);
  for (String pattern : patterns) {
    if (CompilerConfigurationImpl.isPatternNegated(pattern)) {
      myPatternSet.add(new Exclude("**/" + pattern.substring(1)));
    }
    else {
      myPatternSet.add(new Include("**/" + pattern));
    }
  }
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
private static VirtualFile[] getCompilableFiles(Project project, VirtualFile[] files) {
  if (files == null || files.length == 0) {
    return VirtualFile.EMPTY_ARRAY;
  }
  final PsiManager psiManager = PsiManager.getInstance(project);
  final CompilerConfiguration compilerConfiguration = CompilerConfiguration.getInstance(project);
  final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  final CompilerManager compilerManager = CompilerManager.getInstance(project);
  final List<VirtualFile> filesToCompile = new ArrayList<VirtualFile>();
  for (final VirtualFile file : files) {
    if (!fileIndex.isInSourceContent(file)) {
      continue;
    }
    if (!file.isInLocalFileSystem()) {
      continue;
    }
    if (file.isDirectory()) {
      final PsiDirectory directory = psiManager.findDirectory(file);
      if (directory == null || JavaDirectoryService.getInstance().getPackage(directory) == null) {
        continue;
      }
    }
    else {
      FileType fileType = file.getFileType();
      if (!(compilerManager.isCompilableFileType(fileType) || compilerConfiguration.isCompilableResourceFile(project, file))) {
        continue;
      }
    }
    filesToCompile.add(file);
  }
  return VfsUtilCore.toVirtualFileArray(filesToCompile);
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
public void testDoNotCopyExcludedStandardResources() throws Exception {

    CompilerConfigurationImpl configuration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(myProject);
    configuration.addResourceFilePattern("*.zzz");

    createProjectSubFile("res/file.xxx");
    createProjectSubFile("res/file.zzz");

    importProject("<groupId>test</groupId>" +
                  "<artifactId>project</artifactId>" +
                  "<version>1</version>" +

                  "<build>" +
                  "  <resources>" +
                  "    <resource>" +
                  "      <directory>res</directory>" +
                  "      <includes>" +
                  "        <include>**/*.xxx</include>" +
                  "      </includes>" +
                  "      <excludes>" +
                  "        <exclude>**/*.zzz</exclude>" +
                  "      </excludes>" +
                  "    </resource>" +
                  "  </resources>" +
                  "</build>");

    compileModules("project");
    assertCopied("target/classes/file.xxx");
    assertNotCopied("target/classes/file.zzz");
  }
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
@NotNull
@Override
protected BaseInspectionVisitor buildVisitor() {
  return new BaseInspectionVisitor() {
    @Override
    public void visitFile(GroovyFileBase file) {
      CompilerConfiguration configuration = CompilerConfiguration.getInstance(file.getProject());
      if (configuration != null && !configuration.isResourceFile(file.getVirtualFile()) && fileSeemsToBeTypeCustomizer(file)) {
        final LocalQuickFix[] fixes = {new AddToResourceFix(file)};
        final String message = GroovyInspectionBundle.message("type.customizer.is.not.marked.as.a.resource.file");
        registerError(file, message, fixes, ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
      }
    }
  };
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
private static VirtualFile[] getCompilableFiles(Project project, VirtualFile[] files) {
  if (files == null || files.length == 0) {
    return VirtualFile.EMPTY_ARRAY;
  }
  final PsiManager psiManager = PsiManager.getInstance(project);
  final CompilerConfiguration compilerConfiguration = CompilerConfiguration.getInstance(project);
  final FileTypeManager typeManager = FileTypeManager.getInstance();
  final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  final CompilerManager compilerManager = CompilerManager.getInstance(project);
  final List<VirtualFile> filesToCompile = new ArrayList<VirtualFile>();
  for (final VirtualFile file : files) {
    if (!fileIndex.isInSourceContent(file)) {
      continue;
    }
    if (!file.isInLocalFileSystem()) {
      continue;
    }
    if (file.isDirectory()) {
      final PsiDirectory directory = psiManager.findDirectory(file);
      if (directory == null || JavaDirectoryService.getInstance().getPackage(directory) == null) {
        continue;
      }
    }
    else {
      FileType fileType = file.getFileType();
      if (!(compilerManager.isCompilableFileType(fileType) || isCompilableResourceFile(project, compilerConfiguration, file))) {
        continue;
      }
    }
    filesToCompile.add(file);
  }
  return VfsUtil.toVirtualFileArray(filesToCompile);
}
 

import com.intellij.compiler.CompilerConfiguration; //导入方法依赖的package包/类
private void openConfigurationDialog() {
  final CompilerConfigurationImpl configuration = (CompilerConfigurationImpl)CompilerConfiguration.getInstance(myProject);
  final Collection<BackendCompiler> compilers = configuration.getRegisteredJavaCompilers();
  final BackendCompiler defaultCompiler = configuration.getDefaultCompiler();
  final JavaCompilersTab compilersTab = new JavaCompilersTab(myProject, compilers, defaultCompiler);

  ShowSettingsUtil.getInstance().editConfigurable(myProject, compilersTab);
}