MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-04-19 04:51:24 +07:00
Code Issues Packages Projects Releases Wiki Activity

lambda: check interface functional

Browse Source
This commit is contained in:
anna
2012-07-18 11:42:44 +02:00
parent af13d2a99e
commit 507a7bbd48
15 changed files with 224 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/FunctionalInterfaceUtil.java Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright 2000-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.psi.impl.source.tree.java;
import com.intellij.psi.*;
import com.intellij.psi.util.MethodSignature;
import com.intellij.psi.util.MethodSignatureUtil;
import com.intellij.psi.util.TypeConversionUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
/**
* User: anna
* Date: 7/17/12
*/
public class FunctionalInterfaceUtil {
@Nullable
public static String checkInterfaceFunctional(@NotNull PsiClass psiClass) {
if (psiClass.isInterface()) {
final List<MethodSignature> methods = new ArrayList<MethodSignature>();
final PsiMethod[] psiClassMethods = psiClass.getAllMethods();
for (PsiMethod psiMethod : psiClassMethods) {
if (!psiMethod.hasModifierProperty(PsiModifier.ABSTRACT)) continue;
final PsiClass methodContainingClass = psiMethod.getContainingClass();
if (!overridesPublicObjectMethod(psiMethod)) {
methods.add(getMethodSignature(psiMethod, psiClass, methodContainingClass));
}
}
return hasSubsignature(methods);
}
return "Target type of a lambda conversion must be an interface";
}
private static boolean overridesPublicObjectMethod(PsiMethod psiMethod) {
boolean overrideObject = false;
for (PsiMethod superMethod : psiMethod.findDeepestSuperMethods()) {
final PsiClass containingClass = superMethod.getContainingClass();
if (containingClass != null && CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName())) {
if (superMethod.hasModifierProperty(PsiModifier.PUBLIC)) {
overrideObject = true;
break;
}
}
}
return overrideObject;
}
private static MethodSignature getMethodSignature(PsiMethod method, PsiClass psiClass, PsiClass containingClass) {
final MethodSignature methodSignature;
if (containingClass != null && containingClass != psiClass) {
methodSignature = method.getSignature(TypeConversionUtil.getSuperClassSubstitutor(containingClass, psiClass, PsiSubstitutor.EMPTY));
}
else {
methodSignature = method.getSignature(PsiSubstitutor.EMPTY);
}
return methodSignature;
}
@Nullable
private static String hasSubsignature(List<MethodSignature> signatures) {
for (MethodSignature signature : signatures) {
boolean subsignature = true;
for (MethodSignature methodSignature : signatures) {
if (!signature.equals(methodSignature)) {
if (!MethodSignatureUtil.isSubsignature(signature, methodSignature)) {
subsignature = false;
break;
}
}
}
if (subsignature) return null;
}
if (signatures.isEmpty()) return "No target method found";
return signatures.size() == 1 ? null : "Multiple non-overriding abstract methods found";
}
}

1
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/AbstractClass.java Normal file
View File

@@ -0,0 +1 @@
abstract class Foo { public abstract void run(); }

4
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/Clone.java Normal file
View File

@@ -0,0 +1,4 @@
interface Foo {
int m();
Object clone();
}

3
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/MethodWithTypeParam.java Normal file
View File

@@ -0,0 +1,3 @@
interface Foo { <T> T execute(Action<T> a); }
interface Action<A>{}
// Functional

3
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/MultipleMethods.java Normal file
View File

@@ -0,0 +1,3 @@
interface Bar { boolean equals(Object obj); }
interface Foo extends Bar { int compare(String o1, String o2); }

4
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/MultipleMethodsInOne.java Normal file
View File

@@ -0,0 +1,4 @@
interface Foo<T> {
boolean equals(Object obj);
int compare(T o1, T o2);
}

1
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/NoMethods.java Normal file
View File

@@ -0,0 +1 @@
interface Foo { boolean equals(Object obj); }

1
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/Simple.java Normal file
View File

@@ -0,0 +1 @@
interface Foo { void run(); }

4
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/TwoMethodsNoSubSignature.java Normal file
View File

@@ -0,0 +1,4 @@
interface X { int m(Iterable<String> arg); }
interface Y { int m(Iterable<Integer> arg); }
interface Foo extends X, Y {}
// Not functional: No method has a subsignature of all abstract methods

4
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/TwoMethodsNoSubSignature1.java Normal file
View File

@@ -0,0 +1,4 @@
interface X { int m(Iterable<String> arg, Class c); }
interface Y { int m(Iterable arg, Class<?> c); }
interface Foo extends X, Y {}
// Not functional: No method has a subsignature of all abstract methods

4
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/TwoMethodsSameSignature.java Normal file
View File

@@ -0,0 +1,4 @@
import java.util.*;
interface X { int m(Iterable<String> arg); }
interface Y { int m(Iterable<String> arg); }
interface Foo extends X, Y {}

5
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/TwoMethodsSameSignatureTypeParams.java Normal file
View File

@@ -0,0 +1,5 @@
interface Action<A>{}
interface X { <T> T execute(Action<T> a); }
interface Y { <S> S execute(Action<S> a); }
interface Foo extends X, Y {}
// Functional: signatures are "the same"

5
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/TwoMethodsSameSubstSignature.java Normal file
View File

@@ -0,0 +1,5 @@
interface Foo1<T, N extends Number> {
void m(T arg);
void m(N arg);
}
interface Foo extends Foo1<Integer, Integer> {}

4
java/java-tests/testData/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface/TwoMethodsSubSignature.java Normal file
View File

@@ -0,0 +1,4 @@
import java.util.*;
interface X { Iterable m(Iterable<String> arg); }
interface Y { Iterable<String> m(Iterable arg); }
interface Foo extends X, Y {}

88
java/java-tests/testSrc/com/intellij/codeInsight/daemon/FunctionalInterfaceTest.java Normal file
View File

@@ -0,0 +1,88 @@
/*
* Copyright 2000-2012 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.codeInsight.daemon;
import com.intellij.psi.PsiClass;
import com.intellij.psi.impl.source.tree.java.FunctionalInterfaceUtil;
import com.intellij.psi.search.GlobalSearchScope;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.Nullable;
public class FunctionalInterfaceTest extends LightDaemonAnalyzerTestCase {
@NonNls static final String BASE_PATH = "/codeInsight/daemonCodeAnalyzer/lambda/functionalInterface";
private void doTestFunctionalInterface(@Nullable String expectedErrorMessage) throws Exception {
String filePath = BASE_PATH + "/" + getTestName(false) + ".java";
configureByFile(filePath);
final PsiClass psiClass = getJavaFacade().findClass("Foo", GlobalSearchScope.projectScope(getProject()));
assertNotNull("Class Foo not found", psiClass);
final String errorMessage = FunctionalInterfaceUtil.checkInterfaceFunctional(psiClass);
assertEquals(expectedErrorMessage, errorMessage);
}
public void testSimple() throws Exception {
doTestFunctionalInterface(null);
}
public void testNoMethods() throws Exception {
doTestFunctionalInterface("No target method found");
}
public void testMultipleMethods() throws Exception {
doTestFunctionalInterface(null);
}
public void testMultipleMethodsInOne() throws Exception {
doTestFunctionalInterface(null);
}
public void testClone() throws Exception {
doTestFunctionalInterface("Multiple non-overriding abstract methods found");
}
public void testTwoMethodsSameSignature() throws Exception {
doTestFunctionalInterface(null);
}
public void testTwoMethodsSubSignature() throws Exception {
doTestFunctionalInterface(null);
}
public void testTwoMethodsNoSubSignature() throws Exception {
doTestFunctionalInterface("Multiple non-overriding abstract methods found");
}
public void testTwoMethodsNoSubSignature1() throws Exception {
doTestFunctionalInterface("Multiple non-overriding abstract methods found");
}
public void testTwoMethodsSameSubstSignature() throws Exception {
doTestFunctionalInterface(null);
}
public void testMethodWithTypeParam() throws Exception {
doTestFunctionalInterface(null);
}
public void testTwoMethodsSameSignatureTypeParams() throws Exception {
doTestFunctionalInterface(null);
}
public void testAbstractClass() throws Exception {
doTestFunctionalInterface("Target type of a lambda conversion must be an interface");
}
}