pyrefly 0.19.2__tar.gz → 0.20.0__tar.gz

{pyrefly-0.19.2 → pyrefly-0.20.0}/Cargo.lock

@@ -239,9 +239,9 @@ checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
 
 [[package]]
 name = "blake3"
-version = "1.5.5"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8ee0c1824c4dea5b5f81736aff91bae041d2c07ee1192bec91054e10e3e601e"
+checksum = "675f87afced0413c9bb02843499dbbd3882a237645883f71a2b59644a6d2f753"
 dependencies = [
  "arrayref",
  "arrayvec",
@@ -322,14 +322,14 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.39"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
+checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "num-traits",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
@@ -765,9 +765,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "foldhash"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
 name = "form_urlencoded"
@@ -1841,7 +1841,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.19.2"
+version = "0.20.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1899,7 +1899,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.19.2"
+version = "0.20.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1908,7 +1908,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.19.2"
+version = "0.20.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2250,9 +2250,9 @@ checksum = "764cad9e7e1ca5fe15b552859ff5d96a314e6ed2934f2260168cd5dfa5891409"
 
 [[package]]
 name = "serde"
-version = "1.0.217"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
 dependencies = [
  "serde_derive",
 ]
@@ -2293,9 +2293,9 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.217"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2909,9 +2909,9 @@ checksum = "a210d160f08b701c8721ba1c726c11662f877ea6b7094007e1ca9a1041945034"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
 dependencies = [
  "tinyvec",
 ]
@@ -3160,6 +3160,12 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-link"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+
 [[package]]
 name = "windows-sys"
 version = "0.45.0"

{pyrefly-0.19.2 → pyrefly-0.20.0}/PKG-INFO

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

{pyrefly-0.19.2 → pyrefly-0.20.0}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.19.2"
+version = "0.20.0"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -20,8 +20,8 @@ path = "bin/main.rs"
 anstream = "0.6.11"
 anyhow = "1.0.95"
 append-only-vec = "0.1.2"
-base64 = "0.22.1"
-blake3 = { version = "=1.5.5", features = ["mmap", "rayon", "traits-preview"] }
+base64 = { version = "0.22.1", features = ["alloc"] }
+blake3 = { version = "=1.6.1", features = ["mmap", "rayon", "traits-preview"] }
 clap = { version = "4.5.38", features = ["derive", "env", "string", "unicode", "wrap_help"] }
 configparser = { version = "3.0.3", features = ["indexmap"] }
 convert_case = "0.6"

{pyrefly-0.19.2 → pyrefly-0.20.0}/pyrefly/lib/alt/attr.rs

@@ -8,8 +8,6 @@
 use std::iter;
 
 use dupe::Dupe;
-use itertools::Either;
-use ruff_python_ast::Expr;
 use ruff_python_ast::name::Name;
 use ruff_text_size::TextRange;
 use starlark_map::small_set::SmallSet;
@@ -17,6 +15,7 @@ use starlark_map::small_set::SmallSet;
 use crate::alt::answers::AnswersSolver;
 use crate::alt::answers::LookupAnswer;
 use crate::alt::callable::CallArg;
+use crate::alt::expr::TypeOrExpr;
 use crate::alt::types::class_metadata::EnumMetadata;
 use crate::binding::binding::ExprOrBinding;
 use crate::binding::binding::KeyExport;
@@ -499,10 +498,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         range: TextRange,
         errors: &ErrorCollector,
     ) -> Option<Type> {
+        let ty;
         let got = match got {
-            ExprOrBinding::Expr(value) => Either::Left(value),
+            ExprOrBinding::Expr(value) => TypeOrExpr::Expr(value),
             ExprOrBinding::Binding(got) => {
-                Either::Right(self.solve_binding(got, errors).arc_clone_ty())
+                ty = self.solve_binding(got, errors);
+                TypeOrExpr::Type(ty.ty(), range)
             }
         };
         self.check_attr_set_and_infer_narrow(
@@ -520,7 +521,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self,
         base: &Type,
         attr_name: &Name,
-        got: Either<&Expr, Type>,
+        got: TypeOrExpr,
         range: TextRange,
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
@@ -537,7 +538,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 LookupResult::Found(attr) => match attr.inner {
                     AttributeInner::Simple(want, Visibility::ReadWrite) => {
                         let ty = match &got {
-                            Either::Left(got) => self.expr(
+                            TypeOrExpr::Expr(got) => self.expr(
                                 got,
                                 Some((&want, &|| TypeCheckContext {
                                     kind: TypeCheckKind::Attribute(attr_name.clone()),
@@ -545,12 +546,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                 })),
                                 errors,
                             ),
-                            Either::Right(got) => {
+                            TypeOrExpr::Type(got, _) => {
                                 self.check_type(&want, got, range, errors, &|| TypeCheckContext {
                                     kind: TypeCheckKind::Attribute(attr_name.clone()),
                                     context: context.map(|ctx| ctx()),
                                 });
-                                got.clone()
+                                (*got).clone()
                             }
                         };
                         if let Some(narrowed_types) = &mut narrowed_types {
@@ -588,19 +589,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         );
                     }
                     AttributeInner::Property(_, Some(setter), _) => {
-                        let got = match &got {
-                            Either::Left(got) => CallArg::Expr(got),
-                            Either::Right(got) => CallArg::Type(got, range),
-                        };
+                        let got = CallArg::arg(got);
                         self.call_property_setter(setter, got, range, errors, context);
                     }
                     AttributeInner::Descriptor(d) => {
                         match (d.base, d.setter) {
                             (DescriptorBase::Instance(class_type), Some(setter)) => {
-                                let got = match &got {
-                                    Either::Left(got) => CallArg::Expr(got),
-                                    Either::Right(got) => CallArg::Type(got, range),
-                                };
+                                let got = CallArg::arg(got);
                                 self.call_descriptor_setter(
                                     setter, class_type, got, range, errors, context,
                                 );

{pyrefly-0.19.2 → pyrefly-0.20.0}/pyrefly/lib/alt/call.rs

@@ -5,9 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+use append_only_vec::AppendOnlyVec;
 use dupe::Dupe;
-use ruff_python_ast::Keyword;
 use ruff_python_ast::name::Name;
+use ruff_text_size::Ranged;
 use ruff_text_size::TextRange;
 use starlark_map::small_set::SmallSet;
 use vec1::Vec1;
@@ -17,6 +18,8 @@ use crate::alt::answers::AnswersSolver;
 use crate::alt::answers::LookupAnswer;
 use crate::alt::attr::DescriptorBase;
 use crate::alt::callable::CallArg;
+use crate::alt::callable::CallKeyword;
+use crate::alt::expr::TypeOrExpr;
 use crate::dunder;
 use crate::error::collector::ErrorCollector;
 use crate::error::context::ErrorContext;
@@ -249,7 +252,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         method_name: &Name,
         range: TextRange,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
     ) -> Type {
@@ -275,7 +278,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         method_name: &Name,
         range: TextRange,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
     ) -> Option<Type> {
@@ -306,7 +309,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         method_name: &Name,
         range: TextRange,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
     ) -> Type {
@@ -330,7 +333,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         cls: &ClassType,
         range: TextRange,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
     ) -> Option<Type> {
@@ -366,7 +369,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self,
         cls: ClassType,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         range: TextRange,
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
@@ -385,7 +388,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let (overrides_new, dunder_new_has_errors) =
             if let Some(new_method) = self.get_dunder_new(&cls) {
                 let cls_ty = Type::type_form(instance_ty.clone());
-                let mut full_args = vec![CallArg::Type(&cls_ty, range)];
+                let mut full_args = vec![CallArg::ty(&cls_ty, range)];
                 full_args.extend_from_slice(args);
                 let dunder_new_errors = self.error_collector();
                 let ret = self.call_infer(
@@ -451,7 +454,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self,
         typed_dict: TypedDict,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         range: TextRange,
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
@@ -479,8 +482,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     fn first_arg_type(&self, args: &[CallArg], errors: &ErrorCollector) -> Option<Type> {
         if let Some(first_arg) = args.first() {
             match first_arg {
-                CallArg::Expr(e) => Some(self.expr_infer(e, errors)),
-                CallArg::Type(t, _) => Some((**t).clone()),
+                CallArg::Arg(x) => Some(x.infer(self, errors)),
                 CallArg::Star(..) => None,
             }
         } else {
@@ -492,7 +494,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         &self,
         call_target: CallTarget,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         range: TextRange,
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
@@ -533,7 +535,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 self.construct_typed_dict(td, args, keywords, range, errors, context)
             }
             Target::BoundMethod(obj, func) => {
-                let first_arg = CallArg::Type(&obj, range);
+                let first_arg = CallArg::ty(&obj, range);
                 self.callable_infer(
                     func.signature,
                     Some(func.metadata.kind.as_func_id()),
@@ -599,7 +601,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Target::BoundMethodOverload(obj, overloads, meta) => self.call_overloads(
                 overloads,
                 meta,
-                Some(CallArg::Type(&obj, range)),
+                Some(CallArg::ty(&obj, range)),
                 args,
                 keywords,
                 range,
@@ -610,14 +612,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 // Make sure we still catch errors in the arguments.
                 for arg in args {
                     match arg {
-                        CallArg::Expr(e) | CallArg::Star(e, _) => {
-                            self.expr_infer(e, errors);
+                        CallArg::Arg(e) | CallArg::Star(e, _) => {
+                            e.infer(self, errors);
                         }
-                        CallArg::Type(..) => {}
                     }
                 }
                 for kw in keywords {
-                    self.expr_infer(&kw.value, errors);
+                    kw.value.infer(self, errors);
                 }
                 style.propagate()
             }
@@ -626,7 +627,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         if is_dataclass && let Type::Callable(c) = res {
             let mut kws = BoolKeywords::new();
             for kw in keywords {
-                kws.set_keyword(kw.arg.as_ref(), self.expr_infer(&kw.value, errors));
+                kws.set_keyword(kw.arg, kw.value.infer(self, errors));
             }
             Type::Function(Box::new(Function {
                 signature: *c,
@@ -646,11 +647,72 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         metadata: FuncMetadata,
         self_arg: Option<CallArg>,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         range: TextRange,
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
     ) -> Type {
+        self.call_overloads_with_store(
+            &AppendOnlyVec::new(),
+            overloads,
+            metadata,
+            self_arg,
+            args,
+            keywords,
+            range,
+            errors,
+            context,
+        )
+    }
+
+    fn call_overloads_with_store<'t>(
+        &self,
+        type_store: &'t AppendOnlyVec<Type>,
+        overloads: Vec1<Callable>,
+        metadata: FuncMetadata,
+        self_arg: Option<CallArg<'t>>,
+        args: &[CallArg<'t>],
+        keywords: &[CallKeyword<'t>],
+        range: TextRange,
+        errors: &ErrorCollector,
+        context: Option<&dyn Fn() -> ErrorContext>,
+    ) -> Type {
+        let type_or_expr = |x: TypeOrExpr<'t>| -> TypeOrExpr<'t> {
+            match x {
+                TypeOrExpr::Expr(e) => {
+                    let t = self.expr_infer(e, errors);
+                    let i = type_store.push(t);
+                    TypeOrExpr::Type(&type_store[i], e.range())
+                }
+                TypeOrExpr::Type(t, r) => TypeOrExpr::Type(t, r),
+            }
+        };
+        let call_arg = |x: CallArg<'t>| -> CallArg<'t> {
+            match x {
+                CallArg::Arg(x) => CallArg::Arg(type_or_expr(x)),
+                CallArg::Star(x, r) => CallArg::Star(type_or_expr(x), r),
+            }
+        };
+        let call_keyword = |x: CallKeyword<'t>| -> CallKeyword<'t> {
+            CallKeyword {
+                range: x.range,
+                arg: x.arg,
+                value: type_or_expr(x.value),
+            }
+        };
+
+        // There may be Expr values in self_arg, args and keywords.
+        // If we infer them for each overload, we may end up infering them multiple times.
+        // If those overloads contain nested overloads, then we can easily end up with O(2^n) perf.
+        // Therefore, flatten all TypeOrExpr's into Type before we start
+        let self_arg = self_arg.map(call_arg);
+        let args = args.iter().cloned().map(&call_arg).collect::<Vec<_>>();
+        let keywords = keywords
+            .iter()
+            .cloned()
+            .map(&call_keyword)
+            .collect::<Vec<_>>();
+
         let mut closest_overload: Option<CalledOverload> = None;
         for callable in overloads.iter() {
             let arg_errors = self.error_collector();
@@ -659,8 +721,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 callable.clone(),
                 Some(metadata.kind.as_func_id()),
                 self_arg.clone(),
-                args,
-                keywords,
+                &args,
+                &keywords,
                 range,
                 &arg_errors,
                 &call_errors,
@@ -802,7 +864,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             ),
             DescriptorBase::ClassDef(class) => (Type::ClassDef(class), Type::None),
         };
-        let args = [CallArg::Type(&obj, range), CallArg::Type(&objtype, range)];
+        let args = [CallArg::ty(&obj, range), CallArg::ty(&objtype, range)];
         let call_target = self.as_call_target_or_error(
             getter_method,
             CallStyle::FreeForm,
@@ -827,7 +889,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // Descriptor setters cannot be called on a class (an attempt to assign will overwrite the
         // descriptor itself rather than call the setter).
         let instance = Type::ClassType(class_type);
-        let args = [CallArg::Type(&instance, range), got];
+        let args = [CallArg::ty(&instance, range), got];
         let call_target = self.as_call_target_or_error(
             setter_method,
             CallStyle::FreeForm,
@@ -851,7 +913,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let attr_name_ty = Type::Literal(Lit::Str(attr_name.as_str().into()));
         self.call_infer(
             call_target,
-            &[CallArg::Type(&attr_name_ty, range)],
+            &[CallArg::ty(&attr_name_ty, range)],
             &[],
             range,
             errors,

{pyrefly-0.19.2 → pyrefly-0.20.0}/pyrefly/lib/alt/callable.rs

@@ -10,6 +10,7 @@ use itertools::Itertools;
 use pyrefly_util::display::count;
 use pyrefly_util::prelude::VecExt;
 use ruff_python_ast::Expr;
+use ruff_python_ast::Identifier;
 use ruff_python_ast::Keyword;
 use ruff_python_ast::name::Name;
 use ruff_text_size::Ranged;
@@ -19,6 +20,7 @@ use starlark_map::small_set::SmallSet;
 
 use crate::alt::answers::AnswersSolver;
 use crate::alt::answers::LookupAnswer;
+use crate::alt::expr::TypeOrExpr;
 use crate::alt::solve::Iterable;
 use crate::error::collector::ErrorCollector;
 use crate::error::context::ErrorContext;
@@ -37,26 +39,64 @@ use crate::types::tuple::Tuple;
 use crate::types::types::Type;
 use crate::types::types::Var;
 
+#[derive(Clone, Debug)]
+pub struct CallKeyword<'a> {
+    pub range: TextRange,
+    pub arg: Option<&'a Identifier>,
+    pub value: TypeOrExpr<'a>,
+}
+
+impl Ranged for CallKeyword<'_> {
+    fn range(&self) -> TextRange {
+        self.range
+    }
+}
+
+impl<'a> CallKeyword<'a> {
+    pub fn new(x: &'a Keyword) -> Self {
+        Self {
+            range: x.range,
+            arg: x.arg.as_ref(),
+            value: TypeOrExpr::Expr(&x.value),
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub enum CallArg<'a> {
-    /// Bundles a `Type` with a `TextRange`, allowing us to typecheck function calls
-    /// when we only know the types of the arguments but not the original expressions.
-    Type(&'a Type, TextRange),
-    Expr(&'a Expr),
-    Star(&'a Expr, TextRange),
+    Arg(TypeOrExpr<'a>),
+    Star(TypeOrExpr<'a>, TextRange),
 }
 
 impl Ranged for CallArg<'_> {
     fn range(&self) -> TextRange {
         match self {
-            Self::Type(_, r) => *r,
-            Self::Expr(e) => e.range(),
+            Self::Arg(x) => x.range(),
             Self::Star(_, r) => *r,
         }
     }
 }
 
-impl CallArg<'_> {
+impl<'a> CallArg<'a> {
+    pub fn arg(x: TypeOrExpr<'a>) -> Self {
+        Self::Arg(x)
+    }
+
+    pub fn expr(x: &'a Expr) -> Self {
+        Self::Arg(TypeOrExpr::Expr(x))
+    }
+
+    pub fn ty(ty: &'a Type, range: TextRange) -> Self {
+        Self::Arg(TypeOrExpr::Type(ty, range))
+    }
+
+    pub fn expr_maybe_starred(x: &'a Expr) -> Self {
+        match x {
+            Expr::Starred(inner) => Self::Star(TypeOrExpr::Expr(&inner.value), x.range()),
+            _ => Self::expr(x),
+        }
+    }
+
     // Splat arguments might be fixed-length tuples, which are handled precisely, or have unknown
     // length. This function evaluates splat args to determine how many params should be consumed,
     // but does not evaluate other expressions, which might be contextually typed.
@@ -66,10 +106,10 @@ impl CallArg<'_> {
         arg_errors: &ErrorCollector,
     ) -> CallArgPreEval {
         match self {
-            Self::Type(ty, _) => CallArgPreEval::Type(ty, false),
-            Self::Expr(e) => CallArgPreEval::Expr(e, false),
+            Self::Arg(TypeOrExpr::Type(ty, _)) => CallArgPreEval::Type(ty, false),
+            Self::Arg(TypeOrExpr::Expr(e)) => CallArgPreEval::Expr(e, false),
             Self::Star(e, range) => {
-                let ty = solver.expr_infer(e, arg_errors);
+                let ty = e.infer(solver, arg_errors);
                 let iterables = solver.iterate(&ty, *range, arg_errors);
                 // If we have a union of iterables, use a fixed length only if every iterable is
                 // fixed and has the same length. Otherwise, use star.
@@ -251,7 +291,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     fn is_param_spec_args(&self, x: &CallArg, q: Quantified, errors: &ErrorCollector) -> bool {
         match x {
             CallArg::Star(x, _) => {
-                let mut ty = self.expr_infer(x, errors);
+                let mut ty = x.infer(self, errors);
                 self.expand_type_mut(&mut ty);
                 ty == Type::Args(q)
             }
@@ -259,8 +299,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
-    fn is_param_spec_kwargs(&self, x: &Keyword, q: Quantified, errors: &ErrorCollector) -> bool {
-        let mut ty = self.expr_infer(&x.value, errors);
+    fn is_param_spec_kwargs(
+        &self,
+        x: &CallKeyword,
+        q: Quantified,
+        errors: &ErrorCollector,
+    ) -> bool {
+        let mut ty = x.value.infer(self, errors);
         self.expand_type_mut(&mut ty);
         ty == Type::Kwargs(q)
     }
@@ -275,7 +320,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         mut paramspec: Option<Var>,
         self_arg: Option<CallArg>,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         range: TextRange,
         arg_errors: &ErrorCollector,
         call_errors: &ErrorCollector,
@@ -561,9 +606,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         };
         let mut splat_kwargs = Vec::new();
         for kw in keywords {
-            match &kw.arg {
+            match kw.arg {
                 None => {
-                    let ty = self.expr_infer(&kw.value, arg_errors);
+                    let ty = kw.value.infer(self, arg_errors);
                     if let Type::TypedDict(typed_dict) = ty {
                         for (name, field) in self.typed_dict_fields(&typed_dict).iter() {
                             let mut hint = kwargs.as_ref().map(|(_, ty)| ty.clone());
@@ -679,11 +724,22 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         },
                         context: context.map(|ctx| ctx()),
                     };
-                    self.expr_with_separate_check_errors(
-                        &kw.value,
-                        hint.as_ref().map(|ty| (ty, tcc, call_errors)),
-                        arg_errors,
-                    );
+                    match kw.value {
+                        TypeOrExpr::Expr(x) => {
+                            self.expr_with_separate_check_errors(
+                                x,
+                                hint.as_ref().map(|ty| (ty, tcc, call_errors)),
+                                arg_errors,
+                            );
+                        }
+                        TypeOrExpr::Type(x, range) => {
+                            if let Some(hint) = &hint
+                                && !hint.is_any()
+                            {
+                                self.check_type(hint, x, range, call_errors, tcc);
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -746,7 +802,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         callable_name: Option<FuncId>,
         self_arg: Option<CallArg>,
         args: &[CallArg],
-        keywords: &[Keyword],
+        keywords: &[CallKeyword],
         range: TextRange,
         arg_errors: &ErrorCollector,
         call_errors: &ErrorCollector,