Java Code Examples for org.eclipse.jdt.core.dom.ClassInstanceCreation#arguments()

@Override
public boolean visit(ClassInstanceCreation node) {
	if (inFrame) {
		List arguments = node.arguments();
		if (arguments.size() > 0) {
			for (int i = 0; i < arguments.size(); i++) {
				Expression exp = (Expression) arguments.get(i);
				if (exp instanceof SimpleName) {
					AbstractDebugVariableCodeMining<IJavaStackFrame> m = new JavaDebugElementCodeMining(
							(SimpleName) exp, fFrame, viewer, provider);
					minings.add(m);
				}
			}
		}
	}
	return super.visit(node);
}
 

@Override
public boolean visit(ClassInstanceCreation node) {
	/*
	 * if (Utils.isGeneratedByLombok(node)) { return super.visit(node); }
	 */
	if (showParameterName || showParameterType) {
		List arguments = node.arguments();
		if (arguments.size() > 0 && acceptMethod(node)) {
			for (int i = 0; i < arguments.size(); i++) {
				Expression exp = (Expression) arguments.get(i);
				if (showParameterOnlyForLiteral && !isLiteral(exp)) {
					continue;
				}
				minings.add(new JavaMethodParameterCodeMining(node, exp, i, cu, provider, showParameterName,
						showParameterType, showParameterByUsingFilters));
			}
		}
	}
	return super.visit(node);
}
 

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;
}
 

@SuppressWarnings("rawtypes")
@Override
public boolean visit(ClassInstanceCreation node) {
    List args = node.arguments();
    Map<String, Integer> scopeBindings = getNodeScopes().get(node);
    List<String> argTypes = translateArgsToTypes(args, scopeBindings);
    String type = getNameOfType(node.getType());
    if (!methodStack.empty()) {
        MethodDeclaration currentMethod = methodStack.peek();
        MethodDecl methodDecl = getMethodDecl(currentMethod);
        List<MethodInvokRef> invoks = methodInvoks.get(methodDecl);
        if (invoks == null) {
            invoks = new ArrayList<>();
            methodInvoks.put(methodDecl, invoks);
        }
        MethodInvokRef methodInvokRef = new MethodInvokRef(removeSpecialSymbols(node.getType().toString()),
                type, "", args
                .size(), node.getStartPosition(), argTypes, node.getLength(), true,
                getReturnType(node));
        invoks.add(methodInvokRef);
    }
    return super.visit(node);
}
 

public ObjectCreation(CompilationUnit cu, String filePath, ClassInstanceCreation creation) {
	this.locationInfo = new LocationInfo(cu, filePath, creation, CodeElementType.CLASS_INSTANCE_CREATION);
	this.type = UMLType.extractTypeObject(cu, filePath, creation.getType(), 0);
	this.typeArguments = creation.arguments().size();
	this.arguments = new ArrayList<String>();
	List<Expression> args = creation.arguments();
	for(Expression argument : args) {
		this.arguments.add(argument.toString());
	}
	if(creation.getExpression() != null) {
		this.expression = creation.getExpression().toString();
	}
	if(creation.getAnonymousClassDeclaration() != null) {
		this.anonymousClassDeclaration = creation.getAnonymousClassDeclaration().toString();
	}
}
 

@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);
}
 

protected void replaceThisExpressionWithContextParameterInClassInstanceCreationArguments(Statement newStatement, AST subclassAST, ASTRewrite subclassRewriter) {
	ExpressionExtractor expressionExtractor = new ExpressionExtractor();
	List<Expression> classInstanceCreations = expressionExtractor.getClassInstanceCreations(newStatement);
	for(Expression creation : classInstanceCreations) {
		ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation)creation;
		List<Expression> arguments = classInstanceCreation.arguments();
		for(Expression argument : arguments) {
			if(argument instanceof ThisExpression) {
				String parameterName = sourceTypeDeclaration.getName().getIdentifier();
				parameterName = parameterName.substring(0,1).toLowerCase() + parameterName.substring(1,parameterName.length());
				ListRewrite argumentsRewrite = subclassRewriter.getListRewrite(classInstanceCreation, ClassInstanceCreation.ARGUMENTS_PROPERTY);
				argumentsRewrite.replace(argument, subclassAST.newSimpleName(parameterName), null);
			}
		}
	}
}
 

private void replaceThisExpressionWithSourceClassParameterInClassInstanceCreationArguments(MethodDeclaration newMethodDeclaration, ASTRewrite targetRewriter) {
	ExpressionExtractor extractor = new ExpressionExtractor();
	List<Expression> classInstanceCreations = extractor.getClassInstanceCreations(newMethodDeclaration.getBody());
	for(Expression creation : classInstanceCreations) {
		ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation)creation;
		List<Expression> arguments = classInstanceCreation.arguments();
		for(Expression argument : arguments) {
			if(argument instanceof ThisExpression) {
				SimpleName parameterName = null;
				if(!additionalArgumentsAddedToMovedMethod.contains("this")) {
					parameterName = addSourceClassParameterToMovedMethod(newMethodDeclaration, targetRewriter);
				}
				else {
					AST ast = newMethodDeclaration.getAST();
					String sourceTypeName = sourceTypeDeclaration.getName().getIdentifier();
					parameterName = ast.newSimpleName(sourceTypeName.replaceFirst(Character.toString(sourceTypeName.charAt(0)), Character.toString(Character.toLowerCase(sourceTypeName.charAt(0)))));
				}
				ListRewrite argumentRewrite = targetRewriter.getListRewrite(classInstanceCreation, ClassInstanceCreation.ARGUMENTS_PROPERTY);
				argumentRewrite.replace(argument, parameterName, null);
			}
		}
	}
}
 

private ClassInstanceCreate visit(ClassInstanceCreation node) {
	int startLine = _cunit.getLineNumber(node.getStartPosition());
	int endLine = _cunit.getLineNumber(node.getStartPosition() + node.getLength());
	ClassInstanceCreate classInstanceCreate = new ClassInstanceCreate(startLine, endLine, node);
	
	if(node.getExpression() != null){
		Expr expression = (Expr) process(node.getExpression());
		expression.setParent(classInstanceCreate);
		classInstanceCreate.setExpression(expression);
	}
	
	if(node.getAnonymousClassDeclaration() != null){
		AnonymousClassDecl anonymousClassDecl = (AnonymousClassDecl) process(node.getAnonymousClassDeclaration());
		anonymousClassDecl.setParent(classInstanceCreate);
		classInstanceCreate.setAnonymousClassDecl(anonymousClassDecl);
	}

	List<Expr> arguments = new ArrayList<>();
	for(Object object : node.arguments()){
		Expr arg = (Expr) process((ASTNode) object);
		arg.setParent(classInstanceCreate);
		arguments.add(arg);
	}
	classInstanceCreate.setArguments(arguments);
	
	classInstanceCreate.setClassType(node.getType());
	classInstanceCreate.setType(node.getType());
	
	return classInstanceCreate;
}
 

public static String processClassInstanceCreation(ClassInstanceCreation node) {
	StringBuilder sb = new StringBuilder();
	sb.append("new").append(" ");
	sb.append(node.getType().toString());
	List<Expression> arguments = node.arguments();
	if(arguments.size() > 0) {
	    for(int i=0; i<arguments.size()-1; i++)
	        sb.append(arguments.get(i).toString()).append(", ");
	    sb.append(arguments.get(arguments.size()-1).toString());
	}
	sb.append(")");
	return sb.toString();
}
 

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;
}
 

/**
 * 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);
	}
}
 

@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()]);
}
 

@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(")");
}
 

@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(")");
}