Merge branch 'master' into upsource-master

java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java

@@ -498,6 +498,7 @@ public class HighlightMethodUtil {
     AddTypeArgumentsFix.REGISTRAR.registerCastActions(methodCandidates, methodCall, highlightInfo, fixRange);
     registerMethodAccessLevelIntentions(methodCandidates, methodCall, list, highlightInfo);
     ChangeMethodSignatureFromUsageFix.registerIntentions(methodCandidates, list, highlightInfo, fixRange);
+    RemoveRedundantArgumentsFix.registerIntentions(methodCandidates, list, highlightInfo, fixRange);
     ConvertDoubleToFloatFix.registerIntentions(methodCandidates, list, highlightInfo, fixRange);
     WrapExpressionFix.registerWrapAction(methodCandidates, list.getExpressions(), highlightInfo);
     ChangeParameterClassFix.registerQuickFixActions(methodCall, list, highlightInfo);

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/CreateGetterOrSetterFix.java

@@ -76,19 +76,39 @@ public class CreateGetterOrSetterFix implements IntentionAction, LowPriorityActi
   @Override
   public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
     if (!myField.isValid()) return false;
-    PsiClass aClass = myField.getContainingClass();
+
+    final PsiClass aClass = myField.getContainingClass();
     if (aClass == null) {
       return false;
     }
-    if (myCreateGetter && PropertyUtil.findPropertyGetter(aClass, myPropertyName, myField.hasModifierProperty(PsiModifier.STATIC), false) != null) {
-      return false;
+
+    if (myCreateGetter){
+      if (isStaticFinal(myField) || PropertyUtil.findPropertyGetter(aClass, myPropertyName, isStatic(myField), false) != null){
+        return false;
+      }
     }
-    if (myCreateSetter && PropertyUtil.findPropertySetter(aClass, myPropertyName, myField.hasModifierProperty(PsiModifier.STATIC), false) != null) {
-      return false;
+
+    if (myCreateSetter){
+      if(isFinal(myField) || PropertyUtil.findPropertySetter(aClass, myPropertyName, isStatic(myField), false) != null){
+        return false;
+      }
     }
+
     return true;
   }
 
+  private static boolean isFinal(@NotNull PsiField field){
+    return field.hasModifierProperty(PsiModifier.FINAL);
+  }
+
+  private static boolean isStatic(@NotNull PsiField field){
+    return field.hasModifierProperty(PsiModifier.STATIC);
+  }
+
+  private static boolean isStaticFinal(@NotNull PsiField field){
+    return isStatic(field) && isFinal(field);
+  }
+
   @Override
   public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
     if (!CodeInsightUtilBase.preparePsiElementForWrite(myField)) return;

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/RemoveRedundantArgumentsFix.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2000-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.intellij.codeInsight.daemon.impl.quickfix;
+
+import com.intellij.codeInsight.CodeInsightUtilBase;
+import com.intellij.codeInsight.daemon.QuickFixBundle;
+import com.intellij.codeInsight.daemon.impl.HighlightInfo;
+import com.intellij.codeInsight.daemon.impl.analysis.HighlightUtil;
+import com.intellij.codeInsight.intention.IntentionAction;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.*;
+import com.intellij.psi.util.TypeConversionUtil;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+
+/**
+ * @author Danila Ponomarenko
+ */
+public class RemoveRedundantArgumentsFix implements IntentionAction {
+  private final PsiMethod myTargetMethod;
+  private final PsiExpression[] myArguments;
+  private final PsiSubstitutor mySubstitutor;
+
+  private RemoveRedundantArgumentsFix(@NotNull PsiMethod targetMethod,
+                                     @NotNull PsiExpression[] arguments,
+                                     @NotNull PsiSubstitutor substitutor) {
+    myTargetMethod = targetMethod;
+    myArguments = arguments;
+    mySubstitutor = substitutor;
+  }
+
+  @NotNull
+  @Override
+  public String getText() {
+    return QuickFixBundle.message("remove.redundant.arguments.text", HighlightUtil.formatMethod(myTargetMethod));
+  }
+
+  @NotNull
+  @Override
+  public String getFamilyName() {
+    return QuickFixBundle.message("remove.redundant.arguments.family");
+  }
+
+  @Override
+  public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+    if (!myTargetMethod.isValid() || myTargetMethod.getContainingClass() == null) return false;
+    for (PsiExpression expression : myArguments) {
+      if (!expression.isValid()) return false;
+    }
+    if (!mySubstitutor.isValid()) return false;
+
+    return findRedundantArgument(myArguments, myTargetMethod.getParameterList().getParameters(), mySubstitutor) != null;
+  }
+
+  @Nullable
+  private static PsiExpression[] findRedundantArgument(@NotNull PsiExpression[] arguments,
+                                                       @NotNull PsiParameter[] parameters,
+                                                       @NotNull PsiSubstitutor substitutor) {
+    if (arguments.length <= parameters.length) return null;
+
+    for (int i = 0; i < parameters.length; i++) {
+      final PsiExpression argument = arguments[i];
+      final PsiParameter parameter = parameters[i];
+
+      final PsiType argumentType = argument.getType();
+      if (argumentType == null) return null;
+      final PsiType parameterType = substitutor.substitute(parameter.getType());
+
+      if (!TypeConversionUtil.isAssignable(parameterType, argumentType)) {
+        return null;
+      }
+    }
+
+    return Arrays.copyOfRange(arguments, parameters.length, arguments.length);
+  }
+
+  @Override
+  public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
+    if (!CodeInsightUtilBase.prepareFileForWrite(file)) return;
+    final PsiExpression[] redundantArguments = findRedundantArgument(myArguments, myTargetMethod.getParameterList().getParameters(), mySubstitutor);
+    if (redundantArguments != null) {
+      for (PsiExpression argument : redundantArguments) {
+        argument.delete();
+      }
+    }
+  }
+
+  @Override
+  public boolean startInWriteAction() {
+    return true;
+  }
+
+  public static void registerIntentions(@NotNull JavaResolveResult[] candidates,
+                                        @NotNull PsiExpressionList arguments,
+                                        @NotNull HighlightInfo highlightInfo,
+                                        TextRange fixRange) {
+    for (JavaResolveResult candidate : candidates) {
+      registerIntention(arguments, highlightInfo, fixRange, candidate, arguments);
+    }
+  }
+
+  private static void registerIntention(@NotNull PsiExpressionList arguments,
+                                        @NotNull HighlightInfo highlightInfo,
+                                        TextRange fixRange,
+                                        @NotNull JavaResolveResult candidate,
+                                        @NotNull PsiElement context) {
+    if (!candidate.isStaticsScopeCorrect()) return;
+    PsiMethod method = (PsiMethod)candidate.getElement();
+    PsiSubstitutor substitutor = candidate.getSubstitutor();
+    if (method != null && context.getManager().isInProject(method)) {
+      QuickFixAction.registerQuickFixAction(highlightInfo, fixRange, new RemoveRedundantArgumentsFix(method, arguments.getExpressions(), substitutor));
+    }
+  }
+}

java/java-impl/src/com/intellij/psi/impl/file/PsiPackageImplementationHelperImpl.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2011 JetBrains s.r.o.
+ * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,6 +27,7 @@ import com.intellij.openapi.module.ModuleManager;
 import com.intellij.openapi.module.ModuleUtil;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.*;
+import com.intellij.openapi.roots.impl.ModuleRootManagerImpl;
 import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.wm.ToolWindow;
@@ -118,9 +119,10 @@ public class PsiPackageImplementationHelperImpl extends PsiPackageImplementation
     }
 
     if (!modelsToCommit.isEmpty()) {
-      ProjectRootManager.getInstance(psiPackage.getProject()).multiCommit(
-        modelsToCommit.toArray(new ModifiableRootModel[modelsToCommit.size()])
-      );
+      ModifiableRootModel[] rootModels = modelsToCommit.toArray(new ModifiableRootModel[modelsToCommit.size()]);
+      if (rootModels.length > 0) {
+        ModuleRootManagerImpl.multiCommit(rootModels, ModuleManager.getInstance(rootModels[0].getProject()).getModifiableModel());
+      }
       return true;
     } else {
       return false;

java/java-impl/src/com/intellij/refactoring/extractSuperclass/ExtractSuperBaseProcessor.java

@@ -27,6 +27,7 @@ import com.intellij.psi.util.MethodSignatureUtil;
 import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.refactoring.turnRefsToSuper.TurnRefsToSuperProcessorBase;
 import com.intellij.refactoring.util.DocCommentPolicy;
+import com.intellij.refactoring.util.RefactoringUIUtil;
 import com.intellij.refactoring.util.RefactoringUtil;
 import com.intellij.refactoring.util.classMembers.MemberInfo;
 import com.intellij.usageView.UsageInfo;
@@ -127,9 +128,14 @@ public abstract class ExtractSuperBaseProcessor extends TurnRefsToSuperProcessor
       myClass.setName(myNewClassName);
       PsiClass superClass = extractSuper(superClassName);
       final PsiDirectory initialDirectory = myClass.getContainingFile().getContainingDirectory();
-      if (myTargetDirectory != initialDirectory) {
-        myTargetDirectory.add(myClass.getContainingFile().copy());
-        myClass.getContainingFile().delete();
+      try {
+        if (myTargetDirectory != initialDirectory) {
+          myTargetDirectory.add(myClass.getContainingFile().copy());
+          myClass.getContainingFile().delete();
+        }
+      }
+      catch (IncorrectOperationException e) {
+        RefactoringUIUtil.processIncorrectOperation(myProject, e);
       }
       for (final UsageInfo usage : usages) {
         if (usage instanceof BindToOldUsageInfo) {