dart/editor/tools/plugins/com.google.dart.engine.services/src/com/google/dart/engine/services/internal/refactoring/RenameClassMemberValidator.java

/*
 * Copyright (c) 2013, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 * 
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.dart.engine.services.internal.refactoring;

import com.google.common.base.Objects;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.dart.engine.context.AnalysisContext;
import com.google.dart.engine.element.ClassElement;
import com.google.dart.engine.element.Element;
import com.google.dart.engine.element.ElementKind;
import com.google.dart.engine.element.LocalElement;
import com.google.dart.engine.search.SearchEngine;
import com.google.dart.engine.search.SearchMatch;
import com.google.dart.engine.services.internal.correction.CorrectionUtils;
import com.google.dart.engine.services.refactoring.ProgressMonitor;
import com.google.dart.engine.services.status.RefactoringStatus;
import com.google.dart.engine.services.status.RefactoringStatusContext;
import com.google.dart.engine.services.util.HierarchyUtils;
import com.google.dart.engine.source.Source;
import com.google.dart.engine.source.SourceFactory;

import static com.google.dart.engine.services.internal.correction.CorrectionUtils.getChildren;
import static com.google.dart.engine.services.internal.correction.CorrectionUtils.getElementKindName;
import static com.google.dart.engine.services.internal.correction.CorrectionUtils.getElementQualifiedName;

import java.text.MessageFormat;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

/**
 * Helper to check if renaming or creating {@link Element} with given name will cause any problems.
 */
class RenameClassMemberValidator {
  private final SearchEngine searchEngine;
  private final AnalysisContext activeContext;
  private final ElementKind elementKind;
  private final ClassElement elementClass;
  private final String oldName;
  private final String newName;
  private Set<ClassElement> superClasses;
  private Set<ClassElement> subClasses;
  boolean hasIgnoredElements = false;
  Set<Element> renameElements = Sets.newHashSet();
  List<SearchMatch> renameElementsReferences = Lists.newArrayList();

  public RenameClassMemberValidator(SearchEngine searchEngine, ElementKind elementKind,
      ClassElement elementClass, String oldName, String newName) {
    this.searchEngine = searchEngine;
    this.activeContext = elementClass.getContext();
    this.elementKind = elementKind;
    this.elementClass = elementClass;
    this.oldName = oldName;
    this.newName = newName;
  }

  RefactoringStatus validate(ProgressMonitor pm, boolean isRename) {
    pm.beginTask("Analyze possible conflicts", 4);
    try {
      final RefactoringStatus result = new RefactoringStatus();
      // prepare
      prepareHierarchyClasses(result);
      // check if there are members with "newName" in the same ClassElement
      for (Element newNameMember : getChildren(elementClass, newName)) {
        String message = MessageFormat.format(
            "Class ''{0}'' already declares {1} with name ''{2}''.",
            elementClass.getDisplayName(),
            getElementKindName(newNameMember),
            newName);
        result.addError(message, new RefactoringStatusContext(newNameMember));
      }
      pm.worked(1);
      // check shadowing in hierarchy
      List<SearchMatch> nameDeclarations = searchEngine.searchDeclarations(newName, null, null);
      {
        for (SearchMatch nameDeclaration : nameDeclarations) {
          Element member = nameDeclaration.getElement();
          member = HierarchyUtils.getSyntheticAccessorVariable(member);
          Element memberDeclClass = member.getEnclosingElement();
          // renamed Element shadows member of super-class
          if (superClasses.contains(memberDeclClass)) {
            String message = MessageFormat.format(
                isRename ? "Renamed {0} will shadow {1} ''{2}''."
                    : "Created {0} will shadow {1} ''{2}''.",
                getElementKindName(elementKind),
                getElementKindName(member),
                getElementQualifiedName(member));
            result.addError(message, new RefactoringStatusContext(member));
          }
          // renamed Element is shadowed by member of sub-class
          if (isRename && subClasses.contains(memberDeclClass)) {
            String message = MessageFormat.format(
                "Renamed {0} will be shadowed by {1} ''{2}''.",
                getElementKindName(elementKind),
                getElementKindName(member),
                getElementQualifiedName(member));
            result.addError(message, new RefactoringStatusContext(member));
          }
        }
        pm.worked(1);
      }
      // check if shadowed by local
      {
        for (SearchMatch nameDeclaration : nameDeclarations) {
          Element nameElement = nameDeclaration.getElement();
          if (nameElement instanceof LocalElement) {
            LocalElement localElement = (LocalElement) nameElement;
            ClassElement enclosingClass = nameElement.getAncestor(ClassElement.class);
            if (Objects.equal(enclosingClass, elementClass) || subClasses.contains(enclosingClass)) {
              for (SearchMatch reference : renameElementsReferences) {
                if (RenameRefactoringImpl.isReferenceInLocalRange(localElement, reference)) {
                  String message = MessageFormat.format(
                      "Usage of renamed {0} will be shadowed by {1} ''{2}''.",
                      getElementKindName(elementKind),
                      getElementKindName(localElement),
                      localElement.getDisplayName());
                  result.addError(message, RefactoringStatusContext.create(reference));
                }
              }
            }
          }
        }
        pm.worked(1);
      }
      // TODO(scheglov) may be top-level shadows reference
      {
        pm.worked(1);
      }
      // done
      return result;
    } finally {
      pm.done();
    }
  }

  /**
   * Fills {@link #hierarchyClasses} with super- and sub- {@link ClassElement}s; and
   * {@link #renameElements} with all {@link Element}s which should be renamed, i.e. overridden in
   * super- and overrides in sub-classes.
   */
  private void prepareHierarchyClasses(RefactoringStatus status) {
    // prepare elements to rename
    superClasses = HierarchyUtils.getSuperClasses(elementClass);
    subClasses = Sets.newHashSet();
    renameElements.clear();
    // process super-classes with "oldName" and their sub-classes
    Set<ClassElement> processed = Sets.newHashSet();
    LinkedList<ClassElement> toProcess = Lists.newLinkedList();
    toProcess.addAll(superClasses);
    toProcess.add(elementClass);
    while (!toProcess.isEmpty()) {
      ClassElement classElement = toProcess.removeFirst();
      // maybe already processed
      if (!processed.add(classElement)) {
        continue;
      }
      // add "oldName" children
      List<Element> children = CorrectionUtils.getChildren(classElement, oldName);
      for (Element child : children) {
        // ignore if Source cannot be updated
        Source source = child.getSource();
        SourceFactory activeSourceFactory = activeContext.getSourceFactory();
        if (!activeSourceFactory.isLocalSource(source)) {
          hasIgnoredElements = true;
          continue;
        }
        // add element to rename
        renameElements.add(child);
        // process sub-classes if this class has an "oldName" child
        toProcess.addAll(HierarchyUtils.getSubClasses(searchEngine, classElement));
      }
      // add sub-class
      if (!superClasses.contains(classElement)) {
        subClasses.add(classElement);
      }
    }
    // prepare references
    renameElementsReferences.clear();
    for (Element renameElement : renameElements) {
      List<SearchMatch> references = searchEngine.searchReferences(renameElement, null, null);
      renameElementsReferences.addAll(references);
    }
  }
}