diff --git a/crates/ruff_linter/src/rules/flake8_pyi/rules/custom_type_var_return_type.rs b/crates/ruff_linter/src/rules/flake8_pyi/rules/custom_type_var_return_type.rs
index 4d30fd3eb..7128fddb1 100644
--- a/crates/ruff_linter/src/rules/flake8_pyi/rules/custom_type_var_return_type.rs
+++ b/crates/ruff_linter/src/rules/flake8_pyi/rules/custom_type_var_return_type.rs
@@ -8,7 +8,7 @@ use ruff_python_ast::{
 };
 use ruff_python_semantic::analyze::function_type::{self, FunctionType};
 use ruff_python_semantic::analyze::visibility::{is_abstract, is_overload};
-use ruff_python_semantic::{Binding, BindingKind, SemanticModel};
+use ruff_python_semantic::{Binding, BindingKind, ScopeId, SemanticModel};
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
 use crate::checkers::ast::Checker;
@@ -138,7 +138,7 @@ pub(crate) fn custom_type_var_return_type(
         }),
     };
 
-    if !method.uses_custom_var(semantic) {
+    if !method.uses_custom_var(semantic, binding.scope) {
         return None;
     }
 
@@ -162,9 +162,9 @@ enum Method<'a> {
 }
 
 impl Method<'_> {
-    fn uses_custom_var(&self, semantic: &SemanticModel) -> bool {
+    fn uses_custom_var(&self, semantic: &SemanticModel, scope: ScopeId) -> bool {
         match self {
-            Self::Class(class_method) => class_method.uses_custom_var(semantic),
+            Self::Class(class_method) => class_method.uses_custom_var(semantic, scope),
             Self::Instance(instance_method) => instance_method.uses_custom_var(),
         }
     }
@@ -180,7 +180,7 @@ struct ClassMethod<'a> {
 impl ClassMethod<'_> {
     /// Returns `true` if the class method is annotated with
     /// a custom `TypeVar` that is likely private.
-    fn uses_custom_var(&self, semantic: &SemanticModel) -> bool {
+    fn uses_custom_var(&self, semantic: &SemanticModel, scope: ScopeId) -> bool {
         let Expr::Subscript(ast::ExprSubscript {
             value: cls_annotation_value,
             slice: cls_annotation_typevar,
@@ -196,7 +196,15 @@ impl ClassMethod<'_> {
 
         let cls_annotation_typevar = &cls_annotation_typevar.id;
 
-        if !semantic.match_builtin_expr(cls_annotation_value, "type") {
+        let Expr::Name(ExprName { id, ..}) = &**cls_annotation_value else {
+            return false;
+        };
+
+        if id != "type" {
+            return false;
+        }
+
+        if !semantic.has_builtin_binding_in_scope("type", scope) {
             return false;
         }
 
@@ -206,7 +214,10 @@ impl ClassMethod<'_> {
                 let Expr::Name(return_annotation_typevar) = &**slice else {
                     return false;
                 };
-                if !semantic.match_builtin_expr(value, "type") {
+                let Expr::Name(ExprName { id, ..}) = &**value else {
+                    return false;
+                };
+                if id != "type" {
                     return false;
                 }
                 &return_annotation_typevar.id
diff --git a/crates/ruff_python_semantic/src/model.rs b/crates/ruff_python_semantic/src/model.rs
index 4ef240e23..825ee3256 100644
--- a/crates/ruff_python_semantic/src/model.rs
+++ b/crates/ruff_python_semantic/src/model.rs
@@ -265,13 +265,22 @@ impl<'a> SemanticModel<'a> {
         self.shadowed_bindings.get(&binding_id).copied()
     }
 
-    /// Return `true` if `member` is bound as a builtin.
+    /// Return `true` if `member` is bound as a builtin *in the scope we are currently visiting*.
     ///
     /// Note that a "builtin binding" does *not* include explicit lookups via the `builtins`
     /// module, e.g. `import builtins; builtins.open`. It *only* includes the bindings
     /// that are pre-populated in Python's global scope before any imports have taken place.
     pub fn has_builtin_binding(&self, member: &str) -> bool {
-        self.lookup_symbol(member)
+        self.has_builtin_binding_in_scope(member, self.scope_id)
+    }
+
+    /// Return `true` if `member` is bound as a builtin *in a given scope*.
+    ///
+    /// Note that a "builtin binding" does *not* include explicit lookups via the `builtins`
+    /// module, e.g. `import builtins; builtins.open`. It *only* includes the bindings
+    /// that are pre-populated in Python's global scope before any imports have taken place.
+    pub fn has_builtin_binding_in_scope(&self, member: &str, scope_id: ScopeId) -> bool {
+        self.lookup_symbol_in_scope(member, scope_id, false)
             .map(|binding_id| &self.bindings[binding_id])
             .is_some_and(|binding| binding.kind.is_builtin())
     }