public <T, A extends T> void visitCtAssignment(final spoon.reflect.code.CtAssignment<T, A> assignement) { spoon.reflect.code.CtAssignment<T, A> aCtAssignment = assignement.getFactory().Core().createAssignment(); this.builder.copy(assignement, aCtAssignment); aCtAssignment.setAnnotations(this.cloneHelper.clone(assignement.getAnnotations())); aCtAssignment.setType(this.cloneHelper.clone(assignement.getType())); aCtAssignment.setTypeCasts(this.cloneHelper.clone(assignement.getTypeCasts())); aCtAssignment.setAssigned(this.cloneHelper.clone(assignement.getAssigned())); aCtAssignment.setAssignment(this.cloneHelper.clone(assignement.getAssignment())); aCtAssignment.setComments(this.cloneHelper.clone(assignement.getComments())); this.cloneHelper.tailor(assignement, aCtAssignment); this.other = aCtAssignment; }
@Override public <T, A extends T> CtAssignment<T, A> createAssignment() { CtAssignment<T, A> e = new CtAssignmentImpl<>(); e.setFactory(getMainFactory()); return e; }
@Override public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> assignement) { if (child instanceof CtExpression) { if (assignement.getAssigned() == null) { assignement.setAssigned((CtExpression<T>) child); return; } else if (assignement.getAssignment() == null) { assignement.setAssignment((CtExpression<A>) child); return; } } super.visitCtAssignment(assignement); }
public <T, A extends T> void visitCtAssignment(final spoon.reflect.code.CtAssignment<T, A> assignement) { spoon.reflect.code.CtAssignment other = ((spoon.reflect.code.CtAssignment) (this.stack.peek())); enter(assignement); biScan(spoon.reflect.path.CtRole.ANNOTATION, assignement.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.TYPE, assignement.getType(), other.getType()); biScan(spoon.reflect.path.CtRole.CAST, assignement.getTypeCasts(), other.getTypeCasts()); biScan(spoon.reflect.path.CtRole.ASSIGNED, assignement.getAssigned(), other.getAssigned()); biScan(spoon.reflect.path.CtRole.ASSIGNMENT, assignement.getAssignment(), other.getAssignment()); biScan(spoon.reflect.path.CtRole.COMMENT, assignement.getComments(), other.getComments()); exit(assignement); }
@Override public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> assignement) { enterCtStatement(assignement); enterCtExpression(assignement); scan(assignement.getAssigned()); printer.writeSpace().writeOperator("=").writeSpace(); scan(assignement.getAssignment()); exitCtExpression(assignement); exitCtStatement(assignement); }
@SuppressWarnings("unchecked") @Override public <T, U> U getValue(T element) { return ((U) ((Object) (castTarget(element).getAssigned()))); }
public <T, A extends T> void visitCtAssignment( CtAssignment<T, A> assignement) { for (CtTypeReference<?> ref : assignement.getTypeCasts()) { write("("); scan(ref); write(")"); } write("("); scan(assignement.getAssigned()); write(" = "); scan(assignement.getAssignment()); write(")"); }
@Override public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> variableAssignment) { CtAssignment<T, A> a = variableAssignment.clone(); a.setAssignment(evaluate(a.getAssignment())); setResult(a); }
/** checks that all assignments are aither a CtFieldWrite, a CtVariableWrite or a CtArrayWrite */ public void checkAssignmentContracts() { for (CtAssignment assign : _rootPackage.getElements(new TypeFilter<>(CtAssignment.class))) { CtExpression assigned = assign.getAssigned(); if (!(assigned instanceof CtFieldWrite || assigned instanceof CtVariableWrite || assigned instanceof CtArrayWrite)) { throw new AssertionError("AssignmentContract error:" + assign.getPosition() + "\n" + assign.toString() + "\nAssigned is " + assigned.getClass()); } } }
public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> variableAssignment) { CtAssignment<T, A> a = variableAssignment.getFactory().Core().clone(variableAssignment); a.setAssignment(evaluate(a, a.getAssignment())); setResult(a); }
/** * Creates a variable assignment (can be an expression or a statement). * * @param <T> * the type of the assigned variable * @param variable * a reference to the assigned variable * @param isStatic * tells if the assigned variable is static or not * @param expression * the assigned expression * @return a variable assignment */ public <A, T extends A> CtAssignment<A, T> createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression) { CtVariableAccess<A> vaccess = createVariableRead(variable, isStatic); return factory.Core().<A, T>createAssignment().<CtAssignment<A, T>>setAssignment(expression).setAssigned(vaccess); }
public LiteralReplacer(Class<?> cl, CtStatement statement, RepairType repairType) { super(statement, repairType); if (statement instanceof CtAssignment<?, ?>) { super.setDefaultValue(((CtAssignment<?, ?>) statement).getAssignment().toString()); } else if (statement instanceof CtLocalVariable<?>) { super.setDefaultValue(((CtLocalVariable<?>) statement).getDefaultExpression().toString()); } super.setType(cl); }
@java.lang.Override public void set(spoon.reflect.code.CtExpression replace) { this.element.setAssigned(replace); } }
} else if (candidate instanceof CtAssignment<?, ?>) { CtAssignment<?, ?> ctAssignment = (CtAssignment<?, ?>) candidate; Class<?> localVariableClass = ctAssignment.getType() .getActualClass();
public <T, A extends T> void visitCtAssignment(final CtAssignment<T, A> assignement) { enter(assignement); scan(CtRole.ANNOTATION, assignement.getAnnotations()); scan(CtRole.TYPE, assignement.getType()); scan(CtRole.CAST, assignement.getTypeCasts()); scan(CtRole.ASSIGNED, assignement.getAssigned()); scan(CtRole.ASSIGNMENT, assignement.getAssignment()); scan(CtRole.COMMENT, assignement.getComments()); exit(assignement); }
@Override public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> assignement) { if (assignement.getAssigned() == null) { assignement.setAssigned((CtExpression<T>) child); return; } else if (assignement.getAssignment() == null) { assignement.setAssignment((CtExpression<A>) child); return; } super.visitCtAssignment(assignement); }
@Override public <T, A extends T> void visitCtAssignment(CtAssignment<T, A> assignment) { scan(assignment.getAssigned()); scan(assignment.getAssignment()); }
@Override public boolean matches(CtAssignment<?, ?> element) { return element.getAssigned().getShortRepresentation().equals(variable().getShortRepresentation()); }
/** * Creates a variable assignment (can be an expression or a statement). * * @param <T> * the type of the assigned variable * @param variable * a reference to the assigned variable * @param isStatic * tells if the assigned variable is static or not * @param expression * the assigned expression * @return a variable assignment */ public <A, T extends A> CtAssignment<A, T> createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression) { CtVariableAccess<A> vaccess = createVariableRead(variable, isStatic); return factory.Core().<A, T>createAssignment().<CtAssignment<A, T>>setAssignment(expression).setAssigned(vaccess); }
@Override public void process(CtStatement ctStatement) { if (!(ctStatement instanceof CtLocalVariable<?>) && !(ctStatement instanceof CtAssignment<?, ?>)) return; Class<?> localVariableClass = ((CtTypedElement<?>) ctStatement).getType().getActualClass(); if (localVariableClass.equals(Integer.class) || localVariableClass.equals(int.class)) { if (ctStatement instanceof CtAssignment<?, ?>) { replaceInteger(((CtAssignment<?, ?>) ctStatement).getAssignment()); } else { replaceInteger(((CtLocalVariable<?>) ctStatement).getDefaultExpression()); } } else if (localVariableClass.equals(Double.class) || localVariableClass.equals(double.class)) { if (ctStatement instanceof CtAssignment<?, ?>) { replaceDouble(((CtAssignment<?, ?>) ctStatement).getAssignment()); } else { replaceDouble(((CtLocalVariable<?>) ctStatement).getDefaultExpression()); } } else if (localVariableClass.equals(Boolean.class) || localVariableClass.equals(boolean.class)) { if (ctStatement instanceof CtAssignment<?, ?>) { replaceBoolean(((CtAssignment<?, ?>) ctStatement).getAssignment()); } else { replaceBoolean(((CtLocalVariable<?>) ctStatement).getDefaultExpression()); } } }