From 4b547ab2fe7e9a2fad01cdf037510a3ef875ad36 Mon Sep 17 00:00:00 2001 From: Bas Leijdekkers Date: Mon, 30 Nov 2015 13:34:47 +0100 Subject: [PATCH 1/3] speed search for scopes combo box in file colors settings --- .../intellij/ui/tabs/FileColorConfigurationEditDialog.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/platform/lang-impl/src/com/intellij/ui/tabs/FileColorConfigurationEditDialog.java b/platform/lang-impl/src/com/intellij/ui/tabs/FileColorConfigurationEditDialog.java index 194cd9bf9973..cf6b19761f9d 100644 --- a/platform/lang-impl/src/com/intellij/ui/tabs/FileColorConfigurationEditDialog.java +++ b/platform/lang-impl/src/com/intellij/ui/tabs/FileColorConfigurationEditDialog.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2014 JetBrains s.r.o. + * Copyright 2000-2015 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. @@ -24,6 +24,7 @@ import com.intellij.psi.search.scope.packageSet.NamedScope; import com.intellij.psi.search.scope.packageSet.NamedScopeManager; import com.intellij.psi.search.scope.packageSet.NamedScopesHolder; import com.intellij.ui.ColorUtil; +import com.intellij.ui.ComboboxSpeedSearch; import com.intellij.ui.FileColorManager; import com.intellij.util.ArrayUtil; import com.intellij.util.containers.HashMap; @@ -105,6 +106,7 @@ public class FileColorConfigurationEditDialog extends DialogWrapper { updateOKButton(); } }); + new ComboboxSpeedSearch(myScopeComboBox); final JLabel pathLabel = new JLabel("Scope:"); pathLabel.setDisplayedMnemonic('S'); From d84e18ec58ab9cce244606ecc239cf629ff20b9f Mon Sep 17 00:00:00 2001 From: Bas Leijdekkers Date: Mon, 30 Nov 2015 13:51:18 +0100 Subject: [PATCH 2/3] add call/method/type hierarchy predefined scope --- .../ide/hierarchy/HierarchyBrowserBase.java | 40 ++++++++++++++++++- .../PredefinedSearchScopeProviderImpl.java | 30 ++++++++++++++ 2 files changed, 69 insertions(+), 1 deletion(-) diff --git a/platform/lang-impl/src/com/intellij/ide/hierarchy/HierarchyBrowserBase.java b/platform/lang-impl/src/com/intellij/ide/hierarchy/HierarchyBrowserBase.java index e5fd9cd57cf0..e253a213aa68 100644 --- a/platform/lang-impl/src/com/intellij/ide/hierarchy/HierarchyBrowserBase.java +++ b/platform/lang-impl/src/com/intellij/ide/hierarchy/HierarchyBrowserBase.java @@ -43,9 +43,10 @@ import org.jetbrains.annotations.Nullable; import javax.swing.*; import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.TreeModel; import javax.swing.tree.TreePath; import javax.swing.tree.TreeSelectionModel; -import java.util.ArrayList; +import java.util.*; /** * @author yole @@ -147,6 +148,43 @@ public abstract class HierarchyBrowserBase extends SimpleToolWindowPanel impleme return null; } + public PsiElement[] getAvailableElements() { + final JTree tree = getCurrentTree(); + if (tree == null) { + return PsiElement.EMPTY_ARRAY; + } + final TreeModel model = tree.getModel(); + final Object root = model.getRoot(); + if (!(root instanceof DefaultMutableTreeNode)) { + return PsiElement.EMPTY_ARRAY; + } + final DefaultMutableTreeNode node = (DefaultMutableTreeNode)root; + final HierarchyNodeDescriptor descriptor = getDescriptor(node); + final Set result = new HashSet(); + collectElements(descriptor, result); + return result.toArray(PsiElement.EMPTY_ARRAY); + } + + private void collectElements(HierarchyNodeDescriptor descriptor, Set out) { + if (descriptor == null) { + return; + } + final PsiElement element = getElementFromDescriptor(descriptor); + if (element != null) { + out.add(element); + } + final Object[] children = descriptor.getCachedChildren(); + if (children == null) { + return; + } + for (Object child : children) { + if (child instanceof HierarchyNodeDescriptor) { + final HierarchyNodeDescriptor childDescriptor = (HierarchyNodeDescriptor)child; + collectElements(childDescriptor, out); + } + } + } + public final HierarchyNodeDescriptor[] getSelectedDescriptors() { final JTree tree = getCurrentTree(); if (tree == null) { diff --git a/platform/lang-impl/src/com/intellij/psi/search/PredefinedSearchScopeProviderImpl.java b/platform/lang-impl/src/com/intellij/psi/search/PredefinedSearchScopeProviderImpl.java index 14912d1e409c..538456935a24 100644 --- a/platform/lang-impl/src/com/intellij/psi/search/PredefinedSearchScopeProviderImpl.java +++ b/platform/lang-impl/src/com/intellij/psi/search/PredefinedSearchScopeProviderImpl.java @@ -17,6 +17,7 @@ package com.intellij.psi.search; import com.intellij.ide.IdeBundle; import com.intellij.ide.favoritesTreeView.FavoritesManager; +import com.intellij.ide.hierarchy.HierarchyBrowserBase; import com.intellij.ide.projectView.impl.AbstractUrl; import com.intellij.openapi.actionSystem.CommonDataKeys; import com.intellij.openapi.actionSystem.DataContext; @@ -30,12 +31,17 @@ import com.intellij.openapi.util.Condition; import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.TextRange; import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.openapi.wm.ToolWindow; +import com.intellij.openapi.wm.ToolWindowId; +import com.intellij.openapi.wm.ToolWindowManager; import com.intellij.psi.PsiDocumentManager; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiFile; import com.intellij.psi.PsiWhiteSpace; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.psi.util.PsiUtilCore; +import com.intellij.ui.content.Content; +import com.intellij.ui.content.ContentManager; import com.intellij.usages.Usage; import com.intellij.usages.UsageView; import com.intellij.usages.UsageViewManager; @@ -47,6 +53,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jps.model.java.JavaSourceRootType; +import javax.swing.*; import java.util.*; public class PredefinedSearchScopeProviderImpl extends PredefinedSearchScopeProvider { @@ -139,6 +146,7 @@ public class PredefinedSearchScopeProviderImpl extends PredefinedSearchScopeProv } if (usageView) { + addHierarchyScope(project, result); UsageView selectedUsageView = UsageViewManager.getInstance(project).getSelectedUsageView(); if (selectedUsageView != null && !selectedUsageView.isSearchInProgress()) { final Set usages = selectedUsageView.getUsages(); @@ -239,6 +247,28 @@ public class PredefinedSearchScopeProviderImpl extends PredefinedSearchScopeProv return ContainerUtil.newArrayList(result); } + private static void addHierarchyScope(@NotNull Project project, Collection result) { + final ToolWindow toolWindow = ToolWindowManager.getInstance(project).getToolWindow(ToolWindowId.HIERARCHY); + if (toolWindow == null) { + return; + } + final ContentManager contentManager = toolWindow.getContentManager(); + final Content content = contentManager.getSelectedContent(); + if (content == null) { + return; + } + final String name = content.getDisplayName(); + final JComponent component = content.getComponent(); + if (!(component instanceof HierarchyBrowserBase)) { + return; + } + final HierarchyBrowserBase hierarchyBrowserBase = (HierarchyBrowserBase)component; + final PsiElement[] elements = hierarchyBrowserBase.getAvailableElements(); + if (elements.length > 0) { + result.add(new LocalSearchScope(elements, "Hierarchy '" + name + '\'')); + } + } + @Nullable private static SearchScope getSelectedFilesScope(final Project project, @Nullable DataContext dataContext) { final VirtualFile[] filesOrDirs = dataContext == null ? null : CommonDataKeys.VIRTUAL_FILE_ARRAY.getData(dataContext); From 621795bbee27a1bf9e77fa0cb73fb2a145ec9966 Mon Sep 17 00:00:00 2001 From: Anna Kozlova Date: Mon, 30 Nov 2015 15:02:29 +0100 Subject: [PATCH 3/3] isApplicability check based on pertinentToApplicability --- .../daemon/impl/analysis/HighlightMethodUtil.java | 4 ++++ .../src/com/intellij/psi/infos/MethodCandidateInfo.java | 2 +- .../constraints/StrictSubtypingConstraint.java | 3 +++ .../constraints/TypeEqualityConstraint.java | 4 ++++ .../genericsHighlighting8/IDEA106964.java | 5 ++++- .../genericsHighlighting8/IDEA57311.java | 2 +- .../genericsHighlighting8/IDEA67746.java | 2 +- .../graphInference/IncompatibleBoundsFromAssignment.java | 8 ++++---- .../lambda/graphInference/IntersectionWithArray.java | 4 ++-- .../graphInference/OuterCallConflictResolution.java | 2 +- .../highlighting/AmbiguityReturnValueResolution2.java | 2 +- .../highlighting/AmbiguityReturnValueResolution3.java | 2 +- .../lambda/highlighting/ReturnTypeCompatibility.java | 4 ++-- .../lambda/highlighting/ReturnTypeCompatibility1.java | 6 +++--- .../lambda/incomplete/InsideParenthesis.java | 2 +- .../lambda/methodRef/InferenceFromReturnType.java | 6 +++--- .../lambda/methodRef/MethodTypeParamsInference.java | 2 +- .../daemonCodeAnalyzer/lambda/methodRef/RawQualifier.java | 2 +- .../lambda/methodRef/ReturnTypeSpecific.java | 6 +++--- .../lambda/mostSpecific/JDK8034223.java | 2 +- .../lambda/mostSpecific/TargetTypeParameter.java | 2 +- ...HighlightReferenceWhenContradictBoundsAreInferred.java | 4 ++-- ...turnsOfExplicitlyTypedLambdaWhenPrimitiveCouldWin.java | 2 +- .../PertinentToApplicabilityOfExplicitlyTypedLambda.java | 2 +- 24 files changed, 47 insertions(+), 33 deletions(-) diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java index 426170abe4aa..8d5dc904368b 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java @@ -367,6 +367,10 @@ public class HighlightMethodUtil { final String errorMessage = ((MethodCandidateInfo)resolveResult).getInferenceErrorMessage(); if (errorMessage != null) { highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).descriptionAndTooltip(errorMessage).range(fixRange).create(); + if (highlightInfo != null) { + registerMethodCallIntentions(highlightInfo, methodCall, list, resolveHelper); + registerMethodReturnFixAction(highlightInfo, (MethodCandidateInfo)resolveResult, methodCall); + } } } } diff --git a/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java b/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java index d5357d4acf99..61fc9850813d 100644 --- a/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java +++ b/java/java-psi-api/src/com/intellij/psi/infos/MethodCandidateInfo.java @@ -82,7 +82,7 @@ public class MethodCandidateInfo extends CandidateInfo{ } public boolean isApplicable(){ - return getApplicabilityLevel() != ApplicabilityLevel.NOT_APPLICABLE; + return getPertinentApplicabilityLevel() != ApplicabilityLevel.NOT_APPLICABLE; } @ApplicabilityLevelConstant diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/StrictSubtypingConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/StrictSubtypingConstraint.java index 16f7ad751770..49a4e18938b4 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/StrictSubtypingConstraint.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/StrictSubtypingConstraint.java @@ -140,6 +140,9 @@ public class StrictSubtypingConstraint implements ConstraintFormula { for (PsiTypeParameter parameter : CClass.getTypeParameters()) { final PsiType tSubstituted = tSubstitutor.substitute(parameter); final PsiType sSubstituted = sSubstitutor.substituteWithBoundsPromotion(parameter); + if (tSubstituted == null ^ sSubstituted == null) { + return false; + } constraints.add(new SubtypingConstraint(tSubstituted, sSubstituted)); } return true; diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/TypeEqualityConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/TypeEqualityConstraint.java index 5ddbfc4b0c22..2720ff7322e9 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/TypeEqualityConstraint.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/TypeEqualityConstraint.java @@ -107,6 +107,10 @@ public class TypeEqualityConstraint implements ConstraintFormula { if (tSubstituted != null && sSubstituted != null) { constraints.add(new TypeEqualityConstraint(tSubstituted, sSubstituted)); } + if (tSubstituted == null ^ sSubstituted == null) { + session.registerIncompatibleErrorMessage("Incompatible equality constraint: " + myT.getPresentableText() + " and " + myS.getPresentableText()); + return false; + } } return true; } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA106964.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA106964.java index d767e8cb8dbf..21140e7df2b8 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA106964.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA106964.java @@ -7,6 +7,9 @@ abstract class Test { abstract T test(Serializable type); private void call(){ - String s = test(String[].class); + String s = test(String[].class); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA57311.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA57311.java index f51997bb58e3..6eb766620620 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA57311.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA57311.java @@ -4,7 +4,7 @@ class A { } void bar(A x){ - baz(x.foo()); + baz(x.foo()); } void baz(A> x){} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA67746.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA67746.java index 8e847e6a68ae..b8bca3d9c327 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA67746.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting8/IDEA67746.java @@ -4,6 +4,6 @@ abstract class B { abstract void foo(List> x); void bar(List x){ - foo(x); + foo(x); } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IncompatibleBoundsFromAssignment.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IncompatibleBoundsFromAssignment.java index d5b8b03050d5..74c53d3a5dde 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IncompatibleBoundsFromAssignment.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IncompatibleBoundsFromAssignment.java @@ -3,10 +3,10 @@ import java.util.Map; class Test { public static void main(String[] args) { - Map b = newMapTrie(); - Map> c = newMapTrie(); - Map>> d = newMapTrie(); - Map>>> e = newMapTrie(); + Map b = newMapTrie(); + Map> c = newMapTrie(); + Map>> d = newMapTrie(); + Map>>> e = newMapTrie(); } public static > T newMapTrie() { diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IntersectionWithArray.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IntersectionWithArray.java index f2c5e403208a..54d3f1102418 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IntersectionWithArray.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/IntersectionWithArray.java @@ -6,8 +6,8 @@ class Issue { public static void main(String[] args) { consume(get()); - consume(getSerizalizable()); - consume(getObject()); + consume(getSerizalizable()); + consume(getObject()); } public static T get() { diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/OuterCallConflictResolution.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/OuterCallConflictResolution.java index dd04a51b2703..23c3e720b5c2 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/OuterCallConflictResolution.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/graphInference/OuterCallConflictResolution.java @@ -8,7 +8,7 @@ class Test { { m(foo()); - m(bar()); + m(bar()); } List foo() { diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java index fba4d622f457..5d90067536f4 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution2.java @@ -20,7 +20,7 @@ public class Test { public static void main(String[] args) { Inner inn = new Inner<>(); inn.m8(p -> 1.0); - new Test().foo(p -> 1.0); + new Test().foo(p -> 1.0); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java index e7570ba72b23..da88474bfbe0 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/AmbiguityReturnValueResolution3.java @@ -8,7 +8,7 @@ class Test { IntStream mi = sp.map(Inner::foo); Stream mI = sp.map(Inner::fooBoxed); - IntStream li = sp.map(inner->inner.foo()); + IntStream li = sp.map(inner->inner.foo()); Stream lI = sp.map(inner -> inner.fooBoxed()); } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility.java index 9134ede93aab..0c75ae1d7d6e 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility.java @@ -25,7 +25,7 @@ class ReturnTypeIncompatibility { } public static void main(String[] args) { - call(i-> {return i;}); + call(i-> {return i;}); } } @@ -57,7 +57,7 @@ class ReturnTypeCompatibility { } public static void main(String[] args) { - call(i-> {return i;}); + call(i-> {return i;}); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility1.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility1.java index d5dcb3d9472d..fd5858ad02bf 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility1.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/highlighting/ReturnTypeCompatibility1.java @@ -21,9 +21,9 @@ class Test { } void foo(Foo as, final Foo ac) { - boolean b1 = as.forAll(s -> ac.forAll(c -> false)); - String s1 = as.forAll(s -> ac.forAll(c -> "")); - boolean b2 = as.forAll(s -> ac.forAll(c -> "")); + boolean b1 = as.forAll(s -> ac.forAll(c -> false)); + String s1 = as.forAll(s -> ac.forAll(c -> "")); + boolean b2 = as.forAll(s -> ac.forAll(c -> "")); String s2 = as.forAll2(s -> ac.forAll2(c -> false)); boolean b3 = as.forAll((I)s -> ac.forAll((I)c -> "")); String s3 = as.forAll((II)s -> ac.forAll((II)c -> false)); diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/incomplete/InsideParenthesis.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/incomplete/InsideParenthesis.java index f6348bb2e479..86195b342bd5 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/incomplete/InsideParenthesis.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/incomplete/InsideParenthesis.java @@ -9,6 +9,6 @@ class Calls { void foo(Function computable) {} { - ((x) -> a(b(c(x)))); + ((x) -> a(b(c(x)))); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/InferenceFromReturnType.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/InferenceFromReturnType.java index b21f90a0ab67..0b027f84225d 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/InferenceFromReturnType.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/InferenceFromReturnType.java @@ -21,7 +21,7 @@ class MyTestDefaultConstructor { private static void foo(I3 i) {System.out.println(i);} static { - foo(Foo::new); + foo(Foo::new); } } @@ -49,7 +49,7 @@ class MyTestConstructor { private static void foo(I3 i) {System.out.println(i);} static { - foo(Foo::new); + foo(Foo::new); } } @@ -78,6 +78,6 @@ class MyTestMethod { private static void foo(I3 i) {System.out.println(i);} static { - foo(MyTestMethod::m); + foo(MyTestMethod::m); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodTypeParamsInference.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodTypeParamsInference.java index 06e45209cf81..e31035349c0d 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodTypeParamsInference.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/MethodTypeParamsInference.java @@ -20,7 +20,7 @@ class MyTest { static void foo(I3 i) {} static { - foo(MyTest::m); + foo(MyTest::m); foo(MyTest::m1); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RawQualifier.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RawQualifier.java index 67bbac28af1e..69fd19863ad2 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RawQualifier.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/RawQualifier.java @@ -39,6 +39,6 @@ class MyTest1 { static void foo(I3 i) {} static { - foo(Foo::new); + foo(Foo::new); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ReturnTypeSpecific.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ReturnTypeSpecific.java index 6b4de4e565a8..848c423302c6 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ReturnTypeSpecific.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/methodRef/ReturnTypeSpecific.java @@ -29,7 +29,7 @@ class MyTest { } public static void main(String[] args) { - foo(Foo::m); + foo(Foo::m); } } @@ -67,7 +67,7 @@ class MyTest1 { } public static void main(String[] args) { - m(Foo::new); + m(Foo::new); } } class MyTest2 { @@ -104,6 +104,6 @@ class MyTest2 { } public static void main(String[] args) { - m(Foo::new); + m(Foo::new); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/JDK8034223.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/JDK8034223.java index 8299f3984481..272bd619be02 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/JDK8034223.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/JDK8034223.java @@ -12,7 +12,7 @@ class MS { void test(boolean cond) { m(cond ? () -> 26 : () -> 24); - m(cond ? () -> 26 : () -> new Integer(42)); + m(cond ? () -> 26 : () -> new Integer(42)); m(cond ? () -> new Integer(26) : () -> new Integer(42)); } } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/TargetTypeParameter.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/TargetTypeParameter.java index 1164a45f976c..5b246569c17f 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/TargetTypeParameter.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/mostSpecific/TargetTypeParameter.java @@ -3,7 +3,7 @@ import java.util.function.Supplier; class Test { public static void main(String... args) { - c(() -> 3, () -> 10); + c(() -> 3, () -> 10); } public static void c(Supplier s1, Supplier s2) {} diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/HighlightReferenceWhenContradictBoundsAreInferred.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/HighlightReferenceWhenContradictBoundsAreInferred.java index a36c4a3970c1..0814550220a9 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/HighlightReferenceWhenContradictBoundsAreInferred.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/newMethodRef/HighlightReferenceWhenContradictBoundsAreInferred.java @@ -32,12 +32,12 @@ class Test { meth1(Foo::new); meth2(Foo::new); meth3(Foo::new); - meth4(Foo::new); + meth4(Foo::new); meth1(Test::foo); meth2(Test::foo); meth3(Test::foo); - meth4(Test::foo); + meth4(Test::foo); } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/DetectPolyExpressionInReturnsOfExplicitlyTypedLambdaWhenPrimitiveCouldWin.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/DetectPolyExpressionInReturnsOfExplicitlyTypedLambdaWhenPrimitiveCouldWin.java index e2adfb39896a..6202133dad55 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/DetectPolyExpressionInReturnsOfExplicitlyTypedLambdaWhenPrimitiveCouldWin.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/DetectPolyExpressionInReturnsOfExplicitlyTypedLambdaWhenPrimitiveCouldWin.java @@ -11,7 +11,7 @@ class Test { } void test(boolean cond) { - m(() -> { + m(() -> { if (cond) return 42; else diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/PertinentToApplicabilityOfExplicitlyTypedLambda.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/PertinentToApplicabilityOfExplicitlyTypedLambda.java index 869fdf0b5720..33076ec73200 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/PertinentToApplicabilityOfExplicitlyTypedLambda.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/overloadResolution/PertinentToApplicabilityOfExplicitlyTypedLambda.java @@ -12,6 +12,6 @@ abstract class PertinentToApplicabilityOfExplicitlyTypedLambdaTest { abstract void foo(B b); { - foo(x -> y -> 42); + foo(x -> y -> 42); } }