SONARJAVA-1418 fix computation of lub to not fail semantic analysis

Author: Wohops

java-squid/src/main/java/org/sonar/java/resolve/Types.java

@@ -24,6 +24,7 @@
 import org.sonar.java.resolve.JavaType.ParametrizedTypeJavaType;
 import org.sonar.plugins.java.api.semantic.Type;
 
+import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
@@ -131,27 +132,34 @@ private static Type best(List<Type> minimalCandidates) {
   }
 
   private static List<Set<Type>> supertypes(Iterable<Type> types) {
-    List<Set<Type>> results = new LinkedList<>();
-    for (Type type : types) {
-      checkParametrizedType(type);
-      Set<Type> supertypes = new LinkedHashSet<>();
-      supertypes.add(type);
-      for (Type supertype : ((JavaType) type).symbol.superTypes()) {
-        checkParametrizedType(supertype);
-        supertypes.add(supertype);
+    try {
+      List<Set<Type>> results = new LinkedList<>();
+      for (Type type : types) {
+        checkParametrizedType(type);
+        Set<Type> supertypes = new LinkedHashSet<>();
+        supertypes.add(type);
+        for (Type supertype : ((JavaType) type).symbol.superTypes()) {
+          checkParametrizedType(supertype);
+          supertypes.add(supertype);
+        }
+        results.add(supertypes);
       }
-      results.add(supertypes);
+      return results;
+    } catch (UnsupportedOperationException e) {
+      return Collections.emptyList();
     }
-    return results;
   }
 
   private static void checkParametrizedType(Type type) {
     if (type instanceof ParametrizedTypeJavaType) {
-      throw new IllegalArgumentException("Generics are not handled");
+      throw new UnsupportedOperationException("Generics are not handled");
     }
   }
 
   private static List<Type> intersection(List<Set<Type>> supertypes) {
+    if (supertypes.isEmpty()) {
+      return Collections.emptyList();
+    }
     List<Type> results = new LinkedList<>(supertypes.get(0));
     for (int i = 1; i < supertypes.size(); i++) {
       results.retainAll(supertypes.get(i));

java-squid/src/test/java/org/sonar/java/resolve/TypesTest.java

@@ -21,8 +21,6 @@
 
 import com.google.common.base.Charsets;
 import com.google.common.collect.Lists;
-import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.collections.Predicate;
 import org.fest.assertions.Fail;
 import org.junit.Test;
 import org.sonar.java.ast.parser.JavaParser;
@@ -31,7 +29,6 @@
 import org.sonar.plugins.java.api.tree.ClassTree;
 import org.sonar.plugins.java.api.tree.CompilationUnitTree;
 import org.sonar.plugins.java.api.tree.Tree;
-import org.sonar.plugins.java.api.tree.VariableTree;
 
 import java.io.File;
 import java.util.Arrays;
@@ -249,21 +246,15 @@ public void lub_with_unknown_inheritance() {
 
   @Test
   public void lub_ignores_generics() {
-    List<Type> typesFromInput = typesOfVariables(
-      "import java.util.List;",
-      "class A {",
-      "  List<String> a;",
-      "  List<String> b;",
-      "}");
+    List<Type> typesFromInput = declaredTypes(
+      "class A extends Exception {}",
+      "class B extends Exception implements I1<Exception> {}",
+      "interface I1<T> {}");
     Type a = typesFromInput.get(0);
     Type b = typesFromInput.get(1);
-    try {
-      types.leastUpperBound(Lists.newArrayList(a, b));
-      Fail.fail("should have failed");
-    } catch (Exception e) {
-      assertThat(e).isInstanceOf(IllegalArgumentException.class);
-      assertThat(e.getMessage()).isEqualTo("Generics are not handled");
-    }
+
+    Type lub = types.leastUpperBound(Lists.newArrayList(a, b));
+    assertThat(lub.isUnknown()).isTrue();
   }
 
   private static List<Type> declaredTypes(String... lines) {
@@ -276,24 +267,6 @@ private static List<Type> declaredTypes(String... lines) {
     return results;
   }
 
-  private static List<Type> typesOfVariables(String... lines) {
-    CompilationUnitTree tree = treeOf(lines);
-    List<Tree> members = ((ClassTree) tree.types().get(0)).members();
-    CollectionUtils.filter(members, new Predicate() {
-      @Override
-      public boolean evaluate(Object object) {
-        Tree tree = (Tree) object;
-        return tree.is(Tree.Kind.VARIABLE);
-      }
-    });
-    List<Type> results = Lists.newLinkedList();
-    for (Tree member : members) {
-      Type type = ((VariableTree) member).type().symbolType();
-      results.add(type);
-    }
-    return results;
-  }
-
   private static CompilationUnitTree treeOf(String... lines) {
     StringBuilder builder = new StringBuilder();
     for (String line : lines) {