/** * Override this method to get access to details about this refactoring issue * @param usedParameter to be removed parameter, which is used by `parameterUsage` * @param parameterUsage the usage of parameter, which avoids it's remove */ protected void createParameterUsedIssue(CtParameter<?> usedParameter, CtParameterReference<?> parameterUsage) { throw new RefactoringException("The parameter " + usedParameter.getSimpleName() + " cannot be removed because it is used (" + parameterUsage.getPosition() + ")"); }
private CtParameter<T> lookupDynamically() { CtElement element = this; CtParameter optional = null; String name = getSimpleName(); try { do { CtExecutable executable = element.getParent(CtExecutable.class); if (executable == null) { return null; } for (CtParameter parameter : (List<CtParameter>) executable.getParameters()) { if (name.equals(parameter.getSimpleName())) { optional = parameter; } } element = executable; } while (optional == null); } catch (ParentNotInitializedException e) { return null; } return optional; }
/** * Creates a parameter reference from an existing parameter. * * @param <T> * the parameter's type * @param parameter * the parameter */ public <T> CtParameterReference<T> createParameterReference(CtParameter<T> parameter) { CtParameterReference<T> ref = factory.Core().createParameterReference(); ref.setSimpleName(parameter.getSimpleName()); ref.setType(parameter.getType()); return ref; }
@Override public <T> void visitCtParameter(CtParameter<T> parameter) { elementPrinterHelper.writeComment(parameter); elementPrinterHelper.writeAnnotations(parameter); elementPrinterHelper.writeModifiers(parameter); if (parameter.isVarArgs()) { scan(((CtArrayTypeReference<T>) parameter.getType()).getComponentType()); printer.writeSeparator("..."); } else { scan(parameter.getType()); } printer.writeSpace(); printer.writeIdentifier(parameter.getSimpleName()); }
public <T> void visitCtParameter(CtParameter<T> parameter) { write(parameter.getSimpleName()); }
private boolean isCurrentTemplate(Object object, CtElement inMulti) { if (object instanceof CtInvocation<?>) { return object.equals(inMulti); } if (object instanceof CtParameter) { CtParameter<?> param = (CtParameter<?>) object; for (CtFieldReference<?> varArg : varArgs) { if (param.getSimpleName().equals(varArg.getSimpleName())) { return varArg.equals(inMulti); } } } return false; }
adaptedParams.add(factory.Executable().createParameter(null, adaptType(parameter.getType()), parameter.getSimpleName()));
@Override @SuppressWarnings("unchecked") public CtParameter<T> getDeclaration() { CtExecutable<?> exec = executable.getDeclaration(); if (exec == null) { return null; } List<CtParameter<?>> params = exec.getParameters(); for (CtParameter<?> p : params) { if (this.getSimpleName().equals(p.getSimpleName())) { return (CtParameter<T>) p; } } throw new IllegalStateException( "Cannot found declaration for parameter " + getSimpleName()); }
/** * Replaces method parameters when defined as a list of * {@link CtParameter}. */ @Override public <R> void scanCtExecutable(CtExecutable<R> e) { // replace method parameters for (CtParameter<?> parameter : new ArrayList<CtParameter<?>>(e.getParameters())) { String name = parameter.getSimpleName(); for (String pname : parameterNames) { if (name.equals(pname)) { Object value = Parameters.getValue(template, pname, null); int i = parameter.getParent().getParameters().indexOf(parameter); if (value instanceof List) { List<?> l = (List<?>) value; for (Object p : l) { CtParameter<?> p2 = e.getFactory().Core().clone((CtParameter<?>) p); p2.setParent(parameter.getParent()); parameter.getParent().getParameters().add(i++, p2); } parameter.getParent().getParameters().remove(parameter); } } } } super.scanCtExecutable(e); }
if (methodToInvokeToAdd.getSimpleName().equals("equals") && RandomHelper.getRandom().nextFloat() >= 0.25F) { localVariable = ValueCreator.createRandomLocalVar(target.getType(), parameter.getSimpleName()); } else { localVariable = ValueCreator.createRandomLocalVar(parameter.getType(), parameter.getSimpleName());
public <T> void visitCtParameter(CtParameter<T> parameter) { writeAnnotations(parameter); writeModifiers(parameter); if (parameter.isVarArgs()) { scan(((CtArrayTypeReference<T>) parameter.getType()).getComponentType()); write("..."); } else { scan(parameter.getType()); } write(" "); write(parameter.getSimpleName()); }
/** * Creates a parameter reference from an existing parameter. * * @param <T> * the parameter's type * @param parameter * the parameter */ public <T> CtParameterReference<T> createParameterReference(CtParameter<T> parameter) { CtParameterReference<T> ref = factory.Core().createParameterReference(); if (parameter.getParent() != null) { ref.setDeclaringExecutable(factory.Executable().createReference((CtExecutable<?>) parameter.getParent())); } ref.setSimpleName(parameter.getSimpleName()); ref.setType(parameter.getType()); return ref; }