| /******************************************************************************* |
| * Copyright (c) 2007-2009 University of Illinois at Urbana-Champaign 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: |
| * UIUC - Initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.photran.internal.core.refactoring; |
| |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatusContext; |
| import org.eclipse.photran.internal.core.analysis.binding.Definition; |
| import org.eclipse.photran.internal.core.lexer.Token; |
| import org.eclipse.photran.internal.core.refactoring.infrastructure.FortranEditorRefactoring; |
| import org.eclipse.photran.internal.core.refactoring.interfaces.IRenameRefactoring; |
| import org.eclipse.photran.internal.core.sourceform.SourceForm; |
| import org.eclipse.photran.internal.core.vpg.PhotranTokenRef; |
| |
| /** |
| * Refactoring to rename identifiers in Fortran programs. |
| * |
| * @author Jeff Overbey |
| */ |
| public class RenameRefactoring extends FortranEditorRefactoring implements IRenameRefactoring |
| { |
| private Definition definitionToRename = null; |
| private Collection<PhotranTokenRef> allReferences = null; |
| private String oldName = null, newName = null; |
| private boolean shouldBindInterfacesAndExternals = true; |
| |
| @Override |
| public String getName() |
| { |
| return Messages.RenameRefactoring_Name; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // User-Accessible Parameters |
| /////////////////////////////////////////////////////////////////////////// |
| |
| public String getOldNameOfIdentifier() |
| { |
| assert oldName != null; |
| |
| return oldName; |
| } |
| |
| public void setNewNameForIdentifier(String newName) |
| { |
| assert newName != null; |
| |
| this.newName = newName; |
| } |
| |
| public void setShouldBindInterfacesAndExternals(boolean value) |
| { |
| this.shouldBindInterfacesAndExternals = value; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Initial Preconditions |
| /////////////////////////////////////////////////////////////////////////// |
| |
| @Override |
| protected void doCheckInitialConditions(RefactoringStatus status, IProgressMonitor pm) throws PreconditionFailure |
| { |
| ensureProjectHasRefactoringEnabled(status); |
| |
| oldName = findEnclosingToken().getText(); |
| definitionToRename = findDeclarationToRename(); |
| |
| checkIfDefinitionCanBeRenamed(); |
| } |
| |
| private Token findEnclosingToken() throws PreconditionFailure |
| { |
| Token selectedToken = findEnclosingToken(this.astOfFileInEditor, this.selectedRegionInEditor); |
| if (selectedToken == null || !isIdentifier(selectedToken)) |
| fail(Messages.RenameRefactoring_PleaseSelectAnIdentifier); |
| return selectedToken; |
| } |
| |
| private Definition findDeclarationToRename() throws PreconditionFailure |
| { |
| List<Definition> declarations = findEnclosingToken().resolveBinding(); |
| |
| if (declarations.size() == 0) |
| fail(Messages.bind(Messages.RenameRefactoring_NoDeclarationFoundFor, oldName)); |
| else if (declarations.size() > 1) |
| fail(Messages.bind(Messages.RenameRefactoring_MultipleDeclarationsFoundFor, oldName)); |
| |
| return declarations.get(0); |
| } |
| |
| private void checkIfDefinitionCanBeRenamed() throws PreconditionFailure |
| { |
| if (definitionToRename.isSubprogramArgument()) |
| fail(Messages.RenameRefactoring_CannotRenameSubprogramArgs); |
| |
| // F03 |
| if (definitionToRename.isTypeBoundProcedure() && !definitionToRename.isRenamedTypeBoundProcedure()) |
| fail(Messages.RenameRefactoring_CannotRenameTypeBoundProcedures); |
| |
| if (!definitionToRename.isLocalVariable() |
| && !definitionToRename.isSubprogram() |
| && !definitionToRename.isExternal() |
| && !definitionToRename.isInterface() |
| && !definitionToRename.isDerivedType() |
| && !definitionToRename.isModuleEntityBeforeRename() |
| && !definitionToRename.isRenamedModuleEntity() |
| && !definitionToRename.isMainProgram() |
| && !definitionToRename.isNamelist() |
| && !definitionToRename.isCommon() |
| && !definitionToRename.isBlockData()) |
| { |
| fail( |
| Messages.bind( |
| Messages.RenameRefactoring_CannotRename, |
| definitionToRename.describeClassification(), |
| oldName)); |
| } |
| |
| if (definitionToRename.isIntrinsic()) |
| fail(Messages.bind(Messages.RenameRefactoring_CannotRenameIntrinsicProcedure, oldName)); |
| |
| if (isPreprocessed(definitionToRename.getTokenRef().findToken())) |
| fail(Messages.bind(Messages.RenameRefactoring_CannotRenameInINCLUDEFile, oldName)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Final Preconditions |
| /////////////////////////////////////////////////////////////////////////// |
| |
| @Override |
| protected void doCheckFinalConditions(final RefactoringStatus status, IProgressMonitor pm) throws PreconditionFailure |
| { |
| assert definitionToRename != null; |
| assert newName != null; |
| assert allReferences == null; |
| |
| if (newName.equals(oldName)) |
| fail( |
| Messages.bind( |
| Messages.RenameRefactoring_NewNameIsExactlyTheSame, |
| newName)); |
| // OK if capitalization is different |
| |
| if (!isValidIdentifier(newName)) fail(Messages.bind(Messages.RenameRefactoring_InvalidIdentifier, newName)); |
| |
| allReferences = definitionToRename.findAllReferences(shouldBindInterfacesAndExternals); |
| removeFixedFormReferences(status); |
| removeCPreprocessedReferences(status); |
| checkIfReferencesCanBeRenamed(pm); |
| |
| checkForConflictingBindings( |
| pm, |
| new ConflictingBindingErrorHandler(status), |
| definitionToRename, |
| allReferences, |
| newName); |
| } |
| |
| private final class ConflictingBindingErrorHandler implements IConflictingBindingCallback |
| { |
| private final RefactoringStatus status; |
| |
| private ConflictingBindingErrorHandler(RefactoringStatus status) { this.status = status; } |
| |
| public void addConflictError(List<Conflict> conflictingDef) |
| { |
| Conflict conflict = conflictingDef.get(0); |
| |
| String msg = |
| Messages.bind( |
| Messages.RenameRefactoring_NameConflicts, |
| conflict.name, |
| vpg.getDefinitionFor(conflict.tokenRef)); |
| RefactoringStatusContext context = createContext(conflict.tokenRef); // Highlights problematic definition |
| status.addError(msg, context); |
| } |
| |
| public void addConflictWarning(List<Conflict> conflictingDef) |
| { |
| Conflict conflict = conflictingDef.get(0); |
| |
| String msg = |
| Messages.bind( |
| Messages.RenameRefactoring_NameMightConflict, |
| conflict.name); |
| RefactoringStatusContext context = createContext(conflict.tokenRef); // Highlights problematic definition |
| status.addWarning(msg, context); |
| } |
| |
| public void addReferenceWillChangeError(String newName, Token reference) |
| { |
| // The entity with the new name will shadow the definition to which this binding resolves |
| status.addError( |
| Messages.bind( |
| Messages.RenameRefactoring_ChangingNameWouldChangeMeaning, |
| new Object[] { |
| newName, |
| reference.getText(), |
| reference.getLine(), |
| reference.getTokenRef().getFilename() }), |
| createContext(reference)); // Highlight problematic reference |
| } |
| } |
| |
| private void removeFixedFormReferences(RefactoringStatus status) |
| { |
| if (FIXED_FORM_REFACTORING_ENABLED) return; |
| |
| HashSet<IFile> fixedFormFiles = new HashSet<IFile>(); |
| HashSet<IFile> freeFormFiles = new HashSet<IFile>(); |
| HashSet<PhotranTokenRef> referencesToRemove = new HashSet<PhotranTokenRef>(); |
| |
| for (PhotranTokenRef reference : allReferences) |
| { |
| IFile file = reference.getFile(); |
| |
| if (fixedFormFiles.contains(file)) |
| { |
| referencesToRemove.add(reference); |
| } |
| else if (freeFormFiles.contains(file)) |
| { |
| continue; |
| } |
| else if (SourceForm.isFixedForm(file)) |
| { |
| fixedFormFiles.add(file); |
| status.addError(Messages.bind(Messages.RenameRefactoring_FixedFormFileWillNotBeRefactored, file.getName())); |
| referencesToRemove.add(reference); |
| } |
| else |
| { |
| freeFormFiles.add(file); |
| } |
| } |
| |
| allReferences.removeAll(referencesToRemove); |
| } |
| |
| private void removeCPreprocessedReferences(RefactoringStatus status) |
| { |
| HashSet<IFile> cppFiles = new HashSet<IFile>(); |
| HashSet<IFile> freeFormFiles = new HashSet<IFile>(); |
| HashSet<PhotranTokenRef> referencesToRemove = new HashSet<PhotranTokenRef>(); |
| |
| for (PhotranTokenRef reference : allReferences) |
| { |
| IFile file = reference.getFile(); |
| |
| if (cppFiles.contains(file)) |
| { |
| referencesToRemove.add(reference); |
| } |
| else if (freeFormFiles.contains(file)) |
| { |
| continue; |
| } |
| else if (SourceForm.isCPreprocessed(file)) |
| { |
| cppFiles.add(file); |
| status.addError( |
| Messages.bind( |
| Messages.RenameRefactoring_CPreprocessedFileWillNotBeRefactored, |
| file.getName())); |
| referencesToRemove.add(reference); |
| } |
| else |
| { |
| freeFormFiles.add(file); |
| } |
| } |
| |
| allReferences.removeAll(referencesToRemove); |
| } |
| |
| private void checkIfReferencesCanBeRenamed(IProgressMonitor pm) throws PreconditionFailure |
| { |
| for (PhotranTokenRef ref : allReferences) |
| { |
| pm.subTask(Messages.bind(Messages.RenameRefactoring_StatusCheckingIfReferencesInFileCanBeRenamed, ref.getFilename())); |
| |
| Token reference = ref.findToken(); |
| |
| if (reference.resolveBinding().size() > 1) |
| fail( |
| Messages.bind( |
| Messages.RenameRefactoring_CannotRenameAmbiguous, new Object[] { |
| oldName, |
| describeToken(reference), |
| oldName })); |
| |
| if (isPreprocessed(reference)) |
| fail( |
| Messages.bind( |
| Messages.RenameRefactoring_CannotRenameUsedInINCLUDEFile, |
| oldName, |
| describeToken(reference))); |
| } |
| } |
| |
| |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Change |
| /////////////////////////////////////////////////////////////////////////// |
| |
| @Override |
| protected void doCreateChange(IProgressMonitor pm) throws CoreException, OperationCanceledException |
| { |
| assert definitionToRename != null; |
| assert allReferences != null; |
| assert newName != null; |
| |
| Set<IFile> filesToChange = determineFilesToChange(); |
| pm.beginTask(Messages.RenameRefactoring_StatusRenaming, filesToChange.size()); |
| |
| try |
| { |
| for (IFile file : filesToChange) |
| makeChangesTo(file, pm); |
| } |
| finally |
| { |
| vpg.releaseAllASTs(); |
| pm.done(); |
| } |
| } |
| |
| private Set<IFile> determineFilesToChange() |
| { |
| Set<IFile> files = new HashSet<IFile>(allReferences.size() + 2); |
| |
| files.add(fileInEditor); // File in the editor (containing the reference) |
| files.add(definitionToRename.getTokenRef().getFile()); |
| |
| for (PhotranTokenRef ref : allReferences) |
| files.add(ref.getFile()); |
| |
| return files; |
| } |
| |
| private void makeChangesTo(IFile file, IProgressMonitor pm) throws Error |
| { |
| try |
| { |
| pm.subTask(Messages.bind(Messages.RenameRefactoring_StatusModifyingFile, file.getName())); |
| pm.worked(1); |
| |
| vpg.acquirePermanentAST(file); |
| |
| if (definitionToRename.getTokenRef().getFile().equals(file)) |
| definitionToRename.getTokenRef().findToken().setText(newName); |
| |
| for (PhotranTokenRef ref : allReferences) |
| if (ref.getFile().equals(file)) |
| ref.findToken().setText(newName); |
| |
| addChangeFromModifiedAST(file, pm); |
| |
| vpg.releaseAST(file); |
| } |
| catch (Exception e) |
| { |
| throw new Error(e); |
| } |
| } |
| } |
