private static List<CtTypeReference<?>> getParameterTypes(List<CtParameter<?>> params) { List<CtTypeReference<?>> types = new ArrayList<>(params.size()); for (CtParameter<?> param : params) { types.add(param.getType()); } return types; } }
@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(final spoon.reflect.declaration.CtParameter<T> parameter) { spoon.reflect.declaration.CtParameter<T> aCtParameter = parameter.getFactory().Core().createParameter(); this.builder.copy(parameter, aCtParameter); aCtParameter.setAnnotations(this.cloneHelper.clone(parameter.getAnnotations())); aCtParameter.setType(this.cloneHelper.clone(parameter.getType())); aCtParameter.setComments(this.cloneHelper.clone(parameter.getComments())); this.cloneHelper.tailor(parameter, aCtParameter); this.other = aCtParameter; }
public <T> void visitCtParameter(spoon.reflect.declaration.CtParameter<T> e) { ((spoon.reflect.declaration.CtParameter<T>) (other)).setVarArgs(e.isVarArgs()); ((spoon.reflect.declaration.CtParameter<T>) (other)).setModifiers(e.getModifiers()); ((spoon.reflect.declaration.CtParameter<T>) (other)).setShadow(e.isShadow()); super.visitCtParameter(e); }
public <T> void visitCtParameter(final spoon.reflect.declaration.CtParameter<T> parameter) { spoon.reflect.declaration.CtParameter other = ((spoon.reflect.declaration.CtParameter) (this.stack.peek())); enter(parameter); biScan(spoon.reflect.path.CtRole.ANNOTATION, parameter.getAnnotations(), other.getAnnotations()); biScan(spoon.reflect.path.CtRole.TYPE, parameter.getType(), other.getType()); biScan(spoon.reflect.path.CtRole.COMMENT, parameter.getComments(), other.getComments()); exit(parameter); }
/** * 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; }
/** * Creates a parameter. If the argument have a type == null, we get the type from its binding. A type == null is possible when * this type is implicit like in a lambda where you don't need to specify the type of parameters. * * @param argument * Used to get the name of the parameter, the modifiers, know if it is a var args parameter. * @return a parameter. */ <T> CtParameter<T> createParameter(Argument argument) { CtParameter<T> p = jdtTreeBuilder.getFactory().Core().createParameter(); p.setSimpleName(CharOperation.charToString(argument.name)); p.setVarArgs(argument.isVarArgs()); p.setExtendedModifiers(getModifiers(argument.modifiers, false, false)); if (argument.binding != null && argument.binding.type != null && argument.type == null) { p.setType(jdtTreeBuilder.getReferencesBuilder().<T>getTypeReference(argument.binding.type)); p.getType().setImplicit(argument.type == null); if (p.getType() instanceof CtArrayTypeReference) { ((CtArrayTypeReference) p.getType()).getComponentType().setImplicit(argument.type == null); } } return p; }
/** * 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; }
@Override public boolean visit(Argument argument, BlockScope scope) { CtParameter<Object> p = factory.Core().createParameter(); p.setSimpleName(new String(argument.name)); p.setVarArgs(argument.isVarArgs()); p.setModifiers(getModifiers(argument.modifiers)); if (argument.type != null) { p.setType(references.getTypeReference(argument.type.resolvedType)); } else if (argument.binding != null && argument.binding.type != null) { if (argument.binding.type instanceof WildcardBinding) { p.setType(references.getTypeReference((((WildcardBinding) argument.binding.type).bound))); } else { p.setType(references.getTypeReference((argument.binding.type))); } } context.enter(p, argument); if (argument.initialization != null) { argument.initialization.traverse(this, scope); } if (argument.annotations != null) { for (Annotation a : argument.annotations) { // TODO Sorry for that but there is a bug in JDT : https://bugs.eclipse.org/bugs/show_bug.cgi?id=459528 if (isContainsInTypeAnnotation(argument.type.resolvedType, a)) { a.traverse(this, scope); } } } return false; }
private CtTypeReference<?> getMethodParameterType(CtParameter<?> param) { CtTypeReference<?> paramType = param.getType(); if (paramType instanceof CtTypeParameterReference) { paramType = ((CtTypeParameterReference) paramType).getBoundingType(); } if (paramType == null) { paramType = param.getFactory().Type().OBJECT; } return paramType.clone(); }
public <T> void visitCtParameter(CtParameter<T> parameter) { enter(parameter); scan(parameter.getAnnotations()); scan(parameter.getType()); exit(parameter); }
/** * 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); }
/** * 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() + ")"); }
/** * Creates a new parameter. */ public <T> CtParameter<T> createParameter(CtExecutable<?> parent, CtTypeReference<T> type, String name) { CtParameter<T> parameter = factory.Core().createParameter(); parameter.setType(type); parameter.setSimpleName(name); if (parent != null) { parent.addParameter(parameter); } return parameter; }
@Override public void visitParameter(RtParameter parameter) { final CtParameter ctParameter = factory.Core().createParameter(); ctParameter.setSimpleName(parameter.getName()); ctParameter.setVarArgs(parameter.isVarArgs()); //it is not possible to detect whether parameter is final in runtime // if (parameter.isFinal()) { // ctParameter.addModifier(ModifierKind.FINAL); // } enter(new VariableRuntimeBuilderContext(ctParameter)); super.visitParameter(parameter); exit(); contexts.peek().addParameter(ctParameter); }
/** * @param target the {@link CtParameter} which has to be removed by this refactoring function * @return this to support fluent API */ public CtParameterRemoveRefactoring setTarget(CtParameter<?> target) { if (this.target == target) { return this; } this.target = target; this.parameterIndex = target.getParent().getParameters().indexOf(target); targetExecutables = null; targetInvocations = null; return this; }
@Override public <T extends CtExecutable<R>> T addParameter(CtParameter<?> parameter) { if (parameter == null) { return (T) this; } if (parameters == CtElementImpl.<CtParameter<?>>emptyList()) { parameters = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); } parameter.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, PARAMETER, this.parameters, parameter); parameters.add(parameter); return (T) this; }
@Override public <T> CtParameter<T> createParameter() { CtParameter<T> e = new CtParameterImpl<>(); e.setFactory(getMainFactory()); return e; }
public <T> void visitCtParameter(final CtParameter<T> parameter) { enter(parameter); scan(CtRole.ANNOTATION, parameter.getAnnotations()); scan(CtRole.TYPE, parameter.getType()); scan(CtRole.COMMENT, parameter.getComments()); exit(parameter); }