for (Object parameter : declaration.parameters()) { if (!first) signature.append(", "); first = false;
/** * Generecized version of the equivalent JDT method. * * @param node the node on which to call the equivalent JDT method * @return a List of expressions * @see MethodDeclaration#parameters() */ @SuppressWarnings("unchecked") public static List<SingleVariableDeclaration> parameters(MethodDeclaration node) { return node.parameters(); }
protected void copyParameters(final ASTRewrite rewrite, final ICompilationUnit unit, final MethodDeclaration oldMethod, final MethodDeclaration newMethod, final TypeVariableMaplet[] mapping) throws JavaModelException { SingleVariableDeclaration newDeclaration= null; for (int index= 0, size= oldMethod.parameters().size(); index < size; index++) { final SingleVariableDeclaration oldDeclaration= (SingleVariableDeclaration) oldMethod.parameters().get(index); if (mapping.length > 0) newDeclaration= createPlaceholderForSingleVariableDeclaration(oldDeclaration, unit, mapping, rewrite); else newDeclaration= createPlaceholderForSingleVariableDeclaration(oldDeclaration, unit, rewrite); newMethod.parameters().add(index, newDeclaration); } }
protected void copyParameters(final ASTRewrite rewrite, final ICompilationUnit unit, final MethodDeclaration oldMethod, final MethodDeclaration newMethod, final TypeVariableMaplet[] mapping) throws JavaModelException { SingleVariableDeclaration newDeclaration= null; for (int index= 0, size= oldMethod.parameters().size(); index < size; index++) { final SingleVariableDeclaration oldDeclaration= (SingleVariableDeclaration) oldMethod.parameters().get(index); if (mapping.length > 0) newDeclaration= createPlaceholderForSingleVariableDeclaration(oldDeclaration, unit, mapping, rewrite); else newDeclaration= createPlaceholderForSingleVariableDeclaration(oldDeclaration, unit, rewrite); newMethod.parameters().add(newDeclaration); } }
@Override public MethodSource<O> removeParameter(ParameterSource<O> parameter) { method.parameters().remove(parameter.getInternal()); return this; }
@Override public List<ParameterSource<O>> getParameters() { List<ParameterSource<O>> results = new ArrayList<ParameterSource<O>>(); @SuppressWarnings("unchecked") List<SingleVariableDeclaration> parameters = method.parameters(); for (SingleVariableDeclaration param : parameters) { results.add(new ParameterImpl<O>(parent, param)); } return Collections.unmodifiableList(results); }
private boolean isParameterName(String name) { List<SingleVariableDeclaration> parameters= fDeclaration.parameters(); for (Iterator<SingleVariableDeclaration> iterator= parameters.iterator(); iterator.hasNext();) { SingleVariableDeclaration decl= iterator.next(); if (name.equals(decl.getName().getIdentifier())) { return true; } } return false; }
private boolean haveSameParameters(final MethodDeclaration node, final SuperMethodInvocation bodyMi) { final List<?> parameters = node.parameters(); for (int i = 0; i < node.parameters().size(); i++) { final SingleVariableDeclaration paramName = (SingleVariableDeclaration) parameters.get(i); final Expression paramExpr = (Expression) bodyMi.arguments().get(i); if (!(paramExpr instanceof SimpleName) || !paramName.getName().getIdentifier().equals(((SimpleName) paramExpr).getIdentifier())) { return false; } } return true; }
@Override public void endVisit(MethodDeclaration node) { super.endVisit(node); FlowInfo info = accessFlowInfo(node); for (Iterator<SingleVariableDeclaration> iter = node.parameters().iterator(); iter.hasNext();) { clearAccessMode(info, iter.next()); } }
@Override public boolean visit(MethodDeclaration node) { if (node.isConstructor() && isPrivate(node) && node.parameters().isEmpty()) { return false; } unsupportedConstruct(node, "Enum can contain only fields and a private constructor."); return false; } });
@Override public void endVisit(MethodDeclaration node) { super.endVisit(node); FlowInfo info= accessFlowInfo(node); for (Iterator<SingleVariableDeclaration> iter= node.parameters().iterator(); iter.hasNext();) { clearAccessMode(info, iter.next()); } }
@Override public void endVisit(MethodDeclaration node) { super.endVisit(node); FlowInfo info= accessFlowInfo(node); for (Iterator<SingleVariableDeclaration> iter= node.parameters().iterator(); iter.hasNext();) { clearAccessMode(info, iter.next()); } }
private void mapParameters(MethodDeclaration node, CSParameterized method) { if (method instanceof CSMethod) { mapMethodParameters(node, (CSMethod) method); return; } for (Object p : node.parameters()) { mapParameter((SingleVariableDeclaration) p, method); } }
private boolean isValidEventAddListener(MethodDeclaration addListener) { if (1 != addListener.parameters().size()) return false; final ITypeBinding type = getFirstParameterType(addListener); if (!type.isInterface()) return false; return type.getDeclaredMethods().length == 1; }
private void addLinkedRanges(ASTRewrite rewrite, MethodDeclaration newStub) { List<SingleVariableDeclaration> parameters= newStub.parameters(); for (int i= 0; i < parameters.size(); i++) { SingleVariableDeclaration curr= parameters.get(i); String name= curr.getName().getIdentifier(); addLinkedPosition(rewrite.track(curr.getType()), false, "arg_type_" + name); //$NON-NLS-1$ addLinkedPosition(rewrite.track(curr.getName()), false, "arg_name_" + name); //$NON-NLS-1$ } }
private void addLinkedRanges(ASTRewrite rewrite, MethodDeclaration newStub) { List parameters= newStub.parameters(); for (int i= 0; i < parameters.size(); i++) { SingleVariableDeclaration curr= (SingleVariableDeclaration) parameters.get(i); String name= curr.getName().getIdentifier(); addLinkedPosition(rewrite.track(curr.getType()), false, "arg_type_" + name); //$NON-NLS-1$ addLinkedPosition(rewrite.track(curr.getName()), false, "arg_name_" + name); //$NON-NLS-1$ } }
@Override public boolean visit(MethodDeclaration node) { if (isInside(node)) { Block body= node.getBody(); if (body != null) { body.accept(this); } visitBackwards(node.parameters()); visitBackwards(node.typeParameters()); } return false; }
@Override public void endVisit(MethodDeclaration node) { if (skipNode(node)) { return; } GenericSequentialFlowInfo info = processSequential(node, node.getReturnType2()); process(info, node.parameters()); process(info, node.thrownExceptionTypes()); process(info, node.getBody()); }
@Override public void endVisit(MethodDeclaration node) { if (skipNode(node)) return; GenericSequentialFlowInfo info= processSequential(node, node.getReturnType2()); process(info, node.parameters()); process(info, node.thrownExceptionTypes()); process(info, node.getBody()); }
public void endVisit(MethodDeclaration node) { if (skipNode(node)) return; GenericSequentialFlowInfo info= processSequential(node, node.getReturnType2()); process(info, node.parameters()); process(info, node.thrownExceptions()); process(info, node.getBody()); }