@java.lang.Override public void set(spoon.reflect.reference.CtFieldReference replace) { this.element.setVariable(replace); } }
@java.lang.Override public void set(spoon.reflect.reference.CtFieldReference replace) { this.element.setVariable(replace); } }
@java.lang.Override public void set(spoon.reflect.reference.CtVariableReference replace) { this.element.setVariable(replace); } }
@Override public <T, U> void setValue(T element, U value) { castTarget(element).setVariable(castValue(value)); } }
/** * Creates variable access from a {@link CtVariableReference}. Think to move this method * in the {@link spoon.reflect.factory.CodeFactory} if you think that is a good idea. */ public <T> CtVariableAccess<T> createVariableAccess(CtVariableReference<T> variableReference, boolean isReadAccess) { CtVariableAccess<T> variableAccess; if (isReadAccess) { variableAccess = jdtTreeBuilder.getFactory().Core().createVariableWrite(); } else { variableAccess = jdtTreeBuilder.getFactory().Core().createVariableRead(); } return variableAccess.setVariable(variableReference); }
/** * 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); }
/** * Creates a variable access from its single name. * * @param singleNameReference * Used to build a variable reference which will be contained in the variable access. * @return a variable access. */ <T> CtVariableAccess<T> createVariableAccess(SingleNameReference singleNameReference) { CtVariableAccess<T> va; if (isLhsAssignment(jdtTreeBuilder.getContextBuilder(), singleNameReference)) { va = jdtTreeBuilder.getFactory().Core().createVariableWrite(); } else { va = jdtTreeBuilder.getFactory().Core().createVariableRead(); } va.setVariable(jdtTreeBuilder.getReferencesBuilder().<T>getVariableReference((VariableBinding) singleNameReference.binding)); return va; }
variableReference.setPosition(positionBuilder.buildPosition( singleNameReference.sourceStart(), singleNameReference.sourceEnd())); variableAccess.setVariable(variableReference); return variableAccess;
newVarAccessDestination.setVariable(newVarReference); newVarAccessDestination.setVariable(newVarReference);
/** * 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()); }
va = factory.Core().createFieldRead(); va.setVariable(references.getVariableReference(singleNameReference.fieldBinding())); } else if (singleNameReference.binding instanceof VariableBinding) { if (context.stack.peek().element instanceof CtAssignment && context.assigned) { va = factory.Core().createVariableRead(); va.setVariable(references.getVariableReference((VariableBinding) singleNameReference.binding)); } else if (singleNameReference.binding instanceof TypeBinding) { CtTypeAccess<Object> ta = factory.Core().createTypeAccess();
va = factory.Core().createVariableRead(); va.setVariable(references.getVariableReference((VariableBinding) qualifiedNameReference.binding)); va.setType(va.getVariable().getType()); if (qualifiedNameReference.otherBindings != null) { va.setVariable(varRef); context.enter(va, qualifiedNameReference); return false;