diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/StaticMembersProcessor.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/StaticMembersProcessor.java index bf3df1d7c2ca..d2806b05ba3d 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/StaticMembersProcessor.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/StaticMembersProcessor.java @@ -19,7 +19,7 @@ import com.intellij.codeInsight.CodeInsightUtil; import com.intellij.codeInsight.ImportFilter; import com.intellij.openapi.progress.ProgressManager; import com.intellij.psi.*; -import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiTypesUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.util.ArrayUtilRt; import com.intellij.util.Processor; @@ -79,13 +79,7 @@ abstract class StaticMembersProcessor } } else if (parent instanceof PsiReturnStatement) { - final PsiElement psiElement = PsiTreeUtil.getParentOfType(parent, PsiLambdaExpression.class, PsiMethod.class); - if (psiElement instanceof PsiLambdaExpression) { - return LambdaUtil.getFunctionalInterfaceReturnType(((PsiLambdaExpression)psiElement).getFunctionalInterfaceType()); - } - else if (psiElement instanceof PsiMethod) { - return ((PsiMethod)psiElement).getReturnType(); - } + return PsiTypesUtil.getMethodReturnType(parent); } else if (parent instanceof PsiExpressionList) { final PsiElement pParent = parent.getParent(); diff --git a/java/java-impl/src/com/intellij/codeInspection/OptionalIsPresentInspection.java b/java/java-impl/src/com/intellij/codeInspection/OptionalIsPresentInspection.java index bb4a8899402a..5cedc96d59b4 100644 --- a/java/java-impl/src/com/intellij/codeInspection/OptionalIsPresentInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/OptionalIsPresentInspection.java @@ -22,12 +22,15 @@ import com.intellij.codeInspection.util.LambdaGenerationUtil; import com.intellij.codeInspection.util.OptionalUtil; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Ref; import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleManager; import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.codeStyle.SuggestedNameInfo; import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.impl.PsiDiamondTypeUtil; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiTypesUtil; import com.intellij.psi.util.PsiUtil; import com.siyeh.ig.psiutils.BoolUtils; import com.siyeh.ig.psiutils.ControlFlowUtils; @@ -160,19 +163,23 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo return ((PsiReferenceExpression)qualifier).isReferenceTo(variable); } - @Contract("null, _ -> false") - static boolean isOptionalLambdaCandidate(PsiExpression lambdaCandidate, PsiVariable optionalVariable) { + @Contract("_, null, _ -> false") + static boolean isOptionalLambdaCandidate(PsiVariable optionalVariable, PsiExpression lambdaCandidate, PsiExpression falseExpression) { if (lambdaCandidate == null) return false; + if (ExpressionUtils.isReferenceTo(lambdaCandidate, optionalVariable) && OptionalUtil.isOptionalEmptyCall(falseExpression)) return true; if (!ExceptionUtil.getThrownCheckedExceptions(lambdaCandidate).isEmpty()) return false; + Ref hasOptionalReference = new Ref<>(Boolean.FALSE); return PsiTreeUtil.processElements(lambdaCandidate, e -> { if (!(e instanceof PsiReferenceExpression)) return true; PsiElement element = ((PsiReferenceExpression)e).resolve(); if (!(element instanceof PsiVariable)) return true; // Check that Optional variable is referenced only in context of get() call and other variables are effectively final - return element == optionalVariable - ? isOptionalGetCall(e.getParent().getParent(), optionalVariable) - : HighlightControlFlowUtil.isEffectivelyFinal((PsiVariable)element, lambdaCandidate, null); - }); + if (element == optionalVariable) { + hasOptionalReference.set(Boolean.TRUE); + return isOptionalGetCall(e.getParent().getParent(), optionalVariable); + } + return HighlightControlFlowUtil.isEffectivelyFinal((PsiVariable)element, lambdaCandidate, null); + }) && hasOptionalReference.get(); } @NotNull @@ -195,14 +202,19 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo static String generateOptionalUnwrap(PsiElementFactory factory, PsiVariable optionalVariable, PsiExpression trueValue, - PsiExpression falseValue) { + PsiExpression falseValue, + PsiType targetType) { + if (ExpressionUtils.isReferenceTo(trueValue, optionalVariable) && OptionalUtil.isOptionalEmptyCall(falseValue)) { + trueValue = + factory.createExpressionFromText(CommonClassNames.JAVA_UTIL_OPTIONAL + ".of(" + optionalVariable.getName() + ".get())", trueValue); + } + if (ExpressionUtils.isReferenceTo(falseValue, optionalVariable)) { + falseValue = factory.createExpressionFromText(CommonClassNames.JAVA_UTIL_OPTIONAL + ".empty()", falseValue); + } String lambdaText = generateOptionalLambda(factory, optionalVariable, trueValue); PsiLambdaExpression lambda = (PsiLambdaExpression)factory.createExpressionFromText(lambdaText, trueValue); - if(ExpressionUtils.isReferenceTo(falseValue, optionalVariable)) { - falseValue = factory.createExpressionFromText(CommonClassNames.JAVA_UTIL_OPTIONAL+".empty()", falseValue); - } return OptionalUtil.generateOptionalUnwrap(optionalVariable.getName(), lambda.getParameterList().getParameters()[0], - (PsiExpression)lambda.getBody(), falseValue, falseValue.getType(), true); + (PsiExpression)lambda.getBody(), falseValue, targetType, true); } static class OptionalIfPresentFix implements LocalQuickFix { @@ -260,6 +272,7 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo factory.createStatementFromText(replacementText, cond); PsiElement result = cond.replace(replacement); LambdaCanBeMethodReferenceInspection.replaceAllLambdasWithMethodReferences(result); + PsiDiamondTypeUtil.removeRedundantTypeArguments(result); CodeStyleManager.getInstance(project).reformat(result); } } @@ -281,7 +294,7 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo if (!ExpressionUtils.isSimpleExpression(falseValue) && !LambdaGenerationUtil.canBeUncheckedLambda(falseValue)) return false; PsiExpression trueValue = ((PsiReturnStatement)trueElement).getReturnValue(); - return isOptionalLambdaCandidate(trueValue, optionalVariable); + return isOptionalLambdaCandidate(optionalVariable, trueValue, falseValue); } @Override @@ -293,7 +306,9 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo PsiExpression falseValue = ((PsiReturnStatement)falseElement).getReturnValue(); LOG.assertTrue(trueValue != null); LOG.assertTrue(falseValue != null); - return "return " + generateOptionalUnwrap(factory, optionalVariable, trueValue, falseValue) + ";"; + return "return " + + generateOptionalUnwrap(factory, optionalVariable, trueValue, falseValue, PsiTypesUtil.getMethodReturnType(trueElement)) + + ";"; } } @@ -306,7 +321,7 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo falseAssignment == null || !EquivalenceChecker.getCanonicalPsiEquivalence() .expressionsAreEquivalent(trueAssignment.getLExpression(), falseAssignment.getLExpression()) || - !isOptionalLambdaCandidate(trueAssignment.getRExpression(), optionalVariable)) { + !isOptionalLambdaCandidate(optionalVariable, trueAssignment.getRExpression(), falseAssignment.getRExpression())) { return false; } return ExpressionUtils.isSimpleExpression(falseAssignment.getRExpression()) || @@ -326,7 +341,7 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo PsiExpression trueValue = trueAssignment.getRExpression(); PsiExpression falseValue = falseAssignment.getRExpression(); LOG.assertTrue(falseValue != null); - return lValue.getText() + " = " + generateOptionalUnwrap(factory, optionalVariable, trueValue, falseValue) + ";"; + return lValue.getText() + " = " + generateOptionalUnwrap(factory, optionalVariable, trueValue, falseValue, lValue.getType()) + ";"; } } @@ -334,9 +349,10 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo @Override public boolean isApplicable(PsiVariable optionalVariable, PsiElement trueElement, PsiElement falseElement) { if(!(trueElement instanceof PsiExpression) || !(falseElement instanceof PsiExpression)) return false; - return isOptionalLambdaCandidate((PsiExpression)trueElement, optionalVariable) && - (ExpressionUtils.isSimpleExpression((PsiExpression)falseElement) || - LambdaGenerationUtil.canBeUncheckedLambda((PsiExpression)falseElement)); + PsiExpression trueExpression = (PsiExpression)trueElement; + PsiExpression falseExpression = (PsiExpression)falseElement; + return isOptionalLambdaCandidate(optionalVariable, trueExpression, falseExpression) && + (ExpressionUtils.isSimpleExpression(falseExpression) || LambdaGenerationUtil.canBeUncheckedLambda(falseExpression)); } @Override @@ -344,9 +360,11 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo PsiVariable optionalVariable, PsiElement trueElement, PsiElement falseElement) { + PsiExpression ternary = PsiTreeUtil.getParentOfType(trueElement, PsiConditionalExpression.class); + LOG.assertTrue(ternary != null); PsiExpression trueExpression = (PsiExpression)trueElement; PsiExpression falseExpression = (PsiExpression)falseElement; - return generateOptionalUnwrap(factory, optionalVariable, trueExpression, falseExpression); + return generateOptionalUnwrap(factory, optionalVariable, trueExpression, falseExpression, ternary.getType()); } } @@ -356,7 +374,7 @@ public class OptionalIsPresentInspection extends BaseJavaBatchLocalInspectionToo if (falseElement != null && !(falseElement instanceof PsiEmptyStatement)) return false; if (!(trueElement instanceof PsiExpressionStatement)) return false; PsiExpression expression = ((PsiExpressionStatement)trueElement).getExpression(); - return isOptionalLambdaCandidate(expression, optionalVariable); + return isOptionalLambdaCandidate(optionalVariable, expression, null); } @Override diff --git a/java/java-impl/src/com/intellij/codeInspection/intermediaryVariable/ReturnSeparatedFromComputationInspection.java b/java/java-impl/src/com/intellij/codeInspection/intermediaryVariable/ReturnSeparatedFromComputationInspection.java index fa7c7a6952a2..4b22d0ad640e 100644 --- a/java/java-impl/src/com/intellij/codeInspection/intermediaryVariable/ReturnSeparatedFromComputationInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/intermediaryVariable/ReturnSeparatedFromComputationInspection.java @@ -23,9 +23,9 @@ import com.intellij.psi.*; import com.intellij.psi.codeStyle.CodeStyleManager; import com.intellij.psi.controlFlow.*; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiTypesUtil; import com.intellij.refactoring.util.RefactoringUtil; import com.siyeh.ig.psiutils.ExpressionUtils; -import com.siyeh.ig.psiutils.TypeUtils; import gnu.trove.THashMap; import gnu.trove.THashSet; import org.jetbrains.annotations.Nls; @@ -61,7 +61,7 @@ public class ReturnSeparatedFromComputationInspection extends BaseJavaBatchLocal final PsiCodeBlock returnScope = (PsiCodeBlock)returnParent; final PsiStatement[] statements = returnScope.getStatements(); if (statements.length != 0 && statements[statements.length - 1] == returnStatement) { - final PsiType returnType = TypeUtils.getMethodReturnType(returnStatement); + final PsiType returnType = PsiTypesUtil.getMethodReturnType(returnStatement); if (returnType != null) { PsiStatement refactoredStatement = getPrevNonEmptyStatement(returnStatement, null); if (refactoredStatement != null) { diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithFindFirstFix.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithFindFirstFix.java index e286d947cd1e..ab83c6f07e02 100644 --- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithFindFirstFix.java +++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/ReplaceWithFindFirstFix.java @@ -20,6 +20,7 @@ import com.intellij.codeInspection.util.OptionalUtil; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiTypesUtil; import com.siyeh.ig.psiutils.ExpressionUtils; import org.jetbrains.annotations.NotNull; @@ -50,7 +51,7 @@ class ReplaceWithFindFirstFix extends MigrateToStreamFix { if (nextReturnStatement == null) return null; PsiExpression orElseExpression = nextReturnStatement.getReturnValue(); if (!ExpressionUtils.isSimpleExpression(orElseExpression)) return null; - stream = generateOptionalUnwrap(stream, tb, value, orElseExpression, null); + stream = generateOptionalUnwrap(stream, tb, value, orElseExpression, PsiTypesUtil.getMethodReturnType(returnStatement)); restoreComments(loopStatement, body); boolean sibling = nextReturnStatement.getParent() == loopStatement.getParent(); PsiElement replacement = loopStatement.replace(elementFactory.createStatementFromText("return " + stream + ";", loopStatement)); diff --git a/java/java-impl/src/com/intellij/codeInspection/streamMigration/StreamApiMigrationInspection.java b/java/java-impl/src/com/intellij/codeInspection/streamMigration/StreamApiMigrationInspection.java index 7ce1b8186702..73cf32a2f088 100644 --- a/java/java-impl/src/com/intellij/codeInspection/streamMigration/StreamApiMigrationInspection.java +++ b/java/java-impl/src/com/intellij/codeInspection/streamMigration/StreamApiMigrationInspection.java @@ -23,6 +23,7 @@ import com.intellij.codeInsight.daemon.HighlightDisplayKey; import com.intellij.codeInsight.daemon.impl.analysis.HighlightControlFlowUtil; import com.intellij.codeInspection.*; import com.intellij.codeInspection.ui.MultipleCheckboxOptionsPanel; +import com.intellij.codeInspection.util.OptionalUtil; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.TextRange; @@ -997,10 +998,8 @@ public class StreamApiMigrationInspection extends BaseJavaBatchLocalInspectionTo operationName = "mapToObj"; } PsiExpression expression = myType == null ? myExpression : RefactoringUtil.convertInitializerToNormalExpression(myExpression, myType); - if(myType != null && !(myType instanceof PsiPrimitiveType) && !(myType instanceof PsiCapturedWildcardType)) { - operationName = "<"+myType.getCanonicalText()+">"+operationName; - } - return "." + operationName + "(" + LambdaUtil.createLambda(myVariable, expression) + ")"; + return "." + OptionalUtil.getMapTypeArgument(expression, myType) + operationName + + "(" + LambdaUtil.createLambda(myVariable, expression) + ")"; } @Override diff --git a/java/java-impl/src/com/intellij/codeInspection/util/OptionalUtil.java b/java/java-impl/src/com/intellij/codeInspection/util/OptionalUtil.java index 13c2bfffc2a9..421be5ac900a 100644 --- a/java/java-impl/src/com/intellij/codeInspection/util/OptionalUtil.java +++ b/java/java-impl/src/com/intellij/codeInspection/util/OptionalUtil.java @@ -18,6 +18,7 @@ package com.intellij.codeInspection.util; import com.intellij.codeInsight.PsiEquivalenceUtil; import com.intellij.psi.*; import com.intellij.psi.util.PsiUtil; +import com.intellij.psi.util.TypeConversionUtil; import com.intellij.refactoring.util.RefactoringUtil; import com.siyeh.ig.psiutils.ExpressionUtils; import com.siyeh.ig.psiutils.MethodCallUtils; @@ -112,8 +113,7 @@ public class OptionalUtil { condition.getThenExpression(), falseExpression, targetType, useOrElseGet); } } - if(falseExpression instanceof PsiMethodCallExpression && - MethodCallUtils.isCallToStaticMethod((PsiMethodCallExpression)falseExpression, CommonClassNames.JAVA_UTIL_OPTIONAL, "empty", 0)) { + if(isOptionalEmptyCall(falseExpression)) { // simplify "qualifier.map(x -> Optional.of(x)).orElse(Optional.empty())" to "qualifier" if (trueExpression instanceof PsiMethodCallExpression && MethodCallUtils.isCallToStaticMethod((PsiMethodCallExpression)trueExpression, CommonClassNames.JAVA_UTIL_OPTIONAL, "of", 1)) { @@ -127,7 +127,8 @@ public class OptionalUtil { } trueExpression = targetType == null ? trueExpression : RefactoringUtil.convertInitializerToNormalExpression(trueExpression, targetType); - qualifier += ".map(" + LambdaUtil.createLambda(var, trueExpression) + ")"; + String typeArg = getMapTypeArgument(trueExpression, targetType); + qualifier += "." + typeArg + "map(" + LambdaUtil.createLambda(var, trueExpression) + ")"; } if (useOrElseGet && !ExpressionUtils.isSimpleExpression(falseExpression)) { return qualifier + ".orElseGet(() -> " + falseExpression.getText() + ")"; @@ -135,4 +136,25 @@ public class OptionalUtil { return qualifier + ".orElse(" + falseExpression.getText() + ")"; } } + + @Contract("null -> false") + public static boolean isOptionalEmptyCall(PsiExpression expression) { + return expression instanceof PsiMethodCallExpression && + MethodCallUtils.isCallToStaticMethod((PsiMethodCallExpression)expression, CommonClassNames.JAVA_UTIL_OPTIONAL, "empty", 0); + } + + @NotNull + public static String getMapTypeArgument(PsiExpression expression, PsiType type) { + if (!(type instanceof PsiClassType)) return ""; + PsiExpression copy = + JavaPsiFacade.getElementFactory(expression.getProject()).createExpressionFromText(expression.getText(), expression); + PsiType exprType = copy.getType(); + if (exprType != null && + !exprType.equals(PsiType.NULL) && + !LambdaUtil.notInferredType(exprType) && + TypeConversionUtil.isAssignable(type, exprType)) { + return ""; + } + return "<" + type.getCanonicalText() + ">"; + } } diff --git a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureHandler.java b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureHandler.java index d5d47bb85093..5737c085fe05 100644 --- a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureHandler.java +++ b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureHandler.java @@ -92,7 +92,7 @@ public class JavaChangeSignatureHandler implements ChangeSignatureHandler { final PsiClass containingClass = method.getContainingClass(); final PsiReferenceExpression refExpr = editor != null ? JavaTargetElementEvaluator.findReferenceExpression(editor) : null; final boolean allowDelegation = containingClass != null && (!containingClass.isInterface() || PsiUtil.isLanguageLevel8OrHigher(containingClass)); - InplaceChangeSignature inplaceChangeSignature = InplaceChangeSignature.getCurrentRefactoring(editor); + InplaceChangeSignature inplaceChangeSignature = editor != null ? InplaceChangeSignature.getCurrentRefactoring(editor) : null; ChangeInfo initialChange = inplaceChangeSignature != null ? inplaceChangeSignature.getStableChange() : null; boolean isInplace = Registry.is("inplace.change.signature") && editor != null && editor.getSettings().isVariableInplaceRenameEnabled() && (initialChange == null || initialChange.getMethod() != method); diff --git a/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeStaticJavaCallerChooser.java b/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeStaticJavaCallerChooser.java index 0558f6bea3cd..a82e6b2d8623 100644 --- a/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeStaticJavaCallerChooser.java +++ b/java/java-impl/src/com/intellij/refactoring/makeStatic/MakeStaticJavaCallerChooser.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2014 JetBrains s.r.o. + * Copyright 2000-2016 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. @@ -21,13 +21,13 @@ import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; +import com.intellij.psi.search.searches.OverridingMethodsSearch; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.refactoring.changeSignature.MethodNodeBase; import com.intellij.refactoring.changeSignature.inCallers.JavaCallerChooser; import com.intellij.refactoring.changeSignature.inCallers.JavaMethodNode; import com.intellij.usageView.UsageInfo; import com.intellij.util.Consumer; -import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; import java.util.ArrayList; @@ -49,7 +49,8 @@ abstract class MakeStaticJavaCallerChooser extends JavaCallerChooser { !containingMethod.hasModifierProperty(PsiModifier.STATIC) && !containingMethod.isConstructor() && containingMethod.findDeepestSuperMethods().length == 0 && - !containingMethod.equals(member)) { + !containingMethod.equals(member) && + OverridingMethodsSearch.search(containingMethod).findFirst() == null) { final PsiClass containingClass = containingMethod.getContainingClass(); if (containingClass != null) { final PsiClass gContainingClass = containingClass.getContainingClass(); diff --git a/java/java-impl/src/com/intellij/refactoring/safeDelete/SafeDeleteJavaCallerChooser.java b/java/java-impl/src/com/intellij/refactoring/safeDelete/SafeDeleteJavaCallerChooser.java index 63de4092b4db..a4b0d7223502 100644 --- a/java/java-impl/src/com/intellij/refactoring/safeDelete/SafeDeleteJavaCallerChooser.java +++ b/java/java-impl/src/com/intellij/refactoring/safeDelete/SafeDeleteJavaCallerChooser.java @@ -23,6 +23,7 @@ import com.intellij.openapi.util.Ref; import com.intellij.psi.*; import com.intellij.psi.javadoc.PsiDocTag; import com.intellij.psi.search.LocalSearchScope; +import com.intellij.psi.search.searches.OverridingMethodsSearch; import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; @@ -134,7 +135,8 @@ abstract class SafeDeleteJavaCallerChooser extends JavaCallerChooser { final PsiParameter parameter = ContainerUtil.getFirstItem(paramRefs); if (parameter != null && !parameter.isVarArgs()) { final PsiElement scope = parameter.getDeclarationScope(); - if (scope instanceof PsiMethod && ((PsiMethod)scope).findDeepestSuperMethods().length == 0) { + if (scope instanceof PsiMethod && ((PsiMethod)scope).findDeepestSuperMethods().length == 0 && + OverridingMethodsSearch.search((PsiMethod)scope).findFirst() == null) { final int scopeParamIdx = ((PsiMethod)scope).getParameterList().getParameterIndex(parameter); final Ref ref = new Ref<>(false); if (ReferencesSearch.search(parameter, new LocalSearchScope(scope)).forEach(new Processor() { diff --git a/java/java-impl/src/com/intellij/refactoring/turnRefsToSuper/TurnRefsToSuperProcessorBase.java b/java/java-impl/src/com/intellij/refactoring/turnRefsToSuper/TurnRefsToSuperProcessorBase.java index 93e268b5c9b0..b595e89c15e0 100644 --- a/java/java-impl/src/com/intellij/refactoring/turnRefsToSuper/TurnRefsToSuperProcessorBase.java +++ b/java/java-impl/src/com/intellij/refactoring/turnRefsToSuper/TurnRefsToSuperProcessorBase.java @@ -44,7 +44,6 @@ import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.HashMap; import com.intellij.util.containers.HashSet; import com.intellij.util.containers.Queue; -import com.siyeh.ig.psiutils.TypeUtils; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -532,7 +531,7 @@ public abstract class TurnRefsToSuperProcessorBase extends BaseRefactoringProces final PsiElement parent = element.getParent(); if (parent instanceof PsiReturnStatement) { - constrainingType = TypeUtils.getMethodReturnType(parent); + constrainingType = PsiTypesUtil.getMethodReturnType(parent); } else if (parent instanceof PsiAssignmentExpression) { constrainingType = ((PsiAssignmentExpression)parent).getLExpression().getType(); diff --git a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java index 55c581f13105..4bfc650cf327 100644 --- a/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/LambdaUtil.java @@ -439,12 +439,7 @@ public class LambdaUtil { } } else if (parent instanceof PsiReturnStatement) { - final PsiElement gParent = PsiTreeUtil.getParentOfType(parent, PsiLambdaExpression.class, PsiMethod.class); - if (gParent instanceof PsiLambdaExpression) { - return getFunctionalInterfaceTypeByContainingLambda((PsiLambdaExpression)gParent); - } else if (gParent instanceof PsiMethod) { - return ((PsiMethod)gParent).getReturnType(); - } + return PsiTypesUtil.getMethodReturnType(parent); } else if (parent instanceof PsiLambdaExpression) { return getFunctionalInterfaceTypeByContainingLambda((PsiLambdaExpression)parent); diff --git a/java/java-psi-api/src/com/intellij/psi/util/PsiTypesUtil.java b/java/java-psi-api/src/com/intellij/psi/util/PsiTypesUtil.java index 4c81c52b19ac..0abcca03ea5d 100644 --- a/java/java-psi-api/src/com/intellij/psi/util/PsiTypesUtil.java +++ b/java/java-psi-api/src/com/intellij/psi/util/PsiTypesUtil.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2015 JetBrains s.r.o. + * Copyright 2000-2016 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. @@ -237,14 +237,28 @@ public class PsiTypesUtil { } } else if (gParent instanceof PsiArrayInitializerExpression) { - final PsiType expectedTypeByParent = getExpectedTypeByParent((PsiExpression)parent); + final PsiType expectedTypeByParent = getExpectedTypeByParent(parent); return expectedTypeByParent != null && expectedTypeByParent instanceof PsiArrayType ? ((PsiArrayType)expectedTypeByParent).getComponentType() : null; } } return null; } - + + /** + * Returns the return type for enclosing method or lambda + * + * @param element element inside method or lambda to determine the return type of + * @return the return type or null if cannot be determined + */ + @Nullable + public static PsiType getMethodReturnType(PsiElement element) { + final PsiElement methodOrLambda = PsiTreeUtil.getParentOfType(element, PsiMethod.class, PsiLambdaExpression.class); + return methodOrLambda instanceof PsiMethod + ? ((PsiMethod)methodOrLambda).getReturnType() + : methodOrLambda instanceof PsiLambdaExpression ? LambdaUtil.getFunctionalInterfaceReturnType((PsiLambdaExpression)methodOrLambda) : null; + } + public static boolean compareTypes(PsiType leftType, PsiType rightType, boolean ignoreEllipsis) { if (ignoreEllipsis) { if (leftType instanceof PsiEllipsisType) { diff --git a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaVariableConflictResolver.java b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaVariableConflictResolver.java index 9ebd9dd230ab..b9dcecdabd25 100644 --- a/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaVariableConflictResolver.java +++ b/java/java-psi-impl/src/com/intellij/psi/scope/conflictResolvers/JavaVariableConflictResolver.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2014 JetBrains s.r.o. + * Copyright 2000-2016 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. @@ -69,7 +69,7 @@ public class JavaVariableConflictResolver implements PsiConflictResolver{ Boolean oldClassIsInheritor = null; if (newClass != null && oldClass != null) { if (newClass.isInheritor(oldClass, true)) { - if (scope != null && + if (scope instanceof PsiClass && (scope.equals(oldClass) || scope.equals(newClass) || !((PsiClass)scope).isInheritorDeep(oldClass, newClass))) { diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterAnnotation.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterAnnotation.java new file mode 100644 index 000000000000..c48d0961c8ef --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterAnnotation.java @@ -0,0 +1,15 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.lang.annotation.Annotation; +import java.lang.reflect.AnnotatedElement; +import java.util.Optional; + +public class Main { + public static Optional findAnnotation(Optional element) { + return element.>map(annotatedElement -> annotatedElement.getAnnotations().length == 0 ? Optional.empty() : null).orElseGet(() -> findAnnotation((AnnotatedElement) null)); + } + + private static Optional findAnnotation(AnnotatedElement element) { + return Optional.empty(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterAssignmentSelfOrEmpty.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterAssignmentSelfOrEmpty.java new file mode 100644 index 000000000000..391d66ab72bb --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterAssignmentSelfOrEmpty.java @@ -0,0 +1,11 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.util.*; + +public class Main { + Optional foo(Optional first) { + Optional o; + o = first; + return o; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterOptionalReturnSelfOrEmpty.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterOptionalReturnSelfOrEmpty.java new file mode 100644 index 000000000000..1e2a51eab313 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterOptionalReturnSelfOrEmpty.java @@ -0,0 +1,9 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.util.*; + +public class Main { + Optional foo(Optional first) { + return first; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterReturnFunction.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterReturnFunction.java new file mode 100644 index 000000000000..211f338e150e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterReturnFunction.java @@ -0,0 +1,9 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.util.*; + +public class Main { + public static Runnable get(Optional s) { + return s.map(s1 -> s1::trim).orElse(null); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterTernarySelfOrEmpty.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterTernarySelfOrEmpty.java new file mode 100644 index 000000000000..abd4d40197ba --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/afterTernarySelfOrEmpty.java @@ -0,0 +1,10 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.util.*; + +public class Main { + Optional foo(Optional first) { + Optional o = first; + return o; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAnnotation.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAnnotation.java new file mode 100644 index 000000000000..df23bba47965 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAnnotation.java @@ -0,0 +1,18 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.lang.annotation.Annotation; +import java.lang.reflect.AnnotatedElement; +import java.util.Optional; + +public class Main { + public static Optional findAnnotation(Optional element) { + if (element.isPresent()) { + return element.get().getAnnotations().length == 0 ? Optional.empty() : null; + } + return findAnnotation((AnnotatedElement)null); + } + + private static Optional findAnnotation(AnnotatedElement element) { + return Optional.empty(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAnnotationInverted.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAnnotationInverted.java new file mode 100644 index 000000000000..2b8fadbd3cde --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAnnotationInverted.java @@ -0,0 +1,18 @@ +// "Replace Optional.isPresent() condition with functional style expression" "false" + +import java.lang.annotation.Annotation; +import java.lang.reflect.AnnotatedElement; +import java.util.Optional; + +public class Main { + public static Optional findAnnotation(Optional element) { + if (element.isPresent()) { + return Optional.empty(); + } + return findAnnotation((AnnotatedElement)null); + } + + private static Optional findAnnotation(AnnotatedElement element) { + return Optional.empty(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAssignmentSelfOrEmpty.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAssignmentSelfOrEmpty.java new file mode 100644 index 000000000000..3bda6425d71d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeAssignmentSelfOrEmpty.java @@ -0,0 +1,14 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.util.*; + +public class Main { + Optional foo(Optional first) { + Optional o; + if (first.isPresent()) + o = first; + else + o = Optional.empty(); + return o; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeOptionalReturnSelf.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeOptionalReturnSelf.java new file mode 100644 index 000000000000..ced3cad5af70 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeOptionalReturnSelf.java @@ -0,0 +1,14 @@ +// "Replace Optional.isPresent() condition with functional style expression" "false" + +import java.util.*; + +public class Main { + Optional foo(Optional first) { + // could be replaced in Java-9 with return first.or(() -> "xyz"); + // but the only option in Java-8 is return first.map(Optional::of).orElseGet(() -> Optional.of("xyz")) which is weird + if (first.isPresent()) { + return first; + } + return Optional.of("xyz"); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeOptionalReturnSelfOrEmpty.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeOptionalReturnSelfOrEmpty.java new file mode 100644 index 000000000000..ac49d516cbfe --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeOptionalReturnSelfOrEmpty.java @@ -0,0 +1,12 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.util.*; + +public class Main { + Optional foo(Optional first) { + if (first.isPresent()) { + return first; + } + return Optional.empty(); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeReturnFunction.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeReturnFunction.java new file mode 100644 index 000000000000..5cdb31f51d00 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeReturnFunction.java @@ -0,0 +1,12 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.util.*; + +public class Main { + public static Runnable get(Optional s) { + if(s.isPresent()) { + return s.get()::trim; + } + return null; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeTernarySelfOrEmpty.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeTernarySelfOrEmpty.java new file mode 100644 index 000000000000..cfddf0d960ad --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/optionalIsPresent/beforeTernarySelfOrEmpty.java @@ -0,0 +1,10 @@ +// "Replace Optional.isPresent() condition with functional style expression" "true" + +import java.util.*; + +public class Main { + Optional foo(Optional first) { + Optional o = !first.isPresent() ? Optional.empty() : first; + return o; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCastExpected.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCastExpected.java index 06440af2b9fb..cbf887b56104 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCastExpected.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCastExpected.java @@ -5,7 +5,7 @@ import java.util.stream.Collectors; class Test { public static List> fromString(final T src, Function> extractor) { - final List> result = extractor.apply(src).stream().>map(TokenFilter::new).collect(Collectors.toList()); + final List> result = extractor.apply(src).stream().map((Function>) TokenFilter::new).collect(Collectors.toList()); return result; } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectAnonymous.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectAnonymous.java index 2d76ac58d30f..252a6488f29b 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectAnonymous.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectAnonymous.java @@ -5,7 +5,7 @@ import java.util.stream.Collectors; public class Main { public List test(List list) { - List result = list.stream().map(s -> new Runnable() { + List result = list.stream().map(s -> new Runnable() { @Override public void run() { String str = s; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectContravariant.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectContravariant.java new file mode 100644 index 000000000000..3aaf86530da0 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectContravariant.java @@ -0,0 +1,14 @@ +// "Replace with collect" "true" + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +public class Main { + public static List> test(List list) { + List> strings = list.stream().>map(Collections::singletonList).collect(Collectors.toList()); + return strings; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectListSuperType.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectListSuperType.java new file mode 100644 index 000000000000..5258ba1017ec --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectListSuperType.java @@ -0,0 +1,11 @@ +// "Replace with collect" "true" + +import java.util.*; +import java.util.stream.Collectors; + +public class Main { + public List getListCharSequence(List input) { + List result = input.stream().filter(s -> !s.isEmpty()).map(String::trim).collect(Collectors.toList()); + return result; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectNulls.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectNulls.java new file mode 100644 index 000000000000..fabf0f2c51f3 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectNulls.java @@ -0,0 +1,13 @@ +// "Replace with collect" "true" + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +public class Main { + public static List test() { + List strings = IntStream.range(0, 10).mapToObj(x -> null).collect(Collectors.toList()); + return strings; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectSupertype.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectSupertype.java new file mode 100644 index 000000000000..f242758b3d7c --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterCollectSupertype.java @@ -0,0 +1,14 @@ +// "Replace with collect" "true" + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +public class Main { + public static List> test(List list) { + List> strings = list.stream().map(Collections::singletonList).collect(Collectors.toList()); + return strings; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterFindFirstOptionalType.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterFindFirstOptionalType.java new file mode 100644 index 000000000000..985f639f74db --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterFindFirstOptionalType.java @@ -0,0 +1,10 @@ +// "Replace with findFirst()" "true" + +import java.util.*; + +public class Main { + public List getErrors(List data) { + List def = Collections.singletonList("Not found"); + return data.stream().filter(s -> s.startsWith("xyz")).findFirst().>map(s -> s.length() < 10 ? Collections.emptyList() : Arrays.asList()).orElse(def); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterFindFirstRunnableTernary.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterFindFirstRunnableTernary.java new file mode 100644 index 000000000000..7efcda486949 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/afterFindFirstRunnableTernary.java @@ -0,0 +1,10 @@ +// "Replace with findFirst()" "true" + +import java.util.*; + +public class Main { + public Runnable getRunnable(List data) { + Runnable def = () -> {}; + return data.stream().filter(s -> s.startsWith("xyz")).findFirst().map(s -> s.length() > 2 ? s::trim : System.out::println).orElse(def); + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectContravariant.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectContravariant.java new file mode 100644 index 000000000000..bbf8206bda7e --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectContravariant.java @@ -0,0 +1,17 @@ +// "Replace with collect" "true" + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +public class Main { + public static List> test(List list) { + List> strings = new ArrayList<>(); + for (String s : list) { + List e = Collections.singletonList(s); + strings.add(e); + } + return strings; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectListSuperType.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectListSuperType.java new file mode 100644 index 000000000000..d92f4548953f --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectListSuperType.java @@ -0,0 +1,15 @@ +// "Replace with collect" "true" + +import java.util.*; + +public class Main { + public List getListCharSequence(List input) { + List result = new ArrayList<>(); + for(String s : input) { + if(!s.isEmpty()) { + result.add(s.trim()); + } + } + return result; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectNulls.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectNulls.java new file mode 100644 index 000000000000..476977704b11 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectNulls.java @@ -0,0 +1,14 @@ +// "Replace with collect" "true" + +import java.util.ArrayList; +import java.util.List; + +public class Main { + public static List test() { + List strings = new ArrayList<>(); + for(int x = 0; x < 10; x++) { + strings.add(null); + } + return strings; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectSupertype.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectSupertype.java new file mode 100644 index 000000000000..09ba97e24cef --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeCollectSupertype.java @@ -0,0 +1,17 @@ +// "Replace with collect" "true" + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +public class Main { + public static List> test(List list) { + List> strings = new ArrayList<>(); + for (String s : list) { + List e = Collections.singletonList(s); + strings.add(e); + } + return strings; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeFindFirstOptionalType.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeFindFirstOptionalType.java new file mode 100644 index 000000000000..0f25ac950bbb --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeFindFirstOptionalType.java @@ -0,0 +1,15 @@ +// "Replace with findFirst()" "true" + +import java.util.*; + +public class Main { + public List getErrors(List data) { + List def = Collections.singletonList("Not found"); + for(String s : data) { + if(s.startsWith("xyz")) { + return s.length() < 10 ? Collections.emptyList() : Arrays.asList(); + } + } + return def; + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeFindFirstRunnableTernary.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeFindFirstRunnableTernary.java new file mode 100644 index 000000000000..d9b4affb0143 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/streamApiMigration/beforeFindFirstRunnableTernary.java @@ -0,0 +1,15 @@ +// "Replace with findFirst()" "true" + +import java.util.*; + +public class Main { + public Runnable getRunnable(List data) { + Runnable def = () -> {}; + for(String s : data) { + if(s.startsWith("xyz")) { + return s.length() > 2 ? s::trim : System.out::println; + } + } + return def; + } +} \ No newline at end of file diff --git a/java/typeMigration/src/com/intellij/refactoring/typeMigration/rules/guava/GuavaTypeConversionDescriptor.java b/java/typeMigration/src/com/intellij/refactoring/typeMigration/rules/guava/GuavaTypeConversionDescriptor.java index 9c99cbf25580..7c82412c193c 100644 --- a/java/typeMigration/src/com/intellij/refactoring/typeMigration/rules/guava/GuavaTypeConversionDescriptor.java +++ b/java/typeMigration/src/com/intellij/refactoring/typeMigration/rules/guava/GuavaTypeConversionDescriptor.java @@ -22,7 +22,6 @@ import com.intellij.refactoring.typeMigration.TypeConversionDescriptor; import com.intellij.refactoring.typeMigration.TypeEvaluator; import com.intellij.util.ArrayUtil; import com.intellij.util.IncorrectOperationException; -import com.siyeh.ig.psiutils.TypeUtils; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -64,7 +63,7 @@ public class GuavaTypeConversionDescriptor extends TypeConversionDescriptor { return isIterable(((PsiLocalVariable)parent).getType()); } else if (parent instanceof PsiReturnStatement) { - return isIterable(TypeUtils.getMethodReturnType(parent)); + return isIterable(PsiTypesUtil.getMethodReturnType(parent)); } else if (parent instanceof PsiExpressionList) { final PsiExpressionList expressionList = (PsiExpressionList)parent; diff --git a/platform/lang-impl/src/com/intellij/refactoring/changeSignature/inplace/InplaceChangeSignature.java b/platform/lang-impl/src/com/intellij/refactoring/changeSignature/inplace/InplaceChangeSignature.java index f612d07b36b3..d5c6c93f6629 100644 --- a/platform/lang-impl/src/com/intellij/refactoring/changeSignature/inplace/InplaceChangeSignature.java +++ b/platform/lang-impl/src/com/intellij/refactoring/changeSignature/inplace/InplaceChangeSignature.java @@ -106,7 +106,7 @@ public class InplaceChangeSignature implements DocumentListener { } @Nullable - public static InplaceChangeSignature getCurrentRefactoring(Editor editor) { + public static InplaceChangeSignature getCurrentRefactoring(@NotNull Editor editor) { return editor.getUserData(INPLACE_CHANGE_SIGNATURE); } diff --git a/platform/platform-impl/src/com/intellij/openapi/application/impl/ApplicationImpl.java b/platform/platform-impl/src/com/intellij/openapi/application/impl/ApplicationImpl.java index 82a71f46953b..0b1b5458df4f 100644 --- a/platform/platform-impl/src/com/intellij/openapi/application/impl/ApplicationImpl.java +++ b/platform/platform-impl/src/com/intellij/openapi/application/impl/ApplicationImpl.java @@ -217,6 +217,8 @@ public class ApplicationImpl extends PlatformComponentManagerImpl implements App return Thread.currentThread(); }); myLock = new ReadMostlyRWLock(edt); + + NoSwingUnderWriteAction.watchForEvents(this); } /** diff --git a/platform/platform-impl/src/com/intellij/openapi/application/impl/NoSwingUnderWriteAction.java b/platform/platform-impl/src/com/intellij/openapi/application/impl/NoSwingUnderWriteAction.java new file mode 100644 index 000000000000..49ea7fe00968 --- /dev/null +++ b/platform/platform-impl/src/com/intellij/openapi/application/impl/NoSwingUnderWriteAction.java @@ -0,0 +1,48 @@ +/* + * Copyright 2000-2016 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.openapi.application.impl; + +import com.intellij.ide.IdeEventQueue; +import com.intellij.openapi.application.Application; +import com.intellij.openapi.application.ApplicationAdapter; +import com.intellij.openapi.diagnostic.Logger; +import org.jetbrains.annotations.NotNull; + +import java.util.concurrent.atomic.AtomicBoolean; + +/** + * @author peter + */ +class NoSwingUnderWriteAction { + private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.application.impl.NoSwingUnderWriteAction"); + + static void watchForEvents(Application application) { + AtomicBoolean reported = new AtomicBoolean(); + IdeEventQueue.getInstance().addPostprocessor(e -> { + if (application.isWriteAccessAllowed() && reported.compareAndSet(false, true)) { + LOG.error("AWT events are not allowed inside write action: " + e); + } + return true; + }, application); + + application.addApplicationListener(new ApplicationAdapter() { + @Override + public void afterWriteActionFinished(@NotNull Object action) { + reported.set(false); + } + }); + } +} diff --git a/platform/platform-resources/src/idea/PlatformActions.xml b/platform/platform-resources/src/idea/PlatformActions.xml index c4f5987ff5bd..7e9e747f3359 100644 --- a/platform/platform-resources/src/idea/PlatformActions.xml +++ b/platform/platform-resources/src/idea/PlatformActions.xml @@ -222,6 +222,7 @@ + @@ -410,8 +411,6 @@ - - diff --git a/platform/vcs-log/impl/src/META-INF/vcs-log.xml b/platform/vcs-log/impl/src/META-INF/vcs-log.xml index 960c14f95090..ddb7c123fe4c 100644 --- a/platform/vcs-log/impl/src/META-INF/vcs-log.xml +++ b/platform/vcs-log/impl/src/META-INF/vcs-log.xml @@ -56,8 +56,6 @@ - @@ -83,12 +81,10 @@ - - diff --git a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/render/LabelPainter.java b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/render/LabelPainter.java index 3004786317dc..1cf34ce9d658 100644 --- a/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/render/LabelPainter.java +++ b/platform/vcs-log/impl/src/com/intellij/vcs/log/ui/render/LabelPainter.java @@ -68,6 +68,7 @@ public class LabelPainter implements ReferencePainter { private static final String SEPARATOR = "/"; @SuppressWarnings("UseJBColor") private static final JBColor BACKGROUND = new JBColor(Color.BLACK, Color.WHITE); private static final float BALANCE = 0.08f; + private static final JBColor TEXT_COLOR = new JBColor(new Color(0x7a7a7a), new Color(0x909090)); @NotNull private final VcsLogData myLogData; @@ -89,7 +90,7 @@ public class LabelPainter implements ReferencePainter { boolean isSelected, int availableWidth) { myBackground = background; - myForeground = foreground; + myForeground = isSelected ? foreground : TEXT_COLOR; FontMetrics metrics = component.getFontMetrics(getReferenceFont()); myHeight = metrics.getHeight() + TOP_TEXT_PADDING + BOTTOM_TEXT_PADDING; diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/maturity/ObsoleteCollectionInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/maturity/ObsoleteCollectionInspection.java index cbab7d49a0bb..80e87229f293 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/maturity/ObsoleteCollectionInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/maturity/ObsoleteCollectionInspection.java @@ -19,12 +19,12 @@ import com.intellij.codeInspection.ui.SingleCheckboxOptionsPanel; import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.searches.ReferencesSearch; +import com.intellij.psi.util.PsiTypesUtil; import com.intellij.util.Query; import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.psiutils.LibraryUtil; -import com.siyeh.ig.psiutils.TypeUtils; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -176,7 +176,7 @@ public class ObsoleteCollectionInspection extends BaseInspection { } } else if (parent instanceof PsiReturnStatement) { - final PsiType returnType = TypeUtils.getMethodReturnType(parent); + final PsiType returnType = PsiTypesUtil.getMethodReturnType(parent); if (isObsoleteCollectionType(returnType)) { return true; } diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ExpectedTypeUtils.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ExpectedTypeUtils.java index fd1dbcc13058..3da07ca67df4 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ExpectedTypeUtils.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/ExpectedTypeUtils.java @@ -19,6 +19,7 @@ import com.intellij.codeInsight.ExceptionUtil; import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.tree.IElementType; +import com.intellij.psi.util.PsiTypesUtil; import com.intellij.psi.util.TypeConversionUtil; import com.intellij.util.ArrayUtil; import com.intellij.util.IncorrectOperationException; @@ -378,7 +379,7 @@ public class ExpectedTypeUtils { @Override public void visitReturnStatement(@NotNull PsiReturnStatement returnStatement) { - expectedType = TypeUtils.getMethodReturnType(returnStatement); + expectedType = PsiTypesUtil.getMethodReturnType(returnStatement); } @Override diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/TypeUtils.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/TypeUtils.java index 35e9af3a8502..7e9dcd7007c1 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/TypeUtils.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/TypeUtils.java @@ -19,7 +19,6 @@ import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.InheritanceUtil; -import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.psi.util.TypeConversionUtil; import org.jetbrains.annotations.NonNls; @@ -258,18 +257,4 @@ public class TypeUtils { } return type; } - - /** - * Returns the return type for enclosing method or lambda - * - * @param element element inside method or lambda to determine the return type of - * @return the return type or null if cannot be determined - */ - @Nullable - public static PsiType getMethodReturnType(PsiElement element) { - final PsiElement methodOrLambda = PsiTreeUtil.getParentOfType(element, PsiMethod.class, PsiLambdaExpression.class); - return methodOrLambda instanceof PsiMethod - ? ((PsiMethod)methodOrLambda).getReturnType() - : methodOrLambda instanceof PsiLambdaExpression ? LambdaUtil.getFunctionalInterfaceReturnType((PsiLambdaExpression)methodOrLambda) : null; - } } \ No newline at end of file diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/WeakestTypeFinder.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/WeakestTypeFinder.java index fc06747223a9..28056b11b979 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/WeakestTypeFinder.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/psiutils/WeakestTypeFinder.java @@ -25,6 +25,7 @@ import com.intellij.psi.search.searches.SuperMethodsSearch; import com.intellij.psi.tree.IElementType; import com.intellij.psi.util.InheritanceUtil; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiTypesUtil; import com.intellij.psi.util.PsiUtil; import com.intellij.util.ArrayUtil; import com.intellij.util.Query; @@ -155,7 +156,7 @@ public class WeakestTypeFinder { checkClass(javaLangIterableClass, weakestTypeClasses); } else if (referenceParent instanceof PsiReturnStatement) { - final PsiType type = TypeUtils.getMethodReturnType(referenceParent); + final PsiType type = PsiTypesUtil.getMethodReturnType(referenceParent); if (!checkType(type, weakestTypeClasses)) { return Collections.emptyList(); } diff --git a/plugins/InspectionGadgets/src/com/siyeh/ig/junit/JUnit5AssertionsConverterInspection.java b/plugins/InspectionGadgets/src/com/siyeh/ig/junit/JUnit5AssertionsConverterInspection.java index 6313a048c205..f3917fb92df5 100644 --- a/plugins/InspectionGadgets/src/com/siyeh/ig/junit/JUnit5AssertionsConverterInspection.java +++ b/plugins/InspectionGadgets/src/com/siyeh/ig/junit/JUnit5AssertionsConverterInspection.java @@ -30,6 +30,7 @@ import com.siyeh.InspectionGadgetsBundle; import com.siyeh.ig.BaseInspection; import com.siyeh.ig.BaseInspectionVisitor; import com.siyeh.ig.InspectionGadgetsFix; +import com.siyeh.ig.psiutils.ImportUtils; import com.siyeh.ig.testFrameworks.AssertHint; import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; @@ -181,10 +182,17 @@ public class JUnit5AssertionsConverterInspection extends BaseInspection { if (newAssertClass == null) { return; } + String qualifiedName = newAssertClass.getQualifiedName(); + if (qualifiedName == null) { + return; + } PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); - methodExpression.setQualifierExpression(JavaPsiFacade.getElementFactory(project).createReferenceExpression(newAssertClass)); - JavaCodeStyleManager.getInstance(project).shortenClassReferences(methodExpression); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier != null || !ImportUtils.addStaticImport(qualifiedName, methodName, methodExpression)) { + methodExpression.setQualifierExpression(JavaPsiFacade.getElementFactory(project).createReferenceExpression(newAssertClass)); + JavaCodeStyleManager.getInstance(project).shortenClassReferences(methodExpression); + } } @Nls diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertArrayEquals.after.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertArrayEquals.after.java index 3598b885bb4b..4cf7df0b96e3 100644 --- a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertArrayEquals.after.java +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertArrayEquals.after.java @@ -13,14 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import org.junit.jupiter.api.Assertions; - import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; class Test1 { @org.junit.jupiter.api.Test public void test_first() throws Exception { - Assertions.assertArrayEquals(new Object[] {}, null); + assertArrayEquals(new Object[] {}, null); } } diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertArrayEqualsMessage.after.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertArrayEqualsMessage.after.java index 61b9892218da..5828a361e6cf 100644 --- a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertArrayEqualsMessage.after.java +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertArrayEqualsMessage.after.java @@ -13,14 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import org.junit.jupiter.api.Assertions; - import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; class Test1 { @org.junit.jupiter.api.Test public void test_first() throws Exception { - Assertions.assertArrayEquals(new Object[] {}, null, "message"); + assertArrayEquals(new Object[] {}, null, "message"); } } diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertEquals.after.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertEquals.after.java index 660f132b8107..d6b299b71e29 100644 --- a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertEquals.after.java +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertEquals.after.java @@ -13,14 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import org.junit.jupiter.api.Assertions; - import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertEquals; class Test1 { @org.junit.jupiter.api.Test public void test_first() throws Exception { - Assertions.assertEquals("Expected", "actual", "message"); + assertEquals("Expected", "actual", "message"); } } diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertTrue.after.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertTrue.after.java index c23f10424dfa..e6af964ccd9a 100644 --- a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertTrue.after.java +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssertTrue.after.java @@ -13,15 +13,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import org.junit.jupiter.api.Assertions; - import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.assertTrue; class Test1 { @org.junit.jupiter.api.Test public void test_first() throws Exception { - Assertions.assertTrue(false, "message"); + assertTrue(false, "message"); } } diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssumeTrue.after.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssumeTrue.after.java index 4348ef6ace70..740481194960 100644 --- a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssumeTrue.after.java +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_assertions_converter/AssumeTrue.after.java @@ -13,14 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import org.junit.jupiter.api.Assumptions; - import static org.junit.Assume.*; +import static org.junit.jupiter.api.Assumptions.assumeTrue; class Test1 { @org.junit.jupiter.api.Test public void test_first() throws Exception { - Assumptions.assumeTrue(false, "message"); + assumeTrue(false, "message"); } } diff --git a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_converter/Simple.after.java b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_converter/Simple.after.java index 566d8facf130..8f14ac1809a5 100644 --- a/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_converter/Simple.after.java +++ b/plugins/InspectionGadgets/test/com/siyeh/igfixes/junit/junit5_converter/Simple.after.java @@ -13,23 +13,22 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; public class Simple { @Test public void test_first() throws Exception { - Assertions.assertArrayEquals(new Object[] {}, null); - Assertions.assertArrayEquals(new Object[] {}, null, "message"); + assertArrayEquals(new Object[] {}, null); + assertArrayEquals(new Object[] {}, null, "message"); - Assertions.assertEquals("Expected", "actual"); - Assertions.assertEquals("Expected", "actual", "message"); + assertEquals("Expected", "actual"); + assertEquals("Expected", "actual", "message"); fail(); - Assertions.fail(""); + fail(""); } } diff --git a/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ReplaceIfWithConditionalIntention.java b/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ReplaceIfWithConditionalIntention.java index 12522ae7edef..dd2c81ff9031 100644 --- a/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ReplaceIfWithConditionalIntention.java +++ b/plugins/IntentionPowerPak/src/com/siyeh/ipp/trivialif/ReplaceIfWithConditionalIntention.java @@ -18,11 +18,11 @@ package com.siyeh.ipp.trivialif; import com.intellij.psi.*; import com.intellij.psi.impl.PsiDiamondTypeUtil; import com.intellij.psi.util.PsiTreeUtil; +import com.intellij.psi.util.PsiTypesUtil; import com.siyeh.ig.PsiReplacementUtil; import com.siyeh.ig.psiutils.ControlFlowUtils; import com.siyeh.ig.psiutils.EquivalenceChecker; import com.siyeh.ig.psiutils.ParenthesesUtils; -import com.siyeh.ig.psiutils.TypeUtils; import com.siyeh.ipp.base.Intention; import com.siyeh.ipp.base.PsiElementPredicate; import org.jetbrains.annotations.NonNls; @@ -170,7 +170,7 @@ public class ReplaceIfWithConditionalIntention extends Intention { PsiElement thenBranch, PsiExpression thenReturnValue, PsiExpression elseReturnValue) { - final PsiType methodType = TypeUtils.getMethodReturnType(thenBranch); + final PsiType methodType = PsiTypesUtil.getMethodReturnType(thenBranch); return methodType == null ? null : getConditionalText(condition, thenReturnValue, elseReturnValue, methodType); } diff --git a/plugins/groovy/src/META-INF/groovy-dynamic-members.xml b/plugins/groovy/src/META-INF/groovy-dynamic-members.xml new file mode 100644 index 000000000000..a26b2cc30139 --- /dev/null +++ b/plugins/groovy/src/META-INF/groovy-dynamic-members.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/groovy/src/META-INF/plugin.xml b/plugins/groovy/src/META-INF/plugin.xml index 8af4657b1f95..2aa342ea7748 100644 --- a/plugins/groovy/src/META-INF/plugin.xml +++ b/plugins/groovy/src/META-INF/plugin.xml @@ -94,7 +94,6 @@ - @@ -1573,9 +1572,6 @@ org.jetbrains.plugins.groovy.intentions.declaration.GrRemoveExplicitTypeDeclarationIntention - - @@ -1668,17 +1664,6 @@ - - - - - - - - org.jetbrains.plugins.groovy.annotator.GrReferenceHighlighterFactory - - org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicManager - org.jetbrains.plugins.groovy.annotator.intentions.dynamic.DynamicManagerImpl - org.jetbrains.plugins.groovy.mvc.MvcModuleStructureSynchronizer + diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicManager.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicManager.java index a508214f394f..b9bac95e0357 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicManager.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicManager.java @@ -16,7 +16,7 @@ package org.jetbrains.plugins.groovy.annotator.intentions.dynamic; import com.intellij.openapi.components.PersistentStateComponent; -import com.intellij.openapi.components.ProjectComponent; +import com.intellij.openapi.components.ServiceManager; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiVariable; @@ -32,11 +32,11 @@ import java.util.List; * User: Dmitry.Krasilschikov * Date: 23.11.2007 */ -public abstract class DynamicManager implements ProjectComponent, PersistentStateComponent { +public abstract class DynamicManager implements PersistentStateComponent { @NotNull public static DynamicManager getInstance(@NotNull Project project) { - return project.getComponent(DynamicManager.class); + return ServiceManager.getService(project, DynamicManager.class); } /** diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicManagerImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicManagerImpl.java index 030995bf1a7f..0d10c21ed91f 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicManagerImpl.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicManagerImpl.java @@ -20,7 +20,6 @@ import com.intellij.openapi.application.TransactionGuard; import com.intellij.openapi.components.State; import com.intellij.openapi.components.Storage; import com.intellij.openapi.project.Project; -import com.intellij.openapi.startup.StartupManager; import com.intellij.openapi.wm.ToolWindow; import com.intellij.psi.PsiManager; import com.intellij.psi.PsiMethod; @@ -53,22 +52,12 @@ public class DynamicManagerImpl extends DynamicManager { public DynamicManagerImpl(final Project project) { myProject = project; - StartupManager.getInstance(project).registerPostStartupActivity(() -> { - if (!myRootElement.getContainingClasses().isEmpty()) { - DynamicToolWindowWrapper.getInstance(project).getToolWindow(); //initialize myToolWindow - } - }); } public Project getProject() { return myProject; } - - @Override - public void initComponent() { - } - @Override public void addProperty(DynamicElementSettings settings) { assert settings != null; @@ -390,8 +379,8 @@ public class DynamicManagerImpl extends DynamicManager { } @Nullable - private static DPropertyElement findConcreteDynamicProperty(DRootElement rootElement, final String conatainingClassName, final String propertyName) { - final DClassElement classElement = rootElement.getClassElement(conatainingClassName); + private static DPropertyElement findConcreteDynamicProperty(DRootElement rootElement, final String containingClassName, final String propertyName) { + final DClassElement classElement = rootElement.getClassElement(containingClassName); if (classElement == null) return null; @@ -399,43 +388,17 @@ public class DynamicManagerImpl extends DynamicManager { } @Nullable - private static DClassElement findClassElement(DRootElement rootElement, final String conatainingClassName) { - return rootElement.getClassElement(conatainingClassName); + private static DClassElement findClassElement(DRootElement rootElement, final String containingClassName) { + return rootElement.getClassElement(containingClassName); } - @Override - public void disposeComponent() { - } - - @Override - @NotNull - public String getComponentName() { - return "DynamicManagerImpl"; - } - - @Override - public void projectOpened() { - } - - @Override - public void projectClosed() { - } - - /** - * On exit - */ @Override public DRootElement getState() { -// return XmlSerializer.serialize(myRootElement); return myRootElement; } - /* - * On loading - */ @Override public void loadState(DRootElement element) { -// myRootElement = XmlSerializer.deserialize(element, myRootElement.getClass()); myRootElement = element; } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicMembersStartupActivity.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicMembersStartupActivity.java new file mode 100644 index 000000000000..603a10578a72 --- /dev/null +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/annotator/intentions/dynamic/DynamicMembersStartupActivity.java @@ -0,0 +1,31 @@ +/* + * Copyright 2000-2016 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 org.jetbrains.plugins.groovy.annotator.intentions.dynamic; + +import com.intellij.openapi.project.Project; +import com.intellij.openapi.startup.StartupActivity; +import org.jetbrains.annotations.NotNull; + +public class DynamicMembersStartupActivity implements StartupActivity { + + @Override + public void runActivity(@NotNull Project project) { + DynamicManager manager = DynamicManager.getInstance(project); + if (!manager.getRootElement().getContainingClasses().isEmpty()) { + DynamicToolWindowWrapper.getInstance(project).getToolWindow(); //initialize toolWindow + } + } +} diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/move/MoveGroovyClassHandler.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/move/MoveGroovyClassHandler.java index cf9cf5e10deb..035fecd5b531 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/move/MoveGroovyClassHandler.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/move/MoveGroovyClassHandler.java @@ -18,6 +18,7 @@ package org.jetbrains.plugins.groovy.refactoring.move; import com.intellij.lang.FileASTNode; import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.project.Project; import com.intellij.psi.*; import com.intellij.psi.impl.source.tree.Factory; import com.intellij.psi.javadoc.PsiDocComment; @@ -31,9 +32,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.plugins.groovy.GroovyFileType; import org.jetbrains.plugins.groovy.GroovyLanguage; -import org.jetbrains.plugins.groovy.actions.GroovyTemplates; -import org.jetbrains.plugins.groovy.actions.GroovyTemplatesFactory; -import org.jetbrains.plugins.groovy.actions.NewGroovyActionBase; import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocComment; import org.jetbrains.plugins.groovy.lang.groovydoc.psi.api.GrDocCommentOwner; import org.jetbrains.plugins.groovy.lang.groovydoc.psi.impl.GrDocCommentUtil; @@ -124,23 +122,21 @@ public class MoveGroovyClassHandler implements MoveClassHandler { } else if (((GroovyFile)file).getClasses().length > 1) { correctSelfReferences(aClass, newPackage); - - final PsiFile fromTemplate = - GroovyTemplatesFactory.createFromTemplate(moveDestination, aClass.getName(), aClass.getName() + NewGroovyActionBase.GROOVY_EXTENSION, GroovyTemplates.GROOVY_CLASS, true); - final PsiClass created = ((GroovyFile)fromTemplate).getClasses()[0]; + Project project = aClass.getProject(); + PsiFileFactory fileFactory = PsiFileFactory.getInstance(project); + GroovyFile newFile = (GroovyFile)moveDestination.add(fileFactory.createFileFromText( + aClass.getName() + "." + GroovyFileType.DEFAULT_EXTENSION, + GroovyLanguage.INSTANCE, + "class XXX {}" + )); + final PsiClass created = newFile.getClasses()[0]; PsiDocComment docComment = aClass.getDocComment(); if (docComment != null) { - final PsiDocComment createdDocComment = created.getDocComment(); - if (createdDocComment != null) { - createdDocComment.replace(docComment); - } - else { - created.getContainingFile().addBefore(docComment, created); - } + newFile.addBefore(docComment, created); docComment.delete(); } newClass = (PsiClass)created.replace(aClass); - setPackageDefinition((GroovyFile)file, (GroovyFile)newClass.getContainingFile(), newPackageName); + setPackageDefinition((GroovyFile)file, newFile, newPackageName); correctOldClassReferences(newClass, aClass); aClass.delete(); } diff --git a/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/move/GroovyMoveClassTest.groovy b/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/move/GroovyMoveClassTest.groovy index 89833676eabb..d2339b08d870 100644 --- a/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/move/GroovyMoveClassTest.groovy +++ b/plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/move/GroovyMoveClassTest.groovy @@ -15,8 +15,7 @@ */ package org.jetbrains.plugins.groovy.refactoring.move -import com.intellij.ide.fileTemplates.FileTemplate -import com.intellij.ide.fileTemplates.FileTemplateManager + import com.intellij.openapi.fileEditor.FileDocumentManager import com.intellij.openapi.vfs.VirtualFile import com.intellij.psi.* @@ -24,52 +23,18 @@ import com.intellij.psi.search.GlobalSearchScope import com.intellij.refactoring.PackageWrapper import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesProcessor import com.intellij.refactoring.move.moveClassesOrPackages.SingleSourceRootMoveDestination -import org.jetbrains.plugins.groovy.actions.GroovyTemplates +import groovy.transform.CompileStatic import org.jetbrains.plugins.groovy.util.TestUtils + /** * @author Maxim.Medvedev */ +@CompileStatic class GroovyMoveClassTest extends GroovyMoveTestBase { protected String getBasePath() { return TestUtils.getTestDataPath() + "refactoring/move/moveClass/" } - @Override - protected void setUp() throws Exception { - super.setUp() - final FileTemplateManager templateManager = FileTemplateManager.getInstance(getProject()) - FileTemplate temp = templateManager.getTemplate("GroovyClass.groovyForTest") - if (temp != null) templateManager.removeTemplate(temp) - - temp = templateManager.addTemplate("GroovyClass.groovyForTest", "groovy") - temp.text = '''\ -#if ( $PACKAGE_NAME != \"\" )package ${PACKAGE_NAME} -#end -class ${NAME} { -}''' - - temp = templateManager.getTemplate(GroovyTemplates.GROOVY_CLASS) - if (temp != null) templateManager.removeTemplate(temp) - - temp = templateManager.addTemplate(GroovyTemplates.GROOVY_CLASS, "groovy") - temp.text = '''\ -#if ( $PACKAGE_NAME != \"\" )package ${PACKAGE_NAME} -#end -class ${NAME} { -}''' - } - - @Override - protected void tearDown() throws Exception { - final FileTemplateManager templateManager = FileTemplateManager.getInstance(getProject()) - FileTemplate temp = templateManager.getTemplate(GroovyTemplates.GROOVY_CLASS) - templateManager.removeTemplate(temp) - - temp = templateManager.getTemplate("GroovyClass.groovyForTest") - templateManager.removeTemplate(temp) - super.tearDown() - } - void testMoveMultiple1() throws Exception { doTest("pack2", "pack1.Class1", "pack1.Class2") } diff --git a/plugins/ui-designer/src/com/intellij/uiDesigner/actions/CreateFormAction.java b/plugins/ui-designer/src/com/intellij/uiDesigner/actions/CreateFormAction.java index 195c8b4667ac..c8f590633839 100644 --- a/plugins/ui-designer/src/com/intellij/uiDesigner/actions/CreateFormAction.java +++ b/plugins/ui-designer/src/com/intellij/uiDesigner/actions/CreateFormAction.java @@ -179,7 +179,6 @@ public class CreateFormAction extends AbstractCreateFormAction { if (myValidator.checkInput(inputString) && myValidator.canClose(inputString)) { close(OK_EXIT_CODE); } - close(OK_EXIT_CODE); } public JComponent getPreferredFocusedComponent() {