pyrefly 0.10.1__tar.gz → 0.11.0__tar.gz

pyrefly-0.11.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: pyrefly
+Version: 0.11.0
+Author: Meta
+License: MIT
+Project-URL: Source Code, https://github.com/facebook/pyrefly

{pyrefly-0.10.1 → pyrefly-0.11.0}/pyrefly/Cargo.lock

@@ -151,9 +151,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.97"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "append-only-vec"
@@ -261,9 +261,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.18"
+version = "1.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "525046617d8376e3db1deffb079e91cef90a89fc3ca5c185bbf8c9ecdd15cd5c"
+checksum = "8e3a13707ac958681c13b39b458c073d0d9bc8a22cb1b2f4c8e55eb72c13f362"
 dependencies = [
  "jobserver",
  "libc",
@@ -290,9 +290,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.35"
+version = "4.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8aa86934b44c19c50f87cc2790e19f54f7a67aedb64101c2e1a2e5ecfb73944"
+checksum = "2df961d8c8a0d08aa9945718ccf584145eee3f3aa06cddbeac12933781102e04"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -300,9 +300,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.35"
+version = "4.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2414dbb2dd0695280da6ea9261e327479e9d37b0630f6b53ba2a11c60c679fd9"
+checksum = "132dbda40fb6753878316a489d5a1242a8ef2f0d9e47ba01c951ea8aa7d013a5"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1125,9 +1125,9 @@ checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
 [[package]]
 name = "litemap"
@@ -1576,7 +1576,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.10.1"
+version = "0.11.0"
 dependencies = [
  "anyhow",
  "append-only-vec",
@@ -1882,7 +1882,7 @@ dependencies = [
  "bitflags 2.9.0",
  "errno",
  "libc",
- "linux-raw-sys 0.9.3",
+ "linux-raw-sys 0.9.4",
  "windows-sys 0.59.0",
 ]
 

{pyrefly-0.10.1 → pyrefly-0.11.0}/pyrefly/Cargo.toml

@@ -1,11 +1,11 @@
-# @generated by autocargo from //tools/pyre/pyre2/pyrefly:[pyrefly,pyrefly_library]
+# @generated by autocargo from //pyrefly/pyrefly:[pyrefly,pyrefly_library]
 
 [package]
 name = "pyrefly"
-version = "0.10.1"
+version = "0.11.0"
 authors = ["Meta"]
 edition = "2021"
-repository = "https://github.com/facebook/pyre-check/tree/main/pyre2"
+repository = "https://github.com/facebook/pyrefly"
 license = "MIT"
 build = "build.rs"
 
@@ -62,7 +62,7 @@ tracing-subscriber = { version = "0.3.18", features = ["chrono", "env-filter", "
 vec1 = { version = "1", features = ["serde"] }
 
 [dev-dependencies]
-crossbeam-channel = "0.5.0"
+crossbeam-channel = "0.5.15"
 pretty_assertions = { version = "1.2", features = ["alloc"], default-features = false }
 tempfile = "3.15"
 

{pyrefly-0.10.1 → pyrefly-0.11.0}/pyrefly/bin/main.rs

@@ -10,14 +10,16 @@ use std::env::args_os;
 use std::path::Path;
 use std::path::PathBuf;
 use std::process::ExitCode;
+use std::sync::Arc;
 
 use anyhow::anyhow;
 use anyhow::Context as _;
 use clap::Parser;
 use clap::Subcommand;
+use dupe::Dupe;
 use path_absolutize::Absolutize;
 use pyrefly::clap_env;
-use pyrefly::fs_upward_search::first_match;
+use pyrefly::finder::ConfigFinder;
 use pyrefly::get_args_expanded;
 use pyrefly::globs::FilteredGlobs;
 use pyrefly::globs::Globs;
@@ -29,7 +31,6 @@ use pyrefly::run::ConfigMigrationArgs;
 use pyrefly::run::LspArgs;
 use pyrefly::ConfigFile;
 use pyrefly::NotifyWatcher;
-use starlark_map::small_map::SmallMap;
 use tracing::debug;
 use tracing::info;
 
@@ -98,38 +99,11 @@ fn exit_on_panic() {
     }));
 }
 
-fn get_open_source_config(file: &Path) -> anyhow::Result<ConfigFile> {
-    ConfigFile::from_file(file, true).map_err(|err| {
-        let file_str = file.display();
-        anyhow!("Failed to parse configuration at {file_str}: {err}")
-    })
-}
-
-fn get_implicit_config_path_from(path: &Path) -> anyhow::Result<PathBuf> {
-    if let Some(search_result) = first_match(path, &ConfigFile::CONFIG_FILE_NAMES) {
-        Ok(search_result.to_path_buf())
-    } else {
-        Err(anyhow!(
-            "Cannot locate a config file using upward-searching heuristics from `{}`",
-            path.display()
-        ))
-    }
-}
-
-fn to_exit_code(status: CommandExitStatus) -> ExitCode {
-    match status {
-        CommandExitStatus::Success => ExitCode::SUCCESS,
-        CommandExitStatus::UserError => ExitCode::FAILURE,
-        // Exit code 2 is reserved for Meta-internal usages
-        CommandExitStatus::InfraError => ExitCode::from(3),
-    }
-}
-
 async fn run_check(
     args: pyrefly::run::CheckArgs,
     watch: bool,
     files_to_check: FilteredGlobs,
-    config_finder: &impl Fn(&Path) -> ConfigFile,
+    config_finder: impl Fn(&Path) -> Arc<ConfigFile>,
     allow_forget: bool,
 ) -> anyhow::Result<CommandExitStatus> {
     if watch {
@@ -145,20 +119,19 @@ async fn run_check(
     }
 }
 
-fn get_implicit_config_for_project(
-    override_config: &impl Fn(ConfigFile) -> ConfigFile,
-) -> ConfigFile {
-    fn get_config_path() -> anyhow::Result<ConfigFile> {
-        let current_dir = std::env::current_dir().context("cannot identify current dir")?;
-        let config_path = get_implicit_config_path_from(&current_dir)?;
-        info!("Using config found at {}", config_path.display());
-        get_open_source_config(&config_path)
-    }
-    let config = get_config_path().unwrap_or_else(|err| {
-        debug!("{err}. Default configuration will be used as fallback.");
-        ConfigFile::default()
-    });
-    override_config(config)
+fn config_finder(args: pyrefly::run::CheckArgs) -> ConfigFinder {
+    let args = Arc::new(args);
+    let args2 = args.dupe();
+    let default = move || Arc::new(args.override_config(ConfigFile::default()));
+    // The Box is a bit annoying here, but otherwise I can't persuade it that the `&Path` has a good enough lifetime.
+    let load: Box<dyn Fn(&Path) -> anyhow::Result<Arc<ConfigFile>>> =
+        Box::new(move |config_path| {
+            Ok(Arc::new(args2.override_config(ConfigFile::from_file(
+                config_path,
+                true,
+            )?)))
+        });
+    ConfigFinder::new(default, load)
 }
 
 async fn run_check_on_project(
@@ -168,65 +141,35 @@ async fn run_check_on_project(
     args: pyrefly::run::CheckArgs,
     allow_forget: bool,
 ) -> anyhow::Result<CommandExitStatus> {
-    let config = if let Some(explicit_config_path) = config {
-        info!(
-            "Using config file explicitly provided at `{}`",
-            explicit_config_path.display()
-        );
-        args.override_config(get_open_source_config(&explicit_config_path)?)
-    } else {
-        get_implicit_config_for_project(&|c| args.override_config(c))
+    let config_finder = config_finder(args.clone());
+    let config = match config {
+        Some(explicit) => {
+            info!(
+                "Using config file explicitly provided at `{}`",
+                explicit.display()
+            );
+            // We deliberately don't use the cached object, since we want errors in an explicit config to be fatal
+            Arc::new(args.override_config(ConfigFile::from_file(&explicit, true)?))
+        }
+        None => {
+            let current_dir = std::env::current_dir().context("cannot identify current dir")?;
+            config_finder.directory(&current_dir)
+        }
     };
+
+    debug!("Config is: {}", config);
     let project_excludes =
         project_excludes.map_or_else(|| config.project_excludes.clone(), Globs::new);
     run_check(
         args,
         watch,
         FilteredGlobs::new(config.project_includes.clone(), project_excludes),
-        &|_| config.clone(),
+        |_| config.dupe(),
         allow_forget,
     )
     .await
 }
 
-fn get_implicit_config_for_file<'a>(
-    override_config: &'a impl Fn(ConfigFile) -> ConfigFile,
-) -> impl Fn(&Path) -> ConfigFile + 'a {
-    let mut config_cache: SmallMap<PathBuf, ConfigFile> = SmallMap::new();
-    fn get_implicit_config_path(path: &Path) -> anyhow::Result<PathBuf> {
-        let parent_dir = path
-            .parent()
-            .with_context(|| format!("Path `{}` has no parent directory", path.display()))?
-            .absolutize()
-            .with_context(|| format!("Path `{}` cannot be absolutized", path.display()))?;
-        get_implicit_config_path_from(parent_dir.as_ref())
-    }
-    let log_err = |err| {
-        debug!("{err}. Default configuration will be used as fallback.");
-    };
-
-    let get_implicit_config = move |config_path: PathBuf| -> ConfigFile {
-        if let Some(config) = config_cache.get(&config_path) {
-            return config.clone();
-        }
-        let config = override_config(get_open_source_config(&config_path).unwrap_or_else(|err| {
-            log_err(err);
-            ConfigFile::default()
-        }));
-        config_cache.insert(config_path, config.clone());
-        config
-    };
-    move |path| {
-        get_implicit_config_path(path).map_or_else(
-            |err| {
-                log_err(err);
-                override_config(ConfigFile::default())
-            },
-            get_implicit_config.clone(),
-        )
-    }
-}
-
 async fn run_check_on_files(
     files_to_check: Globs,
     project_excludes: Option<Vec<String>>,
@@ -237,11 +180,12 @@ async fn run_check_on_files(
     let project_excludes =
         project_excludes.map_or_else(ConfigFile::default_project_excludes, Globs::new);
     let files_to_check = files_to_check.from_root(PathBuf::new().absolutize()?.as_ref());
+    let config_finder = config_finder(args.clone());
     run_check(
-        args.clone(),
+        args,
         watch,
         FilteredGlobs::new(files_to_check, project_excludes),
-        &get_implicit_config_for_file(&|c| args.override_config(c)),
+        move |x| config_finder.python_file(x),
         allow_forget,
     )
     .await
@@ -289,7 +233,7 @@ async fn run() -> anyhow::Result<ExitCode> {
             let _ = run_command(args.command.clone(), false).await;
         }
     } else {
-        run_command(args.command, true).await.map(to_exit_code)
+        Ok(run_command(args.command, true).await?.to_exit_code())
     }
 }
 

{pyrefly-0.10.1 → pyrefly-0.11.0}/pyrefly/lib/alt/answers.rs

@@ -13,7 +13,6 @@ use std::sync::Arc;
 
 use dupe::Dupe;
 use dupe::OptionDupedExt;
-use ruff_text_size::Ranged;
 use ruff_text_size::TextRange;
 use starlark_map::small_map::SmallMap;
 use starlark_map::Hashed;
@@ -49,7 +48,6 @@ use crate::types::equality::TypeEq;
 use crate::types::equality::TypeEqCtx;
 use crate::types::stdlib::Stdlib;
 use crate::types::type_info::TypeInfo;
-use crate::types::types::AnyStyle;
 use crate::types::types::NeverStyle;
 use crate::types::types::Type;
 use crate::types::types::Var;
@@ -590,7 +588,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     }
 
     pub fn create_recursive(&self, binding: &Binding) -> Var {
-        let t = if let Binding::Phi(_, Some(default)) = binding {
+        let t = if let Binding::Default(default, _) = binding {
             self.get_calculation(*default)
                 .get()
                 .map(|t| t.arc_clone_ty().promote_literals(self.stdlib))
@@ -658,9 +656,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         errors: &ErrorCollector,
         tcc: &dyn Fn() -> TypeCheckContext,
     ) -> bool {
-        if matches!(got, Type::Any(AnyStyle::Error))
-            || self.solver().is_subset_eq(got, want, self.type_order())
-        {
+        if got.is_error() || self.solver().is_subset_eq(got, want, self.type_order()) {
             true
         } else {
             self.solver().error(want, got, errors, loc, tcc);
@@ -685,6 +681,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::Type(box Type::Union(tys)) => {
                 tys.iter().for_each(|ty| f(&Type::type_form(ty.clone())))
             }
+            Type::Var(v) if let Some(_guard) = self.recurser.recurse(*v) => {
+                self.map_over_union(&self.solver().force_var(*v), f)
+            }
             _ => f(ty),
         }
     }
@@ -697,11 +696,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         self.unions(vec![x, y])
     }
 
-    pub fn todo(&self, errors: &ErrorCollector, msg: &str, x: impl Ranged + Debug) -> Type {
-        errors.todo(msg, x);
-        Type::any_error()
-    }
-
     pub fn error(
         &self,
         errors: &ErrorCollector,

{pyrefly-0.10.1 → pyrefly-0.11.0}/pyrefly/lib/alt/attr.rs

@@ -31,6 +31,7 @@ use crate::export::exports::LookupExport;
 use crate::module::module_info::ModuleInfo;
 use crate::module::module_name::ModuleName;
 use crate::types::callable::FuncMetadata;
+use crate::types::callable::Function;
 use crate::types::callable::FunctionKind;
 use crate::types::callable::Param;
 use crate::types::callable::Required;
@@ -38,10 +39,10 @@ use crate::types::class::Class;
 use crate::types::class::ClassType;
 use crate::types::module::Module;
 use crate::types::quantified::Quantified;
-use crate::types::stdlib::Stdlib;
 use crate::types::tuple::Tuple;
 use crate::types::type_var::Restriction;
 use crate::types::types::AnyStyle;
+use crate::types::types::Overload;
 use crate::types::types::SuperObj;
 use crate::types::types::Type;
 
@@ -56,6 +57,31 @@ enum LookupResult {
     InternalError(InternalError),
 }
 
+/// The result of a read for narrowing purposes. We track whether we are narrowing
+/// a property or descriptor that might not be idempotent, and if so we also
+/// indicate when this came through a union (so that error messages can be clearer).
+#[derive(Debug)]
+pub enum Narrowable {
+    Simple(Type),
+    PropertyOrDescriptor(Type),
+    UnionPropertyOrDescriptor(Type),
+}
+
+impl Narrowable {
+    fn of_no_union(no_union: NarrowableNoUnion) -> Self {
+        match no_union {
+            NarrowableNoUnion::Simple(ty) => Narrowable::Simple(ty),
+            NarrowableNoUnion::PropertyOrDescriptor(ty) => Narrowable::PropertyOrDescriptor(ty),
+        }
+    }
+}
+
+#[derive(Debug)]
+enum NarrowableNoUnion {
+    Simple(Type),
+    PropertyOrDescriptor(Type),
+}
+
 /// The result of looking up an attribute. We can analyze get and set actions
 /// on an attribute, each of which can be allowed with some type or disallowed.
 #[derive(Debug)]
@@ -962,7 +988,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     // This function is intended as a low-level building block
     // Unions or intersections should be handled by callers
     fn lookup_attr_no_union(&self, base: &Type, attr_name: &Name) -> LookupResult {
-        match self.as_attribute_base_no_union(base.clone(), self.stdlib) {
+        match self.as_attribute_base_no_union(base.clone()) {
             None => {
                 LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone()))
             }
@@ -1055,7 +1081,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     // This function is intended as a low-level building block
     // Unions or intersections should be handled by callers
-    fn as_attribute_base_no_union(&self, ty: Type, stdlib: &Stdlib) -> Option<AttributeBase> {
+    fn as_attribute_base_no_union(&self, ty: Type) -> Option<AttributeBase> {
         match ty {
             Type::ClassType(class_type) => Some(AttributeBase::ClassInstance(class_type)),
             Type::ClassDef(cls) => Some(AttributeBase::ClassObject(cls)),
@@ -1063,18 +1089,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::Type(box Type::SelfType(class_type)) => {
                 Some(AttributeBase::ClassObject(class_type.class_object().dupe()))
             }
-            Type::TypedDict(_) => Some(AttributeBase::ClassInstance(stdlib.mapping(
-                stdlib.str().clone().to_type(),
-                stdlib.object().clone().to_type(),
+            Type::TypedDict(_) => Some(AttributeBase::ClassInstance(self.stdlib.mapping(
+                self.stdlib.str().clone().to_type(),
+                self.stdlib.object().clone().to_type(),
             ))),
             Type::Tuple(Tuple::Unbounded(box element)) => {
-                Some(AttributeBase::ClassInstance(stdlib.tuple(element)))
+                Some(AttributeBase::ClassInstance(self.stdlib.tuple(element)))
             }
             Type::Tuple(Tuple::Concrete(elements)) => {
                 Some(AttributeBase::ClassInstance(if elements.is_empty() {
-                    stdlib.tuple(Type::Any(AnyStyle::Implicit))
+                    self.stdlib.tuple(Type::Any(AnyStyle::Implicit))
                 } else {
-                    stdlib.tuple(self.unions(elements))
+                    self.stdlib.tuple(self.unions(elements))
                 }))
             }
             Type::Tuple(Tuple::Unpacked(box (
@@ -1086,65 +1112,86 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 elements.push(middle);
                 elements.extend(suffix);
                 Some(AttributeBase::ClassInstance(
-                    stdlib.tuple(self.unions(elements)),
+                    self.stdlib.tuple(self.unions(elements)),
                 ))
             }
             // TODO(yangdanny): the middle part is AttributeBase::Quantified
             // but we can only return one attribute base
             Type::Tuple(Tuple::Unpacked(_)) => Some(AttributeBase::ClassInstance(
-                stdlib.tuple(Type::any_implicit()),
+                self.stdlib.tuple(Type::any_implicit()),
             )),
-            Type::LiteralString => Some(AttributeBase::ClassInstance(stdlib.str().clone())),
+            Type::LiteralString => Some(AttributeBase::ClassInstance(self.stdlib.str().clone())),
             Type::Literal(lit) => Some(AttributeBase::ClassInstance(
-                lit.general_class_type(stdlib).clone(),
+                lit.general_class_type(self.stdlib).clone(),
             )),
             Type::TypeGuard(_) | Type::TypeIs(_) => {
-                Some(AttributeBase::ClassInstance(stdlib.bool().clone()))
+                Some(AttributeBase::ClassInstance(self.stdlib.bool().clone()))
             }
             Type::Any(style) => Some(AttributeBase::Any(style)),
-            Type::TypeAlias(ta) => self.as_attribute_base_no_union(ta.as_value(stdlib), stdlib),
+            Type::TypeAlias(ta) => self.as_attribute_base_no_union(ta.as_value(self.stdlib)),
             Type::Type(box Type::ClassType(class)) => {
                 Some(AttributeBase::ClassObject(class.class_object().dupe()))
             }
             Type::Type(box Type::Quantified(q)) => Some(AttributeBase::Quantified(q)),
             Type::Type(box Type::Any(style)) => Some(AttributeBase::TypeAny(style)),
             Type::Module(module) => Some(AttributeBase::Module(module)),
-            Type::TypeVar(_) => Some(AttributeBase::ClassInstance(stdlib.type_var().clone())),
-            Type::ParamSpec(_) => Some(AttributeBase::ClassInstance(stdlib.param_spec().clone())),
+            Type::TypeVar(_) => Some(AttributeBase::ClassInstance(self.stdlib.type_var().clone())),
+            Type::ParamSpec(_) => Some(AttributeBase::ClassInstance(
+                self.stdlib.param_spec().clone(),
+            )),
             Type::TypeVarTuple(_) => Some(AttributeBase::ClassInstance(
-                stdlib.type_var_tuple().clone(),
+                self.stdlib.type_var_tuple().clone(),
             )),
             Type::Args(_) => Some(AttributeBase::ClassInstance(
-                stdlib.param_spec_args().clone(),
+                self.stdlib.param_spec_args().clone(),
             )),
             Type::Kwargs(_) => Some(AttributeBase::ClassInstance(
-                stdlib.param_spec_kwargs().clone(),
+                self.stdlib.param_spec_kwargs().clone(),
+            )),
+            Type::None => Some(AttributeBase::ClassInstance(
+                self.stdlib.none_type().clone(),
             )),
-            Type::None => Some(AttributeBase::ClassInstance(stdlib.none_type().clone())),
             Type::Never(_) => Some(AttributeBase::Never),
             _ if ty.is_property_getter() => Some(AttributeBase::Property(ty)),
-            Type::Callable(_) | Type::Function(_) | Type::Overload(_) => {
-                Some(AttributeBase::ClassInstance(stdlib.function_type().clone()))
-            }
-            Type::BoundMethod(_) => {
-                Some(AttributeBase::ClassInstance(stdlib.method_type().clone()))
-            }
+            Type::Callable(_) => Some(AttributeBase::ClassInstance(
+                self.stdlib.function_type().clone(),
+            )),
+            Type::Function(box Function {
+                signature: _,
+                metadata,
+            })
+            | Type::Overload(Overload {
+                signatures: _,
+                metadata: box metadata,
+            }) => Some(AttributeBase::ClassInstance(
+                if let FunctionKind::CallbackProtocol(cls) = metadata.kind {
+                    *cls
+                } else {
+                    self.stdlib.function_type().clone()
+                },
+            )),
+            Type::BoundMethod(_) => Some(AttributeBase::ClassInstance(
+                self.stdlib.method_type().clone(),
+            )),
             Type::Ellipsis => Some(AttributeBase::ClassInstance(
-                stdlib.ellipsis_type()?.clone(),
+                self.stdlib.ellipsis_type()?.clone(),
             )),
-            Type::Forall(forall) => self.as_attribute_base_no_union(forall.body.as_type(), stdlib),
+            Type::Forall(forall) => self.as_attribute_base_no_union(forall.body.as_type()),
             Type::Var(v) => {
                 if let Some(_guard) = self.recurser.recurse(v) {
-                    self.as_attribute_base_no_union(self.solver().force_var(v), stdlib)
+                    self.as_attribute_base_no_union(self.solver().force_var(v))
                 } else {
                     None
                 }
             }
             Type::SuperInstance(box (cls, obj)) => Some(AttributeBase::SuperInstance(cls, obj)),
             Type::Quantified(q) if q.is_type_var() => match q.restriction() {
-                Restriction::Bound(bound) => self.as_attribute_base_no_union(bound.clone(), stdlib),
+                Restriction::Bound(bound) => self.as_attribute_base_no_union(bound.clone()),
                 // TODO: handle constraints
-                Restriction::Constraints(_) | Restriction::Unrestricted => None,
+                Restriction::Constraints(_) => None,
+                Restriction::Unrestricted => {
+                    Some(AttributeBase::ClassInstance(self.stdlib.object().clone()))
+                }
             },
             // TODO: check to see which ones should have class representations
             Type::Union(_)
@@ -1157,6 +1204,93 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             | Type::Quantified(_) => None,
         }
     }
+
+    /// Compute the get (i.e. read) type information of an attribute for narrowing.
+    /// - If the attribute is a descriptor that cannot be narrowed, return `PropertyOrDescriptor({read_type})`,
+    ///   where the `read_type` is the type of a fetch (which can be narrowed under the unchecked
+    ///   assumption that the descriptor return type is consistent).
+    /// - If the base type is a union and at least one case has a descriptor that cannot be narrowed,
+    ///   return UnionPropertyOrDescriptor({read_type}), which will allow us to make error messages
+    ///   clearer for this case.
+    /// - If the attribute is soundly narrowable (up to data races, which we do not currently attempt
+    ///   to model) - which is true for normal attributes and may eventually for known-to-be-sound
+    ///   built-in descriptors, return `Simple({read_type})`
+    /// - If the attribute comes from `__getattr__`, treat it as soundly narrowable. This is unsound but
+    ///   pragmatic, because `__getattr__` stubs are often used to indicate gradual typing.
+    /// - If the attribute cannot be found or read return `Simple(ClassType({object}))`. There will
+    ///   still be a type error on the narrow, but we should treat it as a valid narrow starting
+    ///   from `object` in downstream code.
+    pub fn narrowable_for_attr(
+        &self,
+        base: &Type,
+        attr_name: &Name,
+        range: TextRange,
+        errors: &ErrorCollector,
+    ) -> Narrowable {
+        match base {
+            Type::Union(base_tys) => {
+                let mut has_property_or_descriptor = false;
+                let ty = self.unions(
+                    base_tys
+                        .iter()
+                        .map(|base_ty| {
+                            match self
+                                .narrowable_for_attr_no_union(base_ty, attr_name, range, errors)
+                            {
+                                NarrowableNoUnion::Simple(ty) => ty,
+                                NarrowableNoUnion::PropertyOrDescriptor(ty) => {
+                                    has_property_or_descriptor = true;
+                                    ty
+                                }
+                            }
+                        })
+                        .collect(),
+                );
+                if has_property_or_descriptor {
+                    Narrowable::UnionPropertyOrDescriptor(ty)
+                } else {
+                    Narrowable::Simple(ty)
+                }
+            }
+            _ => Narrowable::of_no_union(
+                self.narrowable_for_attr_no_union(base, attr_name, range, errors),
+            ),
+        }
+    }
+
+    fn narrowable_for_attr_no_union(
+        &self,
+        base: &Type,
+        attr_name: &Name,
+        range: TextRange,
+        errors: &ErrorCollector,
+    ) -> NarrowableNoUnion {
+        let fall_back_to_object_narrowable =
+            || NarrowableNoUnion::Simple(Type::ClassType(self.stdlib.object().clone()));
+        match self.lookup_attr_no_union(base, attr_name) {
+            LookupResult::InternalError(..) | LookupResult::NotFound(..) => {
+                fall_back_to_object_narrowable()
+            }
+            LookupResult::Found(attr) => {
+                let is_property_or_descriptor = match &attr.inner {
+                    AttributeInner::Simple(..)
+                    | AttributeInner::NoAccess(..)
+                    | AttributeInner::GetAttr(..) => false,
+                    AttributeInner::Property(..) | AttributeInner::Descriptor(..) => true,
+                };
+                match self.resolve_get_access(attr, range, errors, None) {
+                    Err(..) => fall_back_to_object_narrowable(),
+                    Ok(ty) => {
+                        if is_property_or_descriptor {
+                            NarrowableNoUnion::PropertyOrDescriptor(ty)
+                        } else {
+                            NarrowableNoUnion::Simple(ty)
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 #[derive(Debug)]
@@ -1212,7 +1346,7 @@ impl<'a, Ans: LookupAnswer + LookupExport> AnswersSolver<'a, Ans> {
     pub fn completions(&self, base: Type, include_types: bool) -> Vec<AttrInfo> {
         let mut res = Vec::new();
         // TODO: expose attributes shared across all union members
-        if let Some(base) = self.as_attribute_base_no_union(base, self.stdlib) {
+        if let Some(base) = self.as_attribute_base_no_union(base) {
             match &base {
                 AttributeBase::ClassInstance(class) => self.completions_class_type(class, &mut res),
                 AttributeBase::SuperInstance(class, _) => {