SONARPY-1896 Fix performance of new type inference hashCode computations (#1821)

Author: maksim-grebeniuk-sonarsource

python-frontend/src/main/java/org/sonar/python/semantic/v2/SymbolV2.java

@@ -27,10 +27,18 @@
 import org.sonar.python.tree.NameImpl;
 
 @Beta
-public record SymbolV2(String name, @Nullable String fullyQualifiedName, List<UsageV2> usages) {
+public class SymbolV2 {
+
+  private final String name;
+  private final List<UsageV2> usages;
+
+  public SymbolV2(String name, List<UsageV2> usages) {
+    this.name = name;
+    this.usages = usages;
+  }
 
   public SymbolV2(String name) {
-    this(name, null, new ArrayList<>());
+    this(name, new ArrayList<>());
   }
 
   void addUsage(Name name, UsageV2.Kind kind) {
@@ -45,4 +53,13 @@ void addUsage(Name name, UsageV2.Kind kind) {
   public boolean hasSingleBindingUsage() {
     return usages.stream().filter(UsageV2::isBindingUsage).toList().size() == 1;
   }
+
+  public String name() {
+    return name;
+  }
+
+  public List<UsageV2> usages() {
+    return usages;
+  }
+
 }

python-frontend/src/main/java/org/sonar/python/semantic/v2/TypeShed.java

@@ -27,6 +27,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -130,7 +131,11 @@ public Map<String, Symbol> symbolsForModule(String moduleName) {
       return Collections.emptyMap();
     }
     if (!typeShedSymbols.containsKey(moduleName)) {
-      Map<String, Symbol> symbols = searchTypeShedForModule(moduleName);
+      var symbols = Optional.of(org.sonar.python.types.TypeShed.getLoadedTypeShedSymbols())
+        .filter(m -> m.containsKey(moduleName))
+        .map(m -> m.get(moduleName))
+        .orElseGet(() -> searchTypeShedForModule(moduleName));
+
       typeShedSymbols.put(moduleName, symbols);
       return symbols;
     }

python-frontend/src/main/java/org/sonar/python/types/TypeShed.java

@@ -115,6 +115,10 @@ public static Map<String, Symbol> builtinSymbols() {
     return builtins;
   }
 
+  public static Map<String, Map<String, Symbol>> getLoadedTypeShedSymbols() {
+    return typeShedSymbols;
+  }
+
   public static ClassSymbol typeShedClass(String fullyQualifiedName) {
     Symbol symbol = builtinSymbols().get(fullyQualifiedName);
     if (symbol == null) {

python-frontend/src/main/java/org/sonar/python/types/v2/ClassType.java

@@ -35,13 +35,29 @@
  * ClassType
  */
 @Beta
-public record ClassType(
-  String name,
-  Set<Member> members,
-  List<PythonType> attributes,
-  List<PythonType> superClasses,
-  List<PythonType> metaClasses,
-  @Nullable LocationInFile locationInFile) implements PythonType {
+public final class ClassType implements PythonType {
+
+  private final String name;
+  private final Set<Member> members;
+  private final List<PythonType> attributes;
+  private final List<PythonType> superClasses;
+  private final List<PythonType> metaClasses;
+  private final LocationInFile locationInFile;
+
+  public ClassType(
+    String name,
+    Set<Member> members,
+    List<PythonType> attributes,
+    List<PythonType> superClasses,
+    List<PythonType> metaClasses,
+    @Nullable LocationInFile locationInFile) {
+    this.name = name;
+    this.members = members;
+    this.attributes = attributes;
+    this.superClasses = superClasses;
+    this.metaClasses = metaClasses;
+    this.locationInFile = locationInFile;
+  }
 
   public ClassType(String name) {
     this(name, new HashSet<>(), new ArrayList<>(), new ArrayList<>(), new ArrayList<>(), null);
@@ -153,11 +169,11 @@ public TriBool hasMember(String memberName) {
 
   public boolean hasMetaClass() {
     return !this.metaClasses.isEmpty() ||
-           this.superClasses()
-             .stream()
-             .filter(ClassType.class::isInstance)
-             .map(ClassType.class::cast)
-             .anyMatch(ClassType::hasMetaClass);
+      this.superClasses()
+        .stream()
+        .filter(ClassType.class::isInstance)
+        .map(ClassType.class::cast)
+        .anyMatch(ClassType::hasMetaClass);
   }
 
   public TriBool instancesHaveMember(String memberName) {
@@ -177,27 +193,28 @@ public Optional<LocationInFile> definitionLocation() {
   }
 
   @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    ClassType classType = (ClassType) o;
-    boolean haveSameAttributes = Objects.equals(name, classType.name) && Objects.equals(members, classType.members) && Objects.equals(attributes, classType.attributes);
-    List<String> parentNames = superClasses.stream().map(PythonType::key).toList();
-    List<String> metaClassNames = metaClasses.stream().map(PythonType::key).toList();
-    List<String> otherParentNames = classType.superClasses.stream().map(PythonType::key).toList();
-    List<String> otherMetaClassNames = classType.metaClasses.stream().map(PythonType::key).toList();
-    return haveSameAttributes && Objects.equals(parentNames, otherParentNames) && Objects.equals(metaClassNames, otherMetaClassNames);
+  public String toString() {
+    return "ClassType[%s]".formatted(name);
   }
 
   @Override
-  public int hashCode() {
-    List<String> parentNames = superClasses.stream().map(PythonType::key).toList();
-    List<String> metaClassNames = metaClasses.stream().map(PythonType::key).toList();
-    return Objects.hash(name, members, attributes, parentNames, metaClassNames);
+  public String name() {
+    return name;
   }
 
-  @Override
-  public String toString() {
-    return "ClassType[%s]".formatted(name);
+  public Set<Member> members() {
+    return members;
+  }
+
+  public List<PythonType> attributes() {
+    return attributes;
+  }
+
+  public List<PythonType> superClasses() {
+    return superClasses;
+  }
+
+  public List<PythonType> metaClasses() {
+    return metaClasses;
   }
 }

python-frontend/src/main/java/org/sonar/python/types/v2/FunctionType.java

@@ -20,8 +20,8 @@
 package org.sonar.python.types.v2;
 
 import java.util.List;
-import java.util.Objects;
 import java.util.Optional;
+import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.sonar.api.Beta;
 import org.sonar.plugins.python.api.LocationInFile;
@@ -30,32 +30,43 @@
  * FunctionType
  */
 @Beta
-public record FunctionType(
-  String name,
-  List<PythonType> attributes,
-  List<ParameterV2> parameters,
-  PythonType returnType,
-  boolean isAsynchronous,
-  boolean hasDecorators,
-  boolean isInstanceMethod,
-  boolean hasVariadicParameter,
-  @Nullable PythonType owner,
-  @Nullable LocationInFile locationInFile
-) implements PythonType {
+public final class FunctionType implements PythonType {
+  private final String name;
+  private final List<PythonType> attributes;
+  private final List<ParameterV2> parameters;
+  private final PythonType returnType;
+  private final boolean isAsynchronous;
+  private final boolean hasDecorators;
+  private final boolean isInstanceMethod;
+  private final boolean hasVariadicParameter;
+  private final PythonType owner;
+  private final LocationInFile locationInFile;
 
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    FunctionType that = (FunctionType) o;
-    return hasDecorators == that.hasDecorators
-      && isAsynchronous == that.isAsynchronous
-      && isInstanceMethod == that.isInstanceMethod
-      && hasVariadicParameter == that.hasVariadicParameter
-      && Objects.equals(name, that.name)
-      && Objects.equals(returnType, that.returnType)
-      && Objects.equals(attributes, that.attributes)
-      && Objects.equals(parameters, that.parameters);
+  /**
+   *
+   */
+  public FunctionType(
+    String name,
+    List<PythonType> attributes,
+    List<ParameterV2> parameters,
+    PythonType returnType,
+    boolean isAsynchronous,
+    boolean hasDecorators,
+    boolean isInstanceMethod,
+    boolean hasVariadicParameter,
+    @Nullable PythonType owner,
+    @Nullable LocationInFile locationInFile
+  ) {
+    this.name = name;
+    this.attributes = attributes;
+    this.parameters = parameters;
+    this.returnType = returnType;
+    this.isAsynchronous = isAsynchronous;
+    this.hasDecorators = hasDecorators;
+    this.isInstanceMethod = isInstanceMethod;
+    this.hasVariadicParameter = hasVariadicParameter;
+    this.owner = owner;
+    this.locationInFile = locationInFile;
   }
 
   @Override
@@ -69,12 +80,45 @@ public Optional<LocationInFile> definitionLocation() {
   }
 
   @Override
-  public int hashCode() {
-    return Objects.hash(name, attributes, parameters, returnType, isAsynchronous, hasDecorators, isInstanceMethod, hasVariadicParameter);
+  public String toString() {
+    return "FunctionType[%s]".formatted(name);
   }
 
   @Override
-  public String toString() {
-    return "FunctionType[%s]".formatted(name);
+  public String name() {
+    return name;
+  }
+
+  public List<PythonType> attributes() {
+    return attributes;
+  }
+
+  public List<ParameterV2> parameters() {
+    return parameters;
+  }
+
+  public PythonType returnType() {
+    return returnType;
+  }
+
+  public boolean isAsynchronous() {
+    return isAsynchronous;
+  }
+
+  public boolean hasDecorators() {
+    return hasDecorators;
+  }
+
+  public boolean isInstanceMethod() {
+    return isInstanceMethod;
+  }
+
+  public boolean hasVariadicParameter() {
+    return hasVariadicParameter;
+  }
+
+  @CheckForNull
+  public PythonType owner() {
+    return owner;
   }
 }

python-frontend/src/main/java/org/sonar/python/types/v2/ModuleType.java

@@ -23,11 +23,22 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 import org.sonar.api.Beta;
 
 @Beta
-public record ModuleType(@Nullable String name, @Nullable ModuleType parent, Map<String, PythonType> members) implements PythonType {
+public final class ModuleType implements PythonType {
+  private final String name;
+  private final ModuleType parent;
+  private final Map<String, PythonType> members;
+
+  public ModuleType(@Nullable String name, @Nullable ModuleType parent, Map<String, PythonType> members) {
+    this.name = name;
+    this.parent = parent;
+    this.members = members;
+  }
+
   public ModuleType(@Nullable String name) {
     this(name, null);
   }
@@ -41,25 +52,27 @@ public Optional<PythonType> resolveMember(String memberName) {
     return Optional.ofNullable(members.get(memberName));
   }
 
-  @Override
-  public boolean equals(Object o) {
-    // TODO: Find a way how we want to compare modules
-    if (this == o) return true;
-    if (o == null || getClass() != o.getClass()) return false;
-    ModuleType that = (ModuleType) o;
-    return Objects.equals(name, that.name) && Objects.equals(members, that.members);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(name, members);
-  }
-
   @Override
   public String toString() {
     return "ModuleType{" +
       "name='" + name + '\'' +
       ", members=" + members +
       '}';
   }
+
+  @Override
+  @CheckForNull
+  public String name() {
+    return name;
+  }
+
+  @CheckForNull
+  public ModuleType parent() {
+    return parent;
+  }
+
+  public Map<String, PythonType> members() {
+    return members;
+  }
+
 }

python-frontend/src/main/java/org/sonar/python/types/v2/ObjectType.java

@@ -72,4 +72,23 @@ public TriBool hasMember(String memberName) {
   public Optional<LocationInFile> definitionLocation() {
     return type.definitionLocation();
   }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    ObjectType that = (ObjectType) o;
+    List<String> membersNames = members.stream().map(Member::name).toList();
+    List<String> otherMembersNames = that.members.stream().map(Member::name).toList();
+    List<String> attributesNames = attributes.stream().map(PythonType::key).toList();
+    List<String> otherAttributesNames = that.attributes.stream().map(PythonType::key).toList();
+    return Objects.equals(type, that.type) && Objects.equals(membersNames, otherMembersNames) && Objects.equals(attributesNames, otherAttributesNames);
+  }
+
+  @Override
+  public int hashCode() {
+    List<String> membersNames = members.stream().map(Member::name).toList();
+    List<String> attributesNames = attributes.stream().map(PythonType::key).toList();
+    return Objects.hash(type, attributesNames, membersNames);
+  }
 }