add FunctionInterfaceLogic

java-symbol-solver-core/src/main/java/me/tomassetti/symbolsolver/logic/FunctionalInterfaceLogic.java

@@ -0,0 +1,25 @@
+package me.tomassetti.symbolsolver.logic;
+
+import me.tomassetti.symbolsolver.model.invokations.MethodUsage;
+import me.tomassetti.symbolsolver.model.typesystem.TypeUsage;
+
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class FunctionalInterfaceLogic {
+
+    public static Optional<MethodUsage> getFunctionalMethod(TypeUsage type) {
+        if (type.isReferenceType() && type.asReferenceTypeUsage().getTypeDeclaration().isInterface()) {
+            //We need to find all abstract methods
+            Set<MethodUsage> methods = type.asReferenceTypeUsage().getTypeDeclaration().getAllMethods().stream().filter(m -> m.getDeclaration().isAbstract()).collect(Collectors.toSet());
+            if (methods.size() == 1) {
+                return Optional.of(methods.iterator().next());
+            } else {
+                return Optional.empty();
+            }
+        } else {
+            return Optional.empty();
+        }
+    }
+}

java-symbol-solver-core/src/main/java/me/tomassetti/symbolsolver/resolution/javaparser/JavaParserFacade.java

@@ -4,6 +4,7 @@
 import com.github.javaparser.ast.body.*;
 import com.github.javaparser.ast.expr.*;
 import com.github.javaparser.ast.type.*;
+import me.tomassetti.symbolsolver.logic.FunctionalInterfaceLogic;
 import me.tomassetti.symbolsolver.model.declarations.MethodDeclaration;
 import me.tomassetti.symbolsolver.model.declarations.TypeDeclaration;
 import me.tomassetti.symbolsolver.model.declarations.ValueDeclaration;
@@ -174,7 +175,7 @@ private TypeUsage getTypeConcrete(Node node, boolean solveLambdas) {
                     //We should find out which is the functional method (e.g., apply) and replace the params of the
                     //solveLambdas with it, to derive so the values. We should also consider the value returned by the
                     //lambdas
-                    Optional<MethodUsage> functionalMethod = getFunctionalMethod(result);
+                    Optional<MethodUsage> functionalMethod = FunctionalInterfaceLogic.getFunctionalMethod(result);
                     if (functionalMethod.isPresent()) {
                         throw new UnsupportedOperationException();
                     }
@@ -308,20 +309,6 @@ private TypeUsage getTypeConcrete(Node node, boolean solveLambdas) {
         }
     }
 
-    private Optional<MethodUsage> getFunctionalMethod(TypeUsage type) {
-        if (type.isReferenceType() && type.asReferenceTypeUsage().getTypeDeclaration().isInterface()) {
-            //We need to find all abstract methods
-            Set<MethodUsage> methods = type.asReferenceTypeUsage().getTypeDeclaration().getAllMethods().stream().filter(m -> m.getDeclaration().isAbstract()).collect(Collectors.toSet());
-            if (methods.size() == 1) {
-                return Optional.of(methods.iterator().next());
-            } else {
-                return Optional.empty();
-            }
-        } else {
-            return Optional.empty();
-        }
-    }
-
     private com.github.javaparser.ast.body.TypeDeclaration findContainingTypeDecl(Node node) {
         if (node instanceof ClassOrInterfaceDeclaration) {
             return (ClassOrInterfaceDeclaration) node;

java-symbol-solver-core/src/test/java/me/tomassetti/symbolsolver/logic/FunctionInterfaceLogicTest.java

@@ -0,0 +1,35 @@
+package me.tomassetti.symbolsolver.logic;
+
+import me.tomassetti.symbolsolver.model.resolution.TypeSolver;
+import me.tomassetti.symbolsolver.model.typesystem.ReferenceTypeUsageImpl;
+import me.tomassetti.symbolsolver.model.typesystem.TypeUsage;
+import me.tomassetti.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import me.tomassetti.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
+import me.tomassetti.symbolsolver.resolution.typesolvers.JreTypeSolver;
+import org.junit.Test;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import static org.junit.Assert.*;
+
+public class FunctionInterfaceLogicTest {
+
+    @Test
+    public void testGetFunctionalMethodNegativeCaseOnClass() {
+        TypeSolver typeSolver = new JreTypeSolver();
+        TypeUsage string = new ReferenceTypeUsageImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        assertEquals(false, FunctionalInterfaceLogic.getFunctionalMethod(string).isPresent());
+    }
+
+    @Test
+    public void testGetFunctionalMethodPositiveCasesOnInterfaces() {
+        TypeSolver typeSolver = new JreTypeSolver();
+        TypeUsage function = new ReferenceTypeUsageImpl(new ReflectionInterfaceDeclaration(Function.class, typeSolver), typeSolver);
+        assertEquals(true, FunctionalInterfaceLogic.getFunctionalMethod(function).isPresent());
+        assertEquals("apply", FunctionalInterfaceLogic.getFunctionalMethod(function).get().getName());
+        TypeUsage consumer = new ReferenceTypeUsageImpl(new ReflectionInterfaceDeclaration(Consumer.class, typeSolver), typeSolver);
+        assertEquals(true, FunctionalInterfaceLogic.getFunctionalMethod(consumer).isPresent());
+        assertEquals("accept", FunctionalInterfaceLogic.getFunctionalMethod(consumer).get().getName());
+    }
+}