Remove compiler-specific casts from semantic helpers

Author: aurelien-coet-sonarsource

java-frontend/src/main/java/org/sonar/java/model/JMethodSymbol.java

@@ -70,6 +70,12 @@ IMethodBinding methodBinding() {
     return (IMethodBinding) binding;
   }
 
+  @Override
+  @Nullable
+  public Object defaultValue() {
+    return EcjSymbolMetadata.convertAnnotationValue(sema, methodBinding().getDefaultValue());
+  }
+
   public boolean isLambda() {
     return methodBinding().getDeclaringMember() != null;
   }

java-frontend/src/main/java/org/sonar/java/model/JType.java

@@ -17,9 +17,11 @@
 package org.sonar.java.model;
 
 import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
+import java.util.Set;
 import java.util.TreeSet;
 import javax.annotation.Nullable;
 import org.eclipse.jdt.core.dom.ITypeBinding;
@@ -63,6 +65,19 @@ final class JType implements Type, Type.ArrayType {
     this.fullyQualifiedName = fullyQualifiedName(typeBinding);
   }
 
+  @Override
+  public Set<Type> directSuperTypes() {
+    Set<Type> result = new HashSet<>();
+    ITypeBinding superclass = typeBinding.getSuperclass();
+    if (superclass != null) {
+      result.add(sema.type(superclass));
+    }
+    Arrays.stream(typeBinding.getInterfaces())
+      .map(sema::type)
+      .forEach(result::add);
+    return result;
+  }
+
   @Override
   public boolean is(String fullyQualifiedName) {
     return fullyQualifiedName.equals(this.fullyQualifiedName());

java-frontend/src/main/java/org/sonar/java/model/JTypeSymbol.java

@@ -162,12 +162,24 @@ public Set<Type> superTypes() {
         superTypes = Collections.emptySet();
       } else {
         superTypes = new HashSet<>();
-        JUtils.collectSuperTypes(superTypes, sema, typeBinding());
+        collectSuperTypes(superTypes, sema, typeBinding());
       }
     }
     return superTypes;
   }
 
+  private void collectSuperTypes(Set<Type> result, JSema sema, ITypeBinding typeBinding) {
+    ITypeBinding s = typeBinding.getSuperclass();
+    if (s != null) {
+      result.add(sema.type(s));
+      collectSuperTypes(result, sema, s);
+    }
+    Arrays.stream(typeBinding.getInterfaces()).forEach(i -> {
+      result.add(sema.type(i));
+      collectSuperTypes(result, sema, i);
+    });
+  }
+
   @Override
   @Nullable
   public TypeSymbol outermostClass() {

java-frontend/src/main/java/org/sonar/java/model/JUtils.java

@@ -16,7 +16,6 @@
  */
 package org.sonar.java.model;
 
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
@@ -26,7 +25,6 @@
 import java.util.Set;
 import java.util.stream.Collectors;
 import javax.annotation.Nullable;
-import org.eclipse.jdt.core.dom.ITypeBinding;
 import org.sonar.plugins.java.api.semantic.Symbol;
 import org.sonar.plugins.java.api.semantic.SymbolMetadata;
 import org.sonar.plugins.java.api.semantic.Type;
@@ -67,19 +65,7 @@ public static Type wrapTypeIfPrimitive(Type type) {
   }
 
   public static boolean isIntersectionType(Type type) {
-    return !type.isUnknown() && ((JType) type).typeBinding.isIntersectionType();
-  }
-
-  public static void collectSuperTypes(Set<Type> result, JSema sema, ITypeBinding typeBinding) {
-    ITypeBinding s = typeBinding.getSuperclass();
-    if (s != null) {
-      result.add(sema.type(s));
-      collectSuperTypes(result, sema, s);
-    }
-    Arrays.stream(typeBinding.getInterfaces()).forEach(i -> {
-      result.add(sema.type(i));
-      collectSuperTypes(result, sema, i);
-    });
+    return !type.isUnknown() && type.isIntersectionType();
   }
 
   public static Symbol getPackage(Symbol symbol) {
@@ -94,7 +80,7 @@ public static Object defaultValue(Symbol.MethodSymbol method) {
     if (method.isUnknown()) {
       return null;
     }
-    return ((JMethodSymbol) method).methodBinding().getDefaultValue();
+    return method.defaultValue();
   }
 
   /**
@@ -161,16 +147,7 @@ public static Set<Type> directSuperTypes(Type type) {
     if (type.isUnknown()) {
       return Collections.emptySet();
     }
-    Set<Type> result = new HashSet<>();
-    JType t = (JType) type;
-    ITypeBinding superclass = t.typeBinding.getSuperclass();
-    if (superclass != null) {
-      result.add(t.sema.type(superclass));
-    }
-    Arrays.stream(t.typeBinding.getInterfaces())
-      .map(t.sema::type)
-      .forEach(result::add);
-    return result;
+    return type.directSuperTypes();
   }
 
   @Nullable

java-frontend/src/main/java/org/sonar/java/model/Symbols.java

@@ -348,6 +348,11 @@ public boolean isMethodSymbol() {
   }
 
   public static final class UnknownType implements Type {
+    @Override
+    public Set<Type> directSuperTypes() {
+      return Collections.emptySet();
+    }
+
     @Override
     public boolean is(String fullyQualifiedName) {
       return false;

java-frontend/src/main/java/org/sonar/plugins/java/api/semantic/Symbol.java

@@ -227,6 +227,15 @@ interface MethodSymbol extends Symbol {
      */
     MethodSymbol UNKNOWN_METHOD = new Symbols.UnknownMethodSymbol();
 
+    /**
+     * Returns the annotation member's default value, or {@code null} when none is available. Values use the
+     * same representation as {@link SymbolMetadata.AnnotationValue#value()}.
+     */
+    @Nullable
+    default Object defaultValue() {
+      return null;
+    }
+
     /**
      * Type of parameters declared by this method.
      * In case of generic types of method invocations, this list of types is more specialized than declarationParameters().stream().map(Symbol::type).

java-frontend/src/main/java/org/sonar/plugins/java/api/semantic/Type.java

@@ -17,6 +17,7 @@
 package org.sonar.plugins.java.api.semantic;
 
 import java.util.List;
+import java.util.Set;
 import javax.annotation.Nullable;
 import org.sonar.java.model.Symbols;
 
@@ -30,6 +31,14 @@ public interface Type {
    */
   Type UNKNOWN = new Symbols.UnknownType();
 
+  /**
+   * Returns the immediate superclass and interfaces, preserving generic substitutions. Unknown types have
+   * no direct supertypes. Interfaces do not acquire an implicit {@code java.lang.Object} superclass.
+   */
+  default Set<Type> directSuperTypes() {
+    return java.util.Collections.emptySet();
+  }
+
   /**
    * Primitive java types.
    */

java-frontend/src/test/java/org/sonar/java/model/JUtilsTest.java

@@ -37,12 +37,28 @@
 import org.sonar.plugins.java.api.tree.TypeParameterTree;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 class JUtilsTest {
 
   static final JSema SEMA = test("").sema;
   private static final Type OBJECT_TYPE = SEMA.type(SEMA.resolveType("java.lang.Object"));
 
+  @Test
+  void semantic_helpers_use_the_existing_api_interfaces() {
+    Type type = mock(Type.class);
+    Type parent = mock(Type.class);
+    when(type.directSuperTypes()).thenReturn(Set.of(parent));
+    assertThat(JUtils.directSuperTypes(type)).containsExactly(parent);
+    Symbol.MethodSymbol method = mock(Symbol.MethodSymbol.class);
+    when(method.defaultValue()).thenReturn(42);
+    assertThat(JUtils.defaultValue(method)).isEqualTo(42);
+    assertThat(Type.UNKNOWN.directSuperTypes()).isEmpty();
+    assertThat(Symbol.MethodSymbol.UNKNOWN_METHOD.defaultValue()).isNull();
+    assertThat(new JInitializerBlockSymbol(Symbol.TypeSymbol.UNKNOWN_TYPE, false).defaultValue()).isNull();
+  }
+
   @Nested
   class PrimitiveType {
     @Test

java-frontend/src/test/java/org/sonar/java/model/SymbolsTest.java

@@ -43,6 +43,7 @@ void unknown_type() {
     Type unknownType = Type.UNKNOWN;
 
     assertThat(unknownType.isUnknown()).isTrue();
+    assertThat(unknownType.directSuperTypes()).isEmpty();
     assertThat(unknownType).isEqualTo(Type.UNKNOWN);
 
     assertThat(unknownType.is("!Unknown!")).isFalse();