SONARJAVA-4700 Update API with methods from JUtils (#4559)

SonarSource · Nov 22, 2023 · f8601c3 · f8601c3
1 parent ec579c8
commit f8601c3
Show file tree

Hide file tree

Showing 28 changed files with 228 additions and 77 deletions.
diff --git a/java-checks/src/main/java/org/sonar/java/checks/AnonymousClassShouldBeLambdaCheck.java b/java-checks/src/main/java/org/sonar/java/checks/AnonymousClassShouldBeLambdaCheck.java
@@ -104,7 +104,7 @@ private static boolean hasSingleAbstractMethodInHierarchy(Set<Type> superTypes)
       // remove objects methods redefined in interfaces
       .filter(symbol -> !isObjectMethod(symbol))
       // remove generic methods, which can not be written as lambda (JLS-11 §15.27)
-      .filter(symbol -> !JUtils.isParametrizedMethod(symbol))
+      .filter(symbol -> !symbol.isParametrizedMethod())
       // always take same symbol if method is redeclared over and over in hierarchy
       .map(AnonymousClassShouldBeLambdaCheck::overridenSymbolIfAny)
       .collect(Collectors.toSet())

diff --git a/java-checks/src/main/java/org/sonar/java/checks/ArrayForVarArgCheck.java b/java-checks/src/main/java/org/sonar/java/checks/ArrayForVarArgCheck.java
@@ -21,7 +21,6 @@
 
 import org.sonar.check.Rule;
 import org.sonar.java.model.ExpressionUtils;
-import org.sonar.java.model.JUtils;
 import org.sonar.java.model.LiteralUtils;
 import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
 import org.sonar.plugins.java.api.semantic.Symbol;
@@ -98,7 +97,7 @@ private void reportIssueForSameType(Symbol.MethodSymbol methodSymbol, NewArrayTr
   private static boolean isLastArgumentVarargs(Symbol.MethodSymbol methodSymbol, Arguments args) {
     // If we have less arguments than parameter types, it means that no arguments was pass to the varargs.
     // If we have more, the last argument can not be an array.
-    return !args.isEmpty() && JUtils.isVarArgsMethod(methodSymbol) && args.size() == methodSymbol.parameterTypes().size();
+    return !args.isEmpty() && methodSymbol.isVarArgsMethod() && args.size() == methodSymbol.parameterTypes().size();
   }
 
   private static Type getLastParameterType(List<? extends Type> list) {

diff --git a/java-checks/src/main/java/org/sonar/java/checks/CallOuterPrivateMethodCheck.java b/java-checks/src/main/java/org/sonar/java/checks/CallOuterPrivateMethodCheck.java
@@ -28,7 +28,6 @@
 import javax.annotation.Nullable;
 import org.sonar.check.Rule;
 import org.sonar.java.model.ExpressionUtils;
-import org.sonar.java.model.JUtils;
 import org.sonar.java.model.JavaTree;
 import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
 import org.sonar.plugins.java.api.JavaFileScannerContext;
@@ -96,7 +95,7 @@ public void visitMethodInvocation(MethodInvocationTree tree) {
         String name = ExpressionUtils.methodName(tree).name();
         unknownInvocations.computeIfAbsent(name, k -> new HashSet<>()).add(tree);
       } else if (isPrivateMethodOfOuterClass(symbol) && isInvocationOnCurrentInstance(tree)) {
-        if (JUtils.isParametrizedMethod(symbol) && symbol.declaration() != null) {
+        if (symbol.isParametrizedMethod() && symbol.declaration() != null) {
           // generic methods requires to use their declaration symbol rather than the parameterized one
           symbol = symbol.declaration().symbol();
         }
@@ -139,7 +138,7 @@ private boolean hasSameArity(Symbol.MethodSymbol methodUsed, MethodInvocationTre
       int formalArity = methodUsed.parameterTypes().size();
       int invokedArity = mit.arguments().size();
       return formalArity == invokedArity ||
-        (JUtils.isVarArgsMethod(methodUsed) && invokedArity >= formalArity - 1);
+        (methodUsed.isVarArgsMethod() && invokedArity >= formalArity - 1);
     }
 
     private void reportIssueOnMethod(@Nullable MethodTree declaration, Symbol.TypeSymbol classSymbol) {

diff --git a/java-checks/src/main/java/org/sonar/java/checks/CollectionInappropriateCallsCheck.java b/java-checks/src/main/java/org/sonar/java/checks/CollectionInappropriateCallsCheck.java
@@ -129,7 +129,7 @@ private static String typeNameWithParameters(Type type) {
   private static boolean isCallToParametrizedOrUnknownMethod(ExpressionTree expressionTree) {
     if (expressionTree.is(Tree.Kind.METHOD_INVOCATION)) {
       Symbol.MethodSymbol symbol = ((MethodInvocationTree) expressionTree).methodSymbol();
-      return symbol.isUnknown() || JUtils.isParametrizedMethod(symbol);
+      return symbol.isUnknown() || symbol.isParametrizedMethod();
     }
     return false;
   }

diff --git a/java-checks/src/main/java/org/sonar/java/checks/ConfusingVarargCheck.java b/java-checks/src/main/java/org/sonar/java/checks/ConfusingVarargCheck.java
@@ -84,7 +84,7 @@ public void visitNode(Tree tree) {
   }
 
   private void checkConfusingVararg(Symbol.MethodSymbol method, Arguments arguments) {
-    if (!JUtils.isVarArgsMethod(method)) {
+    if (!method.isVarArgsMethod()) {
       return;
     }
     List<Type> parameterTypes = method.parameterTypes();

diff --git a/java-checks/src/main/java/org/sonar/java/checks/ConstructorCallingOverridableCheck.java b/java-checks/src/main/java/org/sonar/java/checks/ConstructorCallingOverridableCheck.java
@@ -77,7 +77,7 @@ public void visitMethodInvocation(MethodInvocationTree tree) {
       }
       if (isInvocationOnSelf) {
         Symbol symbol = methodIdentifier.symbol();
-        if (symbol.isMethodSymbol() && JUtils.isOverridable((Symbol.MethodSymbol) symbol) && isMethodDefinedOnConstructedType(symbol)) {
+        if (symbol.isMethodSymbol() && ((Symbol.MethodSymbol) symbol).isOverridable() && isMethodDefinedOnConstructedType(symbol)) {
           reportIssue(methodIdentifier, "Remove this call from a constructor to the overridable \"" + methodIdentifier.name() + "\" method.");
         }
       }

diff --git a/java-checks/src/main/java/org/sonar/java/checks/DiamondOperatorCheck.java b/java-checks/src/main/java/org/sonar/java/checks/DiamondOperatorCheck.java
@@ -28,7 +28,6 @@
 import org.sonar.plugins.java.api.JavaVersionAwareVisitor;
 import org.sonar.java.ast.visitors.SubscriptionVisitor;
 import org.sonar.java.checks.helpers.QuickFixHelper;
-import org.sonar.java.model.JUtils;
 import org.sonar.java.model.JavaTree;
 import org.sonar.java.reporting.JavaQuickFix;
 import org.sonar.java.reporting.JavaTextEdit;
@@ -132,7 +131,7 @@ private static boolean usedAsArgumentWithoutDiamond(NewClassTree newClassTree) {
       return false;
     }
 
-    if (JUtils.isParametrizedMethod(methodSymbol)) {
+    if (methodSymbol.isParametrizedMethod()) {
       // killing the noise - might be required for inference on nested method calls
       return false;
     }

diff --git a/java-checks/src/main/java/org/sonar/java/checks/RedundantAbstractMethodCheck.java b/java-checks/src/main/java/org/sonar/java/checks/RedundantAbstractMethodCheck.java
@@ -68,7 +68,7 @@ private static boolean differentContract(Symbol.MethodSymbol method, Symbol.Meth
   }
 
   private static boolean removingParametrizedAspect(Symbol.MethodSymbol method, Symbol.MethodSymbol overridee) {
-    return !JUtils.isParametrizedMethod(method) && JUtils.isParametrizedMethod(overridee);
+    return !method.isParametrizedMethod() && overridee.isParametrizedMethod();
   }
 
   private static boolean differentThrows(Symbol.MethodSymbol method, Symbol.MethodSymbol overridee) {

diff --git a/java-checks/src/main/java/org/sonar/java/checks/RedundantThrowsDeclarationCheck.java b/java-checks/src/main/java/org/sonar/java/checks/RedundantThrowsDeclarationCheck.java
@@ -81,7 +81,7 @@ public void visitNode(Tree tree) {
 
   private void checkMethodThrownList(MethodTree methodTree, ListTree<TypeTree> thrownList) {
     Set<Type> thrownExceptions = thrownExceptionsFromBody(methodTree);
-    boolean isOverridableMethod = JUtils.isOverridable(methodTree.symbol());
+    boolean isOverridableMethod = methodTree.symbol().isOverridable();
     Set<String> undocumentedExceptionNames = new Javadoc(methodTree).undocumentedThrownExceptions();
     Set<String> reported = new HashSet<>();
 

diff --git a/java-checks/src/main/java/org/sonar/java/checks/SynchronizedOverrideCheck.java b/java-checks/src/main/java/org/sonar/java/checks/SynchronizedOverrideCheck.java
@@ -21,7 +21,6 @@
 
 import java.util.Collections;
 import org.sonar.check.Rule;
-import org.sonar.java.model.JUtils;
 import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
 import org.sonar.plugins.java.api.JavaFileScannerContext;
 import org.sonar.plugins.java.api.semantic.Symbol;
@@ -50,7 +49,7 @@ public void visitNode(Tree tree) {
       return;
     }
     Symbol.MethodSymbol overriddenSymbol = overriddenSymbols.get(0);
-    if (JUtils.isSynchronizedMethod(overriddenSymbol) && !JUtils.isSynchronizedMethod(methodSymbol)) {
+    if (overriddenSymbol.isSynchronizedMethod() && !methodSymbol.isSynchronizedMethod()) {
       List<JavaFileScannerContext.Location> secondaries = Collections.emptyList();
       MethodTree overridenMethodTree = overriddenSymbol.declaration();
       if (overridenMethodTree != null) {

diff --git a/java-checks/src/main/java/org/sonar/java/checks/ThreadAsRunnableArgumentCheck.java b/java-checks/src/main/java/org/sonar/java/checks/ThreadAsRunnableArgumentCheck.java
@@ -20,7 +20,6 @@
 package org.sonar.java.checks;
 
 import org.sonar.check.Rule;
-import org.sonar.java.model.JUtils;
 import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
 import org.sonar.plugins.java.api.semantic.Symbol;
 import org.sonar.plugins.java.api.semantic.Type;
@@ -67,7 +66,7 @@ private void checkArgumentsTypes(List<ExpressionTree> arguments, Symbol.MethodSy
       for (int index = 0; index < arguments.size(); index++) {
         ExpressionTree argument = arguments.get(index);
         Type providedType = argument.symbolType();
-        if (!argument.is(Tree.Kind.NULL_LITERAL) && isThreadAsRunnable(providedType, parametersTypes, index, JUtils.isVarArgsMethod(methodSymbol))) {
+        if (!argument.is(Tree.Kind.NULL_LITERAL) && isThreadAsRunnable(providedType, parametersTypes, index, methodSymbol.isVarArgsMethod())) {
           reportIssue(argument, getMessage(argument, providedType, index));
         }
       }

diff --git a/java-checks/src/main/java/org/sonar/java/checks/VarCanBeUsedCheck.java b/java-checks/src/main/java/org/sonar/java/checks/VarCanBeUsedCheck.java
@@ -103,7 +103,7 @@ public void visitNode(Tree tree) {
   private static boolean isExcludedInitializer(ExpressionTree initializer) {
     if (initializer.is(Tree.Kind.METHOD_INVOCATION)) {
       Symbol.MethodSymbol symbol = ((MethodInvocationTree) initializer).methodSymbol();
-      return !symbol.isUnknown() && JUtils.isParametrizedMethod(symbol);
+      return !symbol.isUnknown() && symbol.isParametrizedMethod();
     }
     return initializer.is(Tree.Kind.CONDITIONAL_EXPRESSION, Tree.Kind.METHOD_REFERENCE, Tree.Kind.LAMBDA_EXPRESSION);
   }

diff --git a/java-checks/src/main/java/org/sonar/java/checks/tests/NoTestInTestClassCheck.java b/java-checks/src/main/java/org/sonar/java/checks/tests/NoTestInTestClassCheck.java
@@ -30,7 +30,6 @@
 import org.apache.commons.lang3.StringUtils;
 import org.sonar.check.Rule;
 import org.sonar.check.RuleProperty;
-import org.sonar.java.model.JUtils;
 import org.sonar.java.model.ModifiersUtils;
 import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
 import org.sonar.plugins.java.api.semantic.Symbol;
@@ -226,7 +225,7 @@ private static Stream<Symbol> getAllMembers(Symbol.TypeSymbol symbol, boolean is
     }
     Stream<Symbol> defaultMethodsFromInterfaces = symbol.interfaces().stream()
       .flatMap(i -> getAllMembers(i.symbol(), false, visitedSymbols))
-      .filter(m -> m.isMethodSymbol() && JUtils.isDefaultMethod((Symbol.MethodSymbol) m));
+      .filter(m -> m.isMethodSymbol() && ((Symbol.MethodSymbol) m).isDefaultMethod());
     members = Stream.concat(members, defaultMethodsFromInterfaces);
     for (Symbol s : symbol.memberSymbols()) {
       if (isNested(s) || isPublicStaticConcrete(s)) {

diff --git a/java-checks/src/main/java/org/sonar/java/checks/unused/UnusedMethodParameterCheck.java b/java-checks/src/main/java/org/sonar/java/checks/unused/UnusedMethodParameterCheck.java
@@ -30,7 +30,6 @@
 import org.sonar.java.checks.helpers.MethodTreeUtils;
 import org.sonar.java.checks.helpers.QuickFixHelper;
 import org.sonar.java.checks.helpers.UnresolvedIdentifiersVisitor;
-import org.sonar.java.model.JUtils;
 import org.sonar.java.model.ModifiersUtils;
 import org.sonar.java.reporting.AnalyzerMessage;
 import org.sonar.java.reporting.JavaQuickFix;
@@ -89,7 +88,7 @@ public void visitNode(Tree tree) {
       return;
     }
     Set<String> undocumentedParameters = new HashSet<>(new Javadoc(methodTree).undocumentedParameters());
-    boolean overridableMethod = JUtils.isOverridable(methodTree.symbol());
+    boolean overridableMethod = methodTree.symbol().isOverridable();
     List<IdentifierTree> unused = new ArrayList<>();
     for (VariableTree parameter : methodTree.parameters()) {
       Symbol symbol = parameter.symbol();

diff --git a/java-frontend/src/main/java/org/sonar/java/model/JInitializerBlockSymbol.java b/java-frontend/src/main/java/org/sonar/java/model/JInitializerBlockSymbol.java
@@ -185,4 +185,29 @@ public String name() {
   public String signature() {
     return owner.name() + "." + name();
   }
+
+  @Override
+  public boolean isOverridable() {
+    return false;
+  }
+
+  @Override
+  public boolean isParametrizedMethod() {
+    return false;
+  }
+
+  @Override
+  public boolean isDefaultMethod() {
+    return false;
+  }
+
+  @Override
+  public boolean isSynchronizedMethod() {
+    return false;
+  }
+
+  @Override
+  public boolean isVarArgsMethod() {
+    return false;
+  }
 }
diff --git a/java-frontend/src/main/java/org/sonar/java/model/JMethodSymbol.java b/java-frontend/src/main/java/org/sonar/java/model/JMethodSymbol.java
@@ -31,6 +31,7 @@
 import org.eclipse.jdt.core.dom.ASTUtils;
 import org.eclipse.jdt.core.dom.IMethodBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
+import org.eclipse.jdt.core.dom.Modifier;
 import org.sonar.java.annotations.VisibleForTesting;
 import org.sonar.plugins.java.api.semantic.Symbol;
 import org.sonar.plugins.java.api.semantic.Type;
@@ -176,6 +177,31 @@ public String signature() {
     return signature;
   }
 
+  @Override
+  public boolean isOverridable() {
+    return !isUnknown() && !(isPrivate() || isStatic() || isFinal() || owner().isFinal());
+  }
+
+  @Override
+  public boolean isParametrizedMethod() {
+    return !isUnknown() && (methodBinding().isParameterizedMethod() || methodBinding().isGenericMethod());
+  }
+
+  @Override
+  public boolean isDefaultMethod() {
+    return !isUnknown() && Modifier.isDefault(binding.getModifiers());
+  }
+
+  @Override
+  public boolean isSynchronizedMethod() {
+    return !isUnknown() && Modifier.isSynchronized(binding.getModifiers());
+  }
+
+  @Override
+  public boolean isVarArgsMethod() {
+    return !isUnknown() && methodBinding().isVarargs();
+  }
+
   @Nullable
   @Override
   public MethodTree declaration() {

diff --git a/java-frontend/src/main/java/org/sonar/java/model/JUtils.java b/java-frontend/src/main/java/org/sonar/java/model/JUtils.java
@@ -146,22 +146,10 @@ public static Symbol getPackage(Symbol symbol) {
     return symbol;
   }
 
-  public static boolean isVarArgsMethod(Symbol.MethodSymbol method) {
-    return !method.isUnknown() && ((JMethodSymbol) method).methodBinding().isVarargs();
-  }
-
-  public static boolean isSynchronizedMethod(Symbol.MethodSymbol method) {
-    return !method.isUnknown() && Modifier.isSynchronized(((JMethodSymbol) method).binding.getModifiers());
-  }
-
   public static boolean isNativeMethod(Symbol.MethodSymbol method) {
     return !method.isUnknown() && Modifier.isNative(((JMethodSymbol) method).binding.getModifiers());
   }
 
-  public static boolean isDefaultMethod(Symbol.MethodSymbol method) {
-    return !method.isUnknown() && Modifier.isDefault(((JMethodSymbol) method).binding.getModifiers());
-  }
-
   @Nullable
   public static Object defaultValue(Symbol.MethodSymbol method) {
     if (method.isUnknown()) {
@@ -170,18 +158,6 @@ public static Object defaultValue(Symbol.MethodSymbol method) {
     return ((JMethodSymbol) method).methodBinding().getDefaultValue();
   }
 
-  public static boolean isOverridable(Symbol.MethodSymbol method) {
-    return !method.isUnknown() && !(method.isPrivate() || method.isStatic() || method.isFinal() || method.owner().isFinal());
-  }
-
-  public static boolean isParametrizedMethod(Symbol.MethodSymbol method) {
-    if (method.isUnknown()) {
-      return false;
-    }
-    return ((JMethodSymbol) method).methodBinding().isParameterizedMethod()
-      || ((JMethodSymbol) method).methodBinding().isGenericMethod();
-  }
-
   public static Set<Type> directSuperTypes(Type type) {
     if (type.isUnknown()) {
       return Collections.emptySet();

diff --git a/java-frontend/src/main/java/org/sonar/java/model/Symbols.java b/java-frontend/src/main/java/org/sonar/java/model/Symbols.java
@@ -294,6 +294,31 @@ public String name() {
     public String signature() {
       return "!unknownMethod!";
     }
+
+    @Override
+    public boolean isOverridable() {
+      return false;
+    }
+
+    @Override
+    public boolean isParametrizedMethod() {
+      return false;
+    }
+
+    @Override
+    public boolean isDefaultMethod() {
+      return false;
+    }
+
+    @Override
+    public boolean isSynchronizedMethod() {
+      return false;
+    }
+
+    @Override
+    public boolean isVarArgsMethod() {
+      return false;
+    }
   }
 
   private static final class UnknownType implements Type {

diff --git a/java-frontend/src/main/java/org/sonar/plugins/java/api/semantic/Symbol.java b/java-frontend/src/main/java/org/sonar/plugins/java/api/semantic/Symbol.java
@@ -215,6 +215,31 @@ interface MethodSymbol extends Symbol {
      * @return the signature of the method, as String
      */
     String signature();
+
+    /**
+     * @return true if the method symbol is overridable.
+     */
+    boolean isOverridable();
+
+    /**
+     * @return true if the method has type parameters.
+     */
+    boolean isParametrizedMethod();
+
+    /**
+     * @return true if the method has a default implementation.
+     */
+    boolean isDefaultMethod();
+
+    /**
+     * @return true if the method is synchronized.
+     */
+    boolean isSynchronizedMethod();
+
+    /**
+     * @return true if the method takes a vararg argument (e.g. `String... args`).
+     */
+    boolean isVarArgsMethod();
   }
 
   /**