Java CompilerOptions类代码示例

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
/**
 * sets the source level (see @link(org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants))
 */
private void setSourceLevel(final long jdkVersion) {
  try {
    this.compilerOptions.sourceLevel = jdkVersion;
    try {
      CompilerOptions.class.getField("originalSourceLevel").setLong(this.compilerOptions, jdkVersion);
    } catch (final Throwable _t) {
      if (_t instanceof NoSuchFieldException) {
      } else {
        throw Exceptions.sneakyThrow(_t);
      }
    }
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
/**
 * sets the compliance level (see @link(org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants))
 */
private void setComplianceLevel(final long jdkVersion) {
  try {
    this.compilerOptions.complianceLevel = jdkVersion;
    try {
      CompilerOptions.class.getField("originalComplianceLevel").setLong(this.compilerOptions, jdkVersion);
    } catch (final Throwable _t) {
      if (_t instanceof NoSuchFieldException) {
      } else {
        throw Exceptions.sneakyThrow(_t);
      }
    }
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
protected CompilerOptions ecjCompilerOptions() {
	CompilerOptions options = new CompilerOptions();
	options.complianceLevel = Eclipse.getLatestEcjCompilerVersionConstant();
	options.sourceLevel = Eclipse.getLatestEcjCompilerVersionConstant();
	options.targetJDK = Eclipse.getLatestEcjCompilerVersionConstant();
	options.docCommentSupport = false;
	options.parseLiteralExpressionsAsConstants = true;
	options.inlineJsrBytecode = true;
	options.reportUnusedDeclaredThrownExceptionExemptExceptionAndThrowable = false;
	options.reportUnusedDeclaredThrownExceptionIncludeDocCommentReference = false;
	options.reportUnusedDeclaredThrownExceptionWhenOverriding = false;
	options.reportUnusedParameterIncludeDocCommentReference = false;
	options.reportUnusedParameterWhenImplementingAbstract = false;
	options.reportUnusedParameterWhenOverridingConcrete = false;
	options.reportDeadCodeInTrivialIfStatement = false;
	options.generateClassFiles = false;
	Map<String, String> warnings = new HashMap<String, String>();
	warnings.put(CompilerOptions.OPTION_ReportUnusedLocal, "ignore");
	warnings.put(CompilerOptions.OPTION_ReportUnusedLabel, "ignore");
	warnings.put(CompilerOptions.OPTION_ReportUnusedImport, "ignore");
	warnings.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, "ignore");
	warnings.put(CompilerOptions.OPTION_Source, "1." + Eclipse.getEcjCompilerVersion());
	options.set(warnings);
	return options;
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
@Override
public void performCompilation() {
    if(environment == null) {
        environment = this.getLibraryAccess();
    }

    this.startTime = System.currentTimeMillis();
    this.compilerOptions = new CompilerOptions(this.options);
    this.compilerOptions.performMethodsFullRecovery = false;
    this.compilerOptions.performStatementsRecovery = false;
    this.batchCompiler = new Compiler(environment, this.getHandlingPolicy(), this.compilerOptions, this.getBatchRequestor(), this.getProblemFactory(), this.out, this.progress);
    this.batchCompiler.remainingIterations = this.maxRepetition - this.currentRepetition;
    String setting = System.getProperty("jdt.compiler.useSingleThread");
    this.batchCompiler.useSingleThread = setting != null && setting.equals("true");

    this.compilerOptions.verbose = this.verbose;
    this.compilerOptions.produceReferenceInfo = this.produceRefInfo;

    try {
        this.logger.startLoggingSources();
        this.batchCompiler.compile(this.getCompilationUnits());
    } finally {
        this.logger.endLoggingSources();
    }
    this.logger.printStats();
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
private static boolean isValidEcj() {
    // When this test is run from within Gradle's testing infrastructure, e.g.
    // via "./gradlew :base:gradle-core:test", Gradle's own *internal* dependencies
    // somehow end up on the classpath, and in particular, an ancient version of
    // (ECJ (3.x)) take priority over our explicit lint dependency which should
    // bring in ECJ 4.
    //
    // This causes the test to fail. For now, make the test only run when a valid
    // ECJ is present.
    try {
        CompilerOptions.class.getField("originalComplianceLevel");
        return true;
    } catch (Throwable t) {
        return false;
    }
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
@Nullable
private static Node parse(String code) {
  CompilerOptions options = new CompilerOptions();
  options.complianceLevel = options.sourceLevel = options.targetJDK = ClassFileConstants.JDK1_7;
  options.parseLiteralExpressionsAsConstants = true;
  ProblemReporter problemReporter = new ProblemReporter(
    DefaultErrorHandlingPolicies.exitOnFirstError(), options, new DefaultProblemFactory());
  Parser parser = new Parser(problemReporter, options.parseLiteralExpressionsAsConstants);
  parser.javadocParser.checkDocComment = false;
  EcjTreeConverter converter = new EcjTreeConverter();
  org.eclipse.jdt.internal.compiler.batch.CompilationUnit sourceUnit =
    new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(code.toCharArray(), "unitTest", "UTF-8");
  CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
  CompilationUnitDeclaration unit = parser.parse(sourceUnit, compilationResult);
  if (unit == null) {
    return null;
  }
  converter.visit(code, unit);
  List<? extends Node> nodes = converter.getAll();
  for (lombok.ast.Node node : nodes) {
    if (node instanceof lombok.ast.CompilationUnit) {
      return node;
    }
  }
  return null;
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
public BaseTest() {
  options.put(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_8);
  options.put(JavaCore.CORE_ENCODING, "UTF-8");
  options.put(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_8);
  options.put(CompilerOptions.OPTION_TargetPlatform, JavaCore.VERSION_1_8);
  options.put(AssistOptions.OPTION_PerformVisibilityCheck, AssistOptions.ENABLED);
  options.put(CompilerOptions.OPTION_ReportUnusedLocal, CompilerOptions.WARNING);
  options.put(CompilerOptions.OPTION_TaskTags, CompilerOptions.WARNING);
  options.put(CompilerOptions.OPTION_ReportUnusedPrivateMember, CompilerOptions.WARNING);
  options.put(CompilerOptions.OPTION_SuppressWarnings, CompilerOptions.DISABLED);
  options.put(JavaCore.COMPILER_TASK_TAGS, "TODO,FIXME,XXX");
  options.put(
      JavaCore.COMPILER_PB_UNUSED_PARAMETER_INCLUDE_DOC_COMMENT_REFERENCE, JavaCore.ENABLED);
  options.put(JavaCore.COMPILER_DOC_COMMENT_SUPPORT, JavaCore.ENABLED);
  options.put(CompilerOptions.OPTION_Process_Annotations, JavaCore.DISABLED);
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
public SourceElementParser getSourceElementParser(
    IJavaProject project, ISourceElementRequestor requestor) {
  // disable task tags to speed up parsing
  Map options = project.getOptions(true);
  options.put(JavaCore.COMPILER_TASK_TAGS, ""); // $NON-NLS-1$
  try {
    SourceElementParser parser =
        new IndexingParser(
            requestor,
            new DefaultProblemFactory(Locale.getDefault()),
            new CompilerOptions(options),
            true, // index local declarations
            true, // optimize string literals
            false); // do not use source javadoc parser to speed up parsing
    parser.reportOnlyOneSyntaxError = true;

    // Always check javadoc while indexing
    parser.javadocParser.checkDocComment = true;
    parser.javadocParser.reportProblems = false;

    return parser;
  } catch (Exception e) {
    e.printStackTrace();
    return null;
  }
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
@Override public ASTNode process(Source in, Void irrelevant) throws ConversionProblem {
	CompilerOptions compilerOptions = ecjCompilerOptions();
	Parser parser = new Parser(new ProblemReporter(
			DefaultErrorHandlingPolicies.proceedWithAllProblems(),
			compilerOptions,
			new DefaultProblemFactory()
		), compilerOptions.parseLiteralExpressionsAsConstants);
	parser.javadocParser.checkDocComment = true;
	CompilationUnit sourceUnit = new CompilationUnit(in.getRawInput().toCharArray(), in.getName(), charset.name());
	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
	CompilationUnitDeclaration cud = parser.parse(sourceUnit, compilationResult);
	
	if (cud.hasErrors()) {
		throw new ConversionProblem(String.format("Can't read file %s due to parse error: %s", in.getName(), compilationResult.getErrors()[0]));
	}
	
	return cud;
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
private static ProblemReporter createDefaultProblemReporter(CompilerOptions options) {
	return new ProblemReporter(new IErrorHandlingPolicy() {
		public boolean proceedOnErrors() {
			return true;
		}
		
		public boolean stopOnFirstError() {
			return false;
		}
		
		@Override
		public boolean ignoreAllErrors() {
			return false;
		}
	}, options, new DefaultProblemFactory(Locale.ENGLISH));
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
private static ProblemReporter createSilentProblemReporter(CompilerOptions options) {
	return new ProblemReporter(new IErrorHandlingPolicy() {
		public boolean proceedOnErrors() {
			return true;
		}
		
		public boolean stopOnFirstError() {
			return false;
		}
		
		@Override
		public boolean ignoreAllErrors() {
			return false;
		}
	}, options, SILENT_PROBLEM_FACTORY);
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
@Override
protected ASTNode parseWithLombok(Source source) {
	CompilerOptions compilerOptions = ecjCompilerOptions();
	Parser parser = new Parser(new ProblemReporter(
			DefaultErrorHandlingPolicies.proceedWithAllProblems(),
			compilerOptions,
			new DefaultProblemFactory()
		), compilerOptions.parseLiteralExpressionsAsConstants);
	parser.javadocParser.checkDocComment = true;
	CompilationUnit sourceUnit = new CompilationUnit(source.getRawInput().toCharArray(), source.getName(), "UTF-8");
	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
	CompilationUnitDeclaration cud = parser.parse(sourceUnit, compilationResult);
	
	if (cud.hasErrors()) return null;
	
	EcjTreeConverter converter = new EcjTreeConverter();
	converter.visit(source.getRawInput(), cud);
	Node lombokized = converter.get();
	
	EcjTreeBuilder builder = new EcjTreeBuilder(source.getRawInput(), source.getName(), ecjCompilerOptions());
	builder.visit(lombokized);
	return builder.get();
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
@Override
protected ASTNode parseWithTargetCompiler(Source source) {
	CompilerOptions compilerOptions = ecjCompilerOptions();
	Parser parser = new Parser(new ProblemReporter(
			DefaultErrorHandlingPolicies.proceedWithAllProblems(),
			compilerOptions,
			new DefaultProblemFactory()
		), compilerOptions.parseLiteralExpressionsAsConstants);
	parser.javadocParser.checkDocComment = true;
	CompilationUnit sourceUnit = new CompilationUnit(source.getRawInput().toCharArray(), source.getName(), "UTF-8");
	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
	CompilationUnitDeclaration cud = parser.parse(sourceUnit, compilationResult);
	
	if (cud.hasErrors()) return null;
	
	return cud;
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
@Override
protected ASTNode parseWithTargetCompiler(Source source) {
	CompilerOptions compilerOptions = ecjCompilerOptions();
	Parser parser = new Parser(new ProblemReporter(
			DefaultErrorHandlingPolicies.proceedWithAllProblems(),
			compilerOptions,
			new DefaultProblemFactory()
		), compilerOptions.parseLiteralExpressionsAsConstants);
	parser.javadocParser.checkDocComment = true;
	CompilationUnit sourceUnit = new CompilationUnit(source.getRawInput().toCharArray(), source.getName(), "UTF-8");
	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
	CompilationUnitDeclaration cud = parser.parse(sourceUnit, compilationResult);
	
	if (cud.hasErrors()) return null;
	return cud;
}
 

import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; //导入依赖的package包/类
protected Node parseWithTargetCompiler(Source source) {
	CompilerOptions compilerOptions = ecjCompilerOptions();
	Parser parser = new Parser(new ProblemReporter(
			DefaultErrorHandlingPolicies.proceedWithAllProblems(),
			compilerOptions,
			new DefaultProblemFactory()
		), compilerOptions.parseLiteralExpressionsAsConstants);
	parser.javadocParser.checkDocComment = true;
	CompilationUnit sourceUnit = new CompilationUnit(source.getRawInput().toCharArray(), source.getName(), "UTF-8");
	CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, 0);
	CompilationUnitDeclaration cud = parser.parse(sourceUnit, compilationResult);
	
	if (cud.hasErrors()) return null;
	
	EcjTreeConverter converter = new EcjTreeConverter();
	converter.visit(source.getRawInput(), cud);
	return converter.get();
}