[DSLX:type_system] Resolve invocation callee using ref/def chain.

This also adds an appropriate check that the callee is a function. Previously
we would check that the function existed at module scope but get confounded by
the local shadow, causing an ICE.

Found via coverage-guided fuzzing.

PiperOrigin-RevId: 597961474

Author: cdleary

xls/dslx/frontend/ast.h

@@ -850,6 +850,10 @@ class NameRef : public Expr {
     return IsBuiltin() ? nullptr
                        : std::get<const NameDef*>(name_def())->definer();
   }
+  AstNode* GetDefiner() {
+    const auto* self = this;
+    return const_cast<AstNode*>(self->GetDefiner());
+  }
 
   template <typename T>
   bool DefinerIs() {

xls/dslx/type_system/deduce.cc

@@ -15,6 +15,7 @@
 #include "xls/dslx/type_system/deduce.h"
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <iterator>
@@ -2923,9 +2924,17 @@ static absl::StatusOr<TypeAndParametricEnv> DeduceInstantiation(
   // top.
   XLS_ASSIGN_OR_RETURN(std::unique_ptr<ConcreteType> callee_type,
                        ctx->Deduce(invocation->callee()));
-  return TypeAndParametricEnv{down_cast<FunctionType*>(callee_type.get())
-                                  ->return_type()
-                                  .CloneToUnique(),
+  FunctionType* callee_fn_type = dynamic_cast<FunctionType*>(callee_type.get());
+
+  // Callee must be a function.
+  if (callee_fn_type == nullptr) {
+    return TypeInferenceErrorStatus(
+        invocation->callee()->span(), callee_type.get(),
+        absl::StrFormat("Invocation callee `%s` is not a function",
+                        invocation->callee()->ToString()));
+  }
+
+  return TypeAndParametricEnv{callee_fn_type->return_type().CloneToUnique(),
                               {}};
 }
 
@@ -3121,17 +3130,22 @@ absl::StatusOr<std::unique_ptr<ConcreteType>> DeduceInvocation(
   auto resolve_fn = [](const Instantiation* node,
                        DeduceCtx* ctx) -> absl::StatusOr<Function*> {
     Expr* callee = node->callee();
+
     Function* fn;
     if (auto* colon_ref = dynamic_cast<ColonRef*>(callee);
         colon_ref != nullptr) {
       XLS_ASSIGN_OR_RETURN(fn,
                            ResolveColonRefToFnForInvocation(colon_ref, ctx));
     } else if (auto* name_ref = dynamic_cast<NameRef*>(callee);
                name_ref != nullptr) {
-      const std::string& callee_name = name_ref->identifier();
-      XLS_ASSIGN_OR_RETURN(fn,
-                           GetMemberOrTypeInferenceError<Function>(
-                               ctx->module(), callee_name, name_ref->span()));
+      AstNode* definer = name_ref->GetDefiner();
+      fn = dynamic_cast<Function*>(definer);
+      if (fn == nullptr) {
+        return TypeInferenceErrorStatus(
+            node->callee()->span(), nullptr,
+            absl::StrFormat("Invocation callee `%s` is not a function",
+                            node->callee()->ToString()));
+      }
     } else {
       return TypeInferenceErrorStatus(
           node->span(), nullptr,

xls/dslx/type_system/typecheck_test.cc

@@ -2214,5 +2214,31 @@ fn f() { fail!%2 }
                                    "it is not being invoked")));
 }
 
+TEST(TypecheckErrorTest, InvokeATokenValueViaShadowing) {
+  EXPECT_THAT(
+      Typecheck(R"(
+fn shadowed() {}
+
+fn f(shadowed: token) {
+  shadowed()
+}
+)")
+          .status(),
+      IsPosError("TypeInferenceError",
+                 HasSubstr("Invocation callee `shadowed` is not a function")));
+}
+
+TEST(TypecheckErrorTest, InvokeATokenValueNoShadowing) {
+  EXPECT_THAT(
+      Typecheck(R"(
+fn f(tok: token) {
+  tok()
+}
+)")
+          .status(),
+      IsPosError("TypeInferenceError",
+                 HasSubstr("Invocation callee `tok` is not a function")));
+}
+
 }  // namespace
 }  // namespace xls::dslx