Java CompilerConfiguration类代码示例

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包/类
@Override
public boolean isAccepted(PsiClass klass) {
    return ApplicationManager.getApplication().runReadAction((Computable<Boolean>) () -> {
        if (isSketchClass(klass)) {
            final CompilerConfiguration compilerConfiguration = CompilerConfiguration.getInstance(project);
            final VirtualFile virtualFile = PsiUtilCore.getVirtualFile(klass);

            if (virtualFile == null) {
                return false;
            }

            return ! compilerConfiguration.isExcludedFromCompilation(virtualFile) &&
                    ! ProjectRootManager.getInstance(project)
                            .getFileIndex()
                            .isUnderSourceRootOfType(virtualFile, JavaModuleSourceRootTypes.RESOURCES);
        }

        return false;
    });
}
 

import com.intellij.compiler.CompilerConfiguration; //导入依赖的package包/类
@Nullable
public static String getAnnotationProcessorsGenerationPath(Module module) {
  final AnnotationProcessingConfiguration config = CompilerConfiguration.getInstance(module.getProject()).getAnnotationProcessingConfiguration(module);
  final String sourceDirName = config.getGeneratedSourcesDirectoryName(false);
  if (config.isOutputRelativeToContentRoot()) {
    final String[] roots = ModuleRootManager.getInstance(module).getContentRootUrls();
    if (roots.length == 0) {
      return null;
    }
    if (roots.length > 1) {
      Arrays.sort(roots, URLS_COMPARATOR);
    }
    return StringUtil.isEmpty(sourceDirName)? VirtualFileManager.extractPath(roots[0]): VirtualFileManager.extractPath(roots[0]) + "/" + sourceDirName;
  }


  final String path = getModuleOutputPath(module, false);
  if (path == null) {
    return null;
  }
  return StringUtil.isEmpty(sourceDirName)? path : path + "/" + sourceDirName;
}
 

import com.intellij.compiler.CompilerConfiguration; //导入依赖的package包/类
public String getChunkSpecificCompileOptions() {
  final StringBuilder options = new StringBuilder();
  final Charset encoding = CompilerEncodingService.getInstance(getProject()).getPreferredModuleEncoding(myMainModule);
  if (encoding != null) {
    appendOption(options, "-encoding", encoding.name());
  }
  
  final String languageLevel = getLanguageLevelOption(ApplicationManager.getApplication().runReadAction(new Computable<LanguageLevel>() {
    @Override
    public LanguageLevel compute() {
      return EffectiveLanguageLevelUtil.getEffectiveLanguageLevel(myMainModule);
    }
  }));
  appendOption(options, "-source", languageLevel);
  
  String bytecodeTarget = CompilerConfiguration.getInstance(getProject()).getBytecodeTargetLevel(myMainModule);
  if (StringUtil.isEmpty(bytecodeTarget)) {
    // according to IDEA rule: if not specified explicitly, set target to be the same as source language level
    bytecodeTarget = languageLevel;
  }
  appendOption(options, "-target", bytecodeTarget);
  
  return options.toString();
}
 

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包/类
public CompileContextImpl(final Project project,
                          final CompilerTask compilerSession,
                          CompileScope compileScope,
                          boolean isMake, boolean isRebuild) {
  myProject = project;
  myBuildSession = compilerSession;
  myCompileScope = compileScope;
  myMake = isMake;
  myIsRebuild = isRebuild;
  myStartCompilationStamp = System.currentTimeMillis();
  myProjectFileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
  myProjectCompileScope = new ProjectCompileScope(myProject);
  myIsAnnotationProcessorsEnabled = CompilerConfiguration.getInstance(project).isAnnotationProcessorsEnabled();

  if (compilerSession != null) {
    final Object sessionId = ExecutionManagerImpl.EXECUTION_SESSION_ID_KEY.get(compileScope);
    if (sessionId != null) {
      // in case compilation is started as a part of some execution session, 
      // all compilation tasks should have the same sessionId in order for successive task not to clean messages 
      // from previous compilation tasks run within this execution session
      compilerSession.setSessionId(sessionId);
    }
  }
  final CompilerWorkspaceConfiguration workspaceConfig = CompilerWorkspaceConfiguration.getInstance(myProject);
  myShouldUpdateProblemsView = workspaceConfig.MAKE_PROJECT_ON_SAVE;
}
 

import com.intellij.compiler.CompilerConfiguration; //导入依赖的package包/类
@Override
public void compilationFinished(boolean aborted, int errors, int warnings, CompileContext compileContext) {
  CompilerManager.getInstance(myProject).removeCompilationStatusListener(this);

  ExcludesConfiguration configuration =
    ((CompilerConfigurationImpl)CompilerConfiguration.getInstance(myProject)).getExcludedEntriesConfiguration();
  ExcludeEntryDescription[] descriptions = configuration.getExcludeEntryDescriptions();

  configuration.removeAllExcludeEntryDescriptions();

  for (ExcludeEntryDescription description : descriptions) {
    if (!myEntriesToRemove.contains(description)) {
      configuration.addExcludeEntryDescription(description);
    }
  }
}
 

import com.intellij.compiler.CompilerConfiguration; //导入依赖的package包/类
public boolean isAccepted(final PsiClass aClass) {
  return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
    @Override
    public Boolean compute() {
      if (aClass.getQualifiedName() != null && ConfigurationUtil.PUBLIC_INSTANTIATABLE_CLASS.value(aClass) &&
          (aClass.isInheritor(myBase, true) || JUnitUtil.isTestClass(aClass))) {
        final CompilerConfiguration compilerConfiguration = CompilerConfiguration.getInstance(getProject());
        final VirtualFile virtualFile = PsiUtilCore.getVirtualFile(aClass);
        if (virtualFile == null) return false;
        return !compilerConfiguration.isExcludedFromCompilation(virtualFile) &&
               !ProjectRootManager.getInstance(myProject).getFileIndex().isUnderSourceRootOfType(virtualFile, JavaModuleSourceRootTypes.RESOURCES);
      }
      return false;
    }
  });
}
 

import com.intellij.compiler.CompilerConfiguration; //导入依赖的package包/类
public void testSettingTargetLevel() throws Exception {
  JavacConfiguration.getOptions(myProject, JavacConfiguration.class).ADDITIONAL_OPTIONS_STRING = "-Xmm500m -Xms128m -target 1.5";

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

                "<build>" +
                "  <plugins>" +
                "    <plugin>" +
                "      <artifactId>maven-compiler-plugin</artifactId>" +
                "        <configuration>" +
                "          <target>1.3</target>" +
                "        </configuration>" +
                "     </plugin>" +
                "  </plugins>" +
                "</build>");

  assertEquals("-Xmm500m -Xms128m", JavacConfiguration.getOptions(myProject, JavacConfiguration.class).ADDITIONAL_OPTIONS_STRING.trim());

  Module module = getModule("project");

  String targetLevel = CompilerConfiguration.getInstance(myProject).getBytecodeTargetLevel(module);

  assertEquals("1.3", targetLevel);
}
 

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包/类
protected void doAction(DataContext dataContext, final Project project) {
  ((CompilerConfigurationImpl)CompilerConfiguration.getInstance(project)).convertPatterns();
  final GenerateAntBuildDialog dialog = new GenerateAntBuildDialog(project);
  dialog.show();
  if (dialog.isOK()) {
    final String[] names = dialog.getRepresentativeModuleNames();
    final GenerationOptionsImpl[] genOptions = {null};
    Runnable runnable = new Runnable() {
      public void run() {
        genOptions[0] = new GenerationOptionsImpl(project, dialog.isGenerateSingleFileBuild(), dialog.isFormsCompilationEnabled(),
                                                  dialog.isBackupFiles(), dialog.isForceTargetJdk(), dialog.isRuntimeClasspathInlined(),
                                                  dialog.isIdeaHomeGenerated(), names, dialog.getOutputFileName());
      }
    };
    if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(runnable, "Analyzing project structure...", true, project)) {
      return;
    }
    if (!validateGenOptions(project, genOptions[0])) {
      return;
    }
    generate(project, genOptions[0]);
  }
}
 

import com.intellij.compiler.CompilerConfiguration; //导入依赖的package包/类
public CompileContextImpl(final Project project,
                          final CompilerTask compilerSession,
                          CompileScope compileScope,
                          DependencyCache dependencyCache, boolean isMake, boolean isRebuild) {
  myProject = project;
  myTask = compilerSession;
  myCompileScope = compileScope;
  myDependencyCache = dependencyCache;
  myMake = isMake;
  myIsRebuild = isRebuild;
  myStartCompilationStamp = System.currentTimeMillis();
  myProjectFileIndex = ProjectRootManager.getInstance(myProject).getFileIndex();
  myProjectCompileScope = new ProjectCompileScope(myProject);
  myIsAnnotationProcessorsEnabled = CompilerConfiguration.getInstance(project).isAnnotationProcessorsEnabled();

  if (compilerSession != null) {
    compilerSession.setContentIdKey(compileScope.getUserData(CompilerManager.CONTENT_ID_KEY));
  }
  recalculateOutputDirs();
  final CompilerWorkspaceConfiguration workspaceConfig = CompilerWorkspaceConfiguration.getInstance(myProject);
  myShouldUpdateProblemsView = workspaceConfig.useOutOfProcessBuild() && workspaceConfig.MAKE_PROJECT_ON_SAVE;
}
 

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);
}