Java Code Examples for org.eclipse.jdt.core.dom.MethodDeclaration#parameters()

ParameterAnnotationRewriteOperation(CompilationUnit unit, MethodDeclaration method, String annotationToAdd, String annotationToRemove, String paramName, boolean allowRemove, String message) {
	fUnit= unit;
	fKey= method.resolveBinding().getKey();
	fAnnotationToAdd= annotationToAdd;
	fAnnotationToRemove= annotationToRemove;
	fAllowRemove= allowRemove;
	fMessage= message;
	for (Object param : method.parameters()) {
		SingleVariableDeclaration argument= (SingleVariableDeclaration) param;
		if (argument.getName().getIdentifier().equals(paramName)) {
			fArgument= argument;
			fKey+= argument.getName().getIdentifier();
			return;
		}
	}
	// shouldn't happen, we've checked that paramName indeed denotes a parameter.
	throw new RuntimeException("Argument " + paramName + " not found in method " + method.getName().getIdentifier()); //$NON-NLS-1$ //$NON-NLS-2$
}
 

@Override
public boolean visit(MethodDeclaration node) {
	int start = _unit.getLineNumber(node.getStartPosition());
	int end = _unit.getLineNumber(node.getStartPosition() + node.getLength());
	if(start <= _line && _line <= end){
		for(Object object : node.parameters()){
			SingleVariableDeclaration svd = (SingleVariableDeclaration) object;
			_vars.put(svd.getName().toString(), svd.getType());
		}
		
		if(node.getBody() != null){
			MethodVisitor methodVisitor = new MethodVisitor();
			node.getBody().accept(methodVisitor);
			methodVisitor.dumpVarMap();
		}
		return false;
	}
	return true;
}
 

/**
 * @param node
 * @return
 */
public static String getMethodType(final MethodDeclaration node) {
	final StringBuffer typeSb = new StringBuffer();
	if (node.getReturnType2() != null) {
		typeSb.append(node.getReturnType2().toString()).append("(");
	} else if (node.isConstructor()) {
		typeSb.append("constructor(");
	} else {
		typeSb.append("void(");
	}
	for (final Object svd : node.parameters()) {
		final SingleVariableDeclaration decl = (SingleVariableDeclaration) svd;
		typeSb.append(decl.getType().toString());
		typeSb.append(",");
	}
	typeSb.append(")");

	final String methodType = typeSb.toString();
	return methodType;
}
 

@SuppressWarnings("unchecked")
private void addAsyncParameters(AST ast, MethodDeclaration asyncMethodDecl) {
  List<SingleVariableDeclaration> asyncMethodParams = asyncMethodDecl.parameters();

  // Clone all the existing sync method parameters
  asyncMethodParams.addAll(JavaASTUtils.cloneParameters(ast,
      getSyncMethodDeclaration().parameters(), getImportRewrite()));

  List<String> existingParamNames = new ArrayList<String>();
  for (SingleVariableDeclaration param : asyncMethodParams) {
    existingParamNames.add(param.getName().getIdentifier());
  }
  String callbackParameterName = StringUtilities.computeUniqueName(
      existingParamNames.toArray(new String[0]), "callback");

  // Add the AsyncCallback parameter to the end
  asyncMethodParams.add(Util.createAsyncCallbackParameter(ast,
      getSyncMethodDeclaration().getReturnType2(), callbackParameterName,
      getImportRewrite()));
}
 

/**
 * Returning method name. Example: [name(parameters list)]
 * @param methodVersion
 * @return
 */
private String getSimpleNameMethod(MethodDeclaration methodVersion){
	String nameMethod = "";
	if(methodVersion != null){
		String parametersMethod = (methodVersion.parameters() != null) ? StringUtils.join(methodVersion.parameters(), ", ") : " ";
		nameMethod = methodVersion.getName() + "(" + parametersMethod + ")";
	}
	return nameMethod;
}
 

@Override
@SuppressWarnings("unchecked")
protected List<SingleVariableDeclaration> adjustSrcParams(
    MethodDeclaration method) {

  // The source method is in the async interface
  List<SingleVariableDeclaration> params = method.parameters();

  if (Util.getCallbackParameter(method) != null) {
    params = params.subList(0, params.size() - 1);
  }

  return params;
}
 

@Override
@SuppressWarnings("unchecked")
protected List<SingleVariableDeclaration> adjustSrcParams(
    MethodDeclaration method) {

  // The source method is in the sync interface
  return method.parameters();
}
 

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 static SimpleName isSetter(MethodDeclaration methodDeclaration) {
	Block methodBody = methodDeclaration.getBody();
	List<SingleVariableDeclaration> parameters = methodDeclaration.parameters();
	if(methodBody != null) {
		List<Statement> statements = methodBody.statements();
		if(statements.size() == 1 && parameters.size() == 1) {
			Statement statement = statements.get(0);
    		if(statement instanceof ExpressionStatement) {
    			ExpressionStatement expressionStatement = (ExpressionStatement)statement;
    			Expression expressionStatementExpression = expressionStatement.getExpression();
    			if(expressionStatementExpression instanceof Assignment) {
    				Assignment assignment = (Assignment)expressionStatementExpression;
    				Expression rightHandSide = assignment.getRightHandSide();
    				if(rightHandSide instanceof SimpleName) {
    					SimpleName rightHandSideSimpleName = (SimpleName)rightHandSide;
    					if(rightHandSideSimpleName.resolveBinding().isEqualTo(parameters.get(0).resolveBinding())) {
    						Expression leftHandSide = assignment.getLeftHandSide();
    						if(leftHandSide instanceof SimpleName) {
    		    				return (SimpleName)leftHandSide;
    		    			}
    		    			else if(leftHandSide instanceof FieldAccess) {
    		    				FieldAccess fieldAccess = (FieldAccess)leftHandSide;
    		    				return fieldAccess.getName();
    		    			}
    					}
    				}
    			}
    		}
		}
	}
	return null;
}
 

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

private static boolean getAssignAllParamsToFieldsProposals(IInvocationContext context, ASTNode node, Collection<ChangeCorrectionProposal> resultingCollections) {
	node = ASTNodes.getNormalizedNode(node);
	ASTNode parent = node.getParent();
	if (!(parent instanceof SingleVariableDeclaration) || !(parent.getParent() instanceof MethodDeclaration)) {
		return false;
	}
	MethodDeclaration methodDecl = (MethodDeclaration) parent.getParent();
	if (methodDecl.getBody() == null) {
		return false;
	}
	List<SingleVariableDeclaration> parameters = methodDecl.parameters();
	if (parameters.size() <= 1) {
		return false;
	}
	ITypeBinding parentType = Bindings.getBindingOfParentType(node);
	if (parentType == null || parentType.isInterface()) {
		return false;
	}
	for (SingleVariableDeclaration param : parameters) {
		IVariableBinding binding = param.resolveBinding();
		if (binding == null || binding.getType() == null) {
			return false;
		}
	}
	if (resultingCollections == null) {
		return true;
	}

	AssignToVariableAssistProposal fieldProposal = new AssignToVariableAssistProposal(context.getCompilationUnit(), parameters, IProposalRelevance.ASSIGN_ALL_PARAMS_TO_NEW_FIELDS);
	resultingCollections.add(fieldProposal);
	return true;
}
 

private List<ConstructorParameterSetterBuilderField> extractArguments(MethodDeclaration constructor) {
    List<ConstructorParameterSetterBuilderField> result = new ArrayList<>();
    List<SingleVariableDeclaration> parameters = constructor.parameters();
    for (int i = 0; i < parameters.size(); ++i) {
        result.add(createConstructorParameterSetterBuilderField(parameters.get(i), i));
    }
    return result;
}
 

/**
 * Returns the callback parameter declaration from an async method.
 *
 * @param method async method declaration
 * @return callback parameter declaration
 */
public static SingleVariableDeclaration getCallbackParameter(
    MethodDeclaration method) {

  @SuppressWarnings("unchecked")
  List<SingleVariableDeclaration> asyncParameters = method.parameters();
  if (asyncParameters.isEmpty()) {
    return null;
  }

  // Grab the last parameter type, which should be the callback
  SingleVariableDeclaration callback = asyncParameters.get(asyncParameters.size() - 1);

  ITypeBinding callbackBinding = callback.getType().resolveBinding();
  if (callbackBinding == null) {
    return null;
  }

  // Make sure the callback is of type AsyncCallback
  String callbackBaseTypeName = callbackBinding.getErasure().getQualifiedName();

  if (RemoteServiceUtilities.ASYNCCALLBACK_QUALIFIED_NAME.equals(callbackBaseTypeName)) {
    return callback;
  }

  return null;
}
 

public static Pair<String, String> getTypeDecAndMethodDec(ASTNode node) {
	ASTNode parent = node.getParent();
	String methodName = null;
	String className = null;
	while(parent != null){
		if(parent instanceof MethodDeclaration){
			MethodDeclaration methodDeclaration = (MethodDeclaration) parent; 
			methodName = methodDeclaration.getName().getFullyQualifiedName();
			String params = "";
			for(Object obj : methodDeclaration.parameters()){
				SingleVariableDeclaration singleVariableDeclaration = (SingleVariableDeclaration) obj;
				params += ","+singleVariableDeclaration.getType().toString();
			}
			methodName += params;
		} else if(parent instanceof TypeDeclaration){
			TypeDeclaration typeDeclaration = (TypeDeclaration) parent;
			if(Modifier.isPublic(typeDeclaration.getModifiers()) && className != null){
				className = typeDeclaration.getName().getFullyQualifiedName() + "$" + className;
			} else {
				if(className == null) {
					className = ((TypeDeclaration)parent).getName().getFullyQualifiedName();
				}
			}
		} else if(parent instanceof EnumDeclaration){
			className = ((EnumDeclaration)parent).getName().getFullyQualifiedName();
		}
		parent = parent.getParent();
	}
	return new Pair<String, String>(className, methodName);
}
 

/**
 * Returning method full name. [access modifier + return + name + (parameters list)]
 * @param methodVersion
 * @return
 */
private String getFullNameMethod(MethodDeclaration methodVersion){
	String nameMethod = "";
	if(methodVersion != null){
		String modifiersMethod = (methodVersion.modifiers() != null) ? (StringUtils.join(methodVersion.modifiers(), " ") + " ") : " ";
		String returnMethod = (methodVersion.getReturnType2() != null) ? (methodVersion.getReturnType2().toString() + " ") : "";
		String parametersMethod = (methodVersion.parameters() != null) ? StringUtils.join(methodVersion.parameters(), ", ") : " ";
		nameMethod = modifiersMethod + returnMethod + methodVersion.getName() + "(" + parametersMethod + ")";
	}
	return nameMethod;
}
 

private MethodDeclaration createNewMethodDeclaration(AST ast, IMethodBinding binding, ASTRewrite rewrite, ImportRewriteContext importRewriteContext, CodeGenerationSettings commentSettings) throws CoreException {
	String name= fTypeNode.getName().getIdentifier();
	MethodDeclaration decl= ast.newMethodDeclaration();
	decl.setConstructor(true);
	decl.setName(ast.newSimpleName(name));
	Block body= ast.newBlock();
	decl.setBody(body);

	SuperConstructorInvocation invocation= null;

	List<SingleVariableDeclaration> parameters= decl.parameters();
	String[] paramNames= getArgumentNames(binding);

	ITypeBinding enclosingInstance= getEnclosingInstance();
	if (enclosingInstance != null) {
		invocation= addEnclosingInstanceAccess(rewrite, importRewriteContext, parameters, paramNames, enclosingInstance);
	}

	if (binding == null) {
		decl.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
	} else {
		decl.modifiers().addAll(ASTNodeFactory.newModifiers(ast, binding.getModifiers()));

		ITypeBinding[] params= binding.getParameterTypes();
		for (int i= 0; i < params.length; i++) {
			SingleVariableDeclaration var= ast.newSingleVariableDeclaration();
			var.setType(getImportRewrite().addImport(params[i], ast, importRewriteContext, TypeLocation.LOCAL_VARIABLE));
			var.setName(ast.newSimpleName(paramNames[i]));
			parameters.add(var);
		}

		List<Type> thrownExceptions= decl.thrownExceptionTypes();
		ITypeBinding[] excTypes= binding.getExceptionTypes();
		for (int i= 0; i < excTypes.length; i++) {
			Type excType= getImportRewrite().addImport(excTypes[i], ast, importRewriteContext, TypeLocation.EXCEPTION);
			thrownExceptions.add(excType);
		}

		if (invocation == null) {
			invocation= ast.newSuperConstructorInvocation();
		}

		List<Expression> arguments= invocation.arguments();
		for (int i= 0; i < paramNames.length; i++) {
			Name argument= ast.newSimpleName(paramNames[i]);
			arguments.add(argument);
			addLinkedPosition(rewrite.track(argument), false, "arg_name_" + paramNames[i]); //$NON-NLS-1$
		}
	}

	String bodyStatement = (invocation == null) ? "" : ASTNodes.asFormattedString(invocation, 0, String.valueOf('\n'), getCompilationUnit().getJavaProject().getOptions(true)); //$NON-NLS-1$
	String placeHolder= CodeGeneration.getMethodBodyContent(getCompilationUnit(), name, name, true, bodyStatement, String.valueOf('\n'));
	if (placeHolder != null) {
		ASTNode todoNode= rewrite.createStringPlaceholder(placeHolder, ASTNode.RETURN_STATEMENT);
		body.statements().add(todoNode);
	}
	if (commentSettings != null) {
		String string= CodeGeneration.getMethodComment(getCompilationUnit(), name, decl, null, String.valueOf('\n'));
		if (string != null) {
			Javadoc javadoc= (Javadoc) rewrite.createStringPlaceholder(string, ASTNode.JAVADOC);
			decl.setJavadoc(javadoc);
		}
	}
	return decl;
}
 

public void visit(MethodDeclaration node) {
	qty = node.parameters() == null ? 0 : node.parameters().size();
}
 

private MethodDeclaration createNewMethodDeclaration(AST ast, IMethodBinding binding, ASTRewrite rewrite, ImportRewriteContext importRewriteContext, CodeGenerationSettings commentSettings) throws CoreException {
	String name= fTypeNode.getName().getIdentifier();
	MethodDeclaration decl= ast.newMethodDeclaration();
	decl.setConstructor(true);
	decl.setName(ast.newSimpleName(name));
	Block body= ast.newBlock();
	decl.setBody(body);

	SuperConstructorInvocation invocation= null;

	List<SingleVariableDeclaration> parameters= decl.parameters();
	String[] paramNames= getArgumentNames(binding);

	ITypeBinding enclosingInstance= getEnclosingInstance();
	if (enclosingInstance != null) {
		invocation= addEnclosingInstanceAccess(rewrite, importRewriteContext, parameters, paramNames, enclosingInstance);
	}

	if (binding == null) {
		decl.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
	} else {
		decl.modifiers().addAll(ASTNodeFactory.newModifiers(ast, binding.getModifiers()));

		ITypeBinding[] params= binding.getParameterTypes();
		for (int i= 0; i < params.length; i++) {
			SingleVariableDeclaration var= ast.newSingleVariableDeclaration();
			var.setType(getImportRewrite().addImport(params[i], ast, importRewriteContext));
			var.setName(ast.newSimpleName(paramNames[i]));
			parameters.add(var);
		}

		List<Type> thrownExceptions= decl.thrownExceptionTypes();
		ITypeBinding[] excTypes= binding.getExceptionTypes();
		for (int i= 0; i < excTypes.length; i++) {
			Type excType= getImportRewrite().addImport(excTypes[i], ast, importRewriteContext);
			thrownExceptions.add(excType);
		}

		if (invocation == null) {
			invocation= ast.newSuperConstructorInvocation();
		}

		List<Expression> arguments= invocation.arguments();
		for (int i= 0; i < paramNames.length; i++) {
			Name argument= ast.newSimpleName(paramNames[i]);
			arguments.add(argument);
			addLinkedPosition(rewrite.track(argument), false, "arg_name_" + paramNames[i]); //$NON-NLS-1$
		}
	}

	String bodyStatement= (invocation == null) ? "" : ASTNodes.asFormattedString(invocation, 0, String.valueOf('\n'), getCompilationUnit().getJavaProject().getOptions(true)); //$NON-NLS-1$
	String placeHolder= CodeGeneration.getMethodBodyContent(getCompilationUnit(), name, name, true, bodyStatement, String.valueOf('\n'));
	if (placeHolder != null) {
		ASTNode todoNode= rewrite.createStringPlaceholder(placeHolder, ASTNode.RETURN_STATEMENT);
		body.statements().add(todoNode);
	}
	if (commentSettings != null) {
		String string= CodeGeneration.getMethodComment(getCompilationUnit(), name, decl, null, String.valueOf('\n'));
		if (string != null) {
			Javadoc javadoc= (Javadoc) rewrite.createStringPlaceholder(string, ASTNode.JAVADOC);
			decl.setJavadoc(javadoc);
		}
	}
	return decl;
}
 

private ITypeBinding[] resolveBindings(String[] types, RefactoringStatus[] results, boolean firstPass) throws CoreException {
	//TODO: split types into parameterTypes and returnType
	int parameterCount= types.length - 1;
	ITypeBinding[] typeBindings= new ITypeBinding[types.length];

	StringBuffer cuString= new StringBuffer();
	cuString.append(fStubTypeContext.getBeforeString());
	int offsetBeforeMethodName= appendMethodDeclaration(cuString, types, parameterCount);
	cuString.append(fStubTypeContext.getAfterString());

	// need a working copy to tell the parser where to resolve (package visible) types
	ICompilationUnit wc= fMethod.getCompilationUnit().getWorkingCopy(new WorkingCopyOwner() {/*subclass*/}, new NullProgressMonitor());
	try {
		wc.getBuffer().setContents(cuString.toString());
		CompilationUnit compilationUnit= new RefactoringASTParser(ASTProvider.SHARED_AST_LEVEL).parse(wc, true);
		ASTNode method= NodeFinder.perform(compilationUnit, offsetBeforeMethodName, METHOD_NAME.length()).getParent();
		Type[] typeNodes= new Type[types.length];
		if (method instanceof MethodDeclaration) {
			MethodDeclaration methodDeclaration= (MethodDeclaration) method;
			typeNodes[parameterCount]= methodDeclaration.getReturnType2();
			List<SingleVariableDeclaration> parameters= methodDeclaration.parameters();
			for (int i= 0; i < parameterCount; i++)
				typeNodes[i]= parameters.get(i).getType();

		} else if (method instanceof AnnotationTypeMemberDeclaration) {
			typeNodes[0]= ((AnnotationTypeMemberDeclaration) method).getType();
		}

		for (int i= 0; i < types.length; i++) {
			Type type= typeNodes[i];
			if (type == null) {
				String msg= Messages.format(RefactoringCoreMessages.TypeContextChecker_couldNotResolveType, BasicElementLabels.getJavaElementName(types[i]));
				results[i]= RefactoringStatus.createErrorStatus(msg);
				continue;
			}
			results[i]= new RefactoringStatus();
			IProblem[] problems= ASTNodes.getProblems(type, ASTNodes.NODE_ONLY, ASTNodes.PROBLEMS);
			if (problems.length > 0) {
				for (int p= 0; p < problems.length; p++)
					if (isError(problems[p], type))
						results[i].addError(problems[p].getMessage());
			}
			ITypeBinding binding= handleBug84585(type.resolveBinding());
			if (firstPass && (binding == null || binding.isRecovered())) {
				types[i]= qualifyTypes(type, results[i]);
			}
			typeBindings[i]= binding;
		}
		return typeBindings;
	} finally {
		wc.discardWorkingCopy();
	}
}
 

/**
		 * {@inheritDoc}
		 */
		@Override
		public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException {

			ASTRewrite rewrite= cuRewrite.getASTRewrite();
			ImportRemover importRemover= cuRewrite.getImportRemover();
			AST ast= rewrite.getAST();

			HashMap<ClassInstanceCreation, HashSet<String>> cicToNewNames= new HashMap<ClassInstanceCreation, HashSet<String>>();
			for (int i= 0; i < fExpressions.size(); i++) {
				ClassInstanceCreation classInstanceCreation= fExpressions.get(i);
				TextEditGroup group= createTextEditGroup(FixMessages.LambdaExpressionsFix_convert_to_lambda_expression, cuRewrite);

				AnonymousClassDeclaration anonymTypeDecl= classInstanceCreation.getAnonymousClassDeclaration();
				List<BodyDeclaration> bodyDeclarations= anonymTypeDecl.bodyDeclarations();

				Object object= bodyDeclarations.get(0);
				if (!(object instanceof MethodDeclaration))
					continue;
				MethodDeclaration methodDeclaration= (MethodDeclaration) object;
				HashSet<String> excludedNames= new HashSet<String>();
				if (i != 0) {
					for (ClassInstanceCreation convertedCic : fExpressions.subList(0, i)) {
						if (ASTNodes.isParent(classInstanceCreation, convertedCic)) {
							excludedNames.addAll(cicToNewNames.get(convertedCic));
						}
					}
				}
				HashSet<String> newNames= makeNamesUnique(excludedNames, methodDeclaration, rewrite, group);
				cicToNewNames.put(classInstanceCreation, new HashSet<String>(newNames));
				List<SingleVariableDeclaration> methodParameters= methodDeclaration.parameters();

				// use short form with inferred parameter types and without parentheses if possible
				LambdaExpression lambdaExpression= ast.newLambdaExpression();
				List<VariableDeclaration> lambdaParameters= lambdaExpression.parameters();
				lambdaExpression.setParentheses(methodParameters.size() != 1);
				for (SingleVariableDeclaration methodParameter : methodParameters) {
					VariableDeclarationFragment lambdaParameter= ast.newVariableDeclarationFragment();
					lambdaParameter.setName((SimpleName) rewrite.createCopyTarget(methodParameter.getName()));
					lambdaParameters.add(lambdaParameter);
				}
				
				Block body= methodDeclaration.getBody();
				List<Statement> statements= body.statements();
				ASTNode lambdaBody= body;
				if (statements.size() == 1) {
					// use short form with just an expression body if possible
					Statement statement= statements.get(0);
					if (statement instanceof ExpressionStatement) {
						lambdaBody= ((ExpressionStatement) statement).getExpression();
					} else if (statement instanceof ReturnStatement) {
						Expression returnExpression= ((ReturnStatement) statement).getExpression();
						if (returnExpression != null) {
							lambdaBody= returnExpression;
						}
					}
				}
				//TODO: Bug 421479: [1.8][clean up][quick assist] convert anonymous to lambda must consider lost scope of interface
//				lambdaBody.accept(new InterfaceAccessQualifier(rewrite, classInstanceCreation.getType().resolveBinding())); //TODO: maybe need a separate ASTRewrite and string placeholder
				
				lambdaExpression.setBody(rewrite.createCopyTarget(lambdaBody));
				Expression replacement= lambdaExpression;
				if (ASTNodes.isTargetAmbiguous(classInstanceCreation, lambdaParameters.isEmpty())) {
					CastExpression cast= ast.newCastExpression();
					cast.setExpression(lambdaExpression);
					ImportRewrite importRewrite= cuRewrite.getImportRewrite();
					ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(classInstanceCreation, importRewrite);
					Type castType= importRewrite.addImport(classInstanceCreation.getType().resolveBinding(), ast, importRewriteContext);
					cast.setType(castType);
					importRemover.registerAddedImports(castType);
					replacement= cast;
				}
				rewrite.replace(classInstanceCreation, replacement, group);

				importRemover.registerRemovedNode(classInstanceCreation);
				importRemover.registerRetainedNode(lambdaBody);
			}
		}