mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-08-18 16:17:00 +07:00
209 lines
11 KiB
Java
209 lines
11 KiB
Java
/*
|
|
* Copyright 2000-2013 JetBrains s.r.o.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package com.intellij.codeInsight.daemon.lambda;
|
|
|
|
import com.intellij.psi.*;
|
|
import com.intellij.psi.impl.source.resolve.graphInference.InferenceSession;
|
|
import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil;
|
|
import com.intellij.psi.util.PsiTreeUtil;
|
|
import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
|
|
|
|
public class PsiPolyExpressionUtilTest extends LightCodeInsightFixtureTestCase {
|
|
public void testPrefixExpression() throws Exception {
|
|
final PsiExpression psiExpression = findExpression(" int j = i<caret>++;");
|
|
assertInstanceOf(psiExpression, PsiPostfixExpression.class);
|
|
assertTrue(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
|
|
assertFalse(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
|
|
}
|
|
|
|
public void testNumericConditionExpression() throws Exception {
|
|
final PsiExpression psiExpression = findExpression(" int j = i == 0 <caret>? i + 1 : i - 1;");
|
|
assertInstanceOf(psiExpression, PsiConditionalExpression.class);
|
|
assertFalse(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
|
|
assertFalse(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
|
|
}
|
|
|
|
public void testPolyConditionExpression() throws Exception {
|
|
myFixture.configureByText("Foo.java", "import java.util.*;" +
|
|
"class Foo {" +
|
|
" String foo(int i) {" +
|
|
" return i == 0 <caret>? bar() : bar();" +
|
|
" }" +
|
|
" String bar() {return null;}" +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
|
|
assertInstanceOf(psiExpression, PsiConditionalExpression.class);
|
|
assertFalse(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
|
|
assertTrue(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
|
|
}
|
|
|
|
public void testNewExpressionDiamond() throws Exception {
|
|
final PsiExpression psiExpression = findExpression(" List<String> l = new Arr<caret>ayList<>();");
|
|
assertInstanceOf(psiExpression, PsiNewExpression.class);
|
|
assertFalse(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
|
|
assertTrue(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
|
|
}
|
|
|
|
public void testNewExpression() throws Exception {
|
|
final PsiExpression psiExpression = findExpression(" List<String> l = new Arr<caret>ayList<String>();");
|
|
assertInstanceOf(psiExpression, PsiNewExpression.class);
|
|
assertFalse(PsiPolyExpressionUtil.hasStandaloneForm(psiExpression));
|
|
assertFalse(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
|
|
}
|
|
|
|
public void testMethodCallInsideArrayCreation() throws Exception {
|
|
myFixture.configureByText("Foo.java", "import java.util.*;" +
|
|
"class Foo {" +
|
|
" <T> T bar() {return null;}" +
|
|
" void foo() {" +
|
|
" String[] a = new String[] {ba<caret>r()};" +
|
|
" }" +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiMethodCallExpression.class);
|
|
assertInstanceOf(psiExpression, PsiMethodCallExpression.class);
|
|
assertTrue(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
|
|
}
|
|
|
|
public void testConditional() throws Exception {
|
|
myFixture.configureByText("Foo.java", "import java.util.function.Supplier;" +
|
|
"class Foo {" +
|
|
" private static <R> void map(Supplier<R> fn) {}\n" +
|
|
" public static void main(String[] args) {\n" +
|
|
" Runnable r = null;\n" +
|
|
" map(() -> (true <caret>? r : r));\n" +
|
|
" }" +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
|
|
assertInstanceOf(psiExpression, PsiConditionalExpression.class);
|
|
assertTrue(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
|
|
}
|
|
|
|
public void testConditionalInAssignment() throws Exception {
|
|
myFixture.configureByText("Foo.java", "class Foo {" +
|
|
" public static void main(String[] args) {\n" +
|
|
" Object obj = new Object();\n" +
|
|
" String str = \"\";\n" +
|
|
" str += args.length == 0 <caret>? obj : args[0];\n" +
|
|
" }" +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
|
|
assertInstanceOf(psiExpression, PsiConditionalExpression.class);
|
|
assertFalse(PsiPolyExpressionUtil.isPolyExpression(psiExpression));
|
|
}
|
|
|
|
|
|
|
|
private PsiExpression findExpression(String textWithExpression) {
|
|
myFixture.configureByText("Foo.java", "import java.util.*;" +
|
|
"class Foo {" +
|
|
" void foo(int i) {" +
|
|
textWithExpression +
|
|
" }" +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
return PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
|
|
}
|
|
|
|
public void testPertinentLambdaExpression() throws Exception {
|
|
assertFalse(doTestLambdaPertinent(" void bar(List<Runnable> l) {" +
|
|
" foo(() <caret>-> {}, l);" +
|
|
" }"));
|
|
}
|
|
|
|
public void testPertinentImplicitLambdaExpression() throws Exception {
|
|
assertFalse(doTestLambdaPertinent(" void bar(List<Comparable<String>> l) {" +
|
|
" foo((String s) <caret>-> 1, l);" +
|
|
" }"));
|
|
}
|
|
|
|
public void testPertinentNestedLambdaExpression() throws Exception {
|
|
assertFalse(doTestLambdaPertinent(" interface Fun<I, O> { O inOut(I i);}\n" +
|
|
" void bar(List<Fun<String, Fun<String, String>>> l) {" +
|
|
" foo((sIn, sOut) -> (sInInner, sOutInner) <caret>-> sOutInner, l);" +
|
|
" }"));
|
|
}
|
|
|
|
public void testPertinentNestedLambdaExpressionWhenTargetIsTypeParameterOfMethod() throws Exception {
|
|
myFixture.configureByText("Foo.java", "interface Supplier<T> { T get();}" +
|
|
"class Foo {" +
|
|
" { Supplier<Runnable> x = foo ((<caret>) -> () -> {});}\n" +
|
|
" static <T> Supplier<T> foo(Supplier<T> delegate) {\n" +
|
|
" return null;\n" +
|
|
" }\n" +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
|
|
assertInstanceOf(psiExpression, PsiLambdaExpression.class);
|
|
final PsiClass aClass = myFixture.findClass("Foo");
|
|
assertNotNull(aClass);
|
|
final PsiMethod[] meths = aClass.findMethodsByName("foo", false);
|
|
assertTrue(meths.length == 1);
|
|
assertFalse(InferenceSession.isPertinentToApplicability(psiExpression, meths[0]));
|
|
}
|
|
|
|
public void testNotExactMethodReferenceOnRawClassType() throws Exception {
|
|
myFixture.configureByText("Foo.java", "class Foo {" +
|
|
" class Test<A>{ Test(){}}" +
|
|
" {Runnable r = Test:<caret>:new;}" +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
|
|
assertInstanceOf(psiExpression, PsiMethodReferenceExpression.class);
|
|
assertFalse(((PsiMethodReferenceExpression)psiExpression).isExact());
|
|
}
|
|
|
|
public void testExactMethodReferenceOnGenericClassType() throws Exception {
|
|
myFixture.configureByText("Foo.java", "class Foo {" +
|
|
" class Test<A>{ Test(){}}" +
|
|
" {Runnable r = Test<String>:<caret>:new;}" +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
|
|
assertInstanceOf(psiExpression, PsiMethodReferenceExpression.class);
|
|
assertTrue(((PsiMethodReferenceExpression)psiExpression).isExact());
|
|
}
|
|
|
|
private boolean doTestLambdaPertinent(final String barText) {
|
|
myFixture.configureByText("Foo.java", "import java.util.*;" +
|
|
"class Foo {" +
|
|
" <T> T foo(T t, List<T> lT) {" +
|
|
" }" +
|
|
barText +
|
|
"}");
|
|
final PsiElement elementAtCaret = myFixture.getFile().findElementAt(myFixture.getCaretOffset());
|
|
assertNotNull(elementAtCaret);
|
|
final PsiExpression psiExpression = PsiTreeUtil.getParentOfType(elementAtCaret, PsiExpression.class);
|
|
assertInstanceOf(psiExpression, PsiLambdaExpression.class);
|
|
final PsiClass aClass = myFixture.findClass("Foo");
|
|
assertNotNull(aClass);
|
|
final PsiMethod[] meths = aClass.findMethodsByName("foo", false);
|
|
assertTrue(meths.length == 1);
|
|
return InferenceSession.isPertinentToApplicability(psiExpression, meths[0]);
|
|
}
|
|
}
|