Add support for method calls

Summary: Adds support for method calls and an associated test.

Reviewed By: martindemello

Differential Revision: D96232153

fbshipit-source-id: 0574d560b23f695f4afaf3c73eef172850491d05

Author: DinoV

cinderx/PythonLib/cinderx/compiler/static/pyrefly_info.py

@@ -6,12 +6,18 @@
 
 import json
 import os
-from ast import AST
+from ast import AST, Attribute
 from dataclasses import dataclass
 from typing import TypedDict
 
 from cinderx.compiler.static.module_table import ModuleTable
-from cinderx.compiler.static.types import Class, TypeEnvironment, Value
+from cinderx.compiler.static.types import (
+    Class,
+    Function,
+    MethodType,
+    TypeEnvironment,
+    Value,
+)
 
 
 class Location(TypedDict):
@@ -93,65 +99,69 @@ def __init__(self, data: TypeInfo) -> None:
             key = LocationInfo.from_location(entry["loc"])
             self._locations[key] = entry["type"]
 
-    def _type_to_str(self, type_index: int) -> str:
-        """Convert a type_table entry to a Python annotation string."""
-        entry = self._type_table[type_index]
-        kind = entry["kind"]
-        if kind == "literal":
-            return ""
-        elif kind == "class":
-            qname = str(entry["qname"])
-            args = entry.get("args", [])
-            assert isinstance(args, list)
-            if not args:
-                return qname
-            arg_strs = [self._type_to_str(a) for a in args]
-            if any(not s for s in arg_strs):
-                return qname
-            return f"{qname}[{', '.join(arg_strs)}]"
-        elif kind == "callable":
-            params = entry.get("params", [])
-            assert isinstance(params, list)
-            ret = entry.get("return_type")
-            param_strs = [self._type_to_str(p) for p in params]
-            ret_str = self._type_to_str(ret) if isinstance(ret, int) else ""
-            if any(not s for s in param_strs) or not ret_str:
-                return ""
-            return f"Callable[[{', '.join(param_strs)}], {ret_str}]"
-        return ""
-
     def _lookup(self, node: AST) -> int | None:
         """Look up the type_table index for an AST node by its source position."""
         key = LocationInfo.from_node(node)
         return self._locations.get(key)
 
-    def lookup(self, node: AST) -> str:
-        """Look up the type string for an AST node by its source position."""
+    def lookup(
+        self,
+        node: AST,
+        modules: dict[str, ModuleTable],
+        type_env: TypeEnvironment,
+    ) -> Value | None:
+        """Look up the type string for an AST node by its source position.
+
+        For now, we only try to get type information for class instances
+        and literals, disregarding any type parameters, bound methods, and
+        doing nothing if we see a some other type_info kind like a callable.
+        """
         type_index = self._lookup(node)
         if type_index is None:
-            return ""
-        return self._type_to_str(type_index)
+            return None
 
-    def _get_type_qname(self, type_index: TypeKind) -> str:
+        entry = self._type_table[type_index]
+        # Try non-types
+        if entry["kind"] == "bound_method":
+            defining_class_qname = str(entry["defining_class"])
+            resolved_class = self.resolve_classname(
+                defining_class_qname, modules, type_env
+            )
+            if resolved_class is not None and isinstance(node, Attribute):
+                member = resolved_class.get_member(node.attr)
+                if isinstance(member, Function):
+                    return MethodType(
+                        resolved_class.type_name,
+                        member.node,
+                        node.value,
+                        member,
+                    )
+
+        # Fallback to types
+        return self.lookup_type(type_index, modules, type_env)
+
+    def lookup_type(
+        self,
+        type_index: TypeKind,
+        modules: dict[str, ModuleTable],
+        type_env: TypeEnvironment,
+    ) -> Value | None:
         entry = self._type_table[type_index]
         if entry["kind"] == "class":
-            # Ignore the generic args
-            return str(entry["qname"])
+            qname = str(entry["qname"])
+            resolved = self.resolve_classname(qname, modules, type_env)
+            if resolved is not None:
+                return resolved.instance
         elif entry["kind"] == "literal":
             if "promoted_type" in entry:
-                return self._get_type_qname(entry["promoted_type"])
-        return ""
-
-    def lookup_typename(self, node: AST) -> str:
-        """Look up the qname for an AST node if its type is a simple class.
+                return self.lookup_type(entry["promoted_type"], modules, type_env)
+        elif entry["kind"] == "other_form":
+            if entry["qname"] == "None":
+                resolved = self.resolve_classname("builtins.None", modules, type_env)
+                if resolved is not None:
+                    return resolved.instance
 
-        We treat generic classes as their unparametrised "base" version,
-        e.g. A[T] -> A
-        """
-        type_index = self._lookup(node)
-        if type_index is None:
-            return ""
-        return self._get_type_qname(type_index)
+        return None
 
     @classmethod
     def load_json(cls, json_path: str) -> PyreflyTypeInfo:

cinderx/PythonLib/cinderx/compiler/static/pyrefly_type_binder.py

@@ -46,17 +46,7 @@ def __init__(
     def visit(self, node: AST, *args: object) -> NarrowingEffect | None:
         ret = super().visit(node, *args)
         if isinstance(node, ast.expr) and self._type_info is not None:
-            # For now, we only try to get type information for class instances
-            # and literals, disregarding any type parameters, and doing nothing
-            # if we see a some other type_info kind like a callable.
-            classname = self._type_info.lookup_typename(node)
-            declared_type = None
-            if classname:
-                resolved = self._type_info.resolve_classname(
-                    classname, self.modules, self.type_env
-                )
-                if resolved is not None:
-                    declared_type = resolved.instance
+            declared_type = self._type_info.lookup(node, self.modules, self.type_env)
 
             if declared_type is None:
                 declared_type = self.type_env.dynamic.instance

cinderx/PythonLib/test_cinderx/test_compiler/test_static/pyreflytests/call.json

@@ -1,35 +1,55 @@
 {
   "type_table": [
     {
-      "kind": "class",
-      "qname": "cinderx.PythonLib.test_cinderx.test_compiler.test_static.pyreflytests.simple.C",
+      "kind": "other_form",
+      "qname": "None",
       "args": [],
-      "hash": 8563325631336090432
+      "hash": 3543722185832507401
     },
     {
-      "kind": "literal",
-      "value": "42",
-      "hash": 8390065111661787820
+      "kind": "callable",
+      "params": [],
+      "return_type": 0,
+      "defining_func": "cinderx.PythonLib.test_cinderx.test_compiler.test_static.pyreflytests.call.f",
+      "hash": 14932184105665906002
     }
   ],
   "locations": [
     {
       "loc": {
-        "start_line": 3,
-        "start_col": 8,
-        "end_line": 3,
-        "end_col": 12
+        "start_line": 1,
+        "start_col": 11,
+        "end_line": 1,
+        "end_col": 15
+      },
+      "type": 0
+    },
+    {
+      "loc": {
+        "start_line": 5,
+        "start_col": 11,
+        "end_line": 5,
+        "end_col": 15
       },
       "type": 0
     },
     {
       "loc": {
-        "start_line": 3,
-        "start_col": 17,
-        "end_line": 3,
-        "end_col": 19
+        "start_line": 6,
+        "start_col": 11,
+        "end_line": 6,
+        "end_col": 14
+      },
+      "type": 0
+    },
+    {
+      "loc": {
+        "start_line": 6,
+        "start_col": 11,
+        "end_line": 6,
+        "end_col": 12
       },
       "type": 1
     }
   ]
-}
+}

cinderx/PythonLib/test_cinderx/test_compiler/test_static/pyreflytests/len.json

@@ -2,34 +2,103 @@
   "type_table": [
     {
       "kind": "class",
-      "qname": "cinderx.PythonLib.test_cinderx.test_compiler.test_static.pyreflytests.simple.C",
+      "qname": "builtins.int",
       "args": [],
-      "hash": 8563325631336090432
+      "hash": 7437843174258217660
     },
     {
-      "kind": "literal",
-      "value": "42",
-      "hash": 8390065111661787820
+      "kind": "other_form",
+      "qname": "typing.Type",
+      "args": [
+        0
+      ],
+      "hash": 6510812805515236383
+    },
+    {
+      "kind": "other_form",
+      "qname": "typing.Any",
+      "args": [],
+      "hash": 16900020518876608212
+    },
+    {
+      "kind": "class",
+      "qname": "builtins.dict",
+      "args": [
+        2,
+        2
+      ],
+      "hash": 6944757485787016286
+    },
+    {
+      "kind": "class",
+      "qname": "typing.Sized",
+      "args": [],
+      "hash": 13039512047080031574
+    },
+    {
+      "kind": "callable",
+      "params": [
+        4
+      ],
+      "return_type": 0,
+      "defining_func": "builtins.len",
+      "hash": 10918511340362036114
     }
   ],
   "locations": [
     {
       "loc": {
-        "start_line": 3,
+        "start_line": 1,
+        "start_col": 11,
+        "end_line": 1,
+        "end_col": 14
+      },
+      "type": 1
+    },
+    {
+      "loc": {
+        "start_line": 2,
+        "start_col": 4,
+        "end_line": 2,
+        "end_col": 5
+      },
+      "type": 3
+    },
+    {
+      "loc": {
+        "start_line": 2,
         "start_col": 8,
+        "end_line": 2,
+        "end_col": 10
+      },
+      "type": 3
+    },
+    {
+      "loc": {
+        "start_line": 3,
+        "start_col": 11,
         "end_line": 3,
-        "end_col": 12
+        "end_col": 17
       },
       "type": 0
     },
     {
       "loc": {
         "start_line": 3,
-        "start_col": 17,
+        "start_col": 11,
         "end_line": 3,
-        "end_col": 19
+        "end_col": 14
       },
-      "type": 1
+      "type": 5
+    },
+    {
+      "loc": {
+        "start_line": 3,
+        "start_col": 15,
+        "end_line": 3,
+        "end_col": 16
+      },
+      "type": 3
     }
   ]
-}
+}