pyrefly 0.15.2__tar.gz → 0.16.0__tar.gz

{pyrefly-0.15.2 → pyrefly-0.16.0}/PKG-INFO

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

{pyrefly-0.15.2 → pyrefly-0.16.0}/pyrefly/Cargo.lock

@@ -296,9 +296,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.22"
+version = "1.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32db95edf998450acc7881c932f94cd9b05c87b4b2599e8bab064753da4acfd1"
+checksum = "5f4ac86a9e5bc1e2b3449ab9d7d3a6a405e3d1bb28d7b9be8614f55846ae3766"
 dependencies = [
  "jobserver",
  "libc",
@@ -1746,7 +1746,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.15.2"
+version = "0.16.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2970,9 +2970,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-core"
-version = "0.61.0"
+version = "0.61.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
+checksum = "46ec44dc15085cea82cf9c78f85a9114c463a369786585ad2882d1ff0b0acf40"
 dependencies = [
  "windows-implement",
  "windows-interface",
@@ -3011,18 +3011,18 @@ checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
 
 [[package]]
 name = "windows-result"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
+checksum = "4b895b5356fc36103d0f64dd1e94dfa7ac5633f1c9dd6e80fe9ec4adef69e09d"
 dependencies = [
  "windows-link",
 ]
 
 [[package]]
 name = "windows-strings"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
+checksum = "2a7ab927b2637c19b3dbe0965e75d8f2d30bdd697a1516191cad2ec4df8fb28a"
 dependencies = [
  "windows-link",
 ]

{pyrefly-0.15.2 → pyrefly-0.16.0}/pyrefly/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.15.2"
+version = "0.16.0"
 authors = ["Meta"]
 edition = "2021"
 repository = "https://github.com/facebook/pyrefly"
@@ -92,5 +92,9 @@ zstd = { version = "0.13", features = ["experimental", "zstdmt"] }
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 zstd = "0.13"
 
+[profile.release]
+lto = true
+codegen-units = 1
+
 [lints]
 rust = { unexpected_cfgs = { check-cfg = ["cfg(fbcode_build)"], level = "warn" } }

{pyrefly-0.15.2 → pyrefly-0.16.0}/pyrefly/lib/alt/class/classdef.rs

@@ -94,7 +94,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         self.get_from_class(cls, &KeyClassMetadata(cls.index()))
     }
 
-    fn get_enum_from_class(&self, cls: &Class) -> Option<EnumMetadata> {
+    pub fn get_enum_from_class(&self, cls: &Class) -> Option<EnumMetadata> {
         self.get_metadata_for_class(cls).enum_metadata().cloned()
     }
 

{pyrefly-0.15.2 → pyrefly-0.16.0}/pyrefly/lib/alt/expr.rs

@@ -911,6 +911,26 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         ),
                     }
                 }
+                Type::ClassDef(ref cls)
+                    if let Expr::StringLiteral(ExprStringLiteral { value: key, .. }) = slice
+                        && self.get_enum_from_class(cls).is_some() =>
+                {
+                    if let Some(member) = self.get_enum_member(cls, &Name::new(key.to_str())) {
+                        Type::Literal(member)
+                    } else {
+                        self.error(
+                            errors,
+                            slice.range(),
+                            ErrorKind::IndexError,
+                            None,
+                            format!(
+                                "Enum `{}` does not have a member named `{}`",
+                                cls.name(),
+                                key.to_str()
+                            ),
+                        )
+                    }
+                }
                 Type::ClassDef(cls) => Type::type_form(self.specialize(
                     &cls,
                     xs.map(|x| self.expr_untype(x, TypeFormContext::TypeArgument, errors)),
@@ -1215,14 +1235,22 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                     value_hint.as_ref(),
                                     errors,
                                 );
-                                key_tys.push(key_t);
-                                value_tys.push(value_t);
+                                if key_t != Type::any_error() {
+                                    key_tys.push(key_t);
+                                }
+                                if value_t != Type::any_error() {
+                                    value_tys.push(value_t);
+                                }
                             }
                             None => {
                                 let ty = self.expr_infer(&x.value, errors);
-                                if let Some((key_ty, value_ty)) = self.unwrap_mapping(&ty) {
-                                    key_tys.push(key_ty);
-                                    value_tys.push(value_ty);
+                                if let Some((key_t, value_t)) = self.unwrap_mapping(&ty) {
+                                    if key_t != Type::any_error() {
+                                        key_tys.push(key_t);
+                                    }
+                                    if value_t != Type::any_error() {
+                                        value_tys.push(value_t);
+                                    }
                                 } else {
                                     self.error(
                                         errors,
@@ -1234,6 +1262,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                 }
                             }
                         });
+                        if key_tys.is_empty() {
+                            key_tys.push(Type::any_error())
+                        }
+                        if value_tys.is_empty() {
+                            value_tys.push(Type::any_error())
+                        }
                         let key_ty = self.unions(key_tys);
                         let value_ty = self.unions(value_tys);
                         self.stdlib.dict(key_ty, value_ty).to_type()

{pyrefly-0.15.2 → pyrefly-0.16.0}/pyrefly/lib/binding/narrow.rs

@@ -149,11 +149,23 @@ impl AtomicNarrowOp {
 }
 
 #[derive(Clone, Debug)]
-enum NarrowingSubject {
+pub enum NarrowingSubject {
     Name(Name),
     Property(Name, PropertyChain),
 }
 
+impl NarrowingSubject {
+    pub fn with_property(&self, prop: PropertyKind) -> Self {
+        match self {
+            Self::Name(name) => Self::Property(name.clone(), PropertyChain::new(Vec1::new(prop))),
+            Self::Property(name, props) => {
+                let props = Vec1::from_vec_push(props.properties().to_vec(), prop);
+                Self::Property(name.clone(), PropertyChain::new(props))
+            }
+        }
+    }
+}
+
 impl NarrowOp {
     pub fn negate(&self) -> Self {
         match self {
@@ -228,21 +240,41 @@ impl NarrowOps {
     pub fn from_single_narrow_op(left: &Expr, op: AtomicNarrowOp, range: TextRange) -> Self {
         let mut narrow_ops = Self::new();
         for subject in expr_to_subjects(left) {
-            let (name, attr) = match subject {
+            let (name, prop) = match subject {
                 NarrowingSubject::Name(name) => (name, None),
-                NarrowingSubject::Property(name, attr) => (name, Some(attr)),
+                NarrowingSubject::Property(name, prop) => (name, Some(prop)),
             };
             if let Some((existing, _)) = narrow_ops.0.get_mut(&name) {
-                existing.and(NarrowOp::Atomic(attr, op.clone()));
+                existing.and(NarrowOp::Atomic(prop, op.clone()));
             } else {
                 narrow_ops
                     .0
-                    .insert(name, (NarrowOp::Atomic(attr, op.clone()), range));
+                    .insert(name, (NarrowOp::Atomic(prop, op.clone()), range));
             }
         }
         narrow_ops
     }
 
+    pub fn from_single_narrow_op_for_subject(
+        subject: NarrowingSubject,
+        op: AtomicNarrowOp,
+        range: TextRange,
+    ) -> Self {
+        let mut narrow_ops = Self::new();
+        let (name, prop) = match subject {
+            NarrowingSubject::Name(name) => (name, None),
+            NarrowingSubject::Property(name, prop) => (name, Some(prop)),
+        };
+        if let Some((existing, _)) = narrow_ops.0.get_mut(&name) {
+            existing.and(NarrowOp::Atomic(prop, op.clone()));
+        } else {
+            narrow_ops
+                .0
+                .insert(name, (NarrowOp::Atomic(prop, op.clone()), range));
+        }
+        narrow_ops
+    }
+
     pub fn from_expr(builder: &BindingsBuilder, test: Option<&Expr>) -> Self {
         match test {
             Some(Expr::Compare(ExprCompare {
@@ -515,7 +547,7 @@ fn subject_for_property(expr: &Expr) -> Option<NarrowingSubject> {
         .map(|(identifier, attr)| NarrowingSubject::Property(identifier.id, attr))
 }
 
-fn expr_to_subjects(expr: &Expr) -> Vec<NarrowingSubject> {
+pub fn expr_to_subjects(expr: &Expr) -> Vec<NarrowingSubject> {
     fn f(expr: &Expr, res: &mut Vec<NarrowingSubject>) {
         match expr {
             Expr::Name(name) => res.push(NarrowingSubject::Name(name.id.clone())),
@@ -527,7 +559,6 @@ fn expr_to_subjects(expr: &Expr) -> Vec<NarrowingSubject> {
             _ => {}
         }
     }
-
     let mut res = Vec::new();
     f(expr, &mut res);
     res

{pyrefly-0.15.2 → pyrefly-0.16.0}/pyrefly/lib/binding/pattern.rs

@@ -8,8 +8,7 @@
 use std::mem;
 
 use ruff_python_ast::Expr;
-use ruff_python_ast::ExprContext;
-use ruff_python_ast::ExprName;
+use ruff_python_ast::ExprStringLiteral;
 use ruff_python_ast::Pattern;
 use ruff_python_ast::PatternKeyword;
 use ruff_python_ast::StmtMatch;
@@ -24,6 +23,9 @@ use crate::binding::binding::UnpackedPosition;
 use crate::binding::bindings::BindingsBuilder;
 use crate::binding::narrow::AtomicNarrowOp;
 use crate::binding::narrow::NarrowOps;
+use crate::binding::narrow::NarrowingSubject;
+use crate::binding::narrow::PropertyKind;
+use crate::binding::narrow::expr_to_subjects;
 use crate::binding::scope::FlowStyle;
 use crate::error::kind::ErrorKind;
 use crate::graph::index::Idx;
@@ -33,7 +35,7 @@ impl<'a> BindingsBuilder<'a> {
     // Traverse a pattern and bind all the names; key is the reference for the value that's being matched on
     fn bind_pattern(
         &mut self,
-        match_subject: Option<&Expr>,
+        match_subject: Option<NarrowingSubject>,
         pattern: Pattern,
         key: Idx<Key>,
     ) -> NarrowOps {
@@ -41,7 +43,7 @@ impl<'a> BindingsBuilder<'a> {
             Pattern::MatchValue(mut p) => {
                 self.ensure_expr(&mut p.value);
                 if let Some(subject) = match_subject {
-                    NarrowOps::from_single_narrow_op(
+                    NarrowOps::from_single_narrow_op_for_subject(
                         subject,
                         AtomicNarrowOp::Eq((*p.value).clone()),
                         p.range(),
@@ -53,7 +55,11 @@ impl<'a> BindingsBuilder<'a> {
             Pattern::MatchSingleton(p) => {
                 let value = Ast::pattern_match_singleton_to_expr(&p);
                 if let Some(subject) = match_subject {
-                    NarrowOps::from_single_narrow_op(subject, AtomicNarrowOp::Is(value), p.range())
+                    NarrowOps::from_single_narrow_op_for_subject(
+                        subject,
+                        AtomicNarrowOp::Is(value),
+                        p.range(),
+                    )
                 } else {
                     NarrowOps::new()
                 }
@@ -61,17 +67,13 @@ impl<'a> BindingsBuilder<'a> {
             Pattern::MatchAs(p) => {
                 // If there's no name for this pattern, refine the variable being matched
                 // If there is a new name, refine that instead
-                let mut subject = match_subject.cloned();
+                let mut subject = match_subject;
                 if let Some(name) = &p.name {
                     self.bind_definition(name, Binding::Forward(key), FlowStyle::None);
-                    subject = Some(Expr::Name(ExprName {
-                        id: name.id.clone(),
-                        range: name.range(),
-                        ctx: ExprContext::Store,
-                    }));
+                    subject = Some(NarrowingSubject::Name(name.id.clone()));
                 };
                 if let Some(box pattern) = p.pattern {
-                    self.bind_pattern(subject.as_ref(), pattern, key)
+                    self.bind_pattern(subject, pattern, key)
                 } else {
                     NarrowOps::new()
                 }
@@ -124,11 +126,26 @@ impl<'a> BindingsBuilder<'a> {
                     .into_iter()
                     .zip(x.patterns)
                     .for_each(|(key_expr, pattern)| {
-                        let mapping_key = self.table.insert(
+                        let key_name = match &key_expr {
+                            Expr::StringLiteral(ExprStringLiteral { value: key, .. }) => {
+                                Some(key.to_string())
+                            }
+                            _ => None,
+                        };
+                        let subject_for_key = key_name.and_then(|key| {
+                            match_subject
+                                .clone()
+                                .map(|s| s.with_property(PropertyKind::Key(key)))
+                        });
+                        let binding_for_key = self.table.insert(
                             Key::Anon(key_expr.range()),
                             Binding::PatternMatchMapping(key_expr, key),
                         );
-                        narrow_ops.and_all(self.bind_pattern(None, pattern, mapping_key))
+                        narrow_ops.and_all(self.bind_pattern(
+                            subject_for_key,
+                            pattern,
+                            binding_for_key,
+                        ))
                     });
                 if let Some(rest) = x.rest {
                     self.bind_definition(&rest, Binding::Forward(key), FlowStyle::None);
@@ -138,7 +155,7 @@ impl<'a> BindingsBuilder<'a> {
             Pattern::MatchClass(mut x) => {
                 self.ensure_expr(&mut x.cls);
                 let mut narrow_ops = if let Some(subject) = match_subject {
-                    NarrowOps::from_single_narrow_op(
+                    NarrowOps::from_single_narrow_op_for_subject(
                         subject,
                         AtomicNarrowOp::IsInstance((*x.cls).clone()),
                         x.cls.range(),
@@ -192,7 +209,7 @@ impl<'a> BindingsBuilder<'a> {
                         )
                     }
                     let mut base = self.scopes.current().flow.clone();
-                    let new_narrow_ops = self.bind_pattern(match_subject, pattern, key);
+                    let new_narrow_ops = self.bind_pattern(match_subject.clone(), pattern, key);
                     if let Some(ref mut ops) = narrow_ops {
                         ops.or_all(new_narrow_ops)
                     } else {
@@ -210,7 +227,7 @@ impl<'a> BindingsBuilder<'a> {
 
     pub fn stmt_match(&mut self, mut x: StmtMatch) {
         self.ensure_expr(&mut x.subject);
-        let match_subject = Some(&*x.subject);
+        let match_subject = *x.subject.clone();
         let key = self.table.insert(
             Key::Anon(x.subject.range()),
             Binding::Expr(None, *x.subject.clone()),
@@ -232,7 +249,8 @@ impl<'a> BindingsBuilder<'a> {
             if case.pattern.is_wildcard() || case.pattern.is_irrefutable() {
                 exhaustive = true;
             }
-            let new_narrow_ops = self.bind_pattern(match_subject, case.pattern, key);
+            let match_narrowing_subject = expr_to_subjects(&match_subject).first().cloned();
+            let new_narrow_ops = self.bind_pattern(match_narrowing_subject, case.pattern, key);
             self.bind_narrow_ops(&negated_prev_ops, case.range);
             self.bind_narrow_ops(&new_narrow_ops, case.range);
             negated_prev_ops.and_all(new_narrow_ops.negate());