| /******************************************************************************* |
| * Copyright (c) 2000, 2011 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * N.Metchev@teamphone.com - contributed fixes for |
| * - convert anonymous to nested should sometimes declare class as static [refactoring] |
| * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=43360) |
| * - Convert anonymous to nested: should show error if field form outer anonymous type is references [refactoring] |
| * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=48282) |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.corext.refactoring.code; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| |
| import org.eclipse.ltk.core.refactoring.Change; |
| import org.eclipse.ltk.core.refactoring.Refactoring; |
| import org.eclipse.ltk.core.refactoring.RefactoringChangeDescriptor; |
| import org.eclipse.ltk.core.refactoring.RefactoringDescriptor; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jdt.core.NamingConventions; |
| import org.eclipse.jdt.core.dom.AST; |
| import org.eclipse.jdt.core.dom.ASTNode; |
| import org.eclipse.jdt.core.dom.ASTVisitor; |
| import org.eclipse.jdt.core.dom.AbstractTypeDeclaration; |
| import org.eclipse.jdt.core.dom.AnonymousClassDeclaration; |
| import org.eclipse.jdt.core.dom.ArrayCreation; |
| import org.eclipse.jdt.core.dom.ArrayInitializer; |
| import org.eclipse.jdt.core.dom.ArrayType; |
| import org.eclipse.jdt.core.dom.Assignment; |
| import org.eclipse.jdt.core.dom.BodyDeclaration; |
| import org.eclipse.jdt.core.dom.ClassInstanceCreation; |
| import org.eclipse.jdt.core.dom.CompilationUnit; |
| import org.eclipse.jdt.core.dom.Expression; |
| import org.eclipse.jdt.core.dom.FieldAccess; |
| import org.eclipse.jdt.core.dom.FieldDeclaration; |
| import org.eclipse.jdt.core.dom.IBinding; |
| import org.eclipse.jdt.core.dom.IMethodBinding; |
| import org.eclipse.jdt.core.dom.ITypeBinding; |
| import org.eclipse.jdt.core.dom.IVariableBinding; |
| import org.eclipse.jdt.core.dom.Initializer; |
| import org.eclipse.jdt.core.dom.Javadoc; |
| import org.eclipse.jdt.core.dom.MethodDeclaration; |
| import org.eclipse.jdt.core.dom.Modifier; |
| import org.eclipse.jdt.core.dom.Name; |
| import org.eclipse.jdt.core.dom.NodeFinder; |
| import org.eclipse.jdt.core.dom.ParameterizedType; |
| import org.eclipse.jdt.core.dom.QualifiedName; |
| import org.eclipse.jdt.core.dom.SimpleName; |
| import org.eclipse.jdt.core.dom.SingleVariableDeclaration; |
| import org.eclipse.jdt.core.dom.Statement; |
| import org.eclipse.jdt.core.dom.SuperConstructorInvocation; |
| import org.eclipse.jdt.core.dom.SuperFieldAccess; |
| import org.eclipse.jdt.core.dom.Type; |
| import org.eclipse.jdt.core.dom.TypeDeclaration; |
| import org.eclipse.jdt.core.dom.TypeParameter; |
| import org.eclipse.jdt.core.dom.VariableDeclarationFragment; |
| import org.eclipse.jdt.core.dom.rewrite.ASTRewrite; |
| import org.eclipse.jdt.core.dom.rewrite.ImportRewrite; |
| import org.eclipse.jdt.core.refactoring.CompilationUnitChange; |
| import org.eclipse.jdt.core.refactoring.IJavaRefactorings; |
| import org.eclipse.jdt.core.refactoring.descriptors.ConvertAnonymousDescriptor; |
| import org.eclipse.jdt.core.refactoring.descriptors.JavaRefactoringDescriptor; |
| |
| import org.eclipse.jdt.internal.core.refactoring.descriptors.RefactoringSignatureDescriptorFactory; |
| import org.eclipse.jdt.internal.corext.codemanipulation.StubUtility; |
| import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory; |
| import org.eclipse.jdt.internal.corext.dom.ASTNodes; |
| import org.eclipse.jdt.internal.corext.dom.Bindings; |
| import org.eclipse.jdt.internal.corext.dom.LinkedNodeFinder; |
| import org.eclipse.jdt.internal.corext.fix.LinkedProposalModel; |
| import org.eclipse.jdt.internal.corext.fix.LinkedProposalPositionGroup; |
| import org.eclipse.jdt.internal.corext.refactoring.Checks; |
| import org.eclipse.jdt.internal.corext.refactoring.JDTRefactoringDescriptorComment; |
| import org.eclipse.jdt.internal.corext.refactoring.JavaRefactoringArguments; |
| import org.eclipse.jdt.internal.corext.refactoring.JavaRefactoringDescriptorUtil; |
| import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages; |
| import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite; |
| import org.eclipse.jdt.internal.corext.refactoring.util.RefactoringASTParser; |
| import org.eclipse.jdt.internal.corext.refactoring.util.ResourceUtil; |
| import org.eclipse.jdt.internal.corext.util.JdtFlags; |
| import org.eclipse.jdt.internal.corext.util.Messages; |
| |
| import org.eclipse.jdt.ui.CodeGeneration; |
| import org.eclipse.jdt.ui.JavaElementLabels; |
| |
| import org.eclipse.jdt.internal.ui.text.correction.ModifierCorrectionSubProcessor; |
| import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels; |
| import org.eclipse.jdt.internal.ui.viewsupport.BindingLabelProvider; |
| |
| public class ConvertAnonymousToNestedRefactoring extends Refactoring { |
| |
| private static final String ATTRIBUTE_VISIBILITY= "visibility"; //$NON-NLS-1$ |
| private static final String ATTRIBUTE_FINAL= "final"; //$NON-NLS-1$ |
| private static final String ATTRIBUTE_STATIC= "static"; //$NON-NLS-1$ |
| |
| private static final String KEY_TYPE_NAME= "type_name"; //$NON-NLS-1$ |
| private static final String KEY_PARAM_NAME_EXT= "param_name_ext"; //$NON-NLS-1$ |
| private static final String KEY_PARAM_NAME_CONST= "param_name_const"; //$NON-NLS-1$ |
| private static final String KEY_FIELD_NAME_EXT= "field_name_ext"; //$NON-NLS-1$ |
| |
| public static class TypeVariableFinder extends ASTVisitor { |
| |
| private final Map<String, ITypeBinding> fBindings= new HashMap<String, ITypeBinding>(); |
| private final List<ITypeBinding> fFound= new ArrayList<ITypeBinding>(); |
| |
| @Override |
| public final boolean visit(final SimpleName node) { |
| Assert.isNotNull(node); |
| final ITypeBinding binding= node.resolveTypeBinding(); |
| if (binding != null && binding.isTypeVariable() && !fBindings.containsKey(binding.getKey())) { |
| fBindings.put(binding.getKey(), binding); |
| fFound.add(binding); |
| } |
| return true; |
| } |
| |
| public final ITypeBinding[] getResult() { |
| final ITypeBinding[] result= new ITypeBinding[fFound.size()]; |
| fFound.toArray(result); |
| return result; |
| } |
| } |
| |
| private int fSelectionStart; |
| private int fSelectionLength; |
| private ICompilationUnit fCu; |
| |
| private int fVisibility; /* see Modifier */ |
| private boolean fDeclareFinal= true; |
| private boolean fDeclareStatic; |
| private String fClassName= ""; //$NON-NLS-1$ |
| |
| private CompilationUnit fCompilationUnitNode; |
| private AnonymousClassDeclaration fAnonymousInnerClassNode; |
| private Set<String> fClassNamesUsed; |
| private boolean fSelfInitializing= false; |
| |
| private LinkedProposalModel fLinkedProposalModel; |
| |
| /** |
| * Creates a new convert anonymous to nested refactoring. |
| * |
| * @param unit the compilation unit, or <code>null</code> if invoked by scripting |
| * @param selectionStart start |
| * @param selectionLength length |
| */ |
| public ConvertAnonymousToNestedRefactoring(ICompilationUnit unit, int selectionStart, int selectionLength) { |
| Assert.isTrue(selectionStart >= 0); |
| Assert.isTrue(selectionLength >= 0); |
| Assert.isTrue(unit == null || unit.exists()); |
| fSelectionStart= selectionStart; |
| fSelectionLength= selectionLength; |
| fCu= unit; |
| fAnonymousInnerClassNode= null; |
| fCompilationUnitNode= null; |
| } |
| |
| public ConvertAnonymousToNestedRefactoring(AnonymousClassDeclaration declaration) { |
| Assert.isTrue(declaration != null); |
| |
| ASTNode astRoot= declaration.getRoot(); |
| Assert.isTrue(astRoot instanceof CompilationUnit); |
| fCompilationUnitNode= (CompilationUnit) astRoot; |
| |
| IJavaElement javaElement= fCompilationUnitNode.getJavaElement(); |
| Assert.isTrue(javaElement instanceof ICompilationUnit); |
| |
| fCu= (ICompilationUnit) javaElement; |
| fSelectionStart= declaration.getStartPosition(); |
| fSelectionLength= declaration.getLength(); |
| } |
| |
| public ConvertAnonymousToNestedRefactoring(JavaRefactoringArguments arguments, RefactoringStatus status) { |
| this(null, 0, 0); |
| RefactoringStatus initializeStatus= initialize(arguments); |
| status.merge(initializeStatus); |
| } |
| |
| public void setLinkedProposalModel(LinkedProposalModel linkedProposalModel) { |
| fLinkedProposalModel= linkedProposalModel; |
| } |
| |
| public int[] getAvailableVisibilities() { |
| if (isLocalInnerType()) { |
| return new int[] { Modifier.NONE }; |
| } else { |
| return new int[] { Modifier.PUBLIC, Modifier.PROTECTED, Modifier.NONE, Modifier.PRIVATE }; |
| } |
| } |
| |
| public boolean isLocalInnerType() { |
| return ASTNodes.getParent(ASTNodes.getParent(fAnonymousInnerClassNode, AbstractTypeDeclaration.class), ASTNode.ANONYMOUS_CLASS_DECLARATION) != null; |
| } |
| |
| public int getVisibility() { |
| return fVisibility; |
| } |
| |
| public void setVisibility(int visibility) { |
| Assert.isTrue(visibility == Modifier.PRIVATE || visibility == Modifier.NONE || visibility == Modifier.PROTECTED || visibility == Modifier.PUBLIC); |
| fVisibility= visibility; |
| } |
| |
| public void setClassName(String className) { |
| Assert.isNotNull(className); |
| fClassName= className; |
| } |
| |
| public boolean canEnableSettingFinal() { |
| return true; |
| } |
| |
| public boolean getDeclareFinal() { |
| return fDeclareFinal; |
| } |
| |
| public boolean getDeclareStatic() { |
| return fDeclareStatic; |
| } |
| |
| public void setDeclareFinal(boolean declareFinal) { |
| fDeclareFinal= declareFinal; |
| } |
| |
| public void setDeclareStatic(boolean declareStatic) { |
| fDeclareStatic= declareStatic; |
| } |
| |
| @Override |
| public String getName() { |
| return RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_name; |
| } |
| |
| private boolean useThisForFieldAccess() { |
| return StubUtility.useThisForFieldAccess(fCu.getJavaProject()); |
| } |
| |
| private boolean doAddComments() { |
| return StubUtility.doAddComments(fCu.getJavaProject()); |
| } |
| |
| @Override |
| public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException { |
| RefactoringStatus result= Checks.validateModifiesFiles( |
| ResourceUtil.getFiles(new ICompilationUnit[]{fCu}), |
| getValidationContext()); |
| if (result.hasFatalError()) |
| return result; |
| |
| initAST(pm); |
| |
| if (fAnonymousInnerClassNode == null) |
| return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_place_caret); |
| if (!fSelfInitializing) |
| initializeDefaults(); |
| if (getSuperConstructorBinding() == null) |
| return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_compile_errors); |
| if (getSuperTypeBinding().isLocal()) |
| return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_extends_local_class); |
| return new RefactoringStatus(); |
| } |
| |
| private void initializeDefaults() { |
| fVisibility= isLocalInnerType() ? Modifier.NONE : Modifier.PRIVATE; |
| fDeclareStatic = mustInnerClassBeStatic(); |
| } |
| |
| private void initAST(IProgressMonitor pm) { |
| if (fCompilationUnitNode == null) { |
| fCompilationUnitNode= RefactoringASTParser.parseWithASTProvider(fCu, true, pm); |
| } |
| if (fAnonymousInnerClassNode == null) { |
| fAnonymousInnerClassNode= getAnonymousInnerClass(NodeFinder.perform(fCompilationUnitNode, fSelectionStart, fSelectionLength)); |
| } |
| if (fAnonymousInnerClassNode != null) { |
| final AbstractTypeDeclaration declaration= (AbstractTypeDeclaration) ASTNodes.getParent(fAnonymousInnerClassNode, AbstractTypeDeclaration.class); |
| if (declaration instanceof TypeDeclaration) { |
| final AbstractTypeDeclaration[] nested= ((TypeDeclaration) declaration).getTypes(); |
| fClassNamesUsed= new HashSet<String>(nested.length); |
| for (int index= 0; index < nested.length; index++) |
| fClassNamesUsed.add(nested[index].getName().getIdentifier()); |
| } else |
| fClassNamesUsed= Collections.emptySet(); |
| } |
| } |
| |
| private static AnonymousClassDeclaration getAnonymousInnerClass(ASTNode node) { |
| if (node == null) |
| return null; |
| if (node instanceof AnonymousClassDeclaration) |
| return (AnonymousClassDeclaration)node; |
| if (node instanceof ClassInstanceCreation) { |
| AnonymousClassDeclaration anon= ((ClassInstanceCreation)node).getAnonymousClassDeclaration(); |
| if (anon != null) |
| return anon; |
| } |
| node= ASTNodes.getNormalizedNode(node); |
| if (node.getLocationInParent() == ClassInstanceCreation.TYPE_PROPERTY) { |
| AnonymousClassDeclaration anon= ((ClassInstanceCreation)node.getParent()).getAnonymousClassDeclaration(); |
| if (anon != null) |
| return anon; |
| } |
| return (AnonymousClassDeclaration)ASTNodes.getParent(node, AnonymousClassDeclaration.class); |
| } |
| |
| public RefactoringStatus validateInput() { |
| RefactoringStatus result= Checks.checkTypeName(fClassName, fCu); |
| if (result.hasFatalError()) |
| return result; |
| |
| if (fClassNamesUsed.contains(fClassName)) |
| return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_type_exists); |
| IMethodBinding superConstructorBinding = getSuperConstructorBinding(); |
| if (superConstructorBinding == null) |
| return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_compile_errors); |
| if (fClassName.equals(superConstructorBinding.getDeclaringClass().getName())) |
| return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_another_name); |
| if (classNameHidesEnclosingType()) |
| return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_name_hides); |
| return result; |
| } |
| |
| private boolean accessesAnonymousFields() { |
| List<IVariableBinding> anonymousInnerFieldTypes = getAllEnclosingAnonymousTypesField(); |
| List<IBinding> accessedField = getAllAccessedFields(); |
| final Iterator<IVariableBinding> it = anonymousInnerFieldTypes.iterator(); |
| while(it.hasNext()) { |
| final IVariableBinding variableBinding = it.next(); |
| final Iterator<IBinding> it2 = accessedField.iterator(); |
| while (it2.hasNext()) { |
| IVariableBinding variableBinding2 = (IVariableBinding) it2.next(); |
| if(Bindings.equals(variableBinding, variableBinding2)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| private List<IBinding> getAllAccessedFields() { |
| final List<IBinding> accessedFields= new ArrayList<IBinding>(); |
| |
| ASTVisitor visitor= new ASTVisitor() { |
| |
| @Override |
| public boolean visit(FieldAccess node) { |
| final IVariableBinding binding= node.resolveFieldBinding(); |
| if (binding != null && !binding.isEnumConstant()) |
| accessedFields.add(binding); |
| return super.visit(node); |
| } |
| |
| @Override |
| public boolean visit(QualifiedName node) { |
| final IBinding binding= node.resolveBinding(); |
| if (binding != null && binding instanceof IVariableBinding) { |
| IVariableBinding variable= (IVariableBinding) binding; |
| if (!variable.isEnumConstant() && variable.isField()) |
| accessedFields.add(binding); |
| } |
| return super.visit(node); |
| } |
| |
| @Override |
| public boolean visit(SimpleName node) { |
| final IBinding binding= node.resolveBinding(); |
| if (binding != null && binding instanceof IVariableBinding) { |
| IVariableBinding variable= (IVariableBinding) binding; |
| if (!variable.isEnumConstant() && variable.isField()) |
| accessedFields.add(binding); |
| } |
| return super.visit(node); |
| } |
| |
| @Override |
| public boolean visit(SuperFieldAccess node) { |
| final IVariableBinding binding= node.resolveFieldBinding(); |
| if (binding != null && !binding.isEnumConstant()) |
| accessedFields.add(binding); |
| return super.visit(node); |
| } |
| }; |
| fAnonymousInnerClassNode.accept(visitor); |
| |
| return accessedFields; |
| } |
| |
| private List<IVariableBinding> getAllEnclosingAnonymousTypesField() { |
| final List<IVariableBinding> ans= new ArrayList<IVariableBinding>(); |
| final AbstractTypeDeclaration declaration= (AbstractTypeDeclaration) ASTNodes.getParent(fAnonymousInnerClassNode, AbstractTypeDeclaration.class); |
| AnonymousClassDeclaration anonymous= (AnonymousClassDeclaration) ASTNodes.getParent(fAnonymousInnerClassNode, ASTNode.ANONYMOUS_CLASS_DECLARATION); |
| while (anonymous != null) { |
| if (ASTNodes.isParent(anonymous, declaration)) { |
| ITypeBinding binding= anonymous.resolveBinding(); |
| if (binding != null) { |
| ans.addAll(Arrays.asList(binding.getDeclaredFields())); |
| } |
| } else { |
| break; |
| } |
| anonymous= (AnonymousClassDeclaration) ASTNodes.getParent(anonymous, ASTNode.ANONYMOUS_CLASS_DECLARATION); |
| } |
| return ans; |
| } |
| |
| private boolean classNameHidesEnclosingType() { |
| ITypeBinding type= ((AbstractTypeDeclaration) ASTNodes.getParent(fAnonymousInnerClassNode, AbstractTypeDeclaration.class)).resolveBinding(); |
| while (type != null) { |
| if (fClassName.equals(type.getName())) |
| return true; |
| type= type.getDeclaringClass(); |
| } |
| return false; |
| } |
| |
| /* |
| * @see org.eclipse.jdt.internal.corext.refactoring.base.Refactoring#checkInput(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| @Override |
| public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException { |
| try { |
| RefactoringStatus status= validateInput(); |
| if (accessesAnonymousFields()) |
| status.merge(RefactoringStatus.createErrorStatus(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_anonymous_field_access)); |
| return status; |
| } finally { |
| pm.done(); |
| } |
| } |
| |
| public CompilationUnitChange createCompilationUnitChange(IProgressMonitor pm) throws CoreException { |
| final CompilationUnitRewrite rewrite= new CompilationUnitRewrite(fCu, fCompilationUnitNode); |
| final ITypeBinding[] typeParameters= getTypeParameters(); |
| addNestedClass(rewrite, typeParameters); |
| modifyConstructorCall(rewrite, typeParameters); |
| return rewrite.createChange(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_name, false, pm); |
| } |
| |
| |
| /* |
| * @see org.eclipse.jdt.internal.corext.refactoring.base.IRefactoring#createChange(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| @Override |
| public Change createChange(IProgressMonitor pm) throws CoreException { |
| final CompilationUnitChange result= createCompilationUnitChange(pm); |
| result.setDescriptor(createRefactoringDescriptor()); |
| return result; |
| } |
| |
| private ITypeBinding[] getTypeParameters() { |
| final List<ITypeBinding> parameters= new ArrayList<ITypeBinding>(4); |
| final ClassInstanceCreation creation= (ClassInstanceCreation) fAnonymousInnerClassNode.getParent(); |
| if (fDeclareStatic) { |
| final TypeVariableFinder finder= new TypeVariableFinder(); |
| creation.accept(finder); |
| return finder.getResult(); |
| } else { |
| final MethodDeclaration declaration= getEnclosingMethodDeclaration(creation); |
| if (declaration != null) { |
| ITypeBinding binding= null; |
| TypeParameter parameter= null; |
| for (final Iterator<TypeParameter> iterator= declaration.typeParameters().iterator(); iterator.hasNext();) { |
| parameter= iterator.next(); |
| binding= parameter.resolveBinding(); |
| if (binding != null) |
| parameters.add(binding); |
| } |
| } |
| } |
| final TypeVariableFinder finder= new TypeVariableFinder(); |
| creation.accept(finder); |
| final ITypeBinding[] variables= finder.getResult(); |
| final List<ITypeBinding> remove= new ArrayList<ITypeBinding>(4); |
| boolean match= false; |
| ITypeBinding binding= null; |
| ITypeBinding variable= null; |
| for (final Iterator<ITypeBinding> iterator= parameters.iterator(); iterator.hasNext();) { |
| match= false; |
| binding= iterator.next(); |
| for (int index= 0; index < variables.length; index++) { |
| variable= variables[index]; |
| if (variable.equals(binding)) |
| match= true; |
| } |
| if (!match) |
| remove.add(binding); |
| } |
| parameters.removeAll(remove); |
| final ITypeBinding[] result= new ITypeBinding[parameters.size()]; |
| parameters.toArray(result); |
| return result; |
| } |
| |
| private MethodDeclaration getEnclosingMethodDeclaration(ASTNode node) { |
| ASTNode parent= node.getParent(); |
| if (parent != null) { |
| if (parent instanceof AbstractTypeDeclaration) |
| return null; |
| else if (parent instanceof MethodDeclaration) |
| return (MethodDeclaration) parent; |
| return getEnclosingMethodDeclaration(parent); |
| } |
| return null; |
| } |
| |
| private RefactoringChangeDescriptor createRefactoringDescriptor() { |
| final ITypeBinding binding= fAnonymousInnerClassNode.resolveBinding(); |
| final String[] labels= new String[] { BindingLabelProvider.getBindingLabel(binding, JavaElementLabels.ALL_FULLY_QUALIFIED), BindingLabelProvider.getBindingLabel(binding.getDeclaringMethod(), JavaElementLabels.ALL_FULLY_QUALIFIED)}; |
| final Map<String, String> arguments= new HashMap<String, String>(); |
| final String projectName= fCu.getJavaProject().getElementName(); |
| final int flags= RefactoringDescriptor.STRUCTURAL_CHANGE | JavaRefactoringDescriptor.JAR_REFACTORING | JavaRefactoringDescriptor.JAR_SOURCE_ATTACHMENT; |
| final String description= RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_descriptor_description_short; |
| final String header= Messages.format(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_descriptor_description, labels); |
| final JDTRefactoringDescriptorComment comment= new JDTRefactoringDescriptorComment(projectName, this, header); |
| comment.addSetting(Messages.format(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_original_pattern, BindingLabelProvider.getBindingLabel(binding, JavaElementLabels.ALL_FULLY_QUALIFIED))); |
| comment.addSetting(Messages.format(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_class_name_pattern, BasicElementLabels.getJavaElementName(fClassName))); |
| String visibility= JdtFlags.getVisibilityString(fVisibility); |
| if (visibility.length() == 0) |
| visibility= RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_default_visibility; |
| comment.addSetting(Messages.format(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_visibility_pattern, visibility)); |
| if (fDeclareFinal && fDeclareStatic) |
| comment.addSetting(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_declare_final_static); |
| else if (fDeclareFinal) |
| comment.addSetting(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_declare_final); |
| else if (fDeclareStatic) |
| comment.addSetting(RefactoringCoreMessages.ConvertAnonymousToNestedRefactoring_declare_static); |
| arguments.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT, JavaRefactoringDescriptorUtil.elementToHandle(projectName, fCu)); |
| arguments.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_NAME, fClassName); |
| arguments.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION, new Integer(fSelectionStart).toString() + ' ' + new Integer(fSelectionLength).toString()); |
| arguments.put(ATTRIBUTE_FINAL, Boolean.valueOf(fDeclareFinal).toString()); |
| arguments.put(ATTRIBUTE_STATIC, Boolean.valueOf(fDeclareStatic).toString()); |
| arguments.put(ATTRIBUTE_VISIBILITY, new Integer(fVisibility).toString()); |
| |
| ConvertAnonymousDescriptor descriptor= RefactoringSignatureDescriptorFactory.createConvertAnonymousDescriptor(projectName, description, comment.asString(), arguments, flags); |
| return new RefactoringChangeDescriptor(descriptor); |
| } |
| |
| private void modifyConstructorCall(CompilationUnitRewrite rewrite, ITypeBinding[] parameters) { |
| rewrite.getASTRewrite().replace(fAnonymousInnerClassNode.getParent(), createNewClassInstanceCreation(rewrite, parameters), null); |
| } |
| |
| private ASTNode createNewClassInstanceCreation(CompilationUnitRewrite rewrite, ITypeBinding[] parameters) { |
| AST ast= fAnonymousInnerClassNode.getAST(); |
| ClassInstanceCreation newClassCreation= ast.newClassInstanceCreation(); |
| newClassCreation.setAnonymousClassDeclaration(null); |
| Type type= null; |
| SimpleName newNameNode= ast.newSimpleName(fClassName); |
| if (parameters.length > 0) { |
| final ParameterizedType parameterized= ast.newParameterizedType(ast.newSimpleType(newNameNode)); |
| for (int index= 0; index < parameters.length; index++) |
| parameterized.typeArguments().add(ast.newSimpleType(ast.newSimpleName(parameters[index].getName()))); |
| type= parameterized; |
| } else |
| type= ast.newSimpleType(newNameNode); |
| newClassCreation.setType(type); |
| copyArguments(rewrite, newClassCreation); |
| addArgumentsForLocalsUsedInInnerClass(newClassCreation); |
| |
| addLinkedPosition(KEY_TYPE_NAME, newNameNode, rewrite.getASTRewrite(), true); |
| |
| return newClassCreation; |
| } |
| |
| private void addArgumentsForLocalsUsedInInnerClass(ClassInstanceCreation newClassCreation) { |
| IVariableBinding[] usedLocals= getUsedLocalVariables(); |
| for (int i= 0; i < usedLocals.length; i++) { |
| final AST ast= fAnonymousInnerClassNode.getAST(); |
| final IVariableBinding binding= usedLocals[i]; |
| Name name= null; |
| if (binding.isEnumConstant()) |
| name= ast.newQualifiedName(ast.newSimpleName(binding.getDeclaringClass().getName()), ast.newSimpleName(binding.getName())); |
| else |
| name= ast.newSimpleName(binding.getName()); |
| newClassCreation.arguments().add(name); |
| } |
| } |
| |
| private void copyArguments(CompilationUnitRewrite rewrite, ClassInstanceCreation newClassCreation) { |
| Iterator<Expression> iter= ((ClassInstanceCreation) fAnonymousInnerClassNode.getParent()).arguments().iterator(); |
| if (!iter.hasNext()) |
| return; |
| |
| IMethodBinding superConstructorBinding= getSuperConstructorBinding(); |
| ITypeBinding[] parameterTypes= superConstructorBinding.getParameterTypes(); |
| |
| List<Expression> arguments= newClassCreation.arguments(); |
| ASTRewrite astRewrite= rewrite.getASTRewrite(); |
| int last= parameterTypes.length - 1; |
| |
| for (int i= 0; i < last; i++) { |
| arguments.add((Expression) astRewrite.createCopyTarget(iter.next())); |
| } |
| if (superConstructorBinding.isVarargs()) { |
| AST ast= astRewrite.getAST(); |
| ArrayCreation arrayCreation= ast.newArrayCreation(); |
| arrayCreation.setType((ArrayType) rewrite.getImportRewrite().addImport(parameterTypes[last], ast)); |
| ArrayInitializer initializer= ast.newArrayInitializer(); |
| arrayCreation.setInitializer(initializer); |
| arguments.add(arrayCreation); |
| arguments= initializer.expressions(); |
| } |
| while (iter.hasNext()) { |
| arguments.add((Expression) astRewrite.createCopyTarget(iter.next())); |
| } |
| } |
| |
| private void addNestedClass(CompilationUnitRewrite rewrite, ITypeBinding[] typeParameters) throws CoreException { |
| final AbstractTypeDeclaration declarations= (AbstractTypeDeclaration) ASTNodes.getParent(fAnonymousInnerClassNode, AbstractTypeDeclaration.class); |
| int index= findIndexOfFistNestedClass(declarations.bodyDeclarations()); |
| if (index == -1) |
| index= 0; |
| rewrite.getASTRewrite().getListRewrite(declarations, declarations.getBodyDeclarationsProperty()).insertAt(createNewNestedClass(rewrite, typeParameters), index, null); |
| } |
| |
| private static int findIndexOfFistNestedClass(List<BodyDeclaration> list) { |
| for (int i= 0, n= list.size(); i < n; i++) { |
| BodyDeclaration each= list.get(i); |
| if (isNestedType(each)) |
| return i; |
| } |
| return -1; |
| } |
| |
| private static boolean isNestedType(BodyDeclaration each) { |
| if (!(each instanceof AbstractTypeDeclaration)) |
| return false; |
| return (each.getParent() instanceof AbstractTypeDeclaration); |
| } |
| |
| private AbstractTypeDeclaration createNewNestedClass(CompilationUnitRewrite rewrite, ITypeBinding[] typeParameters) throws CoreException { |
| final AST ast= fAnonymousInnerClassNode.getAST(); |
| |
| final TypeDeclaration newDeclaration= ast.newTypeDeclaration(); |
| newDeclaration.setInterface(false); |
| newDeclaration.setJavadoc(null); |
| newDeclaration.modifiers().addAll(ASTNodeFactory.newModifiers(ast, createModifiersForNestedClass())); |
| newDeclaration.setName(ast.newSimpleName(fClassName)); |
| |
| TypeParameter parameter= null; |
| for (int index= 0; index < typeParameters.length; index++) { |
| parameter= ast.newTypeParameter(); |
| parameter.setName(ast.newSimpleName(typeParameters[index].getName())); |
| newDeclaration.typeParameters().add(parameter); |
| } |
| setSuperType(newDeclaration); |
| |
| IJavaProject project= fCu.getJavaProject(); |
| |
| IVariableBinding[] bindings= getUsedLocalVariables(); |
| ArrayList<String> fieldNames= new ArrayList<String>(); |
| for (int i= 0; i < bindings.length; i++) { |
| String name= StubUtility.getBaseName(bindings[i], project); |
| String[] fieldNameProposals= StubUtility.getVariableNameSuggestions(NamingConventions.VK_INSTANCE_FIELD, project, name, 0, fieldNames, true); |
| fieldNames.add(fieldNameProposals[0]); |
| |
| |
| if (fLinkedProposalModel != null) { |
| LinkedProposalPositionGroup positionGroup= fLinkedProposalModel.getPositionGroup(KEY_FIELD_NAME_EXT + i, true); |
| for (int k= 0; k < fieldNameProposals.length; k++) { |
| positionGroup.addProposal(fieldNameProposals[k], null, fieldNameProposals.length - k); |
| } |
| } |
| } |
| String[] allFieldNames= fieldNames.toArray(new String[fieldNames.size()]); |
| |
| List<BodyDeclaration> newBodyDeclarations= newDeclaration.bodyDeclarations(); |
| |
| createFieldsForAccessedLocals(rewrite, bindings, allFieldNames, newBodyDeclarations); |
| |
| MethodDeclaration newConstructorDecl= createNewConstructor(rewrite, bindings, allFieldNames); |
| if (newConstructorDecl != null) { |
| newBodyDeclarations.add(newConstructorDecl); |
| } |
| |
| updateAndMoveBodyDeclarations(rewrite, bindings, allFieldNames, newBodyDeclarations, newConstructorDecl); |
| |
| if (doAddComments()) { |
| String[] parameterNames= new String[typeParameters.length]; |
| for (int index= 0; index < parameterNames.length; index++) { |
| parameterNames[index]= typeParameters[index].getName(); |
| } |
| String string= CodeGeneration.getTypeComment(rewrite.getCu(), fClassName, parameterNames, StubUtility.getLineDelimiterUsed(fCu)); |
| if (string != null) { |
| Javadoc javadoc= (Javadoc) rewrite.getASTRewrite().createStringPlaceholder(string, ASTNode.JAVADOC); |
| newDeclaration.setJavadoc(javadoc); |
| } |
| } |
| if (fLinkedProposalModel != null) { |
| addLinkedPosition(KEY_TYPE_NAME, newDeclaration.getName(), rewrite.getASTRewrite(), false); |
| ModifierCorrectionSubProcessor.installLinkedVisibilityProposals(fLinkedProposalModel, rewrite.getASTRewrite(), newDeclaration.modifiers(), false); |
| } |
| |
| return newDeclaration; |
| } |
| |
| private void updateAndMoveBodyDeclarations(CompilationUnitRewrite rewriter, IVariableBinding[] bindings, String[] fieldNames, List<BodyDeclaration> newBodyDeclarations, MethodDeclaration newConstructorDecl) { |
| final ASTRewrite astRewrite= rewriter.getASTRewrite(); |
| final AST ast= astRewrite.getAST(); |
| |
| final boolean useThisAccess= useThisForFieldAccess(); |
| |
| int fieldInsertIndex= newConstructorDecl != null ? newBodyDeclarations.lastIndexOf(newConstructorDecl) : newBodyDeclarations.size(); |
| |
| for (Iterator<BodyDeclaration> iterator= fAnonymousInnerClassNode.bodyDeclarations().iterator(); iterator.hasNext();) { |
| BodyDeclaration body= iterator.next(); |
| |
| for (int i= 0; i < bindings.length; i++) { |
| SimpleName[] names= LinkedNodeFinder.findByBinding(body, bindings[i]); |
| String fieldName= fieldNames[i]; |
| for (int k= 0; k < names.length; k++) { |
| SimpleName newNode= ast.newSimpleName(fieldName); |
| if (useThisAccess) { |
| FieldAccess access= ast.newFieldAccess(); |
| access.setExpression(ast.newThisExpression()); |
| access.setName(newNode); |
| astRewrite.replace(names[k], access, null); |
| } else { |
| astRewrite.replace(names[k], newNode, null); |
| } |
| addLinkedPosition(KEY_FIELD_NAME_EXT + i, newNode, astRewrite, false); |
| } |
| } |
| if (body instanceof Initializer || body instanceof FieldDeclaration) { |
| newBodyDeclarations.add(fieldInsertIndex++, (BodyDeclaration) astRewrite.createMoveTarget(body)); |
| } else { |
| newBodyDeclarations.add((BodyDeclaration) astRewrite.createMoveTarget(body)); |
| } |
| } |
| |
| if (newConstructorDecl != null) { |
| // move initialization of existing fields to constructor if an outer is referenced |
| List<Statement> bodyStatements= newConstructorDecl.getBody().statements(); |
| |
| List<VariableDeclarationFragment> fieldsToInitializeInConstructor= getFieldsToInitializeInConstructor(); |
| for (Iterator<VariableDeclarationFragment> iter= fieldsToInitializeInConstructor.iterator(); iter.hasNext();) { |
| VariableDeclarationFragment fragment= iter.next(); |
| Expression initializer= fragment.getInitializer(); |
| Expression replacement= (Expression) astRewrite.get(fragment, VariableDeclarationFragment.INITIALIZER_PROPERTY); |
| if (replacement == initializer) { |
| replacement= (Expression) astRewrite.createMoveTarget(initializer); |
| } |
| astRewrite.remove(initializer, null); |
| SimpleName fieldNameNode= ast.newSimpleName(fragment.getName().getIdentifier()); |
| bodyStatements.add(newFieldAssignment(ast, fieldNameNode, replacement, useThisAccess)); |
| } |
| } |
| } |
| |
| private void createFieldsForAccessedLocals(CompilationUnitRewrite rewrite, IVariableBinding[] varBindings, String[] fieldNames, List<BodyDeclaration> newBodyDeclarations) throws CoreException { |
| final ImportRewrite importRewrite= rewrite.getImportRewrite(); |
| final ASTRewrite astRewrite= rewrite.getASTRewrite(); |
| final AST ast= astRewrite.getAST(); |
| |
| for (int i= 0; i < varBindings.length; i++) { |
| VariableDeclarationFragment fragment= ast.newVariableDeclarationFragment(); |
| fragment.setExtraDimensions(0); |
| fragment.setInitializer(null); |
| fragment.setName(ast.newSimpleName(fieldNames[i])); |
| FieldDeclaration field= ast.newFieldDeclaration(fragment); |
| ITypeBinding varType= varBindings[i].getType(); |
| field.setType(importRewrite.addImport(varType, ast)); |
| field.modifiers().addAll(ASTNodeFactory.newModifiers(ast, Modifier.PRIVATE | Modifier.FINAL)); |
| if (doAddComments()) { |
| String string= CodeGeneration.getFieldComment(rewrite.getCu(), varType.getName(), fieldNames[i], StubUtility.getLineDelimiterUsed(fCu)); |
| if (string != null) { |
| Javadoc javadoc= (Javadoc) astRewrite.createStringPlaceholder(string, ASTNode.JAVADOC); |
| field.setJavadoc(javadoc); |
| } |
| } |
| |
| newBodyDeclarations.add(field); |
| |
| addLinkedPosition(KEY_FIELD_NAME_EXT + i, fragment.getName(), astRewrite, false); |
| } |
| } |
| |
| private void addLinkedPosition(String key, ASTNode nodeToTrack, ASTRewrite rewrite, boolean isFirst) { |
| if (fLinkedProposalModel != null) { |
| fLinkedProposalModel.getPositionGroup(key, true).addPosition(rewrite.track(nodeToTrack), isFirst); |
| } |
| } |
| |
| |
| private IVariableBinding[] getUsedLocalVariables() { |
| final Set<IBinding> result= new HashSet<IBinding>(0); |
| collectRefrencedVariables(fAnonymousInnerClassNode, result); |
| ArrayList<IVariableBinding> usedLocals= new ArrayList<IVariableBinding>(); |
| for (Iterator<IBinding> iterator= result.iterator(); iterator.hasNext();) { |
| IVariableBinding next= (IVariableBinding) iterator.next(); |
| if (isBindingToTemp(next)) { |
| usedLocals.add(next); |
| } |
| } |
| return usedLocals.toArray(new IVariableBinding[usedLocals.size()]); |
| } |
| |
| private void collectRefrencedVariables(ASTNode root, final Set<IBinding> result) { |
| root.accept(new ASTVisitor() { |
| @Override |
| public boolean visit(SimpleName node) { |
| IBinding binding= node.resolveBinding(); |
| if (binding instanceof IVariableBinding) |
| result.add(binding); |
| return true; |
| } |
| }); |
| } |
| |
| private boolean isBindingToTemp(IVariableBinding variable) { |
| if (variable.isField()) |
| return false; |
| if (!Modifier.isFinal(variable.getModifiers())) |
| return false; |
| ASTNode declaringNode= fCompilationUnitNode.findDeclaringNode(variable); |
| if (declaringNode == null) |
| return false; |
| if (ASTNodes.isParent(declaringNode, fAnonymousInnerClassNode)) |
| return false; |
| return true; |
| } |
| |
| private MethodDeclaration createNewConstructor(CompilationUnitRewrite rewrite, IVariableBinding[] bindings, String[] fieldNames) throws JavaModelException { |
| ClassInstanceCreation instanceCreation= (ClassInstanceCreation) fAnonymousInnerClassNode.getParent(); |
| |
| if (instanceCreation.arguments().isEmpty() && bindings.length == 0) |
| return null; |
| |
| IJavaProject project= fCu.getJavaProject(); |
| AST ast= rewrite.getAST(); |
| ImportRewrite importRewrite= rewrite.getImportRewrite(); |
| ASTRewrite astRewrite= rewrite.getASTRewrite(); |
| |
| MethodDeclaration newConstructor= ast.newMethodDeclaration(); |
| newConstructor.setConstructor(true); |
| newConstructor.setExtraDimensions(0); |
| newConstructor.setJavadoc(null); |
| newConstructor.modifiers().addAll(ASTNodeFactory.newModifiers(ast, fVisibility)); |
| newConstructor.setName(ast.newSimpleName(fClassName)); |
| addLinkedPosition(KEY_TYPE_NAME, newConstructor.getName(), astRewrite, false); |
| |
| newConstructor.setBody(ast.newBlock()); |
| |
| List<Statement> newStatements= newConstructor.getBody().statements(); |
| |
| List<SingleVariableDeclaration> newParameters= newConstructor.parameters(); |
| List<String> newParameterNames= new ArrayList<String>(); |
| |
| // add parameters for elements passed with the instance creation |
| if (!instanceCreation.arguments().isEmpty()) { |
| IMethodBinding constructorBinding= getSuperConstructorBinding(); |
| if (constructorBinding != null) { |
| SuperConstructorInvocation superConstructorInvocation= ast.newSuperConstructorInvocation(); |
| ITypeBinding[] parameterTypes= constructorBinding.getParameterTypes(); |
| String[][] parameterNames= StubUtility.suggestArgumentNamesWithProposals(project, constructorBinding); |
| for (int i= 0; i < parameterNames.length; i++) { |
| String[] nameProposals= parameterNames[i]; |
| String paramName= nameProposals[0]; |
| |
| SingleVariableDeclaration param= newParameterDeclaration(ast, importRewrite, paramName, parameterTypes[i]); |
| newParameters.add(param); |
| newParameterNames.add(paramName); |
| |
| SimpleName newSIArgument= ast.newSimpleName(paramName); |
| superConstructorInvocation.arguments().add(newSIArgument); |
| |
| if (fLinkedProposalModel != null) { |
| LinkedProposalPositionGroup positionGroup= fLinkedProposalModel.getPositionGroup(KEY_PARAM_NAME_CONST+ String.valueOf(i), true); |
| positionGroup.addPosition(astRewrite.track(param.getName()), false); |
| positionGroup.addPosition(astRewrite.track(newSIArgument), false); |
| for (int k= 0; k < nameProposals.length; k++) { |
| positionGroup.addProposal(nameProposals[k], null, nameProposals.length - k); |
| } |
| } |
| } |
| newStatements.add(superConstructorInvocation); |
| } |
| } |
| // add parameters for all outer variables used |
| boolean useThisAccess= useThisForFieldAccess(); |
| for (int i= 0; i < bindings.length; i++) { |
| String baseName= StubUtility.getBaseName(bindings[i], project); |
| String[] paramNameProposals= StubUtility.getVariableNameSuggestions(NamingConventions.VK_PARAMETER, project, baseName, 0, newParameterNames, true); |
| String paramName= paramNameProposals[0]; |
| |
| SingleVariableDeclaration param= newParameterDeclaration(ast, importRewrite, paramName, bindings[i].getType()); |
| newParameters.add(param); |
| newParameterNames.add(paramName); |
| |
| String fieldName= fieldNames[i]; |
| SimpleName fieldNameNode= ast.newSimpleName(fieldName); |
| SimpleName paramNameNode= ast.newSimpleName(paramName); |
| newStatements.add(newFieldAssignment(ast, fieldNameNode, paramNameNode, useThisAccess || newParameterNames.contains(fieldName))); |
| |
| if (fLinkedProposalModel != null) { |
| LinkedProposalPositionGroup positionGroup= fLinkedProposalModel.getPositionGroup(KEY_PARAM_NAME_EXT+ String.valueOf(i), true); |
| positionGroup.addPosition(astRewrite.track(param.getName()), false); |
| positionGroup.addPosition(astRewrite.track(paramNameNode), false); |
| for (int k= 0; k < paramNameProposals.length; k++) { |
| positionGroup.addProposal(paramNameProposals[k], null, paramNameProposals.length - k); |
| } |
| |
| fLinkedProposalModel.getPositionGroup(KEY_FIELD_NAME_EXT + i, true).addPosition(astRewrite.track(fieldNameNode), false); |
| } |
| } |
| |
| addExceptionsToNewConstructor(newConstructor); |
| |
| if (doAddComments()) { |
| try { |
| String[] allParamNames= newParameterNames.toArray(new String[newParameterNames.size()]); |
| String string= CodeGeneration.getMethodComment(fCu, fClassName, fClassName, allParamNames, new String[0], null, new String[0], null, StubUtility.getLineDelimiterUsed(fCu)); |
| if (string != null) { |
| Javadoc javadoc= (Javadoc) astRewrite.createStringPlaceholder(string, ASTNode.JAVADOC); |
| newConstructor.setJavadoc(javadoc); |
| } |
| } catch (CoreException exception) { |
| throw new JavaModelException(exception); |
| } |
| } |
| return newConstructor; |
| } |
| |
| private Statement newFieldAssignment(AST ast, SimpleName fieldNameNode, Expression initializer, boolean useThisAccess) { |
| Assignment assignment= ast.newAssignment(); |
| if (useThisAccess) { |
| FieldAccess access= ast.newFieldAccess(); |
| access.setExpression(ast.newThisExpression()); |
| access.setName(fieldNameNode); |
| assignment.setLeftHandSide(access); |
| } else { |
| assignment.setLeftHandSide(fieldNameNode); |
| } |
| assignment.setOperator(Assignment.Operator.ASSIGN); |
| assignment.setRightHandSide(initializer); |
| |
| return ast.newExpressionStatement(assignment); |
| } |
| |
| |
| // live List of VariableDeclarationFragments |
| private List<VariableDeclarationFragment> getFieldsToInitializeInConstructor() { |
| List<VariableDeclarationFragment> result= new ArrayList<VariableDeclarationFragment>(0); |
| for (Iterator<BodyDeclaration> iter= fAnonymousInnerClassNode.bodyDeclarations().iterator(); iter.hasNext(); ) { |
| Object element= iter.next(); |
| if (element instanceof FieldDeclaration) { |
| List<VariableDeclarationFragment> fragments= ((FieldDeclaration) element).fragments(); |
| for (Iterator<VariableDeclarationFragment> fragmentIter= fragments.iterator(); fragmentIter.hasNext(); ) { |
| VariableDeclarationFragment fragment= fragmentIter.next(); |
| if (isToBeInitializerInConstructor(fragment, result)) |
| result.add(fragment); |
| } |
| } |
| } |
| return result; |
| } |
| |
| private boolean isToBeInitializerInConstructor(VariableDeclarationFragment fragment, List<VariableDeclarationFragment> fieldsToInitialize) { |
| return fragment.getInitializer() != null && areLocalsUsedIn(fragment.getInitializer(), fieldsToInitialize); |
| } |
| |
| private boolean areLocalsUsedIn(Expression fieldInitializer, List<VariableDeclarationFragment> fieldsToInitialize) { |
| Set<IBinding> localsUsed= new HashSet<IBinding>(0); |
| collectRefrencedVariables(fieldInitializer, localsUsed); |
| |
| ITypeBinding anonType= fAnonymousInnerClassNode.resolveBinding(); |
| |
| for (Iterator<IBinding> iterator= localsUsed.iterator(); iterator.hasNext();) { |
| IVariableBinding curr= (IVariableBinding) iterator.next(); |
| if (isBindingToTemp(curr)) { // reference a local from outside |
| return true; |
| } else if (curr.isField() && (curr.getDeclaringClass() == anonType) && fieldsToInitialize.contains(fCompilationUnitNode.findDeclaringNode(curr))) { |
| return true; // references a field that references a local from outside |
| } |
| } |
| return false; |
| } |
| |
| private IMethodBinding getSuperConstructorBinding() { |
| //workaround for missing java core functionality - finding a |
| // super constructor for an anonymous class creation |
| IMethodBinding anonConstr= ((ClassInstanceCreation) fAnonymousInnerClassNode.getParent()).resolveConstructorBinding(); |
| if (anonConstr == null) |
| return null; |
| ITypeBinding superClass= anonConstr.getDeclaringClass().getSuperclass(); |
| IMethodBinding[] superMethods= superClass.getDeclaredMethods(); |
| for (int i= 0; i < superMethods.length; i++) { |
| IMethodBinding superMethod= superMethods[i]; |
| if (superMethod.isConstructor() && parameterTypesMatch(superMethod, anonConstr)) |
| return superMethod; |
| } |
| Assert.isTrue(false);//there's no way - it must be there |
| return null; |
| } |
| |
| private static boolean parameterTypesMatch(IMethodBinding m1, IMethodBinding m2) { |
| ITypeBinding[] m1Params= m1.getParameterTypes(); |
| ITypeBinding[] m2Params= m2.getParameterTypes(); |
| if (m1Params.length != m2Params.length) |
| return false; |
| for (int i= 0; i < m2Params.length; i++) { |
| if (!m1Params[i].equals(m2Params[i])) |
| return false; |
| } |
| return true; |
| } |
| |
| private void addExceptionsToNewConstructor(MethodDeclaration newConstructor) { |
| IMethodBinding constructorBinding= getSuperConstructorBinding(); |
| if (constructorBinding == null) |
| return; |
| ITypeBinding[] exceptions= constructorBinding.getExceptionTypes(); |
| for (int i= 0; i < exceptions.length; i++) { |
| Name exceptionTypeName= fAnonymousInnerClassNode.getAST().newName(Bindings.getNameComponents(exceptions[i])); |
| newConstructor.thrownExceptions().add(exceptionTypeName); |
| } |
| } |
| |
| private SingleVariableDeclaration newParameterDeclaration(AST ast, ImportRewrite importRewrite, String paramName, ITypeBinding paramType) { |
| SingleVariableDeclaration param= ast.newSingleVariableDeclaration(); |
| param.setExtraDimensions(0); |
| param.setInitializer(null); |
| param.setType(importRewrite.addImport(paramType, ast)); |
| param.setName(ast.newSimpleName(paramName)); |
| return param; |
| } |
| |
| private void setSuperType(TypeDeclaration declaration) { |
| ClassInstanceCreation classInstanceCreation= (ClassInstanceCreation) fAnonymousInnerClassNode.getParent(); |
| ITypeBinding binding= classInstanceCreation.resolveTypeBinding(); |
| if (binding == null) |
| return; |
| Type newType= (Type) ASTNode.copySubtree(fAnonymousInnerClassNode.getAST(), classInstanceCreation.getType()); |
| if (binding.getSuperclass().getQualifiedName().equals("java.lang.Object")) { //$NON-NLS-1$ |
| Assert.isTrue(binding.getInterfaces().length <= 1); |
| if (binding.getInterfaces().length == 0) |
| return; |
| declaration.superInterfaceTypes().add(0, newType); |
| } else { |
| declaration.setSuperclassType(newType); |
| } |
| } |
| |
| private ITypeBinding getSuperTypeBinding() { |
| ITypeBinding types= fAnonymousInnerClassNode.resolveBinding(); |
| ITypeBinding[] interfaces= types.getInterfaces(); |
| if (interfaces.length > 0) |
| return interfaces[0]; |
| else |
| return types.getSuperclass(); |
| } |
| |
| private int createModifiersForNestedClass() { |
| int flags= fVisibility; |
| if (fDeclareFinal) |
| flags|= Modifier.FINAL; |
| if (mustInnerClassBeStatic() || fDeclareStatic) |
| flags|= Modifier.STATIC; |
| return flags; |
| } |
| |
| public boolean mustInnerClassBeStatic() { |
| ITypeBinding typeBinding = ((AbstractTypeDeclaration) ASTNodes.getParent(fAnonymousInnerClassNode, AbstractTypeDeclaration.class)).resolveBinding(); |
| ASTNode current = fAnonymousInnerClassNode.getParent(); |
| boolean ans = false; |
| while(current != null) { |
| switch(current.getNodeType()) { |
| case ASTNode.ANONYMOUS_CLASS_DECLARATION: |
| { |
| AnonymousClassDeclaration enclosingAnonymousClassDeclaration= (AnonymousClassDeclaration)current; |
| ITypeBinding binding= enclosingAnonymousClassDeclaration.resolveBinding(); |
| if (binding != null && Bindings.isSuperType(typeBinding, binding.getSuperclass())) { |
| return false; |
| } |
| break; |
| } |
| case ASTNode.FIELD_DECLARATION: |
| { |
| FieldDeclaration enclosingFieldDeclaration= (FieldDeclaration)current; |
| if (Modifier.isStatic(enclosingFieldDeclaration.getModifiers())) { |
| ans = true; |
| } |
| break; |
| } |
| case ASTNode.METHOD_DECLARATION: |
| { |
| MethodDeclaration enclosingMethodDeclaration = (MethodDeclaration)current; |
| if (Modifier.isStatic(enclosingMethodDeclaration.getModifiers())) { |
| ans = true; |
| } |
| break; |
| } |
| case ASTNode.TYPE_DECLARATION: |
| { |
| return ans; |
| } |
| } |
| current = current.getParent(); |
| } |
| return ans; |
| } |
| |
| private RefactoringStatus initialize(JavaRefactoringArguments arguments) { |
| fSelfInitializing= true; |
| final String handle= arguments.getAttribute(JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT); |
| if (handle != null) { |
| final IJavaElement element= JavaRefactoringDescriptorUtil.handleToElement(arguments.getProject(), handle, false); |
| if (element == null || !element.exists() || element.getElementType() != IJavaElement.COMPILATION_UNIT) |
| return JavaRefactoringDescriptorUtil.createInputFatalStatus(element, getName(), IJavaRefactorings.CONVERT_ANONYMOUS); |
| else { |
| fCu= (ICompilationUnit) element; |
| } |
| } else |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT)); |
| final String name= arguments.getAttribute(JavaRefactoringDescriptorUtil.ATTRIBUTE_NAME); |
| if (name != null && !"".equals(name)) //$NON-NLS-1$ |
| fClassName= name; |
| else |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, JavaRefactoringDescriptorUtil.ATTRIBUTE_NAME)); |
| final String visibility= arguments.getAttribute(ATTRIBUTE_VISIBILITY); |
| if (visibility != null && !"".equals(visibility)) {//$NON-NLS-1$ |
| int flag= 0; |
| try { |
| flag= Integer.parseInt(visibility); |
| } catch (NumberFormatException exception) { |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_VISIBILITY)); |
| } |
| fVisibility= flag; |
| } |
| final String selection= arguments.getAttribute(JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION); |
| if (selection != null) { |
| int offset= -1; |
| int length= -1; |
| final StringTokenizer tokenizer= new StringTokenizer(selection); |
| if (tokenizer.hasMoreTokens()) |
| offset= Integer.valueOf(tokenizer.nextToken()).intValue(); |
| if (tokenizer.hasMoreTokens()) |
| length= Integer.valueOf(tokenizer.nextToken()).intValue(); |
| if (offset >= 0 && length >= 0) { |
| fSelectionStart= offset; |
| fSelectionLength= length; |
| } else |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_illegal_argument, new Object[] { selection, JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION})); |
| } else |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION)); |
| final String declareStatic= arguments.getAttribute(ATTRIBUTE_STATIC); |
| if (declareStatic != null) { |
| fDeclareStatic= Boolean.valueOf(declareStatic).booleanValue(); |
| } else |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_STATIC)); |
| final String declareFinal= arguments.getAttribute(ATTRIBUTE_FINAL); |
| if (declareFinal != null) { |
| fDeclareFinal= Boolean.valueOf(declareStatic).booleanValue(); |
| } else |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_FINAL)); |
| return new RefactoringStatus(); |
| } |
| } |
