Snapshot aea001abfc1b38fec3a821bcd5174cc77dc75787 from master branch of git://git.jetbrains.org/idea/community.git

Change-Id: Icdea2a2bd7ad43b4d05967b1f0479db3bda1c93c

9 files changed, 121 insertions, 41 deletions

diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateGetterHandler.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateGetterHandler.java
index d7aca706b64f..1306e20718ae 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateGetterHandler.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateGetterHandler.java
@@ -37,7 +37,7 @@ public class GenerateGetterHandler extends GenerateGetterSetterHandlerBase {
   protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember original) throws IncorrectOperationException {
     if (original instanceof PropertyClassMember) {
       final PropertyClassMember propertyClassMember = (PropertyClassMember)original;
-      final GenerationInfo[] getters = propertyClassMember.generateGetters();
+      final GenerationInfo[] getters = propertyClassMember.generateGetters(aClass);
       if (getters != null) {
         return getters;
       }
diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java
index 5a8eea42ae5f..a58dfe3dae2a 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateMembersUtil.java
@@ -15,6 +15,7 @@
  */
 package com.intellij.codeInsight.generation;
 
+import com.intellij.codeInsight.ExceptionUtil;
 import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.diagnostic.Logger;
@@ -22,6 +23,7 @@ import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.RangeMarker;
 import com.intellij.openapi.editor.ScrollType;
+import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.text.StringUtil;
@@ -30,6 +32,7 @@ import com.intellij.psi.codeStyle.*;
 import com.intellij.psi.impl.light.LightTypeElement;
 import com.intellij.psi.impl.source.tree.PsiWhiteSpaceImpl;
 import com.intellij.psi.javadoc.PsiDocComment;
+import com.intellij.psi.search.GlobalSearchScope;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.util.PsiUtil;
 import com.intellij.psi.util.TypeConversionUtil;
@@ -42,10 +45,7 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 public class GenerateMembersUtil {
   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.generation.GenerateMembersUtil");
@@ -266,7 +266,17 @@ public class GenerateMembersUtil {
         substituteTypeParameters(factory, target, sourceMethod.getTypeParameterList(), resultMethod.getTypeParameterList(), substitutor, sourceMethod);
       substituteReturnType(PsiManager.getInstance(project), resultMethod, sourceMethod.getReturnType(), collisionResolvedSubstitutor);
       substituteParameters(factory, codeStyleManager, sourceMethod.getParameterList(), resultMethod.getParameterList(), collisionResolvedSubstitutor, target);
-      substituteThrows(factory, sourceMethod.getThrowsList(), resultMethod.getThrowsList(), collisionResolvedSubstitutor, sourceMethod);
+      final List<PsiClassType> thrownTypes = ExceptionUtil.collectSubstituted(collisionResolvedSubstitutor, sourceMethod.getThrowsList().getReferencedTypes());
+      if (target instanceof PsiClass) {
+        final PsiClass[] supers = ((PsiClass)target).getSupers();
+        for (PsiClass aSuper : supers) {
+          final PsiMethod psiMethod = aSuper.findMethodBySignature(sourceMethod, true);
+          if (psiMethod != null && psiMethod != sourceMethod) {
+            ExceptionUtil.retainExceptions(thrownTypes, ExceptionUtil.collectSubstituted(TypeConversionUtil.getSuperClassSubstitutor(aSuper, (PsiClass)target, PsiSubstitutor.EMPTY), psiMethod.getThrowsList().getReferencedTypes()));
+          }
+        }
+      }
+      substituteThrows(factory, resultMethod.getThrowsList(), collisionResolvedSubstitutor, sourceMethod, thrownTypes);
       return resultMethod;
     }
     catch (IncorrectOperationException e) {
@@ -400,11 +410,11 @@ public class GenerateMembersUtil {
   }
 
   private static void substituteThrows(@NotNull JVMElementFactory factory,
-                                       @NotNull PsiReferenceList sourceThrowsList,
                                        @NotNull PsiReferenceList targetThrowsList,
-                                       @NotNull PsiSubstitutor substitutor, 
-                                       @NotNull PsiMethod sourceMethod) {
-    for (PsiClassType thrownType : sourceThrowsList.getReferencedTypes()) {
+                                       @NotNull PsiSubstitutor substitutor,
+                                       @NotNull PsiMethod sourceMethod, 
+                                       List<PsiClassType> thrownTypes) {
+    for (PsiClassType thrownType : thrownTypes) {
       targetThrowsList.add(factory.createReferenceElementByType((PsiClassType)substituteType(substitutor, thrownType, sourceMethod)));
     }
   }
@@ -504,7 +514,7 @@ public class GenerateMembersUtil {
     PsiModifierList targetModifierList = targetParam.getModifierList();
     if (sourceModifierList != null && targetModifierList != null) {
       if (sourceParam.getLanguage() == targetParam.getLanguage()) {
-        targetModifierList.replace(sourceModifierList);
+        targetModifierList = (PsiModifierList)targetModifierList.replace(sourceModifierList);
       }
       else {
         JVMElementFactory factory = JVMElementFactories.requireFactory(targetParam.getLanguage(), targetParam.getProject());
@@ -515,6 +525,30 @@ public class GenerateMembersUtil {
           targetModifierList.setModifierProperty(m, sourceParam.hasModifierProperty(m));
         }
       }
+      processAnnotations(sourceModifierList.getProject(), targetModifierList, targetModifierList.getResolveScope());
+    }
+  }
+
+  private static void processAnnotations(Project project, PsiModifierList modifierList, GlobalSearchScope moduleScope) {
+    final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
+    final Set<String> toRemove = new HashSet<String>();
+    for (PsiAnnotation annotation : modifierList.getAnnotations()) {
+      final String qualifiedName = annotation.getQualifiedName();
+      if (qualifiedName != null) {
+        for (OverrideImplementsAnnotationsHandler handler : Extensions.getExtensions(OverrideImplementsAnnotationsHandler.EP_NAME)) {
+          final String[] annotations2Remove = handler.annotationsToRemove(project, qualifiedName);
+          Collections.addAll(toRemove, annotations2Remove);
+          if (moduleScope != null && psiFacade.findClass(qualifiedName, moduleScope) == null) {
+            toRemove.add(qualifiedName);
+          }
+        }
+      }
+    }
+    for (String fqn : toRemove) {
+      final PsiAnnotation psiAnnotation = modifierList.findAnnotation(fqn);
+      if (psiAnnotation != null) {
+        psiAnnotation.delete();
+      }
     }
   }
 }
diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateSetterHandler.java b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateSetterHandler.java
index e33f1b8bb004..76a2251807ab 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/GenerateSetterHandler.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/GenerateSetterHandler.java
@@ -29,7 +29,7 @@ public class GenerateSetterHandler extends GenerateGetterSetterHandlerBase {
   protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember original) throws IncorrectOperationException {
     if (original instanceof PropertyClassMember) {
       final PropertyClassMember propertyClassMember = (PropertyClassMember)original;
-      final GenerationInfo[] getters = propertyClassMember.generateSetters();
+      final GenerationInfo[] getters = propertyClassMember.generateSetters(aClass);
       if (getters != null) {
         return getters;
       }
diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/GetterSetterPrototypeProvider.java b/java/java-impl/src/com/intellij/codeInsight/generation/GetterSetterPrototypeProvider.java
index 727bd8143dd9..521445725ef0 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/GetterSetterPrototypeProvider.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/GetterSetterPrototypeProvider.java
@@ -17,6 +17,7 @@ package com.intellij.codeInsight.generation;
 
 import com.intellij.openapi.extensions.ExtensionPointName;
 import com.intellij.openapi.extensions.Extensions;
+import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiField;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.PsiModifier;
@@ -31,6 +32,17 @@ public abstract class GetterSetterPrototypeProvider {
   public abstract boolean canGeneratePrototypeFor(PsiField field);
   public abstract PsiMethod[] generateGetters(PsiField field); 
   public abstract PsiMethod[] generateSetters(PsiField field);
+  public PsiMethod[] findGetters(PsiClass psiClass, String propertyName) {
+    return null;
+  }
+
+  public String suggestGetterName(String propertyName) {
+    return null;
+  }
+
+  public boolean isSimpleGetter(PsiMethod method, String oldPropertyName) {
+    return false;
+  }
 
   public abstract boolean isReadOnly(PsiField field);
 
@@ -51,4 +63,27 @@ public abstract class GetterSetterPrototypeProvider {
     }
     return field.hasModifierProperty(PsiModifier.FINAL);
   }
+
+  public static PsiMethod[] findGetters(PsiClass aClass, String propertyName, boolean isStatic) {
+    if (!isStatic) {
+      for (GetterSetterPrototypeProvider provider : Extensions.getExtensions(EP_NAME)) {
+        final PsiMethod[] getterSetter = provider.findGetters(aClass, propertyName);
+        if (getterSetter != null) return getterSetter;
+      }
+    }
+    final PsiMethod propertyGetterSetter = PropertyUtil.findPropertyGetter(aClass, propertyName, isStatic, false);
+    if (propertyGetterSetter != null) {
+      return new PsiMethod[] {propertyGetterSetter};
+    }
+    return null; 
+  }
+
+  public static String suggestNewGetterName(String oldPropertyName, String newPropertyName, PsiMethod method) {
+    for (GetterSetterPrototypeProvider provider : Extensions.getExtensions(EP_NAME)) {
+      if (provider.isSimpleGetter(method, oldPropertyName)) {
+        return provider.suggestGetterName(newPropertyName);
+      }
+    }
+    return null;
+  }
 }
diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java
index 68c3684ff662..53630f602ef1 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/OverrideImplementUtil.java
@@ -435,17 +435,6 @@ public class OverrideImplementUtil extends OverrideImplementExploreUtil {
     Collection<CandidateInfo> secondary = toImplement || aClass.isInterface() ?
                                           ContainerUtil.<CandidateInfo>newArrayList() : getMethodsToOverrideImplement(aClass, true);
 
-    if (toImplement && PsiUtil.isLanguageLevel8OrHigher(aClass)) {
-      for (Iterator<CandidateInfo> iterator = candidates.iterator(); iterator.hasNext(); ) {
-        CandidateInfo candidate = iterator.next();
-        PsiElement element = candidate.getElement();
-        if (element instanceof PsiMethod && ((PsiMethod)element).hasModifierProperty(PsiModifier.DEFAULT)) {
-          iterator.remove();
-          secondary.add(candidate);
-        }
-      }
-    }
-
     final MemberChooser<PsiMethodMember> chooser = showOverrideImplementChooser(editor, aClass, toImplement, candidates, secondary);
     if (chooser == null) return;
 
@@ -461,6 +450,9 @@ public class OverrideImplementUtil extends OverrideImplementExploreUtil {
     }.execute();
   }
 
+  /**
+   * @param candidates, secondary should allow modifications
+   */
   @Nullable
   public static MemberChooser<PsiMethodMember> showOverrideImplementChooser(Editor editor,
                                                                             final PsiElement aClass,
@@ -468,6 +460,17 @@ public class OverrideImplementUtil extends OverrideImplementExploreUtil {
                                                                             final Collection<CandidateInfo> candidates,
                                                                             Collection<CandidateInfo> secondary) {
 
+    if (toImplement && PsiUtil.isLanguageLevel8OrHigher(aClass)) {
+      for (Iterator<CandidateInfo> iterator = candidates.iterator(); iterator.hasNext(); ) {
+        CandidateInfo candidate = iterator.next();
+        PsiElement element = candidate.getElement();
+        if (element instanceof PsiMethod && ((PsiMethod)element).hasModifierProperty(PsiModifier.DEFAULT)) {
+          iterator.remove();
+          secondary.add(candidate);
+        }
+      }
+    }
+
     final JavaOverrideImplementMemberChooser chooser =
       JavaOverrideImplementMemberChooser.create(aClass, toImplement, candidates, secondary);
     if (chooser == null) {
@@ -612,7 +615,7 @@ public class OverrideImplementUtil extends OverrideImplementExploreUtil {
     finally {
 
       PsiFile psiFile = psiClass.getContainingFile();
-      Editor editor = fileEditorManager.openTextEditor(new OpenFileDescriptor(psiFile.getProject(), psiFile.getVirtualFile()), false);
+      Editor editor = fileEditorManager.openTextEditor(new OpenFileDescriptor(psiFile.getProject(), psiFile.getVirtualFile()), true);
       if (editor != null && !results.isEmpty()) {
         results.get(0).positionCaret(editor, true);
         editor.getScrollingModel().scrollToCaret(ScrollType.CENTER);
diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/PropertyClassMember.java b/java/java-impl/src/com/intellij/codeInsight/generation/PropertyClassMember.java
index 006e5e539932..7c5378f8286f 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/PropertyClassMember.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/PropertyClassMember.java
@@ -15,6 +15,7 @@
  */
 package com.intellij.codeInsight.generation;
 
+import com.intellij.psi.PsiClass;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.Nullable;
 
@@ -25,13 +26,15 @@ import org.jetbrains.annotations.Nullable;
 public interface PropertyClassMember extends EncapsulatableClassMember {
   /**
    * @return PsiElement or TemplateGenerationInfo
+   * @param aClass
    */
   @Nullable
-  GenerationInfo[] generateGetters() throws IncorrectOperationException;
+  GenerationInfo[] generateGetters(PsiClass aClass) throws IncorrectOperationException;
 
   /**
    * @return PsiElement or TemplateGenerationInfo
+   * @param aClass
    */
   @Nullable
-  GenerationInfo[] generateSetters() throws IncorrectOperationException;
+  GenerationInfo[] generateSetters(PsiClass aClass) throws IncorrectOperationException;
 }
diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/PsiFieldMember.java b/java/java-impl/src/com/intellij/codeInsight/generation/PsiFieldMember.java
index a4817c51c320..a14108b0fdd2 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/PsiFieldMember.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/PsiFieldMember.java
@@ -42,38 +42,37 @@ public class PsiFieldMember extends PsiElementClassMember<PsiField> implements P
   @Nullable
   @Override
   public GenerationInfo generateGetter() throws IncorrectOperationException {
-    final GenerationInfo[] infos = generateGetters();
+    final GenerationInfo[] infos = generateGetters(getElement().getContainingClass());
     return infos != null && infos.length > 0 ? infos[0] : null;
   }
 
   @Nullable
   @Override
-  public GenerationInfo[] generateGetters() throws IncorrectOperationException {
-    final PsiField field = getElement();
-    return createGenerateInfos(field, GetterSetterPrototypeProvider.generateGetterSetters(field, true));
+  public GenerationInfo[] generateGetters(PsiClass aClass) throws IncorrectOperationException {
+    return createGenerateInfos(aClass, GetterSetterPrototypeProvider.generateGetterSetters(getElement(), true));
   }
 
   @Nullable
   @Override
   public GenerationInfo generateSetter() throws IncorrectOperationException {
-    final GenerationInfo[] infos = generateSetters();
+    final GenerationInfo[] infos = generateSetters(getElement().getContainingClass());
     return infos != null && infos.length > 0 ? infos[0] : null;
   }
 
   @Override
   @Nullable
-  public GenerationInfo[] generateSetters() {
+  public GenerationInfo[] generateSetters(PsiClass aClass) {
     final PsiField field = getElement();
     if (GetterSetterPrototypeProvider.isReadOnlyProperty(field)) {
       return null;
     }
-    return createGenerateInfos(field, GetterSetterPrototypeProvider.generateGetterSetters(field, false));
+    return createGenerateInfos(aClass, GetterSetterPrototypeProvider.generateGetterSetters(field, false));
   }
 
-  private static GenerationInfo[] createGenerateInfos(PsiField field, PsiMethod[] prototypes) {
+  private static GenerationInfo[] createGenerateInfos(PsiClass aClass, PsiMethod[] prototypes) {
     final List<GenerationInfo> methods = new ArrayList<GenerationInfo>();
     for (PsiMethod prototype : prototypes) {
-      final PsiMethod method = createMethodIfNotExists(field, prototype);
+      final PsiMethod method = createMethodIfNotExists(aClass, prototype);
       if (method != null) {
         methods.add(new PsiGenerationInfo(method));
       }
@@ -82,8 +81,7 @@ public class PsiFieldMember extends PsiElementClassMember<PsiField> implements P
   }
 
   @Nullable
-  private static PsiMethod createMethodIfNotExists(final PsiField field, final PsiMethod template) {
-    final PsiClass aClass = field.getContainingClass();
+  private static PsiMethod createMethodIfNotExists(PsiClass aClass, final PsiMethod template) {
     PsiMethod existing = aClass.findMethodBySignature(template, false);
     if (existing == null) {
       if (template != null) {
diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/actions/GenerateCreateUIAction.java b/java/java-impl/src/com/intellij/codeInsight/generation/actions/GenerateCreateUIAction.java
index dee80a6a682d..16ec3cc9b1de 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/actions/GenerateCreateUIAction.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/actions/GenerateCreateUIAction.java
@@ -17,6 +17,7 @@ package com.intellij.codeInsight.generation.actions;
 
 import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTypesUtil;
+import com.intellij.util.containers.HashSet;
 
 /**
  * @author Konstantin Bulenkov
@@ -27,12 +28,12 @@ public class GenerateCreateUIAction extends BaseGenerateAction {
   }
 
   @Override
-  protected boolean isValidForClass(PsiClass targetClass) {
+  public boolean isValidForClass(PsiClass targetClass) {
     final PsiModifierList list = targetClass.getModifierList();
     return list != null
            && !list.hasModifierProperty(PsiModifier.ABSTRACT)
            && !hasCreateUIMethod(targetClass)
-           && isComponentUI(targetClass);
+           && isComponentUI(targetClass, new HashSet<PsiClass>());
   }
 
   private static boolean hasCreateUIMethod(PsiClass aClass) {
@@ -49,8 +50,9 @@ public class GenerateCreateUIAction extends BaseGenerateAction {
     return false;
   }
 
-  private static boolean isComponentUI(PsiClass aClass) {
+  private static boolean isComponentUI(PsiClass aClass, HashSet<PsiClass> classes) {
     while (aClass != null) {
+      if (!classes.add(aClass)) return false;
       if ("javax.swing.plaf.ComponentUI".equals(aClass.getQualifiedName())) {
         return true;
       }
diff --git a/java/java-impl/src/com/intellij/codeInsight/generation/surroundWith/JavaWithTryFinallySurrounder.java b/java/java-impl/src/com/intellij/codeInsight/generation/surroundWith/JavaWithTryFinallySurrounder.java
index c9a13f65e8a1..e757ddeacc17 100644
--- a/java/java-impl/src/com/intellij/codeInsight/generation/surroundWith/JavaWithTryFinallySurrounder.java
+++ b/java/java-impl/src/com/intellij/codeInsight/generation/surroundWith/JavaWithTryFinallySurrounder.java
@@ -16,6 +16,7 @@
 package com.intellij.codeInsight.generation.surroundWith;
 
 import com.intellij.codeInsight.CodeInsightBundle;
+import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorModificationUtil;
@@ -28,6 +29,8 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NonNls;
 
 class JavaWithTryFinallySurrounder extends JavaStatementsSurrounder{
+  private static final Logger LOG = Logger.getInstance("#" + JavaWithTryFinallySurrounder.class.getName());
+
   @Override
   public String getTemplateDescription() {
     return CodeInsightBundle.message("surround.with.try.finally.template");
@@ -67,7 +70,9 @@ class JavaWithTryFinallySurrounder extends JavaStatementsSurrounder{
     final Document document = editor.getDocument();
     PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(document);
     editor.getSelectionModel().removeSelection();
-    final PsiStatement firstTryStmt = tryBlock.getStatements()[0];
+    final PsiStatement[] tryBlockStatements = tryBlock.getStatements();
+    LOG.assertTrue(tryBlockStatements.length > 0, tryBlock.getText());
+    final PsiStatement firstTryStmt = tryBlockStatements[0];
     final int indent = firstTryStmt.getTextOffset() - document.getLineStartOffset(document.getLineNumber(firstTryStmt.getTextOffset()));
     EditorModificationUtil.insertStringAtCaret(editor, StringUtil.repeat(" ", indent), false, true);
     return new TextRange(editor.getCaretModel().getOffset(), editor.getCaretModel().getOffset());