@Override public boolean matches(T variableAccess) { return variable.equals(variableAccess.getVariable()); }
@java.lang.Override public void set(spoon.reflect.reference.CtVariableReference replace) { this.element.setVariable(replace); } }
private <T> void visitVariableAccess(CtVariableAccess<T> variableAccess) { CtVariable<?> v = variableAccess.getVariable().getDeclaration(); if (v != null && v.hasModifier(ModifierKind.FINAL) && v.getDefaultExpression() != null) { setResult(evaluate(v.getDefaultExpression())); } else { setResult(variableAccess.clone()); } }
CtTypeReference returnType = variableAccessToReplace.getType();// MutationSupporter.getFactory().createCtTypeReference(Boolean.class); for (CtVariableAccess ctVariableAccess : varsToBeParameters) { CtParameter pari = MutationSupporter.getFactory().createParameter(null, ctVariableAccess.getType(), ctVariableAccess.getVariable().getSimpleName()); parameters.add(pari); realParameters.add(ctVariableAccess.clone().setPositions(new NoSourcePosition())); CtExpression expCloned = variableAccessToReplace.clone(); expCloned.setPosition(new NoSourcePosition()); MutationSupporter.clearPosition(expCloned);
@Override public void apply() { // previousVariable.replace(newLiteral); previousname = affectedVariable.getVariable().getSimpleName(); affectedVariable.getVariable().setSimpleName(placeholder_name); //Workarround affectedVariable.getFactory().getEnvironment().setNoClasspath(true); if (affectedVariable instanceof CtFieldAccess) { CtFieldAccess fieldAccess = (CtFieldAccess) affectedVariable; fieldAccess.getVariable().setDeclaringType(null); } }
CtVariable varNew = mapToFollow.get(var.getVar().getVariable().getSimpleName()); newVarAccessDestination.setVariable(newVarReference); newVarAccessDestination.setVariable(newVarReference); originalVarAccessDestination.replace(newVarAccessDestination); } else { logger.error("No destination resolved");
va = factory.Core().createVariableRead(); va.setVariable(references.getVariableReference((VariableBinding) qualifiedNameReference.binding)); va.setType(va.getVariable().getType()); if (qualifiedNameReference.otherBindings != null) { int i = 0; //positions index; int sourceEnd = (int) (positions[i]); final int[] lineSeparatorPositions = context.compilationunitdeclaration.compilationResult.lineSeparatorPositions; va.setPosition(factory.Core().createSourcePosition(cu, sourceStart, sourceEnd, lineSeparatorPositions)); va = other; i++; va.setVariable(varRef); context.enter(va, qualifiedNameReference); return false;
return; String name = variableAccess.getVariable().getSimpleName(); for (String pname : parameterNames) { if (name.contains(pname)) { CtAbstractInvocation<?> inv = (CtAbstractInvocation<?>) variableAccess.getParent(); int i = inv.getArguments().indexOf(variableAccess); inv.getArguments().remove(i); inv.getExecutable().getActualTypeArguments().remove(i); for (CtExpression<?> va : vas) { va.setParent(variableAccess.getParent()); inv.getArguments().add(i, va); inv.getExecutable().getActualTypeArguments().add(i, va.getType()); variableAccess.getVariable().setSimpleName(name); CtTypeReference<T> reference = variableAccess.getType(); if ((parameterNames != null) && (reference != null) && parameterNames.contains(reference.getSimpleName() )) { throw new RuntimeException("unsupported reference substitution"); variableAccess.setType(t);
@Override public List<VarLiPlaceholder> createTOS(T ingredientStatement) { List<VarLiPlaceholder> results = new ArrayList<>(); List<CtVariableAccess> varAccessCollected = VariableResolver.collectVariableAccess(ingredientStatement, true); for (CtVariableAccess ctVariableAccess : varAccessCollected) { int i = 0; if (ctVariableAccess instanceof CtVariableRead) { if (!(ctVariableAccess instanceof CtFieldRead) || !((CtFieldReference) ctVariableAccess.getVariable()).isStatic()) { VarLiPlaceholder pc = new VarLiPlaceholder(ctVariableAccess, "_lit_" + ctVariableAccess.getType().getSimpleName() + "_" + i); results.add(pc); } } } return results; }
@Override public <T> void visitCtVariableAccess(CtVariableAccess<T> variableAccess) { enter(variableAccess); scan(variableAccess.getAnnotations()); scan(variableAccess.getType()); scanReferences(variableAccess.getTypeCasts()); scan(variableAccess.getVariable()); exit(variableAccess); }
@Override public void apply() { previousVariable.replace(newLiteral); }
/** * Creates a variable access. */ public <T> CtVariableAccess<T> createVariableRead(CtVariableReference<T> variable, boolean isStatic) { CtVariableAccess<T> va; if (variable instanceof CtFieldReference) { va = factory.Core().createFieldRead(); // creates a this target for non-static fields to avoid name conflicts... if (!isStatic) { ((CtFieldAccess<T>) va).setTarget(createThisAccess(((CtFieldReference<T>) variable).getDeclaringType())); } } else { va = factory.Core().createVariableRead(); } return va.setVariable(variable).setType(variable.getType()); }
public List<Transformation> process(ModificationPoint modificationPoint, VarLiPlaceholder varLiPlaceholder) { List<Transformation> transformation = new ArrayList<>(); List<Ingredient> ingredients = getSpace(modificationPoint.getProgramVariant()) .getIngredients(modificationPoint.getCodeElement()); logger.debug("Ingredients lit (" + ingredients.size() + ") " + ingredients); for (Ingredient ctCodeElement : ingredients) { CtLiteral literal4Space = (CtLiteral) ctCodeElement.getCode(); if (literal4Space.getType().isSubtypeOf(varLiPlaceholder.getAffectedVariable().getType())) { Transformation t = new VarLiTransformation(varLiPlaceholder, varLiPlaceholder.getAffectedVariable(), literal4Space.clone()); transformation.add(t); } } return transformation; }
/** * variable read/write of `variable` of type {@link TemplateParameter} * @param variable a variable whose references will be substituted * @return {@link PatternParameterConfigurator} to support fluent API */ public PatternParameterConfigurator byTemplateParameterReference(CtVariable<?> variable) { ParameterInfo pi = getCurrentParameter(); queryModel().map(new VariableReferenceFunction(variable)) .forEach((CtVariableReference<?> varRef) -> { /* * the target of substitution is always the invocation of TemplateParameter#S() */ CtVariableAccess<?> varAccess = (CtVariableAccess<?>) varRef.getParent(); CtElement invocationOfS = varAccess.getParent(); if (invocationOfS instanceof CtInvocation<?>) { CtInvocation<?> invocation = (CtInvocation<?>) invocationOfS; if ("S".equals(invocation.getExecutable().getSimpleName())) { addSubstitutionRequest(pi, invocation); return; } } throw new SpoonException("TemplateParameter reference is NOT used as target of invocation of TemplateParameter#S()"); }); return this; }
va.setPosition(jdtTreeBuilder.getPositionBuilder().buildPosition(sourceStart, sourceEnd)); sourceStart = (int) (positions[qualifiedNameReference.indexOfFirstFieldBinding - 1] >>> 32); for (FieldBinding b : qualifiedNameReference.otherBindings) { va.setPosition(jdtTreeBuilder.getPositionBuilder().buildPosition(sourceStart, sourceEnd)); va = other; va.setPosition(jdtTreeBuilder.getPositionBuilder().buildPosition(qualifiedNameReference.sourceStart(), qualifiedNameReference.sourceEnd())); return va;
private List<Ingredient> computeIngredientsNullCheck(ModificationPoint modificationPoint, List<CtVariableAccess> varAccessInModificationPoints) { List<Ingredient> ingredients = new ArrayList(); for (CtVariableAccess iVariableAccess : varAccessInModificationPoints) { CtVariableAccess iVariableAccessC = iVariableAccess.clone(); MutationSupporter.clearPosition(iVariableAccessC); CtBinaryOperator<Boolean> binaryOp = new CtBinaryOperatorImpl<>(); binaryOp.setLeftHandOperand(iVariableAccessC); binaryOp.setRightHandOperand(MutationSupporter.getFactory().createCodeSnippetExpression("null")); binaryOp.setKind(BinaryOperatorKind.NE); ingredients.add(new Ingredient(binaryOp)); } return ingredients; }
for (CtVariableAccess ctVariableAccess : varsToBeParameters) { CtParameter pari = MutationSupporter.getFactory().createParameter(null, ctVariableAccess.getType(), ctVariableAccess.getVariable().getSimpleName()); parameters.add(pari); realParameters.add(ctVariableAccess.clone().setPositions(new NoSourcePosition()));
CtVariableAccess var = varAccessCollected.get(i); if (VariableResolver.isStatic(var.getVariable())) { continue; if (!varMappings.containsKey(var.getVariable().getSimpleName())) { String currentTypeName = var.getVariable().getType().getSimpleName(); if (currentTypeName.contains("?")) { abstractName = var.getVariable().getSimpleName(); } else { abstractName = "_" + currentTypeName + "_" + nrvar; varMappings.put(var.getVariable().getSimpleName(), abstractName); nrvar++; } else { abstractName = varMappings.get(var.getVariable().getSimpleName()); var.getVariable().setSimpleName(abstractName); var.getFactory().getEnvironment().setNoClasspath(true); if (var instanceof CtFieldAccess) { CtFieldAccess fieldAccess = (CtFieldAccess) var;
List<CtVariable> varMatched = new ArrayList<>(); try { CtTypeReference typeToFind = vartofind.getType(); || ctVariableWithTypes.getSimpleName().equals(vartofind.getVariable().getSimpleName()); if (matchName) { varMatched.add(ctVariableWithTypes);
/** * For each modified variable, it resets the variables by putting their original * var reference * * @param varMapping * @param original */ public static void resetIngredient(Map<VarAccessWrapper, CtVariableAccess> old) { for (VarAccessWrapper newa : old.keySet()) { newa.getVar().replace(old.get(newa)); } }