pyrefly 0.22.1__tar.gz → 0.22.2__tar.gz

{pyrefly-0.22.1 → pyrefly-0.22.2}/Cargo.lock

@@ -1872,7 +1872,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.22.1"
+version = "0.22.2"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1930,7 +1930,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.22.1"
+version = "0.22.2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1939,7 +1939,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.22.1"
+version = "0.22.2"
 dependencies = [
  "anyhow",
  "dupe",
@@ -1960,7 +1960,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.22.1"
+version = "0.22.2"
 dependencies = [
  "anstream",
  "anyhow",

{pyrefly-0.22.1 → pyrefly-0.22.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefly
-Version: 0.22.1
+Version: 0.22.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

{pyrefly-0.22.1 → pyrefly-0.22.2}/crates/pyrefly_python/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_python"
-version = "0.22.1"
+version = "0.22.2"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.22.1 → pyrefly-0.22.2}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.22.1"
+version = "0.22.2"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.22.1 → pyrefly-0.22.2}/pyrefly/lib/alt/answers.rs

@@ -478,6 +478,7 @@ impl Answers {
                 }
             }
         }
+        answers_solver.validate_final_thread_state();
 
         // Now force all types to be fully resolved.
         fn post_solve<K: Keyed>(items: &mut SolutionsEntry<K>, solver: &Solver) {

{pyrefly-0.22.1 → pyrefly-0.22.2}/pyrefly/lib/alt/answers_solver.rs

@@ -7,13 +7,17 @@
 
 use std::cell::RefCell;
 use std::cmp::Ordering;
+use std::fmt;
 use std::fmt::Debug;
+use std::fmt::Display;
 use std::sync::Arc;
 
 use dupe::Dupe;
 use dupe::IterDupedExt;
 use itertools::Either;
 use pyrefly_python::module_name::ModuleName;
+use pyrefly_util::display::DisplayWithCtx;
+use pyrefly_util::display::commas_iter;
 use pyrefly_util::recurser::Recurser;
 use pyrefly_util::uniques::UniqueFactory;
 use ruff_text_size::TextRange;
@@ -60,11 +64,22 @@ use crate::types::types::Var;
 pub struct CalcId(pub Bindings, pub AnyIdx);
 
 impl Debug for CalcId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "CalcId({}, {:?})", self.0.module_info().name(), self.1)
     }
 }
 
+impl Display for CalcId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "CalcId({}, {})",
+            self.0.module_info().name(),
+            self.1.display_with(&self.0),
+        )
+    }
+}
+
 impl PartialEq for CalcId {
     fn eq(&self, other: &Self) -> bool {
         (self.0.module_info(), &self.1) == (other.0.module_info(), &other.1)
@@ -122,6 +137,10 @@ impl CalcStack {
         self.0.borrow().clone()
     }
 
+    fn is_empty(&self) -> bool {
+        self.0.borrow().is_empty()
+    }
+
     /// Return the current cycle, if we are at a (module, idx) that we've already seen in this thread.
     ///
     /// The answer will have the form
@@ -145,6 +164,7 @@ impl CalcStack {
 }
 
 /// Represent a cycle we are currently solving.
+#[derive(Debug, Clone)]
 pub struct Cycle {
     /// Where do we want to break the cycle
     break_at: CalcId,
@@ -165,11 +185,28 @@ pub struct Cycle {
     ///
     /// We'll push to it as we recurs, and then pop as calculations complete.
     unwind_stack: Vec<CalcId>,
+    /// The unwound vec tracks things popped from the unwind stack. It is used for debugging only, because
+    /// without it we can lose track of what the cycle actually looked like.
+    unwound: Vec<CalcId>,
     /// The algorithm doesn't actually require knowing where we were when we detected the cycle, but it is
     /// essentially free and could be very useful for debugging.
     detected_at: CalcId,
 }
 
+impl Display for Cycle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "Cycle{{break_at: {}, recursion_stack: [{}], unwind_stack: [{}], unwound: [{}], detected_at: {}}}",
+            self.break_at,
+            commas_iter(|| &self.recursion_stack),
+            commas_iter(|| &self.unwind_stack),
+            commas_iter(|| &self.unwound),
+            self.detected_at,
+        )
+    }
+}
+
 impl Cycle {
     fn new(raw: Vec1<CalcId>) -> Self {
         let detected_at = raw.first().dupe();
@@ -187,6 +224,7 @@ impl Cycle {
                 break_at: break_at.dupe(),
                 recursion_stack,
                 unwind_stack,
+                unwound: Vec::new(),
                 detected_at,
             }
         } else {
@@ -203,6 +241,7 @@ impl Cycle {
                 break_at: break_at.dupe(),
                 recursion_stack: Vec::new(),
                 unwind_stack,
+                unwound: Vec::new(),
                 detected_at,
             }
         };
@@ -239,49 +278,19 @@ impl Cycle {
 
     /// Do a post-calculation check, to track progress unwinding the cycle
     /// back toward the `break_at` as we produce final results.
-    ///
-    /// TODO(stroxler): This check currently only occurs for the most
-    /// recently detected cycle, but this is actually a bug; cycles can
-    /// overlap in arbitrary ways.
-    fn on_calculation_finished(&mut self, current: &CalcId) -> CycleState {
+    fn on_calculation_finished(&mut self, current: &CalcId) {
         if let Some(c) = self.unwind_stack.last() {
             if current == c {
                 // This is part of the cycle; remove it from the unwind stack.
-                self.unwind_stack.pop();
-                // This is part of the cycle; remove it from the unwind stack.
-                // Check whether this is the break point (we finished the cycle)
-                // or this is an ordinary participant and we have more unwinding
-                // to do.
-                if *current == self.break_at {
-                    CycleState::BreakAt
-                } else {
-                    CycleState::Participant
-                }
-            } else {
-                // There is an active cycle, but the current idx is not participating.
-                //
-                // This case is hit when any cycle participant computes solving additional
-                // dependencies that aren't part of the active cycle.
-                CycleState::NoDetectedCycle
+                let c = self.unwind_stack.pop().unwrap();
+                // Track what we unwound to make debugging easier.
+                self.unwound.push(c);
             }
-        } else {
-            // There is an active cycle, but the current idx is not participating.
-            //
-            // This case is hit if `break_at` computes additional dependencies that aren't
-            // part of the active cycle.
-            CycleState::NoDetectedCycle
         }
     }
 }
 
-/// Represents the current cycle state for a given calculation. We check
-/// the state at two different points in time:
-/// - Before performing calculations, because we need to know when we are in an
-///   already-detected cycle and recursing out toward the `break_at`, and we
-///   need to know to stop and unwind when we reach `break_at`.
-/// - After performing calculations, because we may need to handle results
-///   differently and we need to know to clean up the cycle when we get back
-///   to `break_at`.
+/// Represents the current cycle state prior to attempting a particular calculation.
 enum CycleState {
     /// The current idx is not participating in any currently detected cycle (though it
     /// remains possible we will detect one here).
@@ -293,19 +302,10 @@ enum CycleState {
     NoDetectedCycle,
     /// This idx is part of the active cycle, and we are either (if this is a pre-calculation
     /// check) recursing out toward `break_at` or unwinding back toward `break_at`.
-    ///
-    /// If we are recursing, the current `Calculation` will need its per-thread recursion
-    /// limit bumped, since this will be a duplicate of some frame from before we first
-    /// reached `break_at`.
-    ///
-    /// If we are unwinding, we may need to handle the result with care to avoid data
-    /// races on `Var` pinning.
     Participant,
-    /// This idx is the `break_at` for the active cycle.
-    /// - If this was a pre-calculation check, it means we have reached the end of the
-    ///   recursion and should return a placeholder to our parent frame.
-    /// - If this was a post-calculation check, it means we have completed the cycle
-    ///   and should wrap up.
+    /// This idx is the `break_at` for the active cycle, which means we have
+    /// reached the end of the recursion and should return a placeholder to our
+    /// parent frame.
     BreakAt,
 }
 
@@ -318,6 +318,10 @@ impl Cycles {
         Self(RefCell::new(Vec::new()))
     }
 
+    fn is_empty(&self) -> bool {
+        self.0.borrow().is_empty()
+    }
+
     // Handle a cycle we just detected.
     ///
     /// Return whether or not to break immediately (which is relatively
@@ -341,26 +345,22 @@ impl Cycles {
     /// Handle the completion of a calculation. This might involve progress on
     /// the unwind stack of one or more cycles.
     ///
-    /// TODO(stroxler): We currently only look at the most recently detected cycle,
-    /// which is incorrect; we may need to unwind multiple cycles.
-    ///
     /// Return `true` if there are active cycles after finishing this calculation,
     /// `false` if there are not.
     fn on_calculation_finished(&self, current: &CalcId) -> bool {
         let mut stack = self.0.borrow_mut();
-        let state = if let Some(active_cycle) = stack.last_mut() {
-            active_cycle.on_calculation_finished(current)
-        } else {
-            CycleState::NoDetectedCycle
-        };
-        match state {
-            CycleState::BreakAt => {
+        for cycle in stack.iter_mut() {
+            cycle.on_calculation_finished(current);
+        }
+        while let Some(cycle) = stack.last_mut() {
+            if cycle.unwind_stack.is_empty() {
                 stack.pop();
-                !stack.is_empty()
+            } else {
+                break;
             }
-            CycleState::Participant => true,
-            CycleState::NoDetectedCycle => false,
         }
+        // Do we still have active cycles?
+        !stack.is_empty()
     }
 }
 
@@ -461,6 +461,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         TypeOrder::new(self)
     }
 
+    pub fn validate_final_thread_state(&self) {
+        assert!(
+            self.thread_state.stack.is_empty(),
+            "The calculation stack should be empty in the final thread state"
+        );
+        assert!(
+            self.thread_state.cycles.is_empty(),
+            "The cycle stack should be empty in the final thread state"
+        );
+    }
+
     pub fn get_idx<K: Solve<Ans>>(&self, idx: Idx<K>) -> Arc<K::Answer>
     where
         AnswerTable: TableKeyed<K, Value = AnswerEntry<K>>,
@@ -505,8 +516,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     }
                     // Short circuit if another thread has already written an answer or recursive placeholder.
                     //
-                    // In either case, we needs to treat this as if we finished a calculation to preserve
-                    // the fidelity of the unwind stack.
+                    // In either case, we need to call `on_calculation_finished` to make sure that
+                    // we accurately reflect that this idx is no longer relevant to the unwind stack of
+                    // active cycles.
                     ProposalResult::Calculated(v) => {
                         self.cycles().on_calculation_finished(&current);
                         v

{pyrefly-0.22.1 → pyrefly-0.22.2}/pyrefly/lib/alt/debugging.rs

@@ -77,47 +77,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         format!("{}", self.module_info().name())
     }
 
-    fn show_any_idx_with(&self, bindings: &Bindings, idx: AnyIdx) -> String {
-        let kind = idx.kind();
-        let key = match idx {
-            AnyIdx::Key(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyExpect(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyClass(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyTParams(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyClassField(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyVariance(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyClassSynthesizedFields(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyExport(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyFunction(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyAnnotation(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyClassMetadata(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyClassMro(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyLegacyTypeParam(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyYield(idx) => self.show_idx_with(bindings, idx),
-            AnyIdx::KeyYieldFrom(idx) => self.show_idx_with(bindings, idx),
-        };
-        format!("{} :: {}", kind, key)
-    }
-
-    pub fn show_calc_id(&self, c: CalcId) -> String {
-        match c {
-            CalcId(bindings, idx) => {
-                format!(
-                    "{} . {}",
-                    bindings.module_info().name(),
-                    self.show_any_idx_with(&bindings, idx)
-                )
-            }
-        }
-    }
-
     pub fn show_current_idx(&self) -> String {
         match self.stack().peek() {
             None => {
                 // In practice we'll never hit this debugging, but there's no need to panic if we do.
                 "(None)".to_owned()
             }
-            Some(c) => self.show_calc_id(c),
+            Some(calc_id) => format!("{}", calc_id),
         }
     }
 
@@ -153,13 +119,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         self.stack()
             .into_vec()
             .into_iter()
-            .map(|CalcId(bindings, idx)| {
-                format!(
-                    "{} . {}",
-                    bindings.module_info().name(),
-                    self.show_any_idx_with(&bindings, idx)
-                )
-            })
+            .map(|calc_id| format!("{}", calc_id))
     }
 
     // Get a printable representation of the current cycle.
@@ -170,12 +130,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .current_cycle()
             .unwrap()
             .into_iter()
-            .map(|CalcId(bindings, idx)| {
-                format!(
-                    "{} . {}",
-                    bindings.module_info().name(),
-                    self.show_any_idx_with(&bindings, idx)
-                )
-            })
+            .map(|c| format!("{}", c))
     }
 }

{pyrefly-0.22.1 → pyrefly-0.22.2}/pyrefly/lib/alt/solve.rs

@@ -2753,12 +2753,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             Type::any_implicit()
                         })
                     }
-                    Either::Right((var, function_idx)) => {
-                        // Force the function binding to be evaluated, if it hasn't already.
-                        // Solving the function will also force the Var type to some concrete type,
-                        // and this must happen first so the Var can not interact with other types.
-                        self.get_idx(*function_idx);
-                        var.to_type()
+                    Either::Right(var) => {
+                        // If the context hasn't already been filled in, just assume it is Unknown.
+                        self.solver().force_var(*var)
                     }
                 }
             }

{pyrefly-0.22.1 → pyrefly-0.22.2}/pyrefly/lib/binding/binding.rs

@@ -120,24 +120,24 @@ pub enum AnyIdx {
     KeyYieldFrom(Idx<KeyYieldFrom>),
 }
 
-impl AnyIdx {
-    pub fn kind(&self) -> &'static str {
+impl DisplayWith<Bindings> for AnyIdx {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>, ctx: &Bindings) -> fmt::Result {
         match self {
-            Self::Key(..) => "Key",
-            Self::KeyExpect(..) => "KeyExpect",
-            Self::KeyClass(..) => "KeyClass",
-            Self::KeyTParams(..) => "KeyTParams",
-            Self::KeyClassField(..) => "KeyClassField",
-            Self::KeyVariance(..) => "KeyVariance",
-            Self::KeyClassSynthesizedFields(..) => "KeyClassSynthesizedFields",
-            Self::KeyExport(..) => "KeyExport",
-            Self::KeyFunction(..) => "KeyFunction",
-            Self::KeyAnnotation(..) => "KeyAnnotation",
-            Self::KeyClassMetadata(..) => "KeyClassMetadata",
-            Self::KeyClassMro(..) => "KeyClassMro",
-            Self::KeyLegacyTypeParam(..) => "KeyLegacyTypeParam",
-            Self::KeyYield(..) => "KeyYield",
-            Self::KeyYieldFrom(..) => "KeyYieldFrom",
+            Self::Key(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyExpect(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyClass(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyTParams(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyClassField(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyVariance(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyClassSynthesizedFields(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyExport(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyFunction(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyAnnotation(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyClassMetadata(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyClassMro(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyLegacyTypeParam(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyYield(idx) => write!(f, "{}", ctx.display(*idx)),
+            Self::KeyYieldFrom(idx) => write!(f, "{}", ctx.display(*idx)),
         }
     }
 }
@@ -281,6 +281,8 @@ pub enum Key {
     /// Used for `import foo.x` (the `foo` might not be literally present with `.` modules),
     /// and `from foo import *` (the names are injected from the exports)
     Import(Name, TextRange),
+    /// I am a module-level global variable like `__file__` or `__doc__`.
+    Global(Name),
     /// I am defined in this module at this location.
     Definition(ShortIdentifier),
     /// I am a name assignment that is also a first use of some other name assign.
@@ -335,6 +337,7 @@ impl Ranged for Key {
     fn range(&self) -> TextRange {
         match self {
             Self::Import(_, r) => *r,
+            Self::Global(_) => TextRange::default(),
             Self::Definition(x) => x.range(),
             Self::UpstreamPinnedDefinition(x) => x.range(),
             Self::PinnedDefinition(x) => x.range(),
@@ -362,6 +365,7 @@ impl DisplayWith<ModuleInfo> for Key {
 
         match self {
             Self::Import(n, r) => write!(f, "Key::Import({n} {})", ctx.display(r)),
+            Self::Global(n) => write!(f, "Key::Global({n})"),
             Self::Definition(x) => write!(f, "Key::Definition({})", short(x)),
             Self::UpstreamPinnedDefinition(x) => {
                 write!(f, "Key::UpstreamPinnedDefinition({})", short(x))
@@ -1088,9 +1092,8 @@ pub enum Binding {
     /// Binding for a lambda parameter.
     LambdaParameter(Var),
     /// Binding for a function parameter. We either have an annotation, or we will determine the
-    /// parameter type when solving the function type. To ensure the parameter is solved before it
-    /// can be observed as a Var, we include the function key and force it to be solved first.
-    FunctionParameter(Either<Idx<KeyAnnotation>, (Var, Idx<KeyFunction>)>),
+    /// parameter type when solving the function type.
+    FunctionParameter(Either<Idx<KeyAnnotation>, Var>),
     /// The result of a `super()` call.
     SuperInstance(SuperStyle, TextRange),
     /// The result of assigning to an attribute. This operation cannot change the *type* of the
@@ -1285,7 +1288,7 @@ impl DisplayWith<Bindings> for Binding {
                 "FunctionParameter({})",
                 match x {
                     Either::Left(k) => ctx.display(*k).to_string(),
-                    Either::Right((x, k)) => format!("{x}, {}", ctx.display(*k)),
+                    Either::Right(x) => x.to_string(),
                 }
             ),
             Self::SuperInstance(SuperStyle::ExplicitArgs(cls, obj), _range) => {

{pyrefly-0.22.1 → pyrefly-0.22.2}/pyrefly/lib/binding/bindings.rs

@@ -82,6 +82,7 @@ use crate::state::loader::FindError;
 use crate::table;
 use crate::table_for_each;
 use crate::table_try_for_each;
+use crate::types::globals::Global;
 use crate::types::quantified::QuantifiedKind;
 use crate::types::types::Var;
 
@@ -254,7 +255,7 @@ impl Bindings {
         if let Binding::FunctionParameter(p) = b {
             match p {
                 Either::Left(idx) => Either::Left(*idx),
-                Either::Right((var, _)) => Either::Right(*var),
+                Either::Right(var) => Either::Right(*var),
             }
         } else {
             panic!(
@@ -297,6 +298,7 @@ impl Bindings {
         if module_info.name() != ModuleName::builtins() {
             builder.inject_builtins();
         }
+        builder.inject_globals();
         builder.stmts(x.body);
         assert_eq!(builder.scopes.loop_depth(), 0);
         let scope_trace = builder.scopes.finish();
@@ -620,6 +622,14 @@ impl<'a> BindingsBuilder<'a> {
         }
     }
 
+    fn inject_globals(&mut self) {
+        for global in Global::globals(self.has_docstring) {
+            let key = Key::Global(global.name().clone());
+            let idx = self.table.insert(key, Binding::Global(global.clone()));
+            self.bind_key(global.name(), idx, FlowStyle::Other);
+        }
+    }
+
     fn inject_builtins(&mut self) {
         let builtins_module = ModuleName::builtins();
         match self.lookup.get(builtins_module) {
@@ -1147,7 +1157,6 @@ impl<'a> BindingsBuilder<'a> {
         &mut self,
         target: AnnotationTarget,
         x: AnyParameterRef,
-        function_idx: Idx<KeyFunction>,
         class_key: Option<Idx<KeyClass>>,
     ) {
         let name = x.name();
@@ -1165,7 +1174,7 @@ impl<'a> BindingsBuilder<'a> {
                     KeyAnnotation::Annotation(ShortIdentifier::new(name)),
                     BindingAnnotation::Type(target.clone(), var.to_type()),
                 );
-                (annot, Either::Right((var, function_idx)))
+                (annot, Either::Right(var))
             }
         };
         let key = self.insert_binding(

{pyrefly-0.22.1 → pyrefly-0.22.2}/pyrefly/lib/binding/expr.rs

@@ -6,7 +6,6 @@
  */
 
 use pyrefly_python::ast::Ast;
-use pyrefly_python::dunder;
 use pyrefly_util::visit::VisitMut;
 use ruff_python_ast::Arguments;
 use ruff_python_ast::BoolOp;
@@ -51,7 +50,6 @@ use crate::export::special::SpecialExport;
 use crate::graph::index::Idx;
 use crate::module::short_identifier::ShortIdentifier;
 use crate::types::callable::unexpected_keyword;
-use crate::types::globals::Global;
 use crate::types::types::Type;
 
 /// Looking up names in an expression requires knowing the identity of the binding
@@ -242,12 +240,6 @@ impl<'a> BindingsBuilder<'a> {
                 }
                 self.insert_binding(key, value)
             }
-            Err(_) if name.id == dunder::DOC => {
-                self.insert_binding(key, Binding::Global(Global::doc(self.has_docstring)))
-            }
-            Err(_) if let Some(global) = Global::from_name(&name.id) => {
-                self.insert_binding(key, Binding::Global(global))
-            }
             Err(error) => {
                 // Record a type error and fall back to `Any`.
                 self.error(