import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
void updateFieldTypes() {
    root.getMergedClass().accept(new CtScanner() {

        @Override
        public <T> void visitCtFieldReference(CtFieldReference<T> ref) {
            CtTypeReference<?> declarationType = ref.getDeclaringType();
            if (declarationType != null) {
                CtType<?> ctType = declarationType.getDeclaration();
                if (ctType instanceof CtClass) {
                    CompilationNode node =
                            cxt.getNodeByAnyStagedClass((CtClass) ctType);
                    if (node != null) {
                        ref.setDeclaringType(node.getMergedClass().getReference());
                    }
                }
            }
            super.visitCtFieldReference(ref);
        }
    });
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
protected CtVariableAccess createVariableAccess(CtVariableReference variable, CtVariableAccess toReplace) {
    boolean isStatic = variable.getDeclaration().hasModifier(ModifierKind.STATIC);
    if(toReplace instanceof CtVariableRead) {
        return getFactory().Code().createVariableRead(variable, isStatic);
    } else {
        CtVariableAccess va;
        if (variable instanceof CtFieldReference) {
            va = getFactory().Core().createFieldWrite();
            if (!isStatic) {
                ((CtFieldAccess) va).setTarget(getFactory().Code().createThisAccess(((CtFieldReference) variable).getDeclaringType()));
            }
        } else {
            va = getFactory().Core().createVariableWrite();
        }
        va.setVariable(variable).setType(variable.getType());
        return va;
    }
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
public static Collection<CtField<?>> accessibleFieldsFrom(CtTypeReference<?> accessingType, CtTypeReference<?> accessedType) {
    Collection<CtField<?>> accessibleFields = MetaList.newLinkedList();
    try {
        Collection<CtFieldReference<?>> allFields = accessedType.getAllFields();
        for (CtFieldReference<?> field : allFields) {
            CtField<?> actualField = field.getDeclaration();
            if (actualField != null && isVisibleFrom(accessingType, actualField, field.getDeclaringType(), accessedType)) {
                accessibleFields.add(actualField);
            }
        }
    } catch (Throwable e) {
        logWarning(logger(), e.toString());
    }
    return accessibleFields;
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
protected  CtCodeElement buildReplacementElement() throws BuildTransplantException {
    CtElement transplantationPoint = transformation.getTransplantationPoint().getCtCodeFragment();
    CtCodeElement copyTransplant = transformation.buildReplacementElement();

    Factory factory = copyTransplant.getFactory();

    CtFieldReference<Boolean> fieldRef = factory.Core().createFieldReference();
    fieldRef.setSimpleName("fr.inria.diversify.transformation.switchsosie.Switch.switchTransformation");

    CtIf stmtIf = factory.Core().createIf();
    stmtIf.setParent(transplantationPoint.getParent());

    stmtIf.setCondition(factory.Code().createVariableRead(fieldRef, true));

    CtBlock bodyThen = factory.Core().createBlock();
    stmtIf.setThenStatement(bodyThen);
    CtStatement tmp = (CtStatement) factory.Core().clone(copyTransplant);
    tmp.setParent(stmtIf);
    bodyThen.addStatement(tmp);

    CtBlock bodyElse = factory.Core().createBlock();
    stmtIf.setElseStatement(bodyElse);
    tmp = (CtStatement) factory.Core().clone(transplantationPoint);
    tmp.setParent(stmtIf);
    bodyElse.addStatement(tmp);


    return stmtIf;
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
@Override
public <T> void visitCtFieldRead(CtFieldRead<T> fieldRead) {
    super.visitCtFieldRead(fieldRead);
    String string = fieldRead.toString();
    if(!string.startsWith("super")
            && (!string.contains(".") || string.contains("this."))
            && fieldRead.getParent(CtExecutable.class).equals(method)
            && !isFinalInConstructor(fieldRead)) {
        fields.put(((CtFieldReference) fieldRead.getVariable()), fieldRead.toString());
    }
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
@Override
public <T> void visitCtFieldWrite(CtFieldWrite<T> fieldWrite) {
   super.visitCtFieldWrite(fieldWrite);
    String string = fieldWrite.toString();
    if(!string.startsWith("super")
            && (!string.contains(".") || string.contains("this."))
            && fieldWrite.getParent(CtExecutable.class).equals(method)
            && !isFinalInConstructor(fieldWrite)) {
        fields.put(((CtFieldReference) fieldWrite.getVariable()), fieldWrite.toString());
    }
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
@Override
public void process(final @NotNull CtTypeReference<?> element) {
	final CtElement parent = element.getParent();

	LOG.log(Level.INFO, () -> "PROCESSING " + element + " " + parent.getClass());

	if(parent instanceof CtField<?> || parent instanceof CtLocalVariable<?>) {
		onWidgetVar((CtVariable<?>) parent);
		return;
	}
	if(parent instanceof CtExecutableReference<?> && parent.getParent() instanceof CtConstructorCall<?>) {
		analyseWidgetConstructorCall((CtConstructorCall<?>) parent.getParent());
		return;
	}
	if(parent instanceof CtAssignment<?,?>) {
		analyseWidgetAssignment((CtAssignment<?, ?>) parent);
		return;
	}
	if(parent instanceof CtFieldReference<?>) {
		CtField<?> decl = ((CtFieldReference<?>) parent).getDeclaration();

		if(decl!=null && WidgetHelper.INSTANCE.isTypeRefAWidget(decl.getType())) {
			onWidgetVar(decl);
		}
		return;
	}
	if(parent instanceof CtMethod<?>) {
		analyseMethodUse((CtMethod<?>) parent);
		return;
	}
	if(parent instanceof CtExecutableReference<?>) {
		// A method is called on a widget, so ignored.
		return;
	}
	if(parent instanceof CtTypeAccess<?>) {
		// A static method / attribute is used on a widget class.
		return;
	}
	if(parent instanceof CtClass<?>) {
		// A widget class is used.
		return;
	}

	if(parent instanceof CtLocalVariableReference<?> || parent instanceof CtVariableRead<?>) {
		// A widget var assigned to a local var; or simply used.
		return;
	}

	if(parent instanceof CtThisAccess<?>) {
		// Use of this on a widget object.
		return;
	}

	LOG.log(Level.WARNING, "CTypeReference parent not supported or ignored: " + parent.getClass() + " " + parent);
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
public Map<CtFieldReference, String> getFields() {
    return fields;
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
public <T> void visitCtFieldReference(CtFieldReference<T> reference) {
    if(withField && !(reference.getSimpleName() == "super"))
            variableReferences.add(reference);

    super.visitCtFieldReference(reference);
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
public <T> void visitCtFieldReference(CtFieldReference<T> reference) {
	if (reference.getSimpleName().equals("this")) {
		if (context.currentThis.isEmpty()
				|| (!reference.getType().equals(context.currentThis.peek()) && !reference
						.getDeclaringType().isAnonymous())) {
			context.ignoreGenerics = true;
			scan(reference.getDeclaringType());
			printer.write(".");
			context.ignoreGenerics = false;
		}
	} else {
		boolean isStatic;
		if (reference.getSimpleName().equals("class")) {
			isStatic = true;
		} else if (reference.getSimpleName().equals("super")) {
			isStatic = false;
		} else {
			isStatic = reference.isStatic();
		}

		boolean printType = true;
		if (reference.isFinal() && reference.isStatic()) {
			if (context.currentTopLevel != null) {
				CtTypeReference<?> ref = reference.getDeclaringType();
				CtTypeReference<?> ref2;
				if(context.currentThis!=null && context.currentThis.size()>0)
					ref2 = context.currentThis.lastElement();
				else
					ref2 = context.currentTopLevel.getReference();
				// print type if not annonymous class ref and not within the
				// current scope
				printType = !ref.getSimpleName().equals("")
						&& !(ref.equals(ref2));
			} else {
				printType = true;
			}
		}

		if (isStatic && printType && !context.ignoreStaticAccess) {
			context.ignoreGenerics = true;
			scan(reference.getDeclaringType());
			context.ignoreGenerics = false;
			printer.write(".");
		}
	}
	printer.write(reference.getType().toString());
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
/**
 * Returns all variables in scope, reachable from the ctelement passes as
 * argument
 * 
 * @param element
 * @return
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
public static List<CtVariable> searchVariablesInScope(CtElement element) {
	List<CtVariable> variables = new ArrayList();

	if (element == null) {
		return variables;
	}

	if (element instanceof CtField) {
		return variables;
	}
	// We find the CtClass and returns the fields
	CtClass ctclass = element.getParent(CtClass.class);
	if (ctclass != null) {
		Collection<CtFieldReference<?>> vars = ctclass.getAllFields();
		for (CtFieldReference<?> ctFieldReference : vars) {
			// We dont add private fields from parent classes
			if ((!ctFieldReference.getModifiers().contains(ModifierKind.PRIVATE)
					|| ctclass.getFields().contains(ctFieldReference.getDeclaration()))) {

				// We ignore "serialVersionUID'
				if ((ctFieldReference.getDeclaration() != null)
						&& !"serialVersionUID".equals(ctFieldReference.getDeclaration().getSimpleName()))
					variables.add(ctFieldReference.getDeclaration());
			}
		}

	}

	// We find the parent method and we extract the parameters
	CtMethod method = element.getParent(CtMethod.class);
	if (method != null) {
		List<CtParameter> pars = method.getParameters();
		for (CtParameter ctParameter : pars) {
			variables.add(ctParameter);
		}
	}

	// We find the parent block and we extract the local variables before
	// the element under analysis
	CtBlock parentblock = element.getParent(CtBlock.class);
	if (parentblock != null) {
		int positionEl = parentblock.getStatements().indexOf(element);
		variables.addAll(VariableResolver.retrieveLocalVariables(positionEl, parentblock));
	}

	return variables;

}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
/**
 * Adapt the ingredient to the destination according to the mapping. We
 * directly manipulate the variables from the ingredient, which are stored
 * in VarMapping
 * 
 * @param varMapping
 * @param destination
 * @return it returns the original variable reference of each converted
 *         variable
 */
@SuppressWarnings("unchecked")
public static Map<VarAccessWrapper, CtVariableAccess> convertIngredient(VarMapping varMapping,
		Map<String, CtVariable> mapToFollow) {

	Map<VarAccessWrapper, CtVariableAccess> originalMap = new HashMap<>();

	Map<VarAccessWrapper, List<CtVariable>> mappedVars = varMapping.getMappedVariables();
	for (VarAccessWrapper var : mappedVars.keySet()) {
		CtVariable varNew = mapToFollow.get(var.getVar().getVariable().getSimpleName());
		//
		CtVariableReference newVarReference = varNew.getReference();

		CtVariableAccess originalVarAccessDestination = var.getVar();
		CtVariableAccess newVarAccessDestination = null;

		// if the var to reference is a local or parameter
		if (newVarReference instanceof CtLocalVariableReference
				|| newVarReference instanceof CtParameterReference) {
			// let's check the destination Writes or Reads
			if (originalVarAccessDestination instanceof CtFieldWrite
					|| originalVarAccessDestination instanceof CtVariableWrite) {
				// We replace the Write by a Var writter
				newVarAccessDestination = MutationSupporter.getFactory().Core().createVariableWrite();
				newVarAccessDestination.setVariable(newVarReference);

			} else { // read
				newVarAccessDestination = MutationSupporter.getFactory().Code().createVariableRead(newVarReference,
						varNew.hasModifier(ModifierKind.STATIC));
			}

		} else
		// else, if we want to reference a field
		if (newVarReference instanceof CtFieldReference) {
			// let's check the destination, write or read
			if (originalVarAccessDestination instanceof CtFieldWrite<?>
					|| originalVarAccessDestination instanceof CtFieldRead<?>) {
				newVarAccessDestination = MutationSupporter.getFactory().Core().createFieldWrite();

			} else {
				newVarAccessDestination = MutationSupporter.getFactory().Core().createFieldRead();

			}
			newVarAccessDestination.setVariable(newVarReference);
		}
		// At the end, for all cases:
		if (newVarAccessDestination != null) {
			originalMap.put(new VarAccessWrapper(newVarAccessDestination), originalVarAccessDestination);
			originalVarAccessDestination.replace(newVarAccessDestination);
		} else {
			logger.error("No destination resolved");
		}

	} // end for
	return originalMap;
}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
public static boolean isStatic(CtVariableReference varref) {

		if (!(varref instanceof CtFieldReference)) {
			return false;
		}

		CtFieldReference fieldRef = (CtFieldReference) varref;

		return fieldRef.isStatic();

	}
 

import spoon.reflect.reference.CtFieldReference; //导入依赖的package包/类
protected void addAlwayLog(Map<CtFieldReference, String> fieldUsed) {

    }