pyrefly 0.18.0__tar.gz → 0.18.1__tar.gz

{pyrefly-0.18.0 → pyrefly-0.18.1}/Cargo.lock

@@ -101,9 +101,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.18"
+version = "0.6.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
+checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -116,33 +116,33 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.6"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9"
 dependencies = [
  "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.8"
+version = "3.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6680de5231bd6ee4c6191b8a1325daa282b415391ec9d3a37bd34f2060dc73fa"
+checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
@@ -212,9 +212,9 @@ dependencies = [
 
 [[package]]
 name = "base64"
-version = "0.21.7"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "bitflags"
@@ -266,9 +266,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.17.0"
+version = "3.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
+checksum = "793db76d6187cd04dff33004d8e6c9cc4e05cd330500379d2394209271b4aeee"
 
 [[package]]
 name = "byteorder"
@@ -296,9 +296,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.25"
+version = "1.2.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0fc897dc1e865cc67c0e05a836d9d3f1df3cbe442aa4a9473b18e12624a4951"
+checksum = "956a5e21988b87f372569b66183b78babf23ebc2e744b733e4350a752c4dafac"
 dependencies = [
  "jobserver",
  "libc",
@@ -368,9 +368,9 @@ checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
 
 [[package]]
 name = "colorchoice"
-version = "1.0.3"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
 
 [[package]]
 name = "compact_str"
@@ -1673,9 +1673,9 @@ checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
 
 [[package]]
 name = "potential_utf"
@@ -1754,7 +1754,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.18.0"
+version = "0.18.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1819,7 +1819,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.18.0"
+version = "0.18.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2018,7 +2018,7 @@ checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
 [[package]]
 name = "ruff_python_ast"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff/?rev=3acf4e716d5d1fb9bd1316dc268deb6824a300c8#3acf4e716d5d1fb9bd1316dc268deb6824a300c8"
+source = "git+https://github.com/astral-sh/ruff/?rev=aee3af0f7a018e9fcf921b746ad8ef76d3b84b83#aee3af0f7a018e9fcf921b746ad8ef76d3b84b83"
 dependencies = [
  "aho-corasick",
  "bitflags 2.9.1",
@@ -2035,7 +2035,7 @@ dependencies = [
 [[package]]
 name = "ruff_python_parser"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff/?rev=3acf4e716d5d1fb9bd1316dc268deb6824a300c8#3acf4e716d5d1fb9bd1316dc268deb6824a300c8"
+source = "git+https://github.com/astral-sh/ruff/?rev=aee3af0f7a018e9fcf921b746ad8ef76d3b84b83#aee3af0f7a018e9fcf921b746ad8ef76d3b84b83"
 dependencies = [
  "bitflags 2.9.1",
  "bstr",
@@ -2054,7 +2054,7 @@ dependencies = [
 [[package]]
 name = "ruff_python_trivia"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff/?rev=3acf4e716d5d1fb9bd1316dc268deb6824a300c8#3acf4e716d5d1fb9bd1316dc268deb6824a300c8"
+source = "git+https://github.com/astral-sh/ruff/?rev=aee3af0f7a018e9fcf921b746ad8ef76d3b84b83#aee3af0f7a018e9fcf921b746ad8ef76d3b84b83"
 dependencies = [
  "itertools 0.14.0",
  "ruff_source_file",
@@ -2065,7 +2065,7 @@ dependencies = [
 [[package]]
 name = "ruff_source_file"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff/?rev=3acf4e716d5d1fb9bd1316dc268deb6824a300c8#3acf4e716d5d1fb9bd1316dc268deb6824a300c8"
+source = "git+https://github.com/astral-sh/ruff/?rev=aee3af0f7a018e9fcf921b746ad8ef76d3b84b83#aee3af0f7a018e9fcf921b746ad8ef76d3b84b83"
 dependencies = [
  "memchr",
  "ruff_text_size",
@@ -2074,7 +2074,7 @@ dependencies = [
 [[package]]
 name = "ruff_text_size"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff/?rev=3acf4e716d5d1fb9bd1316dc268deb6824a300c8#3acf4e716d5d1fb9bd1316dc268deb6824a300c8"
+source = "git+https://github.com/astral-sh/ruff/?rev=aee3af0f7a018e9fcf921b746ad8ef76d3b84b83#aee3af0f7a018e9fcf921b746ad8ef76d3b84b83"
 
 [[package]]
 name = "rustc-demangle"
@@ -2237,9 +2237,9 @@ dependencies = [
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.8"
+version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
 dependencies = [
  "serde",
 ]
@@ -2309,9 +2309,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.15.0"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "socket2"
@@ -2634,9 +2634,9 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.8.22"
+version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05ae329d1f08c4d17a59bed7ff5b5a769d062e64a62d34a3261b219e62cd5aae"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
 dependencies = [
  "serde",
  "serde_spanned",
@@ -2646,18 +2646,18 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.9"
+version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3da5db5a963e24bc68be8b17b6fa82814bb22ee8660f192bb182771d498f09a3"
+checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.22.26"
+version = "0.22.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
+checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
  "indexmap",
  "serde",
@@ -2669,9 +2669,9 @@ dependencies = [
 
 [[package]]
 name = "toml_write"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfb942dfe1d8e29a7ee7fcbde5bd2b9a25fb89aa70caea2eba3bee836ff41076"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
 name = "tracing"
@@ -2686,9 +2686,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.28"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "395ae124c09f9e6918a2310af6038fba074bcf474ac352496d5910dd59a2226d"
+checksum = "1b1ffbcf9c6f6b99d386e7444eb608ba646ae452a36b39737deb9663b610f662"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2697,9 +2697,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.33"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e672c95779cf947c5311f83787af4fa8fffd12fb27e4993211a84bdfd9610f9c"
+checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
 dependencies = [
  "once_cell",
  "valuable",

{pyrefly-0.18.0 → pyrefly-0.18.1}/PKG-INFO

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

{pyrefly-0.18.0 → pyrefly-0.18.1}/pyrefly/Cargo.toml

@@ -2,27 +2,25 @@
 
 [package]
 name = "pyrefly"
-version = "0.18.0"
+version = "0.18.1"
 authors = ["Meta"]
-edition = "2021"
+edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
 license = "MIT"
 build = "build.rs"
 
 [lib]
 path = "lib/lib.rs"
-edition = "2024"
 
 [[bin]]
 name = "pyrefly"
 path = "bin/main.rs"
-edition = "2024"
 
 [dependencies]
 anstream = "0.6.11"
 anyhow = "1.0.95"
 append-only-vec = "0.1.2"
-base64 = { version = "0.21", features = ["alloc"] }
+base64 = "0.22.1"
 blake3 = { version = "=1.5.5", features = ["mmap", "rayon", "traits-preview"] }
 clap = { version = "4.5.38", features = ["derive", "env", "string", "unicode", "wrap_help"] }
 configparser = { version = "3.0.3", features = ["indexmap"] }
@@ -45,10 +43,10 @@ pyrefly_derive = { path = "../pyrefly_derive" }
 pyrefly_util = { path = "../pyrefly_util" }
 regex = "1.11.1"
 regex-syntax = "0.7.5"
-ruff_python_ast = { git = "https://github.com/astral-sh/ruff/", rev = "3acf4e716d5d1fb9bd1316dc268deb6824a300c8" }
-ruff_python_parser = { git = "https://github.com/astral-sh/ruff/", rev = "3acf4e716d5d1fb9bd1316dc268deb6824a300c8" }
-ruff_source_file = { git = "https://github.com/astral-sh/ruff/", rev = "3acf4e716d5d1fb9bd1316dc268deb6824a300c8" }
-ruff_text_size = { git = "https://github.com/astral-sh/ruff/", rev = "3acf4e716d5d1fb9bd1316dc268deb6824a300c8" }
+ruff_python_ast = { git = "https://github.com/astral-sh/ruff/", rev = "aee3af0f7a018e9fcf921b746ad8ef76d3b84b83" }
+ruff_python_parser = { git = "https://github.com/astral-sh/ruff/", rev = "aee3af0f7a018e9fcf921b746ad8ef76d3b84b83" }
+ruff_source_file = { git = "https://github.com/astral-sh/ruff/", rev = "aee3af0f7a018e9fcf921b746ad8ef76d3b84b83" }
+ruff_text_size = { git = "https://github.com/astral-sh/ruff/", rev = "aee3af0f7a018e9fcf921b746ad8ef76d3b84b83" }
 serde = { version = "1.0.185", features = ["derive", "rc"] }
 serde_json = { version = "1.0.140", features = ["float_roundtrip", "unbounded_depth"] }
 serde_jsonrc = "0.1"

{pyrefly-0.18.0 → pyrefly-0.18.1}/pyrefly/bin/main.rs

@@ -56,10 +56,10 @@ static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
 struct Args {
     /// Set this to true to run profiling of fast jobs.
     /// Will run the command repeatedly.
-    #[clap(long = "profiling", global = true, hide = true, env = clap_env("PROFILING"))]
+    #[arg(long = "profiling", global = true, hide = true, env = clap_env("PROFILING"))]
     profiling: bool,
 
-    #[clap(flatten)]
+    #[command(flatten)]
     common: CommonGlobalArgs,
 
     #[command(subcommand)]
@@ -75,10 +75,10 @@ struct FullCheckArgs {
     /// are ignored, and we use the default excludes unless overridden with the `--project-excludes` flag.
     files: Vec<String>,
     /// Files to exclude when type checking.
-    #[clap(long, env = clap_env("PROJECT_EXCLUDES"))]
+    #[arg(long, env = clap_env("PROJECT_EXCLUDES"))]
     project_excludes: Option<Vec<String>>,
     /// Watch for file changes and re-check them.
-    #[clap(long, env = clap_env("WATCH"), conflicts_with = "check_all")]
+    #[arg(long, env = clap_env("WATCH"), conflicts_with = "check_all")]
     watch: bool,
 
     /// Explicitly set the Pyre configuration to use when type checking or starting a language server.
@@ -88,10 +88,10 @@ struct FullCheckArgs {
     /// When not set, Pyre will perform an upward-filesystem-walk approach to find the nearest
     /// pyrefly.toml or pyproject.toml with `tool.pyre` section'. If no config is found, Pyre exits with error.
     /// If both a pyrefly.toml and valid pyproject.toml are found, pyrefly.toml takes precedence.
-    #[clap(long, short, env = clap_env("CONFIG"))]
+    #[arg(long, short, env = clap_env("CONFIG"))]
     config: Option<PathBuf>,
 
-    #[clap(flatten)]
+    #[command(flatten)]
     args: CheckArgs,
 }
 

{pyrefly-0.18.0 → pyrefly-0.18.1}/pyrefly/lib/alt/answers.rs

@@ -26,6 +26,7 @@ use ruff_text_size::TextRange;
 use starlark_map::Hashed;
 use starlark_map::small_map::SmallMap;
 use starlark_map::small_set::SmallSet;
+use vec1::vec1;
 
 use crate::alt::attr::AttrDefinition;
 use crate::alt::attr::AttrInfo;
@@ -820,7 +821,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         context: Option<&dyn Fn() -> ErrorContext>,
         msg: String,
     ) -> Type {
-        errors.add(range, msg, kind, context);
+        errors.add(range, kind, context, vec1![msg]);
         Type::any_error()
     }
 

{pyrefly-0.18.0 → pyrefly-0.18.1}/pyrefly/lib/alt/attr.rs

@@ -39,6 +39,7 @@ use crate::types::class::ClassType;
 use crate::types::literal::Lit;
 use crate::types::module::Module;
 use crate::types::quantified::Quantified;
+use crate::types::quantified::QuantifiedKind;
 use crate::types::tuple::Tuple;
 use crate::types::type_var::Restriction;
 use crate::types::typed_dict::TypedDict;
@@ -298,13 +299,15 @@ impl InternalError {
 /// it's corresponding class type.
 #[derive(Clone, Debug)]
 enum AttributeBase {
+    EnumLiteral(ClassType, Name, Type),
     ClassInstance(ClassType),
     ClassObject(Class),
     Module(Module),
     /// The attribute access is on a quantified type form (as in `args: P.args` - this
     /// is only used when the base *is* a quantified type, not when the base is
     /// a term that *has* a quantified type.
-    TypeVar(Quantified),
+    /// The second element is a bound or constraint for the type variable.
+    TypeVar(Quantified, Option<ClassType>),
     Any(AnyStyle),
     Never,
     /// type[Any] is a special case where attribute lookups first check the
@@ -320,6 +323,61 @@ enum AttributeBase {
 }
 
 impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
+    /// Gets the possible attribute bases for a type:
+    /// If the type is a union, we will attempt to generate bases for each member of the union
+    /// If the type is a bounded type var w/ a union upper bound, we will attempt to generate 1 base for
+    /// each member of the union
+    /// If the type is a constrained type var, we will attempt to generate 1 base for each constraint
+    fn get_possible_attribute_bases(&self, base: &Type) -> Vec<Option<AttributeBase>> {
+        let mut bases = Vec::new();
+        self.map_over_union(base, |base| {
+            match base {
+                Type::Quantified(quantified) => match quantified.restriction() {
+                    Restriction::Bound(upper_bound) => {
+                        let mut use_fallback = false;
+                        self.map_over_union(upper_bound, |bound| {
+                            let bound_attr_base = self.as_attribute_base_no_union(bound.clone());
+                            if let Some(AttributeBase::ClassInstance(cls)) = bound_attr_base {
+                                bases.push(Some(AttributeBase::TypeVar(
+                                    quantified.clone(),
+                                    Some(cls),
+                                )));
+                            } else {
+                                use_fallback = true;
+                            }
+                        });
+                        if use_fallback {
+                            bases.push(Some(AttributeBase::TypeVar(quantified.clone(), None)));
+                        }
+                    }
+                    Restriction::Constraints(constraints) => {
+                        let mut use_fallback = false;
+                        for constraint in constraints {
+                            let constraint_attr_base =
+                                self.as_attribute_base_no_union(constraint.clone());
+                            if let Some(AttributeBase::ClassInstance(cls)) = constraint_attr_base {
+                                bases.push(Some(AttributeBase::TypeVar(
+                                    quantified.clone(),
+                                    Some(cls),
+                                )));
+                            } else {
+                                use_fallback = true;
+                            }
+                        }
+                        if use_fallback {
+                            bases.push(Some(AttributeBase::TypeVar(quantified.clone(), None)));
+                        }
+                    }
+                    Restriction::Unrestricted => bases.push(Some(AttributeBase::ClassInstance(
+                        self.stdlib.object().clone(),
+                    ))),
+                },
+                _ => bases.push(self.as_attribute_base_no_union(base.clone())),
+            };
+        });
+        bases
+    }
+
     /// Compute the get (i.e. read) type of an attribute. If the attribute cannot be found or read,
     /// error and return `Any`. Use this to infer the type of a direct attribute fetch.
     pub fn type_of_attr_get(
@@ -331,8 +389,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         context: Option<&dyn Fn() -> ErrorContext>,
         todo_ctx: &str,
     ) -> Type {
-        self.distribute_over_union(base, |base| {
-            let lookup_result = self.lookup_attr_no_union(base, attr_name);
+        let bases = self.get_possible_attribute_bases(base);
+        let mut results = Vec::new();
+        for attr_base in bases {
+            let lookup_result = attr_base.map_or_else(
+                || LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone())),
+                |attr_base| self.lookup_attr_from_base_no_union(attr_base, attr_name),
+            );
             match self.get_type_or_conflated_error_msg(
                 lookup_result,
                 attr_name,
@@ -341,10 +404,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 context,
                 todo_ctx,
             ) {
-                Ok(ty) => ty,
-                Err(msg) => self.error(errors, range, ErrorKind::MissingAttribute, context, msg),
+                Ok(ty) => results.push(ty),
+                Err(msg) => results.push(self.error(
+                    errors,
+                    range,
+                    ErrorKind::MissingAttribute,
+                    context,
+                    msg,
+                )),
             }
-        })
+        }
+        self.unions(results)
     }
 
     /// Compute the get (i.e., read) type of a magic dunder attribute, if it can be found. If reading is not
@@ -716,7 +786,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     is_subset(
                         want_setter,
                         &Type::callable(
-                            vec![Param::PosOnly(got.clone(), Required::Required)],
+                            vec![Param::PosOnly(None, got.clone(), Required::Required)],
                             Type::None,
                         ),
                     )
@@ -869,10 +939,29 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         attr_name: &Name,
     ) -> LookupResult {
         match base {
-            AttributeBase::ClassInstance(class) => {
-                match self.get_instance_attribute(&class, attr_name) {
+            AttributeBase::EnumLiteral(_, member, _)
+                if matches!(attr_name.as_str(), "name" | "_name_") =>
+            {
+                LookupResult::found_type(Type::Literal(Lit::Str(member.as_str().into())))
+            }
+            AttributeBase::EnumLiteral(_, _, raw_type)
+                if matches!(attr_name.as_str(), "value" | "_value_") =>
+            {
+                LookupResult::found_type(raw_type.clone())
+            }
+            AttributeBase::ClassInstance(class) | AttributeBase::EnumLiteral(class, _, _) => {
+                let metadata = self.get_metadata_for_class(class.class_object());
+                let mut attr_name = attr_name.clone();
+                // Special case magic enum properties
+                if metadata.is_enum() && attr_name.as_str() == "value" {
+                    attr_name = Name::new("_value_")
+                }
+                if metadata.is_enum() && attr_name.as_str() == "name" {
+                    attr_name = Name::new("_name_")
+                }
+                match self.get_instance_attribute(&class, &attr_name) {
                     Some(attr) => LookupResult::Found(attr),
-                    None if self.extends_any(class.class_object()) => {
+                    None if metadata.has_base_any() => {
                         LookupResult::found_type(Type::Any(AnyStyle::Implicit))
                     }
                     None => {
@@ -931,12 +1020,24 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 Some(attr) => LookupResult::found_type(attr),
                 None => LookupResult::NotFound(NotFound::ModuleExport(module)),
             },
-            AttributeBase::TypeVar(q) => match (q.is_param_spec(), attr_name.as_str()) {
+            AttributeBase::TypeVar(q, bound) => match (q.kind(), attr_name.as_str()) {
                 // Note that is is for cases like `P.args` where `P` is a param spec, or `T.x` where
                 // `T` is a type variable (the latter is illegal, but a user could write it). It is
                 // not for cases where `base` is a term with a quantified type.
-                (true, "args") => LookupResult::found_type(Type::type_form(Type::Args(q))),
-                (true, "kwargs") => LookupResult::found_type(Type::type_form(Type::Kwargs(q))),
+                (QuantifiedKind::ParamSpec, "args") => {
+                    LookupResult::found_type(Type::type_form(Type::Args(q)))
+                }
+                (QuantifiedKind::ParamSpec, "kwargs") => {
+                    LookupResult::found_type(Type::type_form(Type::Kwargs(q)))
+                }
+                (QuantifiedKind::TypeVar, _) if let Some(upper_bound) = bound => {
+                    match self.get_bounded_type_var_attribute(q.clone(), &upper_bound, attr_name) {
+                        Some(attr) => LookupResult::Found(attr),
+                        None => LookupResult::NotFound(NotFound::Attribute(
+                            upper_bound.class_object().dupe(),
+                        )),
+                    }
+                }
                 _ => {
                     let class = q.as_value(self.stdlib);
                     match self.get_instance_attribute(class, attr_name) {
@@ -1067,27 +1168,10 @@ 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 (base, attr_name.as_str()) {
-            (Type::Literal(Lit::Enum(box (_, member, _))), "_name_" | "name") => {
-                LookupResult::found_type(Type::Literal(Lit::Str(member.as_str().into())))
-            }
-            (Type::Literal(Lit::Enum(box (_, _, raw_type))), "_value_" | "value") => {
-                LookupResult::found_type(raw_type.clone())
-            }
-            (Type::SelfType(cls) | Type::ClassType(cls), "name")
-                if self.get_metadata_for_class(cls.class_object()).is_enum() =>
-            {
-                self.lookup_attr_no_union(base, &Name::new_static("_name_"))
-            }
-            (Type::SelfType(cls) | Type::ClassType(cls), "value")
-                if self.get_metadata_for_class(cls.class_object()).is_enum() =>
-            {
-                self.lookup_attr_no_union(base, &Name::new_static("_value_"))
-            }
-            _ if let Some(base) = self.as_attribute_base_no_union(base.clone()) => {
-                self.lookup_attr_from_base_no_union(base, attr_name)
-            }
-            _ => LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone())),
+        if let Some(base) = self.as_attribute_base_no_union(base.clone()) {
+            self.lookup_attr_from_base_no_union(base, attr_name)
+        } else {
+            LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone()))
         }
     }
 
@@ -1100,11 +1184,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     pub fn try_lookup_attr(&self, base: &Type, attr_name: &Name) -> Vec<Attribute> {
         let mut result = Vec::new();
-        self.map_over_union(base, |base| {
-            if let Some(attr) = self.try_lookup_attr_no_union(base, attr_name) {
-                result.push(attr);
+        let bases = self.get_possible_attribute_bases(base);
+        for attr_base in bases {
+            let lookup_result = attr_base.map_or_else(
+                || LookupResult::InternalError(InternalError::AttributeBaseUndefined(base.clone())),
+                |attr_base| self.lookup_attr_from_base_no_union(attr_base, attr_name),
+            );
+            match lookup_result {
+                LookupResult::Found(attr) => result.push(attr),
+                _ => {}
             }
-        });
+        }
         result
     }
 
@@ -1193,6 +1283,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 self.stdlib.tuple(Type::any_implicit()),
             )),
             Type::LiteralString => Some(AttributeBase::ClassInstance(self.stdlib.str().clone())),
+            Type::Literal(Lit::Enum(box (class, member, raw_ty))) => {
+                Some(AttributeBase::EnumLiteral(class, member, raw_ty))
+            }
             Type::Literal(lit) => Some(AttributeBase::ClassInstance(
                 lit.general_class_type(self.stdlib).clone(),
             )),
@@ -1209,9 +1302,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 Restriction::Bound(bound) => {
                     self.as_attribute_base_no_union(Type::type_form(bound.clone()))
                 }
-                _ => Some(AttributeBase::TypeVar(q)),
+                _ => Some(AttributeBase::TypeVar(q, None)),
             },
-            Type::Type(box Type::Quantified(q)) => Some(AttributeBase::TypeVar(q)),
+            Type::Type(box Type::Quantified(q)) => Some(AttributeBase::TypeVar(q, None)),
             Type::Type(box Type::Any(style)) => Some(AttributeBase::TypeAny(style)),
             Type::Module(module) => Some(AttributeBase::Module(module)),
             Type::TypeVar(_) => Some(AttributeBase::ClassInstance(self.stdlib.type_var().clone())),
@@ -1495,7 +1588,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // TODO: expose attributes shared across all union members
         if let Some(base) = self.as_attribute_base_no_union(base) {
             match &base {
-                AttributeBase::ClassInstance(class) => {
+                AttributeBase::ClassInstance(class) | AttributeBase::EnumLiteral(class, _, _) => {
                     self.completions_class_type(class, expected_attribute_name, &mut res)
                 }
                 AttributeBase::TypedDict(_) => self.completions_class_type(
@@ -1509,7 +1602,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 AttributeBase::ClassObject(class) => {
                     self.completions_class(class, expected_attribute_name, &mut res)
                 }
-                AttributeBase::TypeVar(q) => self.completions_class_type(
+                AttributeBase::TypeVar(q, _) => self.completions_class_type(
                     q.as_value(self.stdlib),
                     expected_attribute_name,
                     &mut res,