Java ClassInstanceCreation.arguments方法代码示例

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public void endVisit(ClassInstanceCreation node) {
  Expression receiver = node.getExpression();
  Type createdType = node.getType();

  ConstraintVariable2 typeCv;
  if (node.getAnonymousClassDeclaration() == null) {
    typeCv = getConstraintVariable(createdType);
  } else {
    typeCv = fTCModel.makeImmutableTypeVariable(createdType.resolveBinding(), null);
    setConstraintVariable(createdType, typeCv);
  }
  setConstraintVariable(node, typeCv);

  IMethodBinding methodBinding = node.resolveConstructorBinding();
  Map<String, IndependentTypeVariable2> methodTypeVariables =
      createMethodTypeArguments(methodBinding);
  List<Expression> arguments = node.arguments();
  doVisitMethodInvocationArguments(
      methodBinding, arguments, receiver, methodTypeVariables, createdType);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public ITypeConstraint[] create(ClassInstanceCreation instanceCreation) {
  List<Expression> arguments = instanceCreation.arguments();
  List<ITypeConstraint> result = new ArrayList<ITypeConstraint>(arguments.size());
  IMethodBinding methodBinding = instanceCreation.resolveConstructorBinding();
  result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding)));
  if (instanceCreation.getAnonymousClassDeclaration() == null) {
    ConstraintVariable constructorVar =
        fConstraintVariableFactory.makeExpressionOrTypeVariable(instanceCreation, getContext());
    ConstraintVariable typeVar =
        fConstraintVariableFactory.makeRawBindingVariable(instanceCreation.resolveTypeBinding());
    result.addAll(
        Arrays.asList(fTypeConstraintFactory.createDefinesConstraint(constructorVar, typeVar)));
  }
  return result.toArray(new ITypeConstraint[result.size()]);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public void endVisit(ClassInstanceCreation instanceCreation) {
	if (instanceCreation.getParent() instanceof ThrowStatement) {
		logger.warn("Ignoring throw statements!");
		return;
	}
	List<?> paramTypes = Arrays.asList(instanceCreation.resolveConstructorBinding().getParameterTypes());
	List<?> paramValues = instanceCreation.arguments();
	Constructor<?> constructor = retrieveConstructor(instanceCreation.getType(),
	                                                 paramTypes, paramValues);
	List<VariableReference> params = convertParams(instanceCreation.arguments(),
	                                               paramTypes);
	VariableReference retVal = retrieveVariableReference(instanceCreation, null);
	retVal.setOriginalCode(instanceCreation.toString());
	ConstructorStatement statement = new ValidConstructorStatement(
	        testCase.getReference(), constructor, retVal, params);
	testCase.addStatement(statement);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public void endVisit(ClassInstanceCreation node) {
	Expression receiver= node.getExpression();
	Type createdType= node.getType();

	ConstraintVariable2 typeCv;
	if (node.getAnonymousClassDeclaration() == null) {
		typeCv= getConstraintVariable(createdType);
	} else {
		typeCv= fTCModel.makeImmutableTypeVariable(createdType.resolveBinding(), null);
		setConstraintVariable(createdType, typeCv);
	}
	setConstraintVariable(node, typeCv);

	IMethodBinding methodBinding= node.resolveConstructorBinding();
	Map<String, IndependentTypeVariable2> methodTypeVariables= createMethodTypeArguments(methodBinding);
	List<Expression> arguments= node.arguments();
	doVisitMethodInvocationArguments(methodBinding, arguments, receiver, methodTypeVariables, createdType);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
protected MethodInvocation createValueOfInvocation(ASTRewrite rewrite, CompilationUnit compilationUnit,
        ClassInstanceCreation primitiveTypeCreation) {
    Assert.isNotNull(rewrite);
    Assert.isNotNull(primitiveTypeCreation);

    final AST ast = rewrite.getAST();
    MethodInvocation valueOfInvocation = ast.newMethodInvocation();
    valueOfInvocation.setName(ast.newSimpleName(VALUE_OF_METHOD_NAME));

    ITypeBinding binding = primitiveTypeCreation.getType().resolveBinding();
    if (isStaticImport()) {
        addStaticImports(rewrite, compilationUnit, binding.getQualifiedName() + "." + VALUE_OF_METHOD_NAME);
    } else {
        valueOfInvocation.setExpression(ast.newSimpleName(binding.getName()));
    }

    List<?> arguments = primitiveTypeCreation.arguments();
    List<Expression> newArguments = valueOfInvocation.arguments();
    for (Object argument : arguments) {
        Expression expression = (Expression) rewrite.createCopyTarget((ASTNode) argument);
        newArguments.add(expression);
    }

    return valueOfInvocation;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public boolean visit(ClassInstanceCreation node) {
    if (badBigDecimalConstructor != null) {
        return false;
    }
    Type type = node.getType();
    if (type instanceof SimpleType
            && "BigDecimal".equals(((SimpleType) type).getName().getFullyQualifiedName())) {

        @SuppressWarnings("unchecked")
        List<Expression> args = node.arguments();
        if (args.size() == 1 && args.get(0) instanceof NumberLiteral) {
            badBigDecimalConstructor = node;
            this.decimalVar = (NumberLiteral) node.arguments().get(0);
        }
    }

    return true;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public boolean visit(ClassInstanceCreation node) {
    if (foundThingToReplace()) {
        return false;
    }
    QMethodAndArgs key = QMethodAndArgs.make(node);

    if (csiConstructors.containsKey(key)) {
        List<Expression> arguments = node.arguments();
        Integer indexVal = (Integer) csiConstructors.get(key);
        int indexOfArgumentToReplace = (arguments.size() - indexVal) - 1;

        // if this was a constant string, resolveConstantExpressionValue() will be nonnull
        Object literalString = arguments.get(indexOfArgumentToReplace).resolveConstantExpressionValue();
        if (null != literalString) {
            this.literalValue = literalString.toString();
            this.badConstructorInvocation = node;
            fixedAstNode = makeFixedConstructorInvocation(node, indexOfArgumentToReplace);
            return false; // don't keep parsing
        }
    }
    return true;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
/**
 * Create the list of actual arguments to the constructor call that is encapsulated inside the
 * factory method, and associate the arguments with the given constructor call object.
 *
 * @param ast utility object used to create AST nodes
 * @param newCtorCall the newly-generated constructor call to be wrapped inside the factory method
 */
private void createFactoryMethodConstructorArgs(AST ast, ClassInstanceCreation newCtorCall) {
  List<Expression> argList = newCtorCall.arguments();

  for (int i = 0; i < fArgTypes.length; i++) {
    ASTNode ctorArg = ast.newSimpleName(fFormalArgNames[i]);

    argList.add((Expression) ctorArg);
  }
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
public Expression createDefaultExpression(List<Expression> invocationArguments, ParameterInfo addedInfo, List<ParameterInfo> parameterInfos, MethodDeclaration enclosingMethod, boolean isRecursive, CompilationUnitRewrite cuRewrite) {
	final AST ast= cuRewrite.getAST();
	final ASTRewrite rewrite= cuRewrite.getASTRewrite();
	if (isRecursive && canReuseParameterObject(invocationArguments, addedInfo, parameterInfos, enclosingMethod)) {
		return ast.newSimpleName(addedInfo.getNewName());
	}
	ClassInstanceCreation classCreation= ast.newClassInstanceCreation();

	int startPosition= enclosingMethod != null ? enclosingMethod.getStartPosition() : cuRewrite.getRoot().getStartPosition();
	ContextSensitiveImportRewriteContext context= fParameterObjectFactory.createParameterClassAwareContext(fCreateAsTopLevel, cuRewrite, startPosition);
	classCreation.setType(fParameterObjectFactory.createType(fCreateAsTopLevel, cuRewrite, startPosition));
	List<Expression> constructorArguments= classCreation.arguments();
	for (Iterator<ParameterInfo> iter= parameterInfos.iterator(); iter.hasNext();) {
		ParameterInfo pi= iter.next();
		if (isValidField(pi)) {
			if (pi.isOldVarargs()) {
				boolean isLastParameter= !iter.hasNext();
				constructorArguments.addAll(computeVarargs(invocationArguments, pi, isLastParameter, cuRewrite, context));
			} else {
				Expression exp= invocationArguments.get(pi.getOldIndex());
				importNodeTypes(exp, cuRewrite, context);
				constructorArguments.add(moveNode(exp, rewrite));
			}
		}
	}
	return classCreation;
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
/**
 * Create the list of actual arguments to the constructor call that is
 * encapsulated inside the factory method, and associate the arguments
 * with the given constructor call object.
 * @param ast utility object used to create AST nodes
 * @param newCtorCall the newly-generated constructor call to be wrapped inside
 * the factory method
 */
private void createFactoryMethodConstructorArgs(AST ast, ClassInstanceCreation newCtorCall) {
	List<Expression> argList= newCtorCall.arguments();

	for(int i=0; i < fArgTypes.length; i++) {
		ASTNode ctorArg= ast.newSimpleName(fFormalArgNames[i]);

		argList.add((Expression) ctorArg);
	}
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public ITypeConstraint[] create(ClassInstanceCreation instanceCreation){
	List<Expression> arguments= instanceCreation.arguments();
	List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(arguments.size());
	IMethodBinding methodBinding= instanceCreation.resolveConstructorBinding();
	result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding)));
	if (instanceCreation.getAnonymousClassDeclaration() == null){
		ConstraintVariable constructorVar= fConstraintVariableFactory.makeExpressionOrTypeVariable(instanceCreation, getContext());
		ConstraintVariable typeVar= fConstraintVariableFactory.makeRawBindingVariable(instanceCreation.resolveTypeBinding());
		result.addAll(Arrays.asList(fTypeConstraintFactory.createDefinesConstraint(constructorVar, typeVar)));
	}
	return result.toArray(new ITypeConstraint[result.size()]);
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
/**
 * Constructor for this class if on the right hand side is a constructor call.
 * @param parent The parent of this artifact.
 * @param expression The Statement expression, which may be edited.
 * @param attributeName then name of the attribute as string
 * @param typeBinding The type of the LHS (qualified name),
 *     i.e. to which <b>TYPE</b> it is assigned <b>TO</b>.
 * @param rhs The creation of the assignment of the right hand side (a constructor call).
 */
JavaAssignment(IJavaParent parent, ExpressionStatement expression, String attributeName, ITypeBinding typeBinding, 
    ClassInstanceCreation rhs) {
    super(parent, expression, attributeName, typeBinding);
    if (null != rhs) {
        ITypeBinding rhsBinding = rhs.resolveTypeBinding();
        arguments = rhs.arguments();
        if (null != rhsBinding) {
            this.fromType = (null != rhs && null != rhsBinding) ? rhsBinding.getQualifiedName() : null;
        }
    }
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public void write(ASTNode node) {
	ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) node;

	//TODO: Handle type arguments
	//TODO: Handle different reference operator used for stack objects

	// TODO: Support inner class creation via object.new
	if (classInstanceCreation.getExpression() != null)
		throw sourceNotSupported("Inner classes not yet supported");

	matchAndWrite("new");
	copySpaceAndComments();

       swiftASTWriters.writeNode(classInstanceCreation.getType());
	copySpaceAndComments();

	matchAndWrite("(");
	copySpaceAndComments();

	List<?> arguments = classInstanceCreation.arguments();

	boolean first = true;
	for (Object object : arguments) {
		Expression argument = (Expression) object;

		if (! first) {
			matchAndWrite(",");
			copySpaceAndComments();
		}

           swiftASTWriters.writeNode(argument);
		copySpaceAndComments();

		first = false;
	}

	matchAndWrite(")");
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@Override
public void write(ClassInstanceCreation classInstanceCreation) {
	//TODO: Handle type arguments
	//TODO: Handle different reference operator used for stack objects

	// TODO: Support inner class creation via object.new
	if (classInstanceCreation.getExpression() != null)
		throw sourceNotSupported("Inner classes not yet supported");

	matchAndWrite("new");
	copySpaceAndComments();

       writeNode(classInstanceCreation.getType());
	copySpaceAndComments();

	matchAndWrite("(");
	copySpaceAndComments();

	List<?> arguments = classInstanceCreation.arguments();

	boolean first = true;
	for (Object object : arguments) {
		Expression argument = (Expression) object;

		if (! first) {
			matchAndWrite(",");
			copySpaceAndComments();
		}

           writeNode(argument);
		copySpaceAndComments();

		first = false;
	}

	matchAndWrite(")");
}
 

import org.eclipse.jdt.core.dom.ClassInstanceCreation; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private ASTNode makeFixedConstructorInvocation(ClassInstanceCreation node, int indexOfArgumentToReplace) {
    if (rootAstNode == null || rewrite == null) {
        return null;
    }
    ClassInstanceCreation newNode = rootAstNode.newClassInstanceCreation();
    newNode.setType((org.eclipse.jdt.core.dom.Type) rewrite.createCopyTarget(node.getType()));

    List<Expression> newArgs = newNode.arguments();
    List<Expression> oldArgs = node.arguments();

    copyArgsAndReplaceWithCharset(oldArgs, newArgs, indexOfArgumentToReplace);
    return newNode;
}