Refine search
ASTNode clone0(AST target) { SingleVariableDeclaration result = new SingleVariableDeclaration(target); result.setSourceRange(getStartPosition(), getLength()); if (this.ast.apiLevel == AST.JLS2_INTERNAL) { result.setModifiers(getModifiers()); } else { result.modifiers().addAll(ASTNode.copySubtrees(target, modifiers())); result.setVarargs(isVarargs()); } result.setType((Type) getType().clone(target)); result.setExtraDimensions(getExtraDimensions()); result.setName((SimpleName) getName().clone(target)); result.setInitializer( (Expression) ASTNode.copySubtree(target, getInitializer())); return result; }
public boolean visit(SingleVariableDeclaration node) { if (found(node, node.getName()) && this.resolveBinding) this.foundBinding = node.resolveBinding(); return true; }
public boolean visit(SingleVariableDeclaration node) { if (node.getAST().apiLevel() == AST.JLS2) { printModifiers(node.getModifiers()); } if (node.getAST().apiLevel() >= AST.JLS3) { printModifiers(node.modifiers()); } node.getType().accept(this); if (node.getAST().apiLevel() >= AST.JLS3) { if (node.isVarargs()) { this.fBuffer.append("...");//$NON-NLS-1$ } } this.fBuffer.append(" ");//$NON-NLS-1$ node.getName().accept(this); for (int i= 0; i < node.getExtraDimensions(); i++) { this.fBuffer.append("[]"); //$NON-NLS-1$ } if (node.getInitializer() != null) { this.fBuffer.append("=");//$NON-NLS-1$ node.getInitializer().accept(this); } return false; }
@Override public boolean visit(SingleVariableDeclaration node) { AST ast = node.getAST(); if (node.getExtraDimensions() > 0) { Type type = (Type) ASTNode.copySubtree(ast, node.getType()); for (int i = node.getExtraDimensions(); i > 0; i--) { type = ast.newArrayType(type); } node.setType(type); node.setExtraDimensions(0); } return true; } }
void accept0(ASTVisitor visitor) { boolean visitChildren = visitor.visit(this); if (visitChildren) { // visit children in normal left to right reading order if (this.ast.apiLevel >= AST.JLS3) { acceptChildren(visitor, this.modifiers); } acceptChild(visitor, getType()); acceptChild(visitor, getName()); acceptChild(visitor, getInitializer()); } visitor.endVisit(this); }
public static void extractParametersAndReturnType(MethodDeclaration methodDeclaration, SDMethod method) { Type returnType = methodDeclaration.getReturnType2(); if (returnType != null) { method.setReturnType(AstUtils.normalizeTypeName(returnType, methodDeclaration.getExtraDimensions(), false)); } else { method.setReturnType(null); } Iterator<SingleVariableDeclaration> parameters = methodDeclaration.parameters().iterator(); while (parameters.hasNext()) { SingleVariableDeclaration parameter = parameters.next(); Type parameterType = parameter.getType(); String typeName = AstUtils.normalizeTypeName(parameterType, parameter.getExtraDimensions(), parameter.isVarargs()); method.addParameter(parameter.getName().getIdentifier(), typeName); } }
/** * Add a method parameter. * * @param name Name * @param type Type * @return declaration */ public SingleVariableDeclaration addParameter(String name, Type type) { SingleVariableDeclaration vdecl = m_ast.newSingleVariableDeclaration(); vdecl.setType(type); vdecl.setName(m_ast.newSimpleName(name)); m_method.parameters().add(vdecl); return vdecl; }
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$ } }
public boolean visit(SingleVariableDeclaration node) { IValue name = values.string(node.getName().getFullyQualifiedName()); IValueList extendedModifiers = parseExtendedModifiers(node.modifiers()); IValue type = visitChild(node.getType()); IValue initializer = node.getInitializer() == null ? null : visitChild(node.getInitializer()); ownValue = constructDeclarationNode("parameter", type, name, values.integer(node.getExtraDimensions()), initializer); if (node.getAST().apiLevel() >= AST.JLS3 && node.isVarargs()) ownValue = constructDeclarationNode("vararg", type, name); setKeywordParameters("modifiers", extendedModifiers); return false; }
public Method ensureMethodFromMethodDeclaration(MethodDeclaration node) { StringJoiner signatureJoiner = new StringJoiner(", ", "(", ")"); Arrays.stream(node.parameters().toArray()) .forEach(p -> signatureJoiner.add((String) ((SingleVariableDeclaration) p).getType().toString())); String methodName = node.getName().toString(); String signature = methodName + signatureJoiner.toString(); return ensureBasicMethod(methodName, signature, (Type) topOfContainerStack(), m -> setUpMethodFromMethodDeclaration(m, node)); }
@Override public boolean visit(SingleVariableDeclaration node) { boolean isNotParam = !getCurrentParent().getLabel().equals(EntityType.PARAMETERS.toString());// @inria pushNode(node, node.getName().getIdentifier()); node.getType().accept(this); return false; }
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; }
public final ASTNode getTargetNode() throws JavaModelException { final SingleVariableDeclaration variable= ast.newSingleVariableDeclaration(); final IMethodBinding method= declaration.resolveBinding(); if (method != null) { final ITypeBinding declaring= method.getDeclaringClass(); if (declaring != null) { adjustTypeVisibility(declaring); variable.setType(rewriter.getImportRewrite().addImport(declaring, ast)); variable.setName(ast.newSimpleName(fTargetName)); if (finder.getResult().size() > 0) variable.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD)); } } return variable; } });
public static SingleVariableDeclaration createParameter(final AST ast, final String typeName, final String name, final ModifierKeyword... keywords) { final SingleVariableDeclaration arg = ast.newSingleVariableDeclaration(); arg.setName(ast.newSimpleName(name)); arg.setType(ast.newSimpleType(ast.newName(typeName))); make(arg, keywords); return arg; }
private TagElement findParamTag(MethodDeclaration decl, SingleVariableDeclaration param) { Javadoc javadoc= decl.getJavadoc(); if (javadoc != null) { return JavadocTagsSubProcessor.findParamTag(javadoc, param.getName().getIdentifier()); } return null; }
private void removeParamTag(ASTRewrite rewrite, SingleVariableDeclaration varDecl) { if (varDecl.getParent() instanceof MethodDeclaration) { Javadoc javadoc= ((MethodDeclaration) varDecl.getParent()).getJavadoc(); if (javadoc != null) { TagElement tagElement= JavadocTagsSubProcessor.findParamTag(javadoc, varDecl.getName().getIdentifier()); if (tagElement != null) { rewrite.remove(tagElement, null); } } } }
@Override public boolean visit(final SingleVariableDeclaration node) { boolean _equals = node.getName().getIdentifier().equals(simpleName.getIdentifier()); if (_equals) { matchesFound.add(node.getType()); } return false; } });
public VariableDeclaration(CompilationUnit cu, String filePath, SingleVariableDeclaration fragment) { this.locationInfo = new LocationInfo(cu, filePath, fragment); this.variableName = fragment.getName().getIdentifier(); this.initializer = fragment.getInitializer() != null ? new AbstractExpression(cu, filePath, fragment.getInitializer()) : null; this.type = UMLType.extractTypeObject(UMLType.getTypeName(extractType(fragment), fragment.getExtraDimensions())); this.variableDeclarationType = extractVariableDeclarationType(fragment); int startOffset = fragment.getStartPosition(); ASTNode scopeNode = getScopeNode(fragment); int endOffset = scopeNode.getStartPosition() + scopeNode.getLength(); this.scope = new VariableScope(cu, filePath, startOffset, endOffset); }
private SingleVariableDeclaration newParameterDeclaration(AST ast, ImportRewrite importRewrite, String paramName, ITypeBinding paramType) { SingleVariableDeclaration param= ast.newSingleVariableDeclaration(); param.setExtraDimensions(0); param.setInitializer(null); param.setType(importRewrite.addImport(paramType, ast)); param.setName(ast.newSimpleName(paramName)); return param; }