SONARJAVA-5763 Cleanup SymbolMetadata API

Author: GabrielFleischer

java-checks-test-sources/default/src/main/java/annotations/nullability/no_default/NullabilityOfParametrizedTypes_Old.java

@@ -62,7 +62,6 @@ final class JSymbolMetadata implements SymbolMetadata {
   private List<AnnotationInstance> symbolAnnotations;
 
   private final Map<NullabilityTarget, NullabilityData> nullabilityCache = new EnumMap<>(NullabilityTarget.class);
-  private final Map<NullabilityTarget, NullabilityData> oldNullabilityCache = new EnumMap<>(NullabilityTarget.class);
 
   JSymbolMetadata(JSema sema, Symbol symbol, IAnnotationBinding[] annotationBindings) {
     this.sema = Objects.requireNonNull(sema);
@@ -156,7 +155,7 @@ public final boolean isAnnotatedWith(String fullyQualifiedName) {
 
   @Nullable
   @Override
-  public final List<AnnotationValue> valuesForAnnotation(String fullyQualifiedNameOfAnnotation) {
+  public List<AnnotationValue> valuesForAnnotation(String fullyQualifiedNameOfAnnotation) {
     for (AnnotationInstance a : annotations()) {
       if (a.symbol().type().is(fullyQualifiedNameOfAnnotation)) {
         // TODO what about repeating annotations?
@@ -175,23 +174,9 @@ public NullabilityData nullabilityData() {
     return nullabilityData(target);
   }
 
-  @Override
-  public NullabilityData oldNullabilityData() {
-    NullabilityTarget target = getTarget(symbol);
-    if (target == null) {
-      return unknownNullabilityAt(NullabilityLevel.UNKNOWN);
-    }
-    return oldNullabilityData(target);
-  }
-
   @Override
   public NullabilityData nullabilityData(NullabilityTarget target) {
-    return nullabilityCache.computeIfAbsent(target, t -> resolveNullability(t, false));
-  }
-
-  @Override
-  public NullabilityData oldNullabilityData(NullabilityTarget target) {
-    return oldNullabilityCache.computeIfAbsent(target, t -> resolveNullability(t, true));
+    return nullabilityCache.computeIfAbsent(target, this::resolveNullability);
   }
 
   @Nullable
@@ -220,16 +205,16 @@ private static AnnotationTree findAnnotationTree(List<AnnotationTree> annotation
     return null;
   }
 
-  private NullabilityData resolveNullability(NullabilityTarget target, boolean useOldMethod) {
+  private NullabilityData resolveNullability(NullabilityTarget target) {
     NullabilityLevel currentLevel = getLevel(symbol);
-    NullabilityData nullabilityDataAtLevel = getNullabilityDataAtLevel(this, target, currentLevel, useOldMethod);
+    NullabilityData nullabilityDataAtLevel = getNullabilityDataAtLevel(this, target, currentLevel);
     if (nullabilityDataAtLevel.type() != NullabilityType.NO_ANNOTATION) {
       return nullabilityDataAtLevel;
     }
 
     // Check nullability from the inheritance hierarchy
     if (symbol.isMethodSymbol()) {
-      NullabilityData nullabilityDataFromInheritance = getNullabilityDataFromInheritance((Symbol.MethodSymbol) symbol, target, useOldMethod);
+      NullabilityData nullabilityDataFromInheritance = getNullabilityDataFromInheritance((Symbol.MethodSymbol) symbol, target);
       if (nullabilityDataFromInheritance.type() != NullabilityType.NO_ANNOTATION) {
         return nullabilityDataFromInheritance;
       }
@@ -242,15 +227,15 @@ private NullabilityData resolveNullability(NullabilityTarget target, boolean use
     Symbol owner = getEffectiveOwner(symbol, currentLevel);
     if (owner == null) return unknownNullabilityAt(currentLevel);
     var metadata = owner.metadata();
-    return useOldMethod ? metadata.oldNullabilityData(target) : metadata.nullabilityData(target);
+    return metadata.nullabilityData(target);
   }
 
-  private static NullabilityData getNullabilityDataFromInheritance(Symbol.MethodSymbol methodSymbol, NullabilityTarget target, boolean useOldMethod) {
+  private static NullabilityData getNullabilityDataFromInheritance(Symbol.MethodSymbol methodSymbol, NullabilityTarget target) {
     List<Symbol.MethodSymbol> overriddenSymbols = methodSymbol.overriddenSymbols();
     NullabilityLevel level = NullabilityLevel.METHOD;
     for (Symbol.MethodSymbol overriddenSymbol : overriddenSymbols) {
       SymbolMetadata metadata = overriddenSymbol.metadata();
-      NullabilityData nullabilityData = getNullabilityDataAtLevel(metadata, target, level, useOldMethod);
+      NullabilityData nullabilityData = getNullabilityDataAtLevel(metadata, target, level);
       if (nullabilityData.type() != NullabilityType.NO_ANNOTATION && !nullabilityData.equals(unknownNullabilityAt(level))) {
         return nullabilityData;
       }

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

@@ -280,29 +280,28 @@ private static void configureAnnotation(Function<AnnotationInstance, Nullability
   /**
    * Return the Nullability data given the metadata of the current symbol, a level and a target.
    */
-  public static NullabilityData getNullabilityDataAtLevel(SymbolMetadata metadata, NullabilityTarget target, NullabilityLevel level, boolean useOldMethod) {
+  public static NullabilityData getNullabilityDataAtLevel(SymbolMetadata metadata, NullabilityTarget target, NullabilityLevel level) {
     TypesForAnnotations typeForAnnotations = configuration.get(new ConfigurationKey(target, level));
     if (typeForAnnotations != null) {
-      return getNullabilityDataAtLevel(new HashSet<>(), metadata, level, false, typeForAnnotations, useOldMethod);
+      return getNullabilityDataAtLevel(new HashSet<>(), metadata, level, false, typeForAnnotations);
     }
     return noNullabilityAnnotationAt(level);
   }
 
   private static NullabilityData getNullabilityDataAtLevel(Set<Type> knownTypes, SymbolMetadata metadata,
-    NullabilityLevel level, boolean isMetaAnnotated, TypesForAnnotations typeForAnnotations, boolean useOldMethod) {
+    NullabilityLevel level, boolean isMetaAnnotated, TypesForAnnotations typeForAnnotations) {
     // Check if the symbol is directly annotated
-    NullabilityData directlyAnnotated = getNullabilityData(metadata, level, isMetaAnnotated, typeForAnnotations, useOldMethod);
+    NullabilityData directlyAnnotated = getNullabilityData(metadata, level, isMetaAnnotated, typeForAnnotations);
     if (directlyAnnotated.type() != NO_ANNOTATION) {
       return directlyAnnotated;
     }
-    for (AnnotationInstance annotationInstance : metadata.annotations()) {
+    for (AnnotationInstance annotationInstance : metadata.symbolAnnotations()) {
       Symbol annotationSymbol = annotationInstance.symbol();
       Type annotationType = annotationSymbol.type();
       if (knownTypes.add(annotationType) && !KNOWN_ANNOTATIONS.contains(annotationType(annotationInstance).fullyQualifiedName())) {
         // Only do recursion when we face unknown annotations, as we already know the nullability impact and might contain contradicting
         // annotations.
-        NullabilityData nullabilityData = getNullabilityDataAtLevel(knownTypes, annotationSymbol.metadata(), level,
-          true, typeForAnnotations, useOldMethod);
+        NullabilityData nullabilityData = getNullabilityDataAtLevel(knownTypes, annotationSymbol.metadata(), level, true, typeForAnnotations);
         if (nullabilityData.type() != NO_ANNOTATION) {
           return nullabilityData;
         }
@@ -314,12 +313,11 @@ private static NullabilityData getNullabilityDataAtLevel(Set<Type> knownTypes, S
   private static NullabilityData getNullabilityData(SymbolMetadata metadata,
     NullabilityLevel level,
     boolean isMetaAnnotated,
-    TypesForAnnotations typeForAnnotations,
-    boolean useOldMethod) {
+    TypesForAnnotations typeForAnnotations) {
 
     NullabilityType nullabilityType = NullabilityType.NO_ANNOTATION;
     AnnotationInstance annotationInstance = null;
-    for (AnnotationInstance annotation : getAnnotations(metadata, useOldMethod)) {
+    for (AnnotationInstance annotation : metadata.symbolAnnotations()) {
       NullabilityType typeFromAnnotation = typeForAnnotations.getTypeFromAnnotation(annotation);
       if (typeFromAnnotation.ordinal() > nullabilityType.ordinal()) {
         nullabilityType = typeFromAnnotation;
@@ -335,10 +333,6 @@ private static NullabilityData getNullabilityData(SymbolMetadata metadata,
       annotationInstance, metadata.findAnnotationTree(annotationInstance), isMetaAnnotated);
   }
 
-  private static List<AnnotationInstance> getAnnotations(SymbolMetadata metadata, boolean useOldMethod) {
-    return useOldMethod ? metadata.annotations() : metadata.symbolAnnotations();
-  }
-
   private static NullabilityType getIfStrongNullable(AnnotationInstance annotation) {
     if (isStrongNullableAnnotation(annotationType(annotation))) {
       return STRONG_NULLABLE;

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

@@ -69,21 +69,11 @@ public NullabilityData nullabilityData() {
       return JSymbolMetadata.unknownNullabilityAt(NullabilityLevel.UNKNOWN);
     }
 
-    @Override
-    public NullabilityData oldNullabilityData() {
-      return JSymbolMetadata.unknownNullabilityAt(NullabilityLevel.UNKNOWN);
-    }
-
     @Override
     public NullabilityData nullabilityData(NullabilityTarget level) {
       return JSymbolMetadata.unknownNullabilityAt(NullabilityLevel.UNKNOWN);
     }
 
-    @Override
-    public NullabilityData oldNullabilityData(NullabilityTarget level) {
-      return JSymbolMetadata.unknownNullabilityAt(NullabilityLevel.UNKNOWN);
-    }
-
     @Nullable
     @Override
     public AnnotationTree findAnnotationTree(AnnotationInstance annotationInstance) {

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

@@ -66,28 +66,16 @@ public interface SymbolMetadata {
    */
   NullabilityData nullabilityData();
 
-  /**
-   * @deprecated use {@link #nullabilityData())} instead,
-   * this method uses the annotation of type parameter to compute nullability which is not correct
-   */
-  @Deprecated(since = "8.19.0")
-  NullabilityData oldNullabilityData();
-
   NullabilityData nullabilityData(NullabilityTarget level);
 
-  /**
-   * @deprecated use {@link #nullabilityData(NullabilityTarget)} instead,
-   * this method uses the annotation of type parameter to compute nullability which is not correct
-   */
-  @Deprecated(since = "8.19.0")
-  NullabilityData oldNullabilityData(NullabilityTarget level);
-
   @Nullable
   AnnotationTree findAnnotationTree(AnnotationInstance annotationInstance);
 
   /**
-   *
-   * @return
+   * @return the metadata of the parameterized types of the current metadata
+   * <p>
+   * If the current metadata is attached to {@code @NonNull List<@Nullable String>},
+   * it will return an array containing one metadata describing {@code @Nullable String}.
    */
   SymbolMetadata[] parameterMetadata();
 

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

@@ -192,14 +192,6 @@ void parametrized_type_level_nullability() throws IOException {
     );
   }
 
-  @Test
-  void parametrized_type_level_nullability_old() throws IOException {
-    assertNullability(
-      NULLABILITY_SOURCE_DIR.resolve(Paths.get("no_default", "NullabilityOfParametrizedTypes_Old.java")),
-      true
-    );
-  }
-
   @Test
   void unsupported_nullability() throws IOException {
     assertNullability(
@@ -360,10 +352,6 @@ void nullability_unknown_type() {
   }
 
   void assertNullability(Path sourceFile) throws IOException {
-    assertNullability(sourceFile, false);
-  }
-
-  void assertNullability(Path sourceFile, boolean useOldMethod) throws IOException {
     CompilationUnitTree cut = JParserTestUtils.parse(sourceFile.toRealPath().toFile(), JParserTestUtils.checksTestClassPath());
     List<Symbol> idSymbols = collectIdentifiers(cut).stream()
       .filter(identifier -> identifier.name().startsWith("id"))
@@ -382,16 +370,16 @@ void assertNullability(Path sourceFile, boolean useOldMethod) throws IOException
       String expectedLine = matcher.group("line");
       boolean metaAnnotation = matcher.group("meta") != null;
 
-      assertNullability(symbol, expectedType, expectedLevel, expectedLine, metaAnnotation, useOldMethod, "\nFile: " + sourceFile.toRealPath() + "\n");
+      assertNullability(symbol, expectedType, expectedLevel, expectedLine, metaAnnotation, "\nFile: " + sourceFile.toRealPath() + "\n");
     }
   }
 
   private static void assertNullability(Symbol symbol, NullabilityType expectedType,
                                         @Nullable NullabilityLevel expectedLevel, @Nullable String expectedLine,
-                                        boolean metaAnnotation, boolean useOldMethod, String context) {
+                                        boolean metaAnnotation, String context) {
 
     String symbolContext = "for symbol: " + symbol.name() + " in " + context;
-    SymbolMetadata.NullabilityData nullabilityData = (useOldMethod ? symbol.metadata().oldNullabilityData() : symbol.metadata().nullabilityData());
+    SymbolMetadata.NullabilityData nullabilityData = symbol.metadata().nullabilityData();
     assertThat(nullabilityData.type()).describedAs(symbolContext).isEqualTo(expectedType);
     if (expectedLevel != null) {
       assertThat(nullabilityData.level()).describedAs(symbolContext).isEqualTo(expectedLevel);