import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public SpoonedFile(File[] sourceFiles, NopolContext nopolContext) {
    this.nopolContext = nopolContext;
    this.sourceFiles = sourceFiles;
    this.projectClasspath = nopolContext.getProjectClasspath();

    factory = SpoonModelLibrary.newFactory();
    factory.getEnvironment().setComplianceLevel(nopolContext.getComplianceLevel());
    factory.getEnvironment().setCommentEnabled(false);
    factory.getEnvironment().setLevel(Level.OFF.toString());

    factory = SpoonModelLibrary.modelFor(factory, sourceFiles, projectClasspath());

    compiler = new DynamicClassCompiler(compilationClasspath(), nopolContext.getComplianceLevel());
    manager = new RuntimeProcessingManager(factory);
    compiledClasses = MetaMap.newHashMap();
    prettyPrinter = new DefaultJavaPrettyPrinter(spoonEnvironment());
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public <T> DefaultJavaPrettyPrinter writeLocalVariable(
		CtLocalVariable<T> localVariable) {
	if (!context.noTypeDecl) {
		elementPrinterHelper.writeModifiers(localVariable);
		scan(localVariable.getType());
		printer.write(" ");
	}
	printer.write(localVariable.getType().toString());
	if (localVariable.getDefaultExpression() != null) {
		printer.write(" = ");
		scan(localVariable.getDefaultExpression());
	}
	return this;
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的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.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
@Override
public CompilationResult compile(Collection<? extends CtType> ctClassList, URL[] cp) {

	Map<String, String> toCompile = new HashMap<String, String>();
	prettyPrinter = new DefaultJavaPrettyPrinter(this.getFactory().getEnvironment());
	dcc = new JavaXToolsCompiler();
	
	for (CtType ctClass : ctClassList) {
		try {
			this.getProcessingManager().process(ctClass);
			toCompile.put(ctClass.getQualifiedName(), sourceForModelledClass(ctClass));
		} catch (Exception e) {
			logger.error("Error printing class "+ctClass.getQualifiedName(),e);
		}
	}

	List<String> cps = new ArrayList<>();
	cps.add("-cp");
	String path = "";
	for (URL url : cp) {
		path += ((url.getPath()) + File.pathSeparator);
	}
	cps.add(path);
	
	String compliance = ConfigurationProperties.getProperty("javacompliancelevel");
	cps.add("-source");
	cps.add("1."+ compliance);

	cps.add("-target");
	cps.add("1."+ compliance);
	
	CompilationResult rbc = dcc.javaBytecodeFor(toCompile, new HashMap<String, byte[]>(), cps);
	return rbc;
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
private String partialElementPrint(CtElement element) {
	DefaultJavaPrettyPrinter print = new DefaultJavaPrettyPrinter(element.getFactory().getEnvironment()) {
		@Override
		public DefaultJavaPrettyPrinter scan(CtElement e) {
			if (e != null && e.getMetadata("isMoved") == null) {
				return super.scan(e);
			}
			return this;
		}
	};

	print.scan(element);
	return print.getResult();
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public void generateOutputFile(File destinationFolder) {
    Processor<?> writer = new JavaOutputProcessor(destinationFolder, new DefaultJavaPrettyPrinter(new StandardEnvironment()));
    process(writer);
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
protected DefaultJavaPrettyPrinter prettyPrinter() {
    return prettyPrinter;
}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
protected void generateProcessedSourceFilesUsingCUs() {

		try {
			getFactory().getEnvironment().debugMessage(
					"Generating source using compilation units...");
			// Check output directory
			if (getSourceOutputDirectory() == null) {
				throw new RuntimeException(
						"You should set output directory before generating source files");
			}
			// Create spooned dir
			if (getSourceOutputDirectory().isFile()) {
				throw new RuntimeException("Output must be a directory");
			}
			if (!getSourceOutputDirectory().exists()) {
				if (!getSourceOutputDirectory().mkdirs()) {
					throw new RuntimeException("Error creating output directory");
				}
			}
			setSourceOutputDirectory(getSourceOutputDirectory().getCanonicalFile());
			getFactory().getEnvironment().debugMessage(
					"Generating source files to: " + getSourceOutputDirectory());

			List<File> printedFiles = new ArrayList<File>();
			printing:
			for (spoon.reflect.cu.CompilationUnit cu : getFactory().CompilationUnit()
					.getMap().values()) {

				getFactory().getEnvironment().debugMessage(
						"Generating source for compilation unit: " + cu.getFile());

				CtType<?> element = cu.getMainType();

				CtPackage pack = element.getPackage();

				// create package directory
				File packageDir;
				if (pack.getQualifiedName()
						.equals(CtPackage.TOP_LEVEL_PACKAGE_NAME)) {
					packageDir = new File(getSourceOutputDirectory().getAbsolutePath());
				} else {
					char dot = '.';
					// Create current package dir
					packageDir = new File(getSourceOutputDirectory().getAbsolutePath()
							+ File.separatorChar
							+ pack.getQualifiedName().replace(dot, File.separatorChar));
				}
				if (!packageDir.exists()) {
					if (!packageDir.mkdirs()) {
						throw new RuntimeException(
								"Error creating output directory");
					}
				}

				File file = new File(packageDir.getAbsolutePath()
						+ File.separatorChar + element.getSimpleName()
						+ DefaultJavaPrettyPrinter.JAVA_FILE_EXTENSION);
				file.createNewFile();

				// the path must be given relatively to to the working directory
				InputStream is = getCompilationUnitInputStream(cu.getFile()
						.getPath());

				IOUtils.copy(is, new FileOutputStream(file));

				if (!printedFiles.contains(file)) {
					printedFiles.add(file);
				}
			} // end for
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}
 

import spoon.reflect.visitor.DefaultJavaPrettyPrinter; //导入依赖的package包/类
public void updateOutput(String output) {
	JavaOutputProcessor fileOutput = new JavaOutputProcessor(new File(output),
			new DefaultJavaPrettyPrinter(getEnvironment()));
	this.javaPrinter = fileOutput;
	fileOutput.setFactory(getFactory());
}