Examples with ImportRewriteContext org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext used on opensource projects

Example 36 with ImportRewriteContext

use of org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext in project che by eclipse.

the class AdvancedQuickAssistProcessor method getConvertIfElseToSwitchProposals.

private static boolean getConvertIfElseToSwitchProposals(IInvocationContext context, ASTNode coveringNode, ArrayList<ICommandAccess> resultingCollections, boolean handleNullArg) {
    final AST ast = coveringNode.getAST();
    final ASTRewrite rewrite = ASTRewrite.create(ast);
    final ImportRewrite importRewrite = StubUtility.createImportRewrite(context.getASTRoot(), true);
    ImportRewriteContext importRewriteContext = new ContextSensitiveImportRewriteContext(ASTResolving.findParentBodyDeclaration(coveringNode), importRewrite);
    IfStatement ifStatement = (IfStatement) coveringNode;
    IfStatement currentIf = ifStatement;
    Statement currentStatement = ifStatement;
    Expression currentExpression = currentIf.getExpression();
    SwitchStatement switchStatement = ast.newSwitchStatement();
    Expression switchExpression = null;
    boolean executeDefaultOnNullExpression = false;
    Statement defaultStatement = null;
    while (currentStatement != null) {
        Expression expression = null;
        List<Expression> caseExpressions = new ArrayList<Expression>();
        if (currentIf != null) {
            while (currentExpression != null) {
                // loop for fall through cases - multiple expressions with || operator
                Expression leftOperand;
                Expression rightOperand;
                boolean isMethodInvocationCase = false;
                if (currentExpression instanceof MethodInvocation) {
                    isMethodInvocationCase = true;
                    if (//$NON-NLS-1$
                    !(((MethodInvocation) currentExpression).getName().getIdentifier()).equals("equals"))
                        return false;
                    MethodInvocation invocation = (MethodInvocation) currentExpression;
                    leftOperand = invocation.getExpression();
                    if (leftOperand == null)
                        return false;
                    ITypeBinding leftBinding = leftOperand.resolveTypeBinding();
                    if (leftBinding != null) {
                        if (leftBinding.getQualifiedName().equals("java.lang.String")) {
                            //$NON-NLS-1$
                            if (!JavaModelUtil.is17OrHigher(context.getCompilationUnit().getJavaProject()))
                                return false;
                        } else if (!leftBinding.isEnum()) {
                            return false;
                        }
                    }
                    List<Expression> arguments = invocation.arguments();
                    if (arguments.size() != 1)
                        return false;
                    rightOperand = arguments.get(0);
                    ITypeBinding rightBinding = leftOperand.resolveTypeBinding();
                    if (rightBinding != null) {
                        if (rightBinding.getQualifiedName().equals("java.lang.String")) {
                            //$NON-NLS-1$
                            if (!JavaModelUtil.is17OrHigher(context.getCompilationUnit().getJavaProject()))
                                return false;
                        } else if (!rightBinding.isEnum()) {
                            return false;
                        }
                    }
                } else if (currentExpression instanceof InfixExpression) {
                    InfixExpression infixExpression = (InfixExpression) currentExpression;
                    Operator operator = infixExpression.getOperator();
                    if (!(operator.equals(InfixExpression.Operator.CONDITIONAL_OR) || operator.equals(InfixExpression.Operator.EQUALS)))
                        return false;
                    leftOperand = infixExpression.getLeftOperand();
                    rightOperand = infixExpression.getRightOperand();
                    if (operator.equals(InfixExpression.Operator.EQUALS)) {
                        ITypeBinding typeBinding = leftOperand.resolveTypeBinding();
                        if (typeBinding != null && typeBinding.getQualifiedName().equals("java.lang.String")) {
                            // don't propose quick assist when == is used to compare strings, since switch will use equals()
                            return false;
                        }
                    } else if (operator.equals(InfixExpression.Operator.CONDITIONAL_OR)) {
                        currentExpression = leftOperand;
                        continue;
                    }
                } else {
                    return false;
                }
                if (leftOperand.resolveConstantExpressionValue() != null) {
                    caseExpressions.add(leftOperand);
                    expression = rightOperand;
                    executeDefaultOnNullExpression |= isMethodInvocationCase;
                } else if (rightOperand.resolveConstantExpressionValue() != null) {
                    caseExpressions.add(rightOperand);
                    expression = leftOperand;
                } else if (leftOperand instanceof QualifiedName) {
                    QualifiedName qualifiedName = (QualifiedName) leftOperand;
                    IVariableBinding binding = (IVariableBinding) qualifiedName.resolveBinding();
                    if (binding == null || !binding.isEnumConstant())
                        return false;
                    importRewrite.addImport(binding.getDeclaringClass(), importRewriteContext);
                    caseExpressions.add(qualifiedName.getName());
                    expression = rightOperand;
                    executeDefaultOnNullExpression |= isMethodInvocationCase;
                } else if (rightOperand instanceof QualifiedName) {
                    QualifiedName qualifiedName = (QualifiedName) rightOperand;
                    IVariableBinding binding = (IVariableBinding) qualifiedName.resolveBinding();
                    if (binding == null || !binding.isEnumConstant())
                        return false;
                    importRewrite.addImport(binding.getDeclaringClass(), importRewriteContext);
                    caseExpressions.add(qualifiedName.getName());
                    expression = leftOperand;
                } else {
                    return false;
                }
                if (expression == null) {
                    // paranoidal check: this condition should never be true
                    return false;
                }
                if (currentExpression.getParent() instanceof InfixExpression) {
                    currentExpression = getNextSiblingExpression(currentExpression);
                } else {
                    currentExpression = null;
                }
                if (switchExpression == null) {
                    switchExpression = expression;
                }
                if (!switchExpression.subtreeMatch(new ASTMatcher(), expression)) {
                    return false;
                }
            }
        }
        Statement thenStatement;
        if (currentIf == null) {
            //currentStatement has the default else block
            thenStatement = currentStatement;
            defaultStatement = currentStatement;
        } else {
            thenStatement = currentIf.getThenStatement();
        }
        SwitchCase[] switchCaseStatements = createSwitchCaseStatements(ast, rewrite, caseExpressions);
        for (int i = 0; i < switchCaseStatements.length; i++) {
            switchStatement.statements().add(switchCaseStatements[i]);
        }
        boolean isBreakRequired = true;
        if (thenStatement instanceof Block) {
            Statement statement = null;
            for (Iterator<Statement> iter = ((Block) thenStatement).statements().iterator(); iter.hasNext(); ) {
                statement = iter.next();
                switchStatement.statements().add(rewrite.createCopyTarget(statement));
            }
            if (statement instanceof ReturnStatement || statement instanceof ThrowStatement)
                isBreakRequired = false;
        } else {
            if (thenStatement instanceof ReturnStatement || thenStatement instanceof ThrowStatement)
                isBreakRequired = false;
            switchStatement.statements().add(rewrite.createCopyTarget(thenStatement));
        }
        if (isBreakRequired)
            switchStatement.statements().add(ast.newBreakStatement());
        // advance currentStatement to the next "else if" or "else":
        if (currentIf != null && currentIf.getElseStatement() != null) {
            Statement elseStatement = currentIf.getElseStatement();
            if (elseStatement instanceof IfStatement) {
                currentIf = (IfStatement) elseStatement;
                currentStatement = currentIf;
                currentExpression = currentIf.getExpression();
            } else {
                currentIf = null;
                currentStatement = elseStatement;
                currentExpression = null;
            }
        } else {
            currentStatement = null;
        }
    }
    if (switchExpression == null)
        return false;
    switchStatement.setExpression((Expression) rewrite.createCopyTarget(switchExpression));
    if (handleNullArg) {
        if (executeDefaultOnNullExpression) {
            IfStatement newIfStatement = ast.newIfStatement();
            InfixExpression infixExpression = ast.newInfixExpression();
            infixExpression.setLeftOperand((Expression) rewrite.createCopyTarget(switchExpression));
            infixExpression.setRightOperand(ast.newNullLiteral());
            infixExpression.setOperator(InfixExpression.Operator.EQUALS);
            newIfStatement.setExpression(infixExpression);
            if (defaultStatement == null) {
                Block block = ast.newBlock();
                newIfStatement.setThenStatement(block);
            } else if (defaultStatement instanceof Block) {
                Block block = ast.newBlock();
                for (Iterator<Statement> iter = ((Block) defaultStatement).statements().iterator(); iter.hasNext(); ) {
                    block.statements().add(rewrite.createCopyTarget(iter.next()));
                }
                newIfStatement.setThenStatement(block);
            } else {
                newIfStatement.setThenStatement((Statement) rewrite.createCopyTarget(defaultStatement));
            }
            Block block = ast.newBlock();
            block.statements().add(switchStatement);
            newIfStatement.setElseStatement(block);
            rewrite.replace(ifStatement, newIfStatement, null);
            //$NON-NLS-1$ //$NON-NLS-2$
            String source = ASTNodes.asString(switchExpression).replaceAll("\r\n?|\n", " ");
            String label = Messages.format(CorrectionMessages.AdvancedQuickAssistProcessor_convertIfElseToSwitch_handleNullArg, source);
            ASTRewriteCorrectionProposal proposal = new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.CONVERT_IF_ELSE_TO_SWITCH);
            proposal.setImportRewrite(importRewrite);
            resultingCollections.add(proposal);
        }
    } else {
        rewrite.replace(ifStatement, switchStatement, null);
        String label = CorrectionMessages.AdvancedQuickAssistProcessor_convertIfElseToSwitch;
        ASTRewriteCorrectionProposal proposal = new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.CONVERT_IF_ELSE_TO_SWITCH);
        proposal.setImportRewrite(importRewrite);
        resultingCollections.add(proposal);
    }
    return true;
}

Example 37 with ImportRewriteContext

use of org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext in project che by eclipse.

the class JavaContext method addImport.

/**
	 * Adds an import for type with type name <code>type</code> if possible.
	 * Returns a string which can be used to reference the type.
	 *
	 * @param type the fully qualified name of the type to import
	 * @return returns a type to which the type binding can be assigned to.
	 * 	The returned type contains is unqualified when an import could be added or was already known.
	 * 	It is fully qualified, if an import conflict prevented the import.
	 * @since 3.4
	 */
public String addImport(String type) {
    if (isReadOnly())
        return type;
    ICompilationUnit cu = getCompilationUnit();
    if (cu == null)
        return type;
    try {
        boolean qualified = type.indexOf('.') != -1;
        if (!qualified) {
            IJavaSearchScope searchScope = SearchEngine.createJavaSearchScope(new IJavaElement[] { cu.getJavaProject() });
            SimpleName nameNode = null;
            TypeNameMatch[] matches = findAllTypes(type, searchScope, nameNode, null, cu);
            if (// only add import if we have a single match
            matches.length != 1)
                return type;
            type = matches[0].getFullyQualifiedName();
        }
        CompilationUnit root = getASTRoot(cu);
        if (fImportRewrite == null) {
            if (root == null) {
                fImportRewrite = StubUtility.createImportRewrite(cu, true);
            } else {
                fImportRewrite = StubUtility.createImportRewrite(root, true);
            }
        }
        ImportRewriteContext context;
        if (root == null)
            context = null;
        else
            context = new ContextSensitiveImportRewriteContext(root, getCompletionOffset(), fImportRewrite);
        return fImportRewrite.addImport(type, context);
    } catch (JavaModelException e) {
        handleException(null, e);
        return type;
    }
}

Example 38 with ImportRewriteContext

use of org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext in project che by eclipse.

the class IntroduceFactoryRefactoring method createFactoryMethod.

/**
	 * Creates and returns a new MethodDeclaration that represents the factory method to be used in
	 * place of direct calls to the constructor in question.
	 * 
	 * @param ast An AST used as a factory for various AST nodes
	 * @param ctorBinding binding for the constructor being wrapped
	 * @param unitRewriter the ASTRewrite to be used
	 * @return the new method declaration
	 * @throws CoreException if an exception occurs while accessing its corresponding resource
	 */
private MethodDeclaration createFactoryMethod(AST ast, IMethodBinding ctorBinding, ASTRewrite unitRewriter) throws CoreException {
    MethodDeclaration newMethod = ast.newMethodDeclaration();
    SimpleName newMethodName = ast.newSimpleName(fNewMethodName);
    ClassInstanceCreation newCtorCall = ast.newClassInstanceCreation();
    ReturnStatement ret = ast.newReturnStatement();
    Block body = ast.newBlock();
    List<Statement> stmts = body.statements();
    String retTypeName = ctorBinding.getName();
    createFactoryMethodSignature(ast, newMethod);
    newMethod.setName(newMethodName);
    newMethod.setBody(body);
    ITypeBinding declaringClass = fCtorBinding.getDeclaringClass();
    ITypeBinding[] ctorOwnerTypeParameters = declaringClass.getTypeParameters();
    setMethodReturnType(newMethod, retTypeName, ctorOwnerTypeParameters, ast);
    newMethod.modifiers().addAll(ASTNodeFactory.newModifiers(ast, Modifier.STATIC | Modifier.PUBLIC));
    setCtorTypeArguments(newCtorCall, retTypeName, ctorOwnerTypeParameters, ast);
    createFactoryMethodConstructorArgs(ast, newCtorCall);
    if (Modifier.isAbstract(declaringClass.getModifiers())) {
        AnonymousClassDeclaration decl = ast.newAnonymousClassDeclaration();
        IMethodBinding[] unimplementedMethods = getUnimplementedMethods(declaringClass);
        CodeGenerationSettings settings = JavaPreferencesSettings.getCodeGenerationSettings(fCUHandle.getJavaProject());
        ImportRewriteContext context = new ContextSensitiveImportRewriteContext(fFactoryCU, decl.getStartPosition(), fImportRewriter);
        for (int i = 0; i < unimplementedMethods.length; i++) {
            IMethodBinding unImplementedMethod = unimplementedMethods[i];
            MethodDeclaration newMethodDecl = StubUtility2.createImplementationStub(fCUHandle, unitRewriter, fImportRewriter, context, unImplementedMethod, unImplementedMethod.getDeclaringClass().getName(), settings, false);
            decl.bodyDeclarations().add(newMethodDecl);
        }
        newCtorCall.setAnonymousClassDeclaration(decl);
    }
    ret.setExpression(newCtorCall);
    stmts.add(ret);
    return newMethod;
}

Example 39 with ImportRewriteContext

use of org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext in project che by eclipse.

the class TypeMismatchSubProcessor method addTypeMismatchProposals.

public static void addTypeMismatchProposals(IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) throws CoreException {
    String[] args = problem.getProblemArguments();
    if (args.length != 2) {
        return;
    }
    ICompilationUnit cu = context.getCompilationUnit();
    CompilationUnit astRoot = context.getASTRoot();
    AST ast = astRoot.getAST();
    ASTNode selectedNode = problem.getCoveredNode(astRoot);
    if (!(selectedNode instanceof Expression)) {
        return;
    }
    Expression nodeToCast = (Expression) selectedNode;
    Name receiverNode = null;
    ITypeBinding castTypeBinding = null;
    int parentNodeType = selectedNode.getParent().getNodeType();
    if (parentNodeType == ASTNode.ASSIGNMENT) {
        Assignment assign = (Assignment) selectedNode.getParent();
        Expression leftHandSide = assign.getLeftHandSide();
        if (selectedNode.equals(leftHandSide)) {
            nodeToCast = assign.getRightHandSide();
        }
        castTypeBinding = assign.getLeftHandSide().resolveTypeBinding();
        if (leftHandSide instanceof Name) {
            receiverNode = (Name) leftHandSide;
        } else if (leftHandSide instanceof FieldAccess) {
            receiverNode = ((FieldAccess) leftHandSide).getName();
        }
    } else if (parentNodeType == ASTNode.VARIABLE_DECLARATION_FRAGMENT) {
        VariableDeclarationFragment frag = (VariableDeclarationFragment) selectedNode.getParent();
        if (selectedNode.equals(frag.getName()) || selectedNode.equals(frag.getInitializer())) {
            nodeToCast = frag.getInitializer();
            castTypeBinding = ASTNodes.getType(frag).resolveBinding();
            receiverNode = frag.getName();
        }
    } else if (parentNodeType == ASTNode.MEMBER_VALUE_PAIR) {
        receiverNode = ((MemberValuePair) selectedNode.getParent()).getName();
        castTypeBinding = ASTResolving.guessBindingForReference(nodeToCast);
    } else if (parentNodeType == ASTNode.SINGLE_MEMBER_ANNOTATION) {
        // use the type name
        receiverNode = ((SingleMemberAnnotation) selectedNode.getParent()).getTypeName();
        castTypeBinding = ASTResolving.guessBindingForReference(nodeToCast);
    } else {
        // try to find the binding corresponding to 'castTypeName'
        castTypeBinding = ASTResolving.guessBindingForReference(nodeToCast);
    }
    if (castTypeBinding == null) {
        return;
    }
    ITypeBinding currBinding = nodeToCast.resolveTypeBinding();
    if (!(nodeToCast instanceof ArrayInitializer)) {
        ITypeBinding castFixType = null;
        if (currBinding == null || castTypeBinding.isCastCompatible(currBinding) || nodeToCast instanceof CastExpression) {
            castFixType = castTypeBinding;
        } else if (JavaModelUtil.is50OrHigher(cu.getJavaProject())) {
            ITypeBinding boxUnboxedTypeBinding = boxUnboxPrimitives(castTypeBinding, currBinding, ast);
            if (boxUnboxedTypeBinding != castTypeBinding && boxUnboxedTypeBinding.isCastCompatible(currBinding)) {
                castFixType = boxUnboxedTypeBinding;
            }
        }
        if (castFixType != null) {
            proposals.add(createCastProposal(context, castFixType, nodeToCast, IProposalRelevance.CREATE_CAST));
        }
    }
    //$NON-NLS-1$
    boolean nullOrVoid = currBinding == null || "void".equals(currBinding.getName());
    // change method return statement to actual type
    if (!nullOrVoid && parentNodeType == ASTNode.RETURN_STATEMENT) {
        BodyDeclaration decl = ASTResolving.findParentBodyDeclaration(selectedNode);
        if (decl instanceof MethodDeclaration) {
            MethodDeclaration methodDeclaration = (MethodDeclaration) decl;
            currBinding = Bindings.normalizeTypeBinding(currBinding);
            if (currBinding == null) {
                //$NON-NLS-1$
                currBinding = ast.resolveWellKnownType("java.lang.Object");
            }
            if (currBinding.isWildcardType()) {
                currBinding = ASTResolving.normalizeWildcardType(currBinding, true, ast);
            }
            ASTRewrite rewrite = ASTRewrite.create(ast);
            String label = Messages.format(CorrectionMessages.TypeMismatchSubProcessor_changereturntype_description, BasicElementLabels.getJavaElementName(currBinding.getName()));
            Image image = JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
            LinkedCorrectionProposal proposal = new LinkedCorrectionProposal(label, cu, rewrite, IProposalRelevance.CHANGE_METHOD_RETURN_TYPE, image);
            ImportRewrite imports = proposal.createImportRewrite(astRoot);
            ImportRewriteContext importRewriteContext = new ContextSensitiveImportRewriteContext(decl, imports);
            Type newReturnType = imports.addImport(currBinding, ast, importRewriteContext);
            rewrite.replace(methodDeclaration.getReturnType2(), newReturnType, null);
            //$NON-NLS-1$
            String returnKey = "return";
            proposal.addLinkedPosition(rewrite.track(newReturnType), true, returnKey);
            ITypeBinding[] typeSuggestions = ASTResolving.getRelaxingTypes(ast, currBinding);
            for (int i = 0; i < typeSuggestions.length; i++) {
                proposal.addLinkedPositionProposal(returnKey, typeSuggestions[i]);
            }
            proposals.add(proposal);
        }
    }
    if (!nullOrVoid && receiverNode != null) {
        currBinding = Bindings.normalizeTypeBinding(currBinding);
        if (currBinding == null) {
            //$NON-NLS-1$
            currBinding = ast.resolveWellKnownType("java.lang.Object");
        }
        if (currBinding.isWildcardType()) {
            currBinding = ASTResolving.normalizeWildcardType(currBinding, true, ast);
        }
        addChangeSenderTypeProposals(context, receiverNode, currBinding, true, IProposalRelevance.CHANGE_TYPE_OF_RECEIVER_NODE, proposals);
    }
    addChangeSenderTypeProposals(context, nodeToCast, castTypeBinding, false, IProposalRelevance.CHANGE_TYPE_OF_NODE_TO_CAST, proposals);
    if (castTypeBinding == ast.resolveWellKnownType("boolean") && currBinding != null && !currBinding.isPrimitive() && !Bindings.isVoidType(currBinding)) {
        //$NON-NLS-1$
        String label = CorrectionMessages.TypeMismatchSubProcessor_insertnullcheck_description;
        Image image = JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
        ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());
        InfixExpression expression = ast.newInfixExpression();
        expression.setLeftOperand((Expression) rewrite.createMoveTarget(nodeToCast));
        expression.setRightOperand(ast.newNullLiteral());
        expression.setOperator(InfixExpression.Operator.NOT_EQUALS);
        rewrite.replace(nodeToCast, expression, null);
        proposals.add(new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, IProposalRelevance.INSERT_NULL_CHECK, image));
    }
}

Example 40 with ImportRewriteContext

use of org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext in project che by eclipse.

the class TypeMismatchSubProcessor method addTypeMismatchInForEachProposals.

public static void addTypeMismatchInForEachProposals(IInvocationContext context, IProblemLocation problem, Collection<ICommandAccess> proposals) {
    CompilationUnit astRoot = context.getASTRoot();
    ASTNode selectedNode = problem.getCoveringNode(astRoot);
    if (selectedNode == null || selectedNode.getLocationInParent() != EnhancedForStatement.EXPRESSION_PROPERTY) {
        return;
    }
    EnhancedForStatement forStatement = (EnhancedForStatement) selectedNode.getParent();
    ITypeBinding expressionBinding = forStatement.getExpression().resolveTypeBinding();
    if (expressionBinding == null) {
        return;
    }
    ITypeBinding expectedBinding;
    if (expressionBinding.isArray()) {
        expectedBinding = expressionBinding.getComponentType();
    } else {
        //$NON-NLS-1$
        IMethodBinding iteratorMethod = Bindings.findMethodInHierarchy(expressionBinding, "iterator", new String[0]);
        if (iteratorMethod == null) {
            return;
        }
        ITypeBinding[] typeArguments = iteratorMethod.getReturnType().getTypeArguments();
        if (typeArguments.length != 1) {
            return;
        }
        expectedBinding = typeArguments[0];
    }
    AST ast = astRoot.getAST();
    expectedBinding = Bindings.normalizeForDeclarationUse(expectedBinding, ast);
    SingleVariableDeclaration parameter = forStatement.getParameter();
    ICompilationUnit cu = context.getCompilationUnit();
    if (parameter.getName().getLength() == 0) {
        SimpleName simpleName = null;
        if (parameter.getType() instanceof SimpleType) {
            SimpleType type = (SimpleType) parameter.getType();
            if (type.getName() instanceof SimpleName) {
                simpleName = (SimpleName) type.getName();
            }
        } else if (parameter.getType() instanceof NameQualifiedType) {
            simpleName = ((NameQualifiedType) parameter.getType()).getName();
        }
        if (simpleName != null) {
            String name = simpleName.getIdentifier();
            int relevance = StubUtility.hasLocalVariableName(cu.getJavaProject(), name) ? 10 : 7;
            String label = Messages.format(CorrectionMessages.TypeMismatchSubProcessor_create_loop_variable_description, BasicElementLabels.getJavaElementName(name));
            Image image = JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_LOCAL);
            proposals.add(new NewVariableCorrectionProposal(label, cu, NewVariableCorrectionProposal.LOCAL, simpleName, null, relevance, image));
            return;
        }
    }
    String label = Messages.format(CorrectionMessages.TypeMismatchSubProcessor_incompatible_for_each_type_description, new String[] { BasicElementLabels.getJavaElementName(parameter.getName().getIdentifier()), BindingLabelProvider.getBindingLabel(expectedBinding, BindingLabelProvider.DEFAULT_TEXTFLAGS) });
    Image image = JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE);
    ASTRewrite rewrite = ASTRewrite.create(ast);
    ASTRewriteCorrectionProposal proposal = new ASTRewriteCorrectionProposal(label, cu, rewrite, IProposalRelevance.INCOMPATIBLE_FOREACH_TYPE, image);
    ImportRewrite importRewrite = proposal.createImportRewrite(astRoot);
    ImportRewriteContext importRewriteContext = new ContextSensitiveImportRewriteContext(ASTResolving.findParentBodyDeclaration(selectedNode), importRewrite);
    Type newType = importRewrite.addImport(expectedBinding, ast, importRewriteContext);
    rewrite.replace(parameter.getType(), newType, null);
    proposals.add(proposal);
}