import spoon.compiler.Environment; //导入依赖的package包/类
protected void report(Environment environment, CategorizedProblem problem) {
    if (problem == null) {
        throw new IllegalArgumentException("problem cannot be null");
    }

    File file = new File(new String(problem.getOriginatingFileName()));
    String filename = file.getAbsolutePath();

    String message = problem.getMessage() + " at " + filename + ":"
            + problem.getSourceLineNumber();

    if (problem.isError()) {
        if (!environment.getNoClasspath()) {
            // by default, compilation errors are notified as exception
            throw new ModelBuildingException(message);
        }
    }

}
 

import spoon.compiler.Environment; //导入依赖的package包/类
public static void printJavaFileWithComment(CtType<?> type, File directory) {
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();
    env.setAutoImports(true);
    env.setCommentEnabled(true);
    JavaOutputProcessor processor = new JavaOutputProcessor(directory, new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);
    processor.createJavaFile(type);
    env.setAutoImports(false);
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
@TaskAction
public void generateClasses() throws IOException {
    // Clean the destination directory
    getProject().delete(getDestinationDir());

    // Initialize spoon
    SpoonAPI spoon = new Launcher();
    spoon.addProcessor(EVENT_CLASS_PROCESSOR);

    final Environment environment = spoon.getEnvironment();
    environment.setComplianceLevel(Integer.parseInt(JavaVersion.toVersion(getSourceCompatibility()).getMajorVersion()));
    environment.setNoClasspath(!this.validateCode);

    // Configure AST generator
    final SpoonModelBuilder compiler = spoon.createCompiler();
    compiler.setSourceClasspath(toPathArray(getClasspath().getFiles()));

    for (Object source : this.source) {
        if (!(source instanceof SourceDirectorySet)) {
            throw new UnsupportedOperationException("Source of type " + source.getClass() + " is not supported.");
        }

        ((SourceDirectorySet) source).getSrcDirs().forEach(compiler::addInputSource);
    }

    this.factory = compiler.getFactory();

    // Generate AST
    compiler.build();

    // Analyse AST
    final EventInterfaceProcessor processor = new EventInterfaceProcessor(getSource());
    compiler.process(Collections.singletonList(processor));
    final Map<CtType<?>, List<Property>> foundProperties = processor.getFoundProperties();

    this.sorter = new PropertySorter(this.sortPriorityPrefix, this.groupingPrefixes);

    dumpClasses(foundProperties);
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
@Override
public @NotNull Environment createEnvironment() {
	env = new StandardEnvironment();
	env.setCommentEnabled(false);
	env.setComplianceLevel(8);
	env.setSelfChecks(false);
	env.setShouldCompile(false);
	return env;
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
private CtModel getExpectedModel(final String path) {
	spoon.Launcher launcher = new spoon.Launcher();
	final Environment env = launcher.getEnvironment();
	env.setComplianceLevel(8);
	launcher.addInputResource(path);
	launcher.buildModel();
	return launcher.getModel();
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
String getRefactoredCode() {
	Environment env = cmdAnalyser.getEnvironment();
	env.useTabulations(true);
	env.setAutoImports(true);
	DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(env);
	printer.calculate(null, new ArrayList<>(cmdAnalyser.getModel().getAllTypes()));
	return printer.getResult().replace(" \n", "\n").replaceAll("(\n)+", "\n");
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
@Override
public void run(final IMarker marker) {
	final Entry<CtExecutable<?>, UIListener> entry = DetectBlobListenerAction.getBlobCommands(marker);
	final WidgetProcessor widgetProc = new WidgetProcessor(true);
	
	System.out.println("Refactoring blob listener: " + entry);
	
	Launcher launcher = new Launcher(Collections.singletonList(widgetProc), DetectBlobListenerAction.currentAnalyser.getCmdAnalyser().getModelBuilder());
	launcher.process();
	
	System.out.println("Widgets processor ended");
	
	final CommandWidgetFinder finder = new CommandWidgetFinder(entry.getValue().getCommands(), widgetProc.getWidgetUsages());
	finder.process();
	final Collection<CommandWidgetFinder.WidgetFinderEntry> allEntries = finder.getResults().values();
	
	System.out.println("Widgets finder ended");
	
	entry.getValue().getCommands().forEach(cmd -> {
		final ListenerCommandRefactor ref = new ListenerCommandRefactor(cmd, null, false, false, false, allEntries);
		ref.execute();
		
		Environment env = widgetProc.getEnvironment();
		env.useTabulations(true);
		env.setAutoImports(true);
		DefaultJavaPrettyPrinter printer = new DefaultJavaPrettyPrinter(env);
		printer.calculate(null, cmd.getAllLocalStatmtsOrdered().stream().
				map(s -> s.getElements(new BasicFilter<CtTypeReference<?>>(CtTypeReference.class))).
				flatMap(s -> s.stream()).map(tref -> tref.getDeclaration()).collect(Collectors.toList()));
		System.out.println(printer.getResult());
	});
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
public static void printAllClasses(Factory factory, File out, File fileFrom) {
    Environment env = factory.getEnvironment();
    Processor processor = new JavaOutputProcessorWithFilter(out, new DefaultJavaPrettyPrinter(env), allClassesName(fileFrom));
    try {
        ProcessingManager pm = new QueueProcessingManager(factory);
        pm.addProcessor(processor);
        pm.process(factory.Package().getRootPackage());
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
public static void printJavaFile(File directory, CtType type) throws IOException {
    try {
        Factory factory = type.getFactory();
        Environment env = factory.getEnvironment();

        JavaOutputProcessor processor = new JavaOutputProcessor(directory, new DefaultJavaPrettyPrinter(env));
        processor.setFactory(factory);

        processor.createJavaFile(type);
        Log.trace("write type {} in directory {}", type.getQualifiedName(), directory);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
@Override
public void printJavaFile(String directory) throws IOException {
    CtType<?> type = getPosition().getCompilationUnit().getMainType();
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), directory);
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
protected void printJavaFile(String directory, List<CtType> classes) throws IOException {
    Environment env = getFactory().getEnvironment();

    classes.stream()
            .forEach(cl -> {
                Log.debug("print java file: {}", directory + "/" + cl.getQualifiedName().replace(".", "/") + ".java");
                cl.getPosition().getCompilationUnit().getDeclaredTypes().stream()
                        .forEach(cc -> {
                            JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
                            processor.setFactory(getFactory());
                            processor.createJavaFile(cc);
                        });
            });
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
@Override
public void printJavaFile(String srcDir) throws IOException {
    CtType<?> type = loop.getParent(CtType.class);
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(srcDir), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), srcDir);
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
@Override
public void printJavaFile(String directory) throws IOException {
    CtType<?> type = transformation.getOriginalClass(transformation.getTransplantationPoint());
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), directory);
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
/**
 * Prints the modified java file. When the transformation is done a new java file is created. This method performs a
 * pretty print of it
 *
 * @param directory Directory where the java file is going to be placed
 * @throws IOException
 */
public void printJavaFile(String directory) throws IOException {
    CtType<?> type = getOriginalClass(transplantationPoint);
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), directory);
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
public void printJavaFile(String directory) throws IOException {
    CtType<?> type = getPosition().getCompilationUnit().getMainType();
    Factory factory = type.getFactory();
    Environment env = factory.getEnvironment();

    JavaOutputProcessor processor = new JavaOutputProcessor(new File(directory), new DefaultJavaPrettyPrinter(env));
    processor.setFactory(factory);

    processor.createJavaFile(type);
    Log.debug("write type {} in directory {}", type.getQualifiedName(), directory);
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
public static Environment getEnvironment() {
	StandardEnvironment env = new StandardEnvironment();

	env.setComplianceLevel(ConfigurationProperties.getPropertyInt("javacompliancelevel"));
	env.setVerbose(false);
	env.setDebug(true);
	env.setTabulationSize(5);
	env.useTabulations(true);
	return env;
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
protected Environment spoonEnvironment() {
    return spoonFactory().getEnvironment();
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
@Override
public void init() {
	ignoredTypes.add(getFactory().Type().createReference(Environment.class));
	ignoredTypes.add(getFactory().Type().createReference(Factory.class));
	ignoredTypes.add(getFactory().Type().createReference(FactoryAccessor.class));
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
public MyPrinter(Environment env) {
    super(env);
}
 

import spoon.compiler.Environment; //导入依赖的package包/类
@Override
public @Nullable Environment getEnvironment() {
	return env;
}