Java SingleVariableDeclaration.setName方法代碼示例

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
@SuppressWarnings("unchecked")
public MethodDeclaration createPrivateConstructorDefinition(AST ast, TypeDeclaration originalType, TypeDeclaration builderType,
        List<BuilderField> builderFields) {

    MethodDeclaration method = ast.newMethodDeclaration();
    method.setConstructor(true);
    method.setName(ast.newSimpleName(originalType.getName().toString()));
    if (preferencesManager.getPreferenceValue(ADD_GENERATED_ANNOTATION)) {
        generatedAnnotationPopulator.addGeneratedAnnotation(ast, method);
    }
    method.modifiers().add(ast.newModifier(ModifierKeyword.PRIVATE_KEYWORD));

    SingleVariableDeclaration methodParameterDeclaration = ast.newSingleVariableDeclaration();
    methodParameterDeclaration.setType(ast.newSimpleType(ast.newName(builderType.getName().toString())));
    methodParameterDeclaration.setName(ast.newSimpleName(camelCaseConverter.toLowerCamelCase(builderType.getName().toString())));

    method.parameters().add(methodParameterDeclaration);
    return method;
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
@Override
protected void addNewParameters(ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params, ImportRewriteContext context) throws CoreException {
	AST ast= rewrite.getAST();

	List<Expression> arguments= fArguments;

	for (int i= 0; i < arguments.size(); i++) {
		Expression elem= arguments.get(i);
		SingleVariableDeclaration param= ast.newSingleVariableDeclaration();

		// argument type
		String argTypeKey= "arg_type_" + i; //$NON-NLS-1$
		Type type= evaluateParameterType(ast, elem, argTypeKey, context);
		param.setType(type);

		// argument name
		String argNameKey= "arg_name_" + i; //$NON-NLS-1$
		String name= evaluateParameterName(takenNames, elem, type, argNameKey);
		param.setName(ast.newSimpleName(name));

		params.add(param);
	}
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
private void copyArguments(MethodDeclaration intermediary, CompilationUnitRewrite rew)
    throws JavaModelException {
  String[] names = fTargetMethod.getParameterNames();
  ITypeBinding[] types = fTargetMethodBinding.getParameterTypes();
  for (int i = 0; i < names.length; i++) {
    ITypeBinding typeBinding = types[i];
    SingleVariableDeclaration newElement = rew.getAST().newSingleVariableDeclaration();
    newElement.setName(rew.getAST().newSimpleName(names[i]));

    if (i == (names.length - 1) && fTargetMethodBinding.isVarargs()) {
      newElement.setVarargs(true);
      if (typeBinding.isArray()) typeBinding = typeBinding.getComponentType();
    }

    newElement.setType(rew.getImportRewrite().addImport(typeBinding, rew.getAST()));
    intermediary.parameters().add(newElement);
  }
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
public SingleVariableDeclaration createWithMethodParameter(AST ast, Type type, String fieldName) {
    SingleVariableDeclaration methodParameterDeclaration = ast.newSingleVariableDeclaration();
    methodParameterDeclaration.setType((Type) ASTNode.copySubtree(ast, type));
    methodParameterDeclaration.setName(ast.newSimpleName(fieldName));
    if (preferencesManager.getPreferenceValue(PluginPreferenceList.ADD_NONNULL_ON_PARAMETERS)) {
        markerAnnotationAttacher.attachNonNull(ast, methodParameterDeclaration);
    }
    return methodParameterDeclaration;
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
private void addNewParameters(ASTRewrite rewrite, List<SingleVariableDeclaration> params, ImportRewriteContext context) throws CoreException {
	if (!isGetter) {
		AST ast = rewrite.getAST();

		SingleVariableDeclaration param = ast.newSingleVariableDeclaration();
		Type type = getImportRewrite().addImport(fVariableBinding.getType(), ast, context, TypeLocation.PARAMETER);
		param.setType(type);
		param.setName(ast.newSimpleName(getArgumentName()));
		params.add(param);
	}
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
private SingleVariableDeclaration createParameterDeclaration(
    String parameterName,
    VariableDeclarationFragment fragement,
    Expression arrayAccess,
    ForStatement statement,
    ImportRewrite importRewrite,
    ASTRewrite rewrite,
    TextEditGroup group,
    LinkedProposalPositionGroup pg,
    boolean makeFinal) {
  CompilationUnit compilationUnit = (CompilationUnit) arrayAccess.getRoot();
  AST ast = compilationUnit.getAST();

  SingleVariableDeclaration result = ast.newSingleVariableDeclaration();

  SimpleName name = ast.newSimpleName(parameterName);
  pg.addPosition(rewrite.track(name), true);
  result.setName(name);

  ITypeBinding arrayTypeBinding = arrayAccess.resolveTypeBinding();
  Type type =
      importType(arrayTypeBinding.getElementType(), statement, importRewrite, compilationUnit);
  if (arrayTypeBinding.getDimensions() != 1) {
    type = ast.newArrayType(type, arrayTypeBinding.getDimensions() - 1);
  }
  result.setType(type);

  if (fragement != null) {
    VariableDeclarationStatement declaration =
        (VariableDeclarationStatement) fragement.getParent();
    ModifierRewrite.create(rewrite, result).copyAllModifiers(declaration, group);
  }
  if (makeFinal
      && (fragement == null
          || ASTNodes.findModifierNode(Modifier.FINAL, ASTNodes.getModifiers(fragement))
              == null)) {
    ModifierRewrite.create(rewrite, result).setModifiers(Modifier.FINAL, 0, group);
  }

  return result;
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
protected SingleVariableDeclaration createNewSingleVariableDeclaration(ParameterInfo info) {
  SingleVariableDeclaration newP = getASTRewrite().getAST().newSingleVariableDeclaration();
  newP.setName(getASTRewrite().getAST().newSimpleName(info.getNewName()));
  newP.setType(
      createNewTypeNode(
          ParameterInfo.stripEllipsis(info.getNewTypeName()), info.getNewTypeBinding()));
  newP.setVarargs(info.isNewVarargs());
  return newP;
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
private SingleVariableDeclaration newParameterDeclaration(
    AST ast, ImportRewrite importRewrite, String paramName, ITypeBinding paramType) {

  SingleVariableDeclaration param = ast.newSingleVariableDeclaration();
  param.setType(importRewrite.addImport(paramType, ast));
  param.setName(ast.newSimpleName(paramName));
  return param;
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
/**
 * Creates and adds the necessary argument declarations to the given factory method.<br>
 * An argument is needed for each original constructor argument for which the evaluation of the
 * actual arguments across all calls was not able to be pushed inside the factory method (e.g.
 * arguments with side-effects, references to fields if the factory method is to be static or
 * reside in a factory class, or arguments that varied across the set of constructor calls).<br>
 * <code>fArgTypes</code> identifies such arguments by a <code>null</code> value.
 *
 * @param ast utility object used to create AST nodes
 * @param newMethod the <code>MethodDeclaration</code> for the factory method
 */
private void createFactoryMethodSignature(AST ast, MethodDeclaration newMethod) {
  List<SingleVariableDeclaration> argDecls = newMethod.parameters();

  for (int i = 0; i < fArgTypes.length; i++) {
    SingleVariableDeclaration argDecl = ast.newSingleVariableDeclaration();
    Type argType;

    if (i == (fArgTypes.length - 1) && fCtorIsVarArgs) {
      // The trailing varargs arg has an extra array dimension, compared to
      // what we need to pass to setType()...
      argType =
          typeNodeForTypeBinding(
              fArgTypes[i].getElementType(), fArgTypes[i].getDimensions() - 1, ast);
      argDecl.setVarargs(true);
    } else argType = typeNodeForTypeBinding(fArgTypes[i], 0, ast);

    argDecl.setName(ast.newSimpleName(fFormalArgNames[i]));
    argDecl.setType(argType);
    argDecls.add(argDecl);
  }

  ITypeBinding[] ctorExcepts = fCtorBinding.getExceptionTypes();
  List<Type> exceptions = newMethod.thrownExceptionTypes();

  for (int i = 0; i < ctorExcepts.length; i++) {
    exceptions.add(fImportRewriter.addImport(ctorExcepts[i], ast));
  }

  copyTypeParameters(ast, newMethod);
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
/**
 * Helper to generate a <code>foreach</code> loop to iterate over an {@link Iterable}.
 *
 * @param ast the {@link AST} instance to rewrite the loop to
 * @return the complete {@link ASTRewrite} object
 */
private ASTRewrite generateForEachRewrite(AST ast) {

  EnhancedForStatement loopStatement = ast.newEnhancedForStatement();

  ASTRewrite rewrite = ASTRewrite.create(ast);
  ITypeBinding loopOverType = extractElementType(ast);

  // generate name proposals and add them to the variable declaration
  SimpleName forDeclarationName =
      resolveLinkedVariableNameWithProposals(rewrite, loopOverType.getName(), null, true);

  SingleVariableDeclaration forLoopInitializer = ast.newSingleVariableDeclaration();
  forLoopInitializer.setType(
      getImportRewrite()
          .addImport(
              loopOverType,
              ast,
              new ContextSensitiveImportRewriteContext(fCurrentNode, getImportRewrite())));
  forLoopInitializer.setName(forDeclarationName);

  loopStatement.setParameter(forLoopInitializer);
  loopStatement.setExpression((Expression) rewrite.createCopyTarget(fCurrentExpression));

  Block forLoopBody = ast.newBlock();
  forLoopBody.statements().add(createBlankLineStatementWithCursorPosition(rewrite));

  loopStatement.setBody(forLoopBody);

  rewrite.replace(fCurrentNode, loopStatement, null);

  return rewrite;
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
private SuperConstructorInvocation addEnclosingInstanceAccess(
    ASTRewrite rewrite,
    ImportRewriteContext importRewriteContext,
    List<SingleVariableDeclaration> parameters,
    String[] paramNames,
    ITypeBinding enclosingInstance) {
  AST ast = rewrite.getAST();
  SuperConstructorInvocation invocation = ast.newSuperConstructorInvocation();

  SingleVariableDeclaration var = ast.newSingleVariableDeclaration();
  var.setType(getImportRewrite().addImport(enclosingInstance, ast, importRewriteContext));
  String[] enclosingArgNames =
      StubUtility.getArgumentNameSuggestions(
          getCompilationUnit().getJavaProject(),
          enclosingInstance.getTypeDeclaration().getName(),
          0,
          paramNames);
  String firstName = enclosingArgNames[0];
  var.setName(ast.newSimpleName(firstName));
  parameters.add(var);

  Name enclosing = ast.newSimpleName(firstName);
  invocation.setExpression(enclosing);

  String key = "arg_name_" + firstName; // $NON-NLS-1$
  addLinkedPosition(rewrite.track(enclosing), false, key);
  for (int i = 0; i < enclosingArgNames.length; i++) {
    addLinkedPositionProposal(key, enclosingArgNames[i], null); // alternative names
  }
  return invocation;
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
@Override
protected void addNewParameters(
    ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params)
    throws CoreException {
  AST ast = rewrite.getAST();

  List<Expression> arguments = fArguments;
  ImportRewriteContext context =
      new ContextSensitiveImportRewriteContext(
          ASTResolving.findParentBodyDeclaration(getInvocationNode()), getImportRewrite());

  for (int i = 0; i < arguments.size(); i++) {
    Expression elem = arguments.get(i);
    SingleVariableDeclaration param = ast.newSingleVariableDeclaration();

    // argument type
    String argTypeKey = "arg_type_" + i; // $NON-NLS-1$
    Type type = evaluateParameterType(ast, elem, argTypeKey, context);
    param.setType(type);

    // argument name
    String argNameKey = "arg_name_" + i; // $NON-NLS-1$
    String name = evaluateParameterName(takenNames, elem, type, argNameKey);
    param.setName(ast.newSimpleName(name));

    params.add(param);

    addLinkedPosition(rewrite.track(param.getType()), false, argTypeKey);
    addLinkedPosition(rewrite.track(param.getName()), false, argNameKey);
  }
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
@Override
protected void addNewParameters(
    ASTRewrite rewrite, List<String> takenNames, List<SingleVariableDeclaration> params)
    throws CoreException {
  AST ast = rewrite.getAST();
  ImportRewrite importRewrite = getImportRewrite();
  ITypeBinding[] bindings = fMethod.getParameterTypes();

  IJavaProject project = getCompilationUnit().getJavaProject();
  String[][] paramNames = StubUtility.suggestArgumentNamesWithProposals(project, fParamNames);

  for (int i = 0; i < bindings.length; i++) {
    ITypeBinding curr = bindings[i];

    String[] proposedNames = paramNames[i];

    SingleVariableDeclaration newParam = ast.newSingleVariableDeclaration();

    newParam.setType(importRewrite.addImport(curr, ast));
    newParam.setName(ast.newSimpleName(proposedNames[0]));

    params.add(newParam);

    String groupId = "arg_name_" + i; // $NON-NLS-1$
    addLinkedPosition(rewrite.track(newParam.getName()), false, groupId);

    for (int k = 0; k < proposedNames.length; k++) {
      addLinkedPositionProposal(groupId, proposedNames[k], null);
    }
  }
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
/**
 * Clones the given parameter declaration.
 */
public static SingleVariableDeclaration cloneMethodParameter(AST ast,
    SingleVariableDeclaration param, ImportRewrite imports) {
  SingleVariableDeclaration newParam = ast.newSingleVariableDeclaration();

  // New parameter has a normalized type equivalent to the original
  Type type = normalizeTypeAndAddImport(ast, param.getType(), imports);
  newParam.setType(type);

  // Give new parameter same name as the original
  newParam.setName(ast.newSimpleName(param.getName().getIdentifier()));

  return newParam;
}
 

import org.eclipse.jdt.core.dom.SingleVariableDeclaration; //導入方法依賴的package包/類
/**
 * Creates a GWT RPC async callback parameter declaration based on the sync
 * method return type.
 *
 * @param ast {@link AST} associated with the destination compilation unit
 * @param syncReturnType the sync method return type
 * @param callbackParameterName name of the callback parameter
 * @param imports {@link ImportsRewrite} for the destination compilation unit
 * @return callback paramter declaration
 */
@SuppressWarnings("unchecked")
public static SingleVariableDeclaration createAsyncCallbackParameter(AST ast,
    Type syncReturnType, String callbackParameterName, ImportRewrite imports) {
  ITypeBinding syncReturnTypeBinding = syncReturnType.resolveBinding();

  SingleVariableDeclaration parameter = ast.newSingleVariableDeclaration();

  String gwtCallbackTypeSig = Signature.createTypeSignature(
      RemoteServiceUtilities.ASYNCCALLBACK_QUALIFIED_NAME, true);
  Type gwtCallbackType = imports.addImportFromSignature(gwtCallbackTypeSig,
      ast);

  if (syncReturnTypeBinding.isPrimitive()) {
    String wrapperName = JavaASTUtils.getWrapperTypeName(syncReturnTypeBinding.getName());
    String wrapperTypeSig = Signature.createTypeSignature(wrapperName, true);
    syncReturnType = imports.addImportFromSignature(wrapperTypeSig, ast);
  } else {
    syncReturnType = JavaASTUtils.normalizeTypeAndAddImport(ast,
        syncReturnType, imports);
  }

  ParameterizedType type = ast.newParameterizedType(gwtCallbackType);
  List<Type> typeArgs = type.typeArguments();
  typeArgs.add(syncReturnType);

  parameter.setType(type);
  parameter.setName(ast.newSimpleName(callbackParameterName));

  return parameter;
}