SONARPY-2133 Modify ObjectType to use TypeWrapper

Author: ghislainpiot

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

@@ -0,0 +1,74 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.semantic.v2;
+
+import java.util.List;
+import org.sonar.plugins.python.api.LocationInFile;
+import org.sonar.python.types.v2.Member;
+import org.sonar.python.types.v2.ObjectType;
+import org.sonar.python.types.v2.PythonType;
+import org.sonar.python.types.v2.TypeSource;
+import org.sonar.python.types.v2.TypeWrapper;
+
+public class ObjectTypeBuilder implements TypeBuilder<ObjectType> {
+
+  private TypeWrapper typeWrapper;
+  private List<PythonType> attributes;
+  private List<Member> members;
+  private TypeSource typeSource;
+
+  @Override
+  public ObjectType build() {
+    return new ObjectType(typeWrapper, attributes, members, typeSource);
+  }
+
+  @Override
+  public TypeBuilder<ObjectType> withDefinitionLocation(LocationInFile definitionLocation) {
+    throw new IllegalStateException("Object type does not have definition location");
+  }
+
+  public ObjectTypeBuilder withTypeWrapper(TypeWrapper typeWrapper) {
+    this.typeWrapper = typeWrapper;
+    return this;
+  }
+
+  public ObjectTypeBuilder withAttributes(List<PythonType> attributes) {
+    this.attributes = attributes;
+    return this;
+  }
+
+  public ObjectTypeBuilder withMembers(List<Member> members) {
+    this.members = members;
+    return this;
+  }
+
+  public ObjectTypeBuilder withTypeSource(TypeSource typeSource) {
+    this.typeSource = typeSource;
+    return this;
+  }
+
+  public static ObjectTypeBuilder fromObjectType(ObjectType objectType) {
+    return new ObjectTypeBuilder()
+      .withTypeWrapper(objectType.typeWrapper())
+      .withAttributes(objectType.attributes())
+      .withMembers(objectType.members())
+      .withTypeSource(objectType.typeSource());
+  }
+}

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

@@ -19,6 +19,8 @@
  */
 package org.sonar.python.types.v2;
 
+import java.util.Objects;
+
 public class LazyTypeWrapper implements TypeWrapper {
   private PythonType type;
 
@@ -39,4 +41,24 @@ public void resolveLazyType(PythonType pythonType) {
     }
     this.type = pythonType;
   }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    LazyTypeWrapper that = (LazyTypeWrapper) o;
+    return Objects.equals(type, that.type);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(type);
+  }
+
+  @Override
+  public String toString() {
+    return "LazyTypeWrapper{" +
+      "type=" + type +
+      '}';
+  }
 }

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

@@ -27,12 +27,31 @@
 import org.sonar.plugins.python.api.LocationInFile;
 
 @Beta
-public record ObjectType(PythonType type, List<PythonType> attributes, List<Member> members, TypeSource typeSource) implements PythonType {
+public final class ObjectType implements PythonType {
+  private final TypeWrapper typeWrapper;
+  private final List<PythonType> attributes;
+  private final List<Member> members;
+  private final TypeSource typeSource;
+
+  public ObjectType(TypeWrapper typeWrapper, List<PythonType> attributes, List<Member> members, TypeSource typeSource) {
+    this.typeWrapper = typeWrapper;
+    this.attributes = attributes;
+    this.members = members;
+    this.typeSource = typeSource;
+  }
+
+  public ObjectType(PythonType type, List<PythonType> attributes, List<Member> members, TypeSource typeSource) {
+    this(new SimpleTypeWrapper(type), attributes, members, typeSource);
+  }
 
   public ObjectType(PythonType type) {
     this(type, TypeSource.EXACT);
   }
 
+  public ObjectType(TypeWrapper typeWrapper) {
+    this(typeWrapper, new ArrayList<>(), new ArrayList<>(), TypeSource.EXACT);
+  }
+
   public ObjectType(PythonType type, TypeSource typeSource) {
     this(type, new ArrayList<>(), new ArrayList<>(), typeSource);
   }
@@ -43,17 +62,17 @@ public ObjectType(PythonType type, List<PythonType> attributes, List<Member> mem
 
   @Override
   public Optional<String> displayName() {
-    return type.instanceDisplayName();
+    return typeWrapper.type().instanceDisplayName();
   }
 
   @Override
   public boolean isCompatibleWith(PythonType another) {
-    return this.type.isCompatibleWith(another);
+    return this.typeWrapper.type().isCompatibleWith(another);
   }
 
   @Override
   public PythonType unwrappedType() {
-    return this.type;
+    return this.typeWrapper.type();
   }
 
   @Override
@@ -62,23 +81,23 @@ public Optional<PythonType> resolveMember(String memberName) {
       .filter(member -> Objects.equals(member.name(), memberName))
       .map(Member::type)
       .findFirst()
-      .or(() -> type.resolveMember(memberName));
+      .or(() -> typeWrapper.type().resolveMember(memberName));
   }
 
   @Override
   public TriBool hasMember(String memberName) {
     if (resolveMember(memberName).isPresent()) {
       return TriBool.TRUE;
     }
-    if (type instanceof ClassType classType) {
+    if (typeWrapper.type() instanceof ClassType classType) {
       return classType.instancesHaveMember(memberName);
     }
     return TriBool.UNKNOWN;
   }
 
   @Override
   public Optional<LocationInFile> definitionLocation() {
-    return type.definitionLocation();
+    return typeWrapper.type().definitionLocation();
   }
 
   @Override
@@ -90,13 +109,44 @@ public boolean equals(Object o) {
     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);
+    return Objects.equals(typeWrapper, that.typeWrapper) && 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);
+    return Objects.hash(typeWrapper, attributesNames, membersNames);
   }
+
+  public PythonType type() {
+    return typeWrapper.type();
+  }
+
+  public TypeWrapper typeWrapper() {
+    return typeWrapper;
+  }
+
+  public List<PythonType> attributes() {
+    return attributes;
+  }
+
+  public List<Member> members() {
+    return members;
+  }
+
+  @Override
+  public TypeSource typeSource() {
+    return typeSource;
+  }
+
+  @Override
+  public String toString() {
+    return "ObjectType[" +
+      "type=" + typeWrapper + ", " +
+      "attributes=" + attributes + ", " +
+      "members=" + members + ", " +
+      "typeSource=" + typeSource + ']';
+  }
+
 }

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

@@ -0,0 +1,55 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.types.v2;
+
+import java.util.Objects;
+
+public class SimpleTypeWrapper implements TypeWrapper {
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    SimpleTypeWrapper that = (SimpleTypeWrapper) o;
+    return Objects.equals(type, that.type);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(type);
+  }
+
+  private final PythonType type;
+
+  public SimpleTypeWrapper(PythonType type) {
+    this.type = type;
+  }
+
+  @Override
+  public PythonType type() {
+    return type;
+  }
+
+  @Override
+  public String toString() {
+    return "SimpleTypeWrapper{" +
+      "type=" + type +
+      '}';
+  }
+}

python-frontend/src/test/java/org/sonar/python/semantic/v2/TypeCheckerBuilderTest.java

@@ -126,4 +126,12 @@ void isInstanceOfTest() {
     );
   }
 
+  @Test
+  void objectTypeThrowsOnDefinitionLocation() {
+    var objectTypeBuilder = new ObjectTypeBuilder();
+    Assertions.assertThatThrownBy(() -> objectTypeBuilder.withDefinitionLocation(null))
+      .isInstanceOf(IllegalStateException.class)
+      .hasMessage("Object type does not have definition location");
+  }
+
 }

python-frontend/src/test/java/org/sonar/python/types/v2/LazyTypeWrapperTest.java

@@ -49,4 +49,18 @@ void resolvingNonLazyTypeThrowsException() {
       .isInstanceOf(IllegalStateException.class)
       .hasMessage("Trying to resolve an already resolved lazy type.");
   }
+
+  @Test
+  void testEquals() {
+    var lazyTypeWrapper = new LazyTypeWrapper(new LazyType("random", Mockito.mock(LazyTypesContext.class)));
+    assertThat(lazyTypeWrapper.equals(lazyTypeWrapper)).isTrue();
+    assertThat(lazyTypeWrapper.equals(null)).isFalse();
+    assertThat(lazyTypeWrapper.equals("str")).isFalse();
+  }
+
+  @Test
+  void testToString() {
+    var lazyTypeWrapper = new LazyTypeWrapper(new LazyType("random", Mockito.mock(LazyTypesContext.class)));
+    assertThat(lazyTypeWrapper.toString()).startsWith("LazyTypeWrapper{type=");
+  }
 }

python-frontend/src/test/java/org/sonar/python/types/v2/SimpleTypeWrapperTest.java

@@ -0,0 +1,36 @@
+/*
+ * SonarQube Python Plugin
+ * Copyright (C) 2011-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.python.types.v2;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SimpleTypeWrapperTest {
+
+  @Test
+  void testEquals() {
+    var simpleTypeWrapper = new SimpleTypeWrapper(PythonType.UNKNOWN);
+    assertThat(simpleTypeWrapper.equals(simpleTypeWrapper)).isTrue();
+    assertThat(simpleTypeWrapper.equals(null)).isFalse();
+    assertThat(simpleTypeWrapper.equals("str")).isFalse();
+  }
+
+}