Refine search
ASTNode clone0(AST target) { VariableDeclarationStatement result = new VariableDeclarationStatement(target); result.setSourceRange(getStartPosition(), getLength()); result.copyLeadingComment(this); if (this.ast.apiLevel == AST.JLS2_INTERNAL) { result.setModifiers(getModifiers()); } if (this.ast.apiLevel >= AST.JLS3_INTERNAL) { result.modifiers().addAll(ASTNode.copySubtrees(target, modifiers())); } result.setType((Type) getType().clone(target)); result.fragments().addAll( ASTNode.copySubtrees(target, fragments())); return result; }
@Override public boolean visit(VariableDeclarationStatement node) { if (node.getAST().apiLevel() >= JLS3) { printModifiers(node.modifiers()); } node.getType().accept(this); this.fBuffer.append(" ");//$NON-NLS-1$ for (Iterator<VariableDeclarationFragment> it= node.fragments().iterator(); it.hasNext();) { VariableDeclarationFragment f= it.next(); f.accept(this); if (it.hasNext()) { this.fBuffer.append(", ");//$NON-NLS-1$ } } this.fBuffer.append(";");//$NON-NLS-1$ return false; }
public boolean visit(VariableDeclarationStatement node) { System.out.println("Visiting variable declaration statement."); for(int i = 0; i < node.fragments().size(); ++i) { VariableDeclarationFragment frag = (VariableDeclarationFragment)node.fragments().get(i); System.out.println("Fragment: " + node.getType() + " " + frag.getName()); } System.out.println(""); return true; }
/** * @return a statement in form of <code>final int maxLen = 10;</code> */ protected VariableDeclarationStatement createMaxLenDeclaration() { VariableDeclarationFragment fragment= fAst.newVariableDeclarationFragment(); fragment.setName(fAst.newSimpleName(fMaxLenVariableName)); fragment.setInitializer(fAst.newNumberLiteral(String.valueOf(fContext.getLimitItemsValue()))); VariableDeclarationStatement declExpression= fAst.newVariableDeclarationStatement(fragment); declExpression.setType(fAst.newPrimitiveType(PrimitiveType.INT)); declExpression.modifiers().add(fAst.newModifier(ModifierKeyword.FINAL_KEYWORD)); return declExpression; }
/** * Declaration of the variable within a block */ @Override public boolean visit(VariableDeclarationStatement node) { for (int i = 0; i < node.fragments().size(); ++i) { String nodeType = node.getType().toString(); VariableDeclarationFragment frag = (VariableDeclarationFragment) node.fragments().get(i); state.getNames().add(frag.getName().getIdentifier()); state.getNameInstance().put(frag.getName().toString(), nodeType.toString()); } processType(node.getType(), TypeReferenceLocation.VARIABLE_DECLARATION, compilationUnit.getLineNumber(node.getStartPosition()), compilationUnit.getColumnNumber(node.getStartPosition()), node.getLength(), node.toString()); return super.visit(node); }
@Override public void endVisit(VariableDeclarationStatement node) { // TODO: in principle, no need to tie the VariableDeclarationFragments together. // The VariableDeclarationExpression can be split up when fragments get different types. // Warning: still need to connect fragments with type! endVisitFieldVariableDeclaration(node.getType(), node.fragments()); }
@Override public boolean visit(final VariableDeclarationStatement node) { final ASTNode parent = node.getParent(); for (final Object fragment : node.fragments()) { final VariableDeclarationFragment frag = (VariableDeclarationFragment) fragment; variableScopes.put(parent, new Variable(frag.getName() .getIdentifier(), node.getType().toString(), ScopeType.SCOPE_LOCAL)); } return false; }
@Override final List internalGetChildListProperty(ChildListPropertyDescriptor property) { if (property == MODIFIERS2_PROPERTY) { return modifiers(); } if (property == FRAGMENTS_PROPERTY) { return fragments(); } // allow default implementation to flag the error return super.internalGetChildListProperty(property); }
/** * The selection corresponds to a VariableDeclarationStatement */ private String variableDeclarationStatementSelected(VariableDeclarationStatement vds) { if (vds.fragments().size() != 1) { return RefactoringCoreMessages.ChangeTypeRefactoring_multiDeclarationsNotSupported; } else { VariableDeclarationFragment elem= (VariableDeclarationFragment) vds.fragments().iterator().next(); SimpleName name= elem.getName(); setSelectionRanges(name); return simpleNameSelected(name); } }
final ASTNode internalGetSetChildProperty(ChildPropertyDescriptor property, boolean get, ASTNode child) { if (property == TYPE_PROPERTY) { if (get) { return getType(); } else { setType((Type) child); return null; } } // allow default implementation to flag the error return super.internalGetSetChildProperty(property, get, child); }
@Override public boolean visit(VariableDeclarationStatement node) { handleVariableDeclarations(node.fragments()); return true; }
private VariableDeclarationStatement createLocalDeclaration(ITypeBinding type, String name, Expression initializer) { String typeName= fImportRewrite.addImport(type); VariableDeclarationStatement decl= (VariableDeclarationStatement)ASTNodeFactory.newStatement( fInvocation.getAST(), typeName + " " + name + ";"); //$NON-NLS-1$ //$NON-NLS-2$ ((VariableDeclarationFragment)decl.fragments().get(0)).setInitializer(initializer); return decl; }
protected VariableDeclarationStatement convertToVariableDeclarationStatement(org.eclipse.jdt.internal.compiler.ast.LocalDeclaration localDeclaration) { final VariableDeclarationFragment variableDeclarationFragment = convertToVariableDeclarationFragment(localDeclaration); final VariableDeclarationStatement variableDeclarationStatement = new VariableDeclarationStatement(this.ast); variableDeclarationStatement.fragments().add(variableDeclarationFragment); if (this.resolveBindings) { recordNodes(variableDeclarationFragment, localDeclaration); } variableDeclarationStatement.setSourceRange(localDeclaration.declarationSourceStart, localDeclaration.declarationSourceEnd - localDeclaration.declarationSourceStart + 1); Type type = convertType(localDeclaration.type); setTypeForVariableDeclarationStatement(variableDeclarationStatement, type, variableDeclarationFragment.getExtraDimensions()); if (localDeclaration.modifiersSourceStart != -1) { setModifiers(variableDeclarationStatement, localDeclaration); } return variableDeclarationStatement; }
@Override public boolean visit(VariableDeclarationStatement node) { if (fAddFinalLocals) handleFragments(node.fragments(), node); List<VariableDeclarationFragment> fragments= node.fragments(); for (Iterator<VariableDeclarationFragment> iterator= fragments.iterator(); iterator.hasNext();) { VariableDeclarationFragment fragment= iterator.next(); Expression initializer= fragment.getInitializer(); if (initializer != null) { initializer.accept(this); } } return false; }
private void removeVariable(final ReturnStatement node, final VariableDeclarationStatement vds, final VariableDeclarationFragment vdf) { final Expression returnExpr = vdf.getInitializer(); if (returnExpr instanceof ArrayInitializer) { final ASTBuilder b = ctx.getASTBuilder(); final ReturnStatement newReturnStmt = b.return0(b.newArray( b.copy((ArrayType) vds.getType()), b.move((ArrayInitializer) returnExpr))); replaceReturnStatementForArray(node, vds, newReturnStmt); } else { replaceReturnStatement(node, vds, returnExpr); } }
public boolean visit(VariableDeclarationStatement node) { if (!hasChildrenChanges(node)) { return doVisitUnchangedChildren(node); } // same code as FieldDeclaration int pos= node.getStartPosition(); if (node.getAST().apiLevel() == JLS2_INTERNAL) { rewriteModifiers(node, INTERNAL_VDS_MODIFIERS_PROPERTY, pos); } else { rewriteModifiers2(node, VariableDeclarationStatement.MODIFIERS2_PROPERTY, pos); } pos= rewriteRequiredNode(node, VariableDeclarationStatement.TYPE_PROPERTY); rewriteNodeList(node, VariableDeclarationStatement.FRAGMENTS_PROPERTY, pos, Util.EMPTY_STRING, ", "); //$NON-NLS-1$ return false; }
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_INTERNAL) { acceptChildren(visitor, this.modifiers); } acceptChild(visitor, getType()); acceptChildren(visitor, this.variableDeclarationFragments); } visitor.endVisit(this); }
public boolean visit(VariableDeclarationStatement node) { for (Object f : node.fragments()) { VariableDeclarationFragment variable = (VariableDeclarationFragment) f; addStatement(new CSDeclarationStatement(node.getStartPosition(), createVariableDeclaration(variable))); } return false; }
@Override public void endVisit(VariableDeclarationStatement node) { checkTypeInDeclaration(node.getType()); super.endVisit(node); }