SONARPY-2126 Implement any Descriptor to a PythonType converter infrastructure (#1968)

Author: maksim-grebeniuk-sonarsource

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

@@ -0,0 +1,52 @@
+/*
+ * 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.converter;
+
+import java.util.Map;
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.semantic.v2.LazyTypesContext;
+import org.sonar.python.types.v2.PythonType;
+
+public class AnyDescriptorToPythonTypeConverter {
+
+  private static final DescriptorToPythonTypeConverter UNKNOWN_DESCRIPTOR_CONVERTER = new UnknownDescriptorToPythonTypeConverter();
+  private final Map<Descriptor.Kind, DescriptorToPythonTypeConverter> converters;
+  private final LazyTypesContext lazyTypesContext;
+
+  public AnyDescriptorToPythonTypeConverter(LazyTypesContext lazyTypesContext) {
+    this.lazyTypesContext = lazyTypesContext;
+    converters = Map.of();
+  }
+
+  public PythonType convert(Descriptor from) {
+    var ctx = new ConversionContext(lazyTypesContext, this::convert);
+    return convert(ctx, from);
+  }
+
+  private PythonType convert(ConversionContext ctx, Descriptor from) {
+    return converterFor(from).convert(ctx, from);
+  }
+
+  private DescriptorToPythonTypeConverter converterFor(Descriptor descriptor) {
+    return converters.getOrDefault(descriptor.kind(), UNKNOWN_DESCRIPTOR_CONVERTER);
+  }
+
+
+}

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

@@ -0,0 +1,58 @@
+/*
+ * 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.converter;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.semantic.v2.LazyTypesContext;
+import org.sonar.python.types.v2.PythonType;
+
+public class ConversionContext {
+  private final LazyTypesContext lazyTypesContext;
+  private final DescriptorToPythonTypeConverter converter;
+  private final Deque<PythonType> parents;
+
+  public ConversionContext(LazyTypesContext lazyTypesContext, DescriptorToPythonTypeConverter converter) {
+    this.lazyTypesContext = lazyTypesContext;
+    this.converter = converter;
+    this.parents = new ArrayDeque<>();
+  }
+
+  public LazyTypesContext lazyTypesContext() {
+    return lazyTypesContext;
+  }
+
+  public PythonType convert(Descriptor from) {
+    return converter.convert(this, from);
+  }
+
+  public void pushParent(PythonType pythonType) {
+    parents.push(pythonType);
+  }
+
+  public PythonType currentParent() {
+    return parents.peek();
+  }
+
+  public PythonType pollParent() {
+    return parents.poll();
+  }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * 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.converter;
+
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.types.v2.PythonType;
+
+public interface DescriptorToPythonTypeConverter {
+
+  PythonType convert(ConversionContext ctx, Descriptor from);
+
+
+}

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

@@ -0,0 +1,30 @@
+/*
+ * 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.converter;
+
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.types.v2.PythonType;
+
+public class UnknownDescriptorToPythonTypeConverter implements DescriptorToPythonTypeConverter {
+  @Override
+  public PythonType convert(ConversionContext ctx, Descriptor from) {
+    return PythonType.UNKNOWN;
+  }
+}

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

@@ -0,0 +1,76 @@
+/*
+ * 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.converter;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.semantic.v2.LazyTypesContext;
+import org.sonar.python.types.v2.PythonType;
+
+class ConversionContextTest {
+
+  @Test
+  void lazyTypeContextTest() {
+    var expectedLazyTypeContext = Mockito.mock(LazyTypesContext.class);
+    var rootConverter = Mockito.mock(DescriptorToPythonTypeConverter.class);
+    var ctx = new ConversionContext(expectedLazyTypeContext, rootConverter);
+    var lazyTypesContext = ctx.lazyTypesContext();
+    Assertions.assertSame(expectedLazyTypeContext, lazyTypesContext);
+  }
+
+  @Test
+  void parentsTest() {
+    var expectedLazyTypeContext = Mockito.mock(LazyTypesContext.class);
+    var rootConverter = Mockito.mock(DescriptorToPythonTypeConverter.class);
+    var ctx = new ConversionContext(expectedLazyTypeContext, rootConverter);
+    var firstParent = Mockito.mock(PythonType.class);
+    var secondParent = Mockito.mock(PythonType.class);
+
+    Assertions.assertNull(ctx.currentParent());
+    ctx.pushParent(firstParent);
+    Assertions.assertSame(firstParent, ctx.currentParent());
+    ctx.pushParent(secondParent);
+    Assertions.assertSame(secondParent, ctx.currentParent());
+    Assertions.assertSame(secondParent, ctx.pollParent());
+    Assertions.assertSame(firstParent, ctx.currentParent());
+    Assertions.assertSame(firstParent, ctx.pollParent());
+    Assertions.assertNull(ctx.currentParent());
+  }
+
+  @Test
+  void convertTest() {
+    var descriptor = Mockito.mock(Descriptor.class);
+    var expectedType = Mockito.mock(PythonType.class);
+
+    var lazyTypeContext = Mockito.mock(LazyTypesContext.class);
+    var rootConverter = Mockito.mock(DescriptorToPythonTypeConverter.class);
+    var ctx = new ConversionContext(lazyTypeContext, rootConverter);
+
+    Mockito.when(rootConverter.convert(ctx, descriptor))
+      .thenReturn(expectedType);
+
+    var type = ctx.convert(descriptor);
+    Assertions.assertSame(expectedType, type);
+  }
+
+
+}

python-frontend/src/test/java/org/sonar/python/semantic/v2/converter/DescriptorToPythonTypeConverterTest.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.semantic.v2.converter;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.sonar.python.index.AmbiguousDescriptor;
+import org.sonar.python.index.Descriptor;
+import org.sonar.python.semantic.v2.LazyTypesContext;
+import org.sonar.python.types.v2.PythonType;
+
+class DescriptorToPythonTypeConverterTest {
+
+  @Test
+  void unknownDescriptorToPythonTypeConverterTest() {
+    var ctx = Mockito.mock(ConversionContext.class);
+    var descriptor = Mockito.mock(Descriptor.class);
+    Mockito.when(descriptor.kind()).thenReturn(null);
+    var converter = new UnknownDescriptorToPythonTypeConverter();
+    var type = converter.convert(ctx, descriptor);
+    Assertions.assertThat(type).isEqualTo(PythonType.UNKNOWN);
+  }
+
+  @Test
+  void ambiguousDescriptorConversionTest() {
+    var lazyTypesContext = Mockito.mock(LazyTypesContext.class);
+    var converter = new AnyDescriptorToPythonTypeConverter(lazyTypesContext);
+    var descriptor = Mockito.mock(AmbiguousDescriptor.class);
+    Mockito.when(descriptor.kind()).thenReturn(Descriptor.Kind.AMBIGUOUS);
+
+    var type = converter.convert(descriptor);
+    Assertions.assertThat(type).isEqualTo(PythonType.UNKNOWN);
+  }
+
+
+
+}