public static void perform(LambdaExpression lambdaExpression, ITypeBinding parentTypeBinding, CompilationUnitRewrite cuRewrite, TextEditGroup group) { SuperThisQualifier qualifier = new SuperThisQualifier(); qualifier.fQualifierTypeBinding = parentTypeBinding; qualifier.fImportRewrite = cuRewrite.getImportRewrite(); qualifier.fASTRewrite = cuRewrite.getASTRewrite(); qualifier.fGroup = group; lambdaExpression.accept(qualifier); }
private void copyExceptions(MethodDeclaration intermediary, CompilationUnitRewrite imRewrite, ImportRewriteContext context) { ITypeBinding[] exceptionTypes= fTargetMethodBinding.getExceptionTypes(); for (int i= 0; i < exceptionTypes.length; i++) { Type exceptionType= imRewrite.getImportRewrite().addImport(exceptionTypes[i], imRewrite.getAST(), context); intermediary.thrownExceptionTypes().add(exceptionType); } }
public static void perform(LambdaExpression lambdaExpression, ITypeBinding parentTypeBinding, CompilationUnitRewrite cuRewrite, TextEditGroup group) { SuperThisQualifier qualifier= new SuperThisQualifier(); qualifier.fQualifierTypeBinding= parentTypeBinding; qualifier.fImportRewrite= cuRewrite.getImportRewrite(); qualifier.fASTRewrite= cuRewrite.getASTRewrite(); qualifier.fGroup= group; lambdaExpression.accept(qualifier); }
public void rewriteAST(CompilationUnitRewrite cuRewrite, List textEditGroups) throws CoreException { Type type= importType(fDeclaringTypeBinding, fQualifier, cuRewrite.getImportRewrite(), cuRewrite.getRoot()); TextEditGroup group= createTextEditGroup(FixMessages.CodeStyleFix_ChangeAccessUsingDeclaring_description); textEditGroups.add(group); cuRewrite.getASTRewrite().replace(fQualifier, type, group); } }
public Type importBinding(ITypeBinding newTypeBinding, CompilationUnitRewrite cuRewrite, ImportRewriteContext context) { Type type= cuRewrite.getImportRewrite().addImport(newTypeBinding, cuRewrite.getAST(), context); cuRewrite.getImportRemover().registerAddedImports(type); return type; }
private Type importBinding(ITypeBinding typeBinding, CompilationUnitRewrite cuRewrite) { Type type= cuRewrite.getImportRewrite().addImport(typeBinding, cuRewrite.getAST()); cuRewrite.getImportRemover().registerAddedImports(type); return type; }
public void updateNode() throws JavaModelException { ImportRewrite importRewrite= fCuRewrite.getImportRewrite(); QualifiedName name= (QualifiedName) fImportDecl.getName(); //will be removed by importRemover if not used elsewhere ... importRewrite.removeStaticImport(name.getFullyQualifiedName()); importRewrite.addStaticImport(name.getQualifier().getFullyQualifiedName(), fMethodName, false); }
private void addSimpleTypeQualification(final CompilationUnitRewrite targetRewrite, final ITypeBinding declaring, final SimpleType simpleType, final TextEditGroup group) { Assert.isNotNull(targetRewrite); Assert.isNotNull(declaring); Assert.isNotNull(simpleType); final AST ast= targetRewrite.getRoot().getAST(); if (!(simpleType.getName() instanceof QualifiedName)) { targetRewrite.getASTRewrite().replace(simpleType, ast.newQualifiedType(targetRewrite.getImportRewrite().addImport(declaring, ast), ast.newSimpleName(simpleType.getName().getFullyQualifiedName())), group); targetRewrite.getImportRemover().registerRemovedNode(simpleType); } }
private void importStatically(SimpleName toImport, IBinding binding) { String newName= fNewLocationCuRewrite.getImportRewrite().addStaticImport(binding); fNewLocationCuRewrite.getImportRemover().registerAddedStaticImport(binding); Name newReference= ASTNodeFactory.newName(fInitializerRewrite.getAST(), newName); fInitializerRewrite.replace(toImport, newReference, null); }
private void rewriteExpression(ASTNode node, Expression exp, ITypeBinding type) { ImportRewriteContext context= new ContextSensitiveImportRewriteContext(exp, fCuRewrite.getImportRewrite()); Type typeNode= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context); fCuRewrite.getASTRewrite().replace(exp, typeNode, fCuRewrite.createGroupDescription(REFERENCE_UPDATE)); fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName()); fCuRewrite.getImportRemover().registerRemovedNode(exp); fNeedsImport= true; nonStaticAccess(node); }
@Override public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException { TextEditGroup group= createTextEditGroup(FixMessages.CodeStyleFix_ChangeAccessUsingDeclaring_description, cuRewrite); if (fQualifier instanceof MethodInvocation || fQualifier instanceof ClassInstanceCreation) extractQualifier(fQualifier, cuRewrite, group); Type type= importType(fDeclaringTypeBinding, fQualifier, cuRewrite.getImportRewrite(), cuRewrite.getRoot()); cuRewrite.getASTRewrite().replace(fQualifier, type, group); }
private Type getConstantType() throws JavaModelException { if (fConstantTypeCache == null) { IExpressionFragment fragment= getSelectedExpression(); ITypeBinding typeBinding= fragment.getAssociatedExpression().resolveTypeBinding(); AST ast= fCuRewrite.getAST(); typeBinding= Bindings.normalizeForDeclarationUse(typeBinding, ast); fConstantTypeCache= fCuRewrite.getImportRewrite().addImport(typeBinding, ast); } return fConstantTypeCache; }
private void importStatically(SimpleName toImport, IBinding binding) { String newName= fNewLocationCuRewrite.getImportRewrite().addStaticImport(binding); fNewLocationCuRewrite.getImportRemover().registerAddedStaticImport(binding); Name newReference= ASTNodeFactory.newName(fInitializerRewrite.getAST(), newName); fInitializerRewrite.replace(toImport, newReference, null); }
protected void rewrite(SimpleName node, ITypeBinding type) { AST ast= node.getAST(); ImportRewriteContext context= new ContextSensitiveImportRewriteContext(node, fCuRewrite.getImportRewrite()); Type result= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST(), context); fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName()); Name dummy= ASTNodeFactory.newName(fCuRewrite.getAST(), ASTFlattener.asString(result)); QualifiedName name= ast.newQualifiedName(dummy, ast.newSimpleName(node.getIdentifier())); fCuRewrite.getASTRewrite().replace(node, name, fCuRewrite.createGroupDescription(REFERENCE_UPDATE)); fCuRewrite.getImportRemover().registerRemovedNode(node); fProcessed.add(node); fNeedsImport= true; }
public Type createType(boolean asTopLevelClass, CompilationUnitRewrite cuRewrite, int position) { String qualifier= asTopLevelClass ? fPackage : fEnclosingType; String concatenateName= JavaModelUtil.concatenateName(qualifier, fClassName); ImportRewrite importRewrite= cuRewrite.getImportRewrite(); ContextSensitiveImportRewriteContext context= createParameterClassAwareContext(asTopLevelClass, cuRewrite, position); String addedImport= importRewrite.addImport(concatenateName, context); cuRewrite.getImportRemover().registerAddedImport(addedImport); AST ast= cuRewrite.getAST(); return ast.newSimpleType(ast.newName(addedImport)); }
private Type getConstantType() throws JavaModelException { if (fConstantTypeCache == null) { IExpressionFragment fragment= getSelectedExpression(); ITypeBinding typeBinding= guessBindingForReference(fragment.getAssociatedExpression()); AST ast= fCuRewrite.getAST(); typeBinding= Bindings.normalizeForDeclarationUse(typeBinding, ast); ImportRewrite importRewrite= fCuRewrite.getImportRewrite(); ImportRewriteContext context= new ContextSensitiveImportRewriteContext(fCuRewrite.getRoot(), fSelectionStart, importRewrite); fConstantTypeCache= importRewrite.addImport(typeBinding, ast, context, TypeLocation.FIELD); } return fConstantTypeCache; }
public Type createType(boolean asTopLevelClass, CompilationUnitRewrite cuRewrite, int position) { String qualifier= asTopLevelClass ? fPackage : fEnclosingType; String concatenateName= JavaModelUtil.concatenateName(qualifier, fClassName); ImportRewrite importRewrite= cuRewrite.getImportRewrite(); ContextSensitiveImportRewriteContext context= createParameterClassAwareContext(asTopLevelClass, cuRewrite, position); String addedImport= importRewrite.addImport(concatenateName, context); cuRewrite.getImportRemover().registerAddedImport(addedImport); AST ast= cuRewrite.getAST(); return ast.newSimpleType(ast.newName(addedImport)); }
private void qualifyToTopLevelClass(SimpleName toQualify) { ITypeBinding declaringClass= getDeclaringClassBinding(toQualify); if (declaringClass == null) return; Type newQualification= fNewLocationCuRewrite.getImportRewrite().addImport(declaringClass.getErasure(), fInitializerRewrite.getAST(), fNewLocationContext); fNewLocationCuRewrite.getImportRemover().registerAddedImports(newQualification); SimpleName newToQualify= (SimpleName) fInitializerRewrite.createMoveTarget(toQualify); Type newType= fInitializerRewrite.getAST().newQualifiedType(newQualification, newToQualify); fInitializerRewrite.replace(toQualify, newType, null); }
public static Type importBinding(ITypeBinding typeBinding, CompilationUnitRewrite cuRewrite, ImportRewriteContext context, TypeLocation typeLocation) { int declaredModifiers= typeBinding.getModifiers(); AST ast= cuRewrite.getAST(); if (Modifier.isPrivate(declaredModifiers) || Modifier.isProtected(declaredModifiers)) { return ast.newSimpleType(ast.newSimpleName(typeBinding.getName())); } Type type= cuRewrite.getImportRewrite().addImport(typeBinding, cuRewrite.getAST(), context, typeLocation); cuRewrite.getImportRemover().registerAddedImports(type); return type; }
protected void rewrite(SimpleName node, ITypeBinding type) { AST ast= node.getAST(); Type result= fCuRewrite.getImportRewrite().addImport(type, fCuRewrite.getAST()); fCuRewrite.getImportRemover().registerAddedImport(type.getQualifiedName()); Name dummy= ASTNodeFactory.newName(fCuRewrite.getAST(), ASTFlattener.asString(result)); QualifiedName name= ast.newQualifiedName(dummy, ast.newSimpleName(node.getIdentifier())); fCuRewrite.getASTRewrite().replace(node, name, fCuRewrite.createGroupDescription(REFERENCE_UPDATE)); fCuRewrite.getImportRemover().registerRemovedNode(node); fProcessed.add(node); fNeedsImport= true; }