import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
public void addBlock(CtBlock ctBlock) {
    if (ctBlock == null) {
        return;
    }

    System.out.println("BLOCK: " + ctBlock.getParent().toString());
    for (CtStatement ctStatement : ctBlock.getStatements()) {
        System.out.println("    STATEMENT: " + ctStatement);

        StatementShovel statementShovel = new StatementShovel(codeWriter, typeMapper);
        if (ctStatement.toString().equals("super()")) {
            // skip super() calls for now
            continue;
        }
        if (ctStatement instanceof CtComment) {
            new CommentWriter(codeWriter).write((CtComment)ctStatement);
        }

        for (CtElement ctElement : ctStatement.getElements(new MatchAllFilter<CtElement>())) {
            System.out.println("        ELEMENT: " + ctElement.getClass().getSimpleName() + " " + ctElement);
            statementShovel.addElement(ctElement);
        }

        statementShovel.finish();
    }
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
/**
 * The statements of the command may refer to the external listener through 'this'. In such a case, the 'this' has to be changed
 * in a variable access.
 */
private void changeThisAccesses(final @NotNull List<CtElement> stats, final @NotNull CtAbstractInvocation<?> regInvok) {
	final Filter<CtThisAccess<?>> filter = new ThisAccessFilter(false);
	final CtExecutable<?> regMethod = regInvok.getParent(CtExecutable.class);

	stats.stream().map(stat -> stat.getElements(filter)).flatMap(s -> s.stream()).forEach(th -> {
		List<CtLocalVariable<?>> thisVar = regMethod.getElements(new BasicFilter<CtLocalVariable<?>>(CtLocalVariable.class) {
			@Override
			public boolean matches(final CtLocalVariable<?> element) {
				final CtType<?> decl = element.getType().getDeclaration();
				return decl!=null && decl.equals(th.getType().getDeclaration());
			}
		});
		if(thisVar.isEmpty()) {
			LOG.log(Level.SEVERE, "Cannot find a local variable for a 'this' access: " + thisVar);
		}else {
			th.replace(regInvok.getFactory().Code().createVariableRead(thisVar.get(0).getReference(), false));
		}
	});
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
@Override
public CtIf processCondition(CtStatement element, String newCondition) {
    //logger.debug("##### {} ##### Before:\n{}", element, element.getParent());
    // if the element is not a line
    if (!new LineFilter().matches(element)) {
        element = element.getParent(new LineFilter());
    }
    CtElement parent = element.getParent();
    CtIf newIf = element.getFactory().Core().createIf();
    CtCodeSnippetExpression<Boolean> condition = element.getFactory().Core().createCodeSnippetExpression();
    condition.setValue(newCondition);
    newIf.setCondition(condition);
    // Fix : warning: ignoring inconsistent parent for [CtElem1] ( [CtElem2] != [CtElem3] )
    newIf.setParent(parent);
    element.replace(newIf);
    // this should be after the replace to avoid an StackOverflowException caused by the circular reference.
    newIf.setThenStatement(element);
    //logger.debug("##### {} ##### After:\n{}", element, element.getParent().getParent());
    return newIf;
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
private void extractCommandsFromConditionalStatements(final @NotNull CtElement condStat, final @NotNull CtExecutable<?> listenerMethod,
													  final @NotNull List<CtStatement> conds) {
	UIListener uiListener;
	synchronized(commands) {
		uiListener = commands.computeIfAbsent(listenerMethod, k -> new UIListener(listenerMethod));
	}

	if(condStat instanceof CtIf) {
		extractCommandsFromIf((CtIf) condStat, uiListener, conds);
		return;
	}

	if(condStat instanceof CtCase<?>) {
		extractCommandsFromSwitchCase((CtCase<?>) condStat, uiListener);
		return;
	}

	LOG.log(Level.SEVERE, "Unsupported conditional blocks: " + condStat);
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
@Test
public void fieldsOfParameters() {
	CtElement element = elementInClassToSpoon("nested2 != null");
	testReachedVariableNames(element, "comparable",
			"nested2",
			"comparable.privateNestedInstanceField",
			"comparable.publicNestedInstanceField",
			"comparable.protectedNestedInstanceField",
			"spoon.example.ClassToSpoon.protectedStaticField",
			"spoon.example.ClassToSpoon.privateStaticField",
			"spoon.example.ClassToSpoon.publicStaticField",
			"nested2.privateInstanceField",
			"nested2.publicInstanceField",
			"nested2.protectedInstanceField",
			"spoon.example.ClassToSpoon.this.publicInstanceField",
			"spoon.example.ClassToSpoon.this.privateInstanceField",
			"spoon.example.ClassToSpoon.this.protectedInstanceField");
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
public List<CtExpression<?>> gatherContainingCondition(List<CtCodeElement> elements, CtExecutable<?> method) {
	List<CtExpression<?>> res = new ArrayList<>();
	CtCodeElement action = elements.get(0);
	CtElement parent = action;
	if (action != null) {
		try {
			parent = action.getParent();
			while (parent != null && parent != method) {
				res.addAll(exploreConditionals(action, (CtCodeElement) parent));// optimize
																				// to
																				// explore
																				// only
																				// action's
																				// parents
				parent = parent.getParent();
			}
		} catch (ParentNotInitializedException e) {
			System.out.println("Parent init exeption: " + parent);
		}
	}
	return res;
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
/**
 * Looks for a parent of the given type from a given element.
 * @param elt The element from which the parent is looked for.
 * @param typeParent The class of the parent to look for.
 * @param butNot The research will stop as soon as the current parent is this element. Can be null.
 * @return The found element or nothing.
 */
public <T extends CtElement> @NotNull Optional<CtElement> getParentOf(final @Nullable CtElement elt, final @NotNull Class<T> typeParent,
																	  final @Nullable CtElement butNot) {
	if(elt == null) return Optional.empty();

	try {
		CtElement parent = elt.getParent();

		while(!typeParent.isInstance(parent) && parent != butNot) {
			parent = parent.getParent();
		}

		if(parent == butNot || !typeParent.isInstance(parent)) return Optional.empty();

		return Optional.of(parent);

	}catch(final ParentNotInitializedException ex) {
		return Optional.empty();
	}
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
/**
 * Searches for the parent or current statement. If elt is a statement, elt is returned.
 * Otherwise, a statement is searched in the parent hierarchy.
 * @param elt The element to analyse.
 * @return The parent statement or elt or nothing.
 */
public Optional<CtStatement> getStatement(final @Nullable CtElement elt) {
	if(elt==null) {
		return Optional.empty();
	}

	if(elt instanceof CtStatement) {
		return Optional.of((CtStatement)elt);
	}

	if(elt.isParentInitialized()) {
		return getStatement(elt.getParent());
	}

	return Optional.empty();
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
private <T> void refactorRegistrationAsLambda(final @NotNull CtAbstractInvocation<?> regInvok,
											  final @NotNull Set<CtAbstractInvocation<?>> unregInvoks,
											  final int regPos, final String widgetName) {
	final Factory fac = regInvok.getFactory();
	final CtTypeReference<T> typeRef = (CtTypeReference<T>) regInvok.getExecutable().getParameters().get(regPos).getTypeDeclaration().getReference();
	final CtLambda<T> lambda = fac.Core().createLambda();
	final List<CtElement> stats = cleanStatements(regInvok, fac);

	if(stats.size()==1 && stats.get(0) instanceof CtExpression<?>) {
		lambda.setExpression((CtExpression<T>)stats.get(0));
	} else {
		final CtBlock<T> block = fac.Core().createBlock();
		stats.stream().filter(stat -> stat instanceof CtStatement).forEach(stat -> block.insertEnd((CtStatement)stat));
		lambda.setBody(block);
	}

	CtParameter<?> oldParam = cmd.getExecutable().getParameters().get(0);
	CtParameter<?> param = fac.Executable().createParameter(lambda, oldParam.getType(), oldParam.getSimpleName());
	lambda.setParameters(Collections.singletonList(param));
	lambda.setType(typeRef);

	replaceRegistrationParameter(lambda, regInvok, unregInvoks, regPos, widgetName);
	changeThisAccesses(stats, regInvok);
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
private CtStatement getParent(CtInvocation invocationToBeCloned) {
    CtElement parent = invocationToBeCloned;
    while (!(parent.getParent() instanceof CtBlock)){
        parent = parent.getParent();
    }
    return (CtStatement) parent;
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
public static boolean elementUsesGUIParam(final CtElement elt, final List<CtParameterReference<?>> guiParams, final CtBlock<?> mainBlock,
										final Set<CtElement> alreadyVisited) {
		if(alreadyVisited.contains(elt)) {
			return false;
		}

		// Check whether a GUI parameter is directly used in the statement.
		//FIXME 5.5
//		if(guiParams.stream().anyMatch(param -> elt.getElements(new BasicFilter<>(CtParameterReference.class)).stream().noneMatch(ref -> ref.equals(param)))){
		if(guiParams.stream().anyMatch(param -> !elt.getReferences(new DirectReferenceFilter<>(param)).isEmpty())) {
			return true;
		}

		alreadyVisited.add(elt);

		// Otherwise, looking for local variables that use a GUI parameter.
		return elt.getElements(new LocalVariableAccessFilter()).stream().
			anyMatch(var ->
				// Maybe the declaration of the variable refers to a GUI parameter
				elementUsesGUIParam(var.getDeclaration(), guiParams, mainBlock, alreadyVisited) ||
					// or an assignment of this variable in the main block refers to a GUI parameter
					// 1. Looking for the assignments in the block
					mainBlock.getElements(new BasicFilter<>(CtAssignment.class)).stream().
						// 2. Keeping only the variable write
						anyMatch(assig -> assig.getAssigned() instanceof CtVariableWrite<?> &&
						// 3. Checking that the assigned variable is our current variable
						((CtVariableWrite<?>)assig.getAssigned()).getVariable().equals(var) &&
							// 4. Checking that the assignment directly or indirectly refers to GUI parameter
							elementUsesGUIParam(assig.getAssignment(), guiParams, mainBlock, alreadyVisited)));
	}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
public static CtBlock<?> asBlock(CtStatement statement, CtElement parent) {
    CtBlock<?> block;
    if (isBlock(statement)) {
        block = (CtBlock<?>) statement;
    } else {
        block = newBlock(statement.getFactory(), statement);
    }
    setParent(parent, block);
    return block;
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
public static void insertBeforeUnderSameParent(CtStatement toBeInserted, CtStatement insertionPoint) {
    CtElement parent;
    if (isBlock(insertionPoint)) {
        CtBlock<?> block = (CtBlock<?>) insertionPoint;
        block.insertBegin(toBeInserted);
        parent = block;
    } else {
        insertionPoint.insertBefore(toBeInserted);
        parent = insertionPoint.getParent();
    }
    setParent(parent, toBeInserted);
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
@Override
public boolean matches(CtElement element) {
    SourcePosition position = element.getPosition();
    if (position != null && position != SourcePosition.NOPOSITION) {
        return FileLibrary.isSameFile(classSourceFile(), position.getFile()) && codeSnippet().equals(element.toString());
    }
    return false;
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
private void removingLocalVarsIfs() {
	CtBlock<?> body = cmd.getExecutable().getBody();
	List<CtIf> iffs = body.getElements(new BasicFilter<>(CtIf.class));
	int oldsize;
	IntegerProperty cpt = new SimpleIntegerProperty();
	Set<CtElement> remain = cmd.getStatements().stream().filter(stat -> !stat.isMainEntry()).flatMap(s -> s.getStatmts().stream()).collect(Collectors.toSet());

	do {
		// Removing all the empty if statements.
		cpt.set(0);
		oldsize = iffs.size();
		iffs.stream().filter(ctif ->
			(ctif.getThenStatement() == null || ctif.getThenStatement() instanceof CtBlock && ((CtBlock<?>) ctif.getThenStatement()).getStatements().isEmpty()) &&
				(ctif.getElseStatement() == null || ctif.getElseStatement() instanceof CtBlock && ((CtBlock<?>) ctif.getElseStatement()).getStatements().isEmpty())).
			forEach(ctif -> ctif.delete());
		iffs = body.getElements(new BasicFilter<>(CtIf.class));

		// Removing all the unused local vars
		Set<CtElement> toRemove = new HashSet<>();
		remain.stream().filter(r -> r instanceof CtLocalVariable).forEach(var -> {
			if(body.getElements(new MyVariableAccessFilter((CtVariable<?>) var)).stream().
				allMatch(access -> remain.stream().allMatch(r -> r != var && r.getElements(new FindElementFilter(access, false)).isEmpty()))) {
				var.delete();
				cpt.set(cpt.get() + 1);
				toRemove.add(var);
			}
		});
		remain.removeAll(toRemove);
		// Doing that until no more removal.
	}while(cpt.get()>0 || iffs.size()!=oldsize);
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
private void markCtElement(final Tuple<String, Command> tuple, final IProject project) {
	final CtElement elt = tuple.b.getMainStatmtEntry().get().getStatmts().get(0);
	final String errorMessage = tuple.a;
	final File source = elt.getPosition().getFile();
	final int begin = project.getLocation().toFile().toString().length() + 1; 
	String path = source.getAbsolutePath().substring(begin);
	IResource r = project.findMember(path);
	
	if(r==null) {
		int i = path.indexOf('/');
		if(i!=-1)
			path = path.substring(i);
		r = project.findMember(path);
	}
	
	if(r==null && path.startsWith("/"+project.getName())) {
		path = path.replaceFirst("/"+project.getName(), "");
		r = project.findMember(path);
	}
	
	if(r!=null) {
		IMarker m;
		try {
			m = r.createMarker(IMarker.PROBLEM);
			m.setAttribute(IMarker.MARKER, ClearMarkersAction.INSPECTOR_MARKER_NAME);
			m.setAttribute(IMarker.MESSAGE, errorMessage);
			m.setAttribute(IMarker.LINE_NUMBER, elt.getPosition().getLine());
			m.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_WARNING);
			infoMapping.put(m, tuple);
			GUIBugsView.getSingleton().addMarker(m); // update the view
		} catch (CoreException e) {
			e.printStackTrace();
		}
	}
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
private boolean isMethod(CtElement ctElement) {
    CtExecutable parent = ctElement.getParent(CtExecutable.class);
    if (parent == null) {
        return false;
    }
    return parent.getSimpleName().equals(buggyMethod);
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
public void process(CtStatement element) {
    logger.debug("##### {} ##### Before:\n{}", element, element.getParent());
    CtElement parent = element.getParent();
    CtIf newIf = element.getFactory().Core().createIf();
    CtCodeSnippetExpression<Boolean> condition;
    if (getValue() != null) {
        switch (getValue()) {
            case "1":
                condition = element.getFactory().Code()
                        .createCodeSnippetExpression("true");
                break;
            case "0":
                condition = element.getFactory().Code()
                        .createCodeSnippetExpression("false");
                break;
            default:
                condition = element.getFactory().Code()
                        .createCodeSnippetExpression(getValue());
        }
    } else {
        condition = element
                .getFactory()
                .Code()
                .createCodeSnippetExpression(
                        Debug.class.getCanonicalName()
                                + ".makeSymbolicBoolean(\"guess_fix\")");
    }
    newIf.setCondition(condition);
    // Fix : warning: ignoring inconsistent parent for [CtElem1] ( [CtElem2] != [CtElem3] )
    newIf.setParent(parent);
    element.replace(newIf);
    // this should be after the replace to avoid an StackOverflowException caused by the circular reference.
    newIf.setThenStatement(element);
    // Fix : warning: ignoring inconsistent parent for [CtElem1] ( [CtElem2] != [CtElem3] )
    newIf.getThenStatement().setParent(newIf);
    logger.debug("##### {} ##### After:\n{}", element, element.getParent().getParent());
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
private CtStatement getFirstStatement(CtExpression ctElement) {
    CtElement ctParent = ctElement.getParent();
    while (!(ctParent instanceof CtStatement) && ctParent != null) {
        ctParent = ctParent.getParent();
    }
    if (ctParent == null) {
        return null;
    }
    return (CtStatement) ctParent;
}
 

import spoon.reflect.declaration.CtElement; //导入依赖的package包/类
@Test
public void reachedVariablesInExample1() {
	CtElement element = elementInNopolProject(1, "index == 0");
	testReachedVariableNames(element, "s",
			"index",
			"nopol_examples.nopol_example_1.NopolExample.this.index",
			"nopol_examples.nopol_example_1.NopolExample.s");
}