Add support for resolving called functions

Summary: We now have `defining_func` coming out, let's start using it. Adds test cases for a user-defined and built-in function.

Reviewed By: yoney

Differential Revision: D96235001

fbshipit-source-id: f345b95f4c76e3e3a677eb3457e416db9de50880

Author: DinoV

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

@@ -136,6 +136,11 @@ def lookup(
                         node.value,
                         member,
                     )
+        elif entry["kind"] == "callable" and "defining_func" in entry:
+            defining_func_qname = str(entry["defining_func"])
+            resolved_func = self.resolve_func(defining_func_qname, modules, type_env)
+            if resolved_func is not None:
+                return resolved_func
 
         # Fallback to types
         return self.lookup_type(type_index, modules, type_env)
@@ -169,6 +174,42 @@ def load_json(cls, json_path: str) -> PyreflyTypeInfo:
             data = json.load(f)
         return cls(data)
 
+    def resolve_func(
+        self,
+        qname: str,
+        modules: dict[str, ModuleTable],
+        type_env: TypeEnvironment,
+    ) -> Value | None:
+        """Resolve a dotted qname like 'module.path.func_name' to a callable Value.
+
+        Splits the qname on '.' and tries progressively shorter prefixes
+        as module names, then looks up the function name in the module.
+        This handles both user-defined Functions and built-in callable
+        types like LenFunction.
+        """
+        parts = qname.split(".")
+
+        for i in range(len(parts) - 1, 0, -1):
+            mod_name = ".".join(parts[:i])
+            if mod_name in modules:
+                mod = modules[mod_name]
+                result = mod.get_child(parts[i], mod_name)
+                if result is None:
+                    continue
+                # Walk remaining parts (e.g. Class.method)
+                for part in parts[i + 1 :]:
+                    if isinstance(result, Class):
+                        result = result.get_member(part)
+                    else:
+                        result = None
+                        break
+                    if result is None:
+                        break
+                if result is not None:
+                    return result
+
+        return None
+
     def resolve_classname(
         self, qname: str, modules: dict[str, ModuleTable], type_env: TypeEnvironment
     ) -> Class | None:

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

@@ -0,0 +1,6 @@
+def f() -> None:
+    pass
+
+
+def g() -> None:
+    return f()

cinderx/PythonLib/test_cinderx/test_compiler/test_static/pyreflytests/call.test.py

@@ -0,0 +1,10 @@
+from types import CodeType
+
+from test_cinderx.test_compiler.test_static.pyrefly_binder import PyreBinderTests
+
+
+def verify(test: PyreBinderTests, code: CodeType) -> None:
+    """Verify that the compiled code includes INVOKE_METHOD."""
+
+    g = test.find_code(code, "g")
+    test.assertInBytecode(g, "INVOKE_FUNCTION")

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

@@ -0,0 +1,3 @@
+def f() -> int:
+    x = {}
+    return len(x)

cinderx/PythonLib/test_cinderx/test_compiler/test_static/pyreflytests/len.test.py

@@ -0,0 +1,10 @@
+from types import CodeType
+
+from test_cinderx.test_compiler.test_static.pyrefly_binder import PyreBinderTests
+
+
+def verify(test: PyreBinderTests, code: CodeType) -> None:
+    """Verify that the compiled code includes FAST_LEN."""
+
+    f = test.find_code(code, "f")
+    test.assertInBytecode(f, "FAST_LEN")