pyrefly 0.16.0__tar.gz → 0.16.1__tar.gz

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

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

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

@@ -992,9 +992,9 @@ checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
 
 [[package]]
 name = "icu_properties"
-version = "2.0.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2549ca8c7241c82f59c80ba2a6f415d931c5b58d24fb8412caa1a1f02c49139a"
+checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
 dependencies = [
  "displaydoc",
  "icu_collections",
@@ -1008,9 +1008,9 @@ dependencies = [
 
 [[package]]
 name = "icu_properties_data"
-version = "2.0.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8197e866e47b68f8f7d95249e172903bec06004b18b2937f1095d40a0c57de04"
+checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
 
 [[package]]
 name = "icu_provider"
@@ -1746,7 +1746,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.16.0"
+version = "0.16.1"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2970,9 +2970,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-core"
-version = "0.61.1"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46ec44dc15085cea82cf9c78f85a9114c463a369786585ad2882d1ff0b0acf40"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
 dependencies = [
  "windows-implement",
  "windows-interface",
@@ -3011,18 +3011,18 @@ checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
 
 [[package]]
 name = "windows-result"
-version = "0.3.3"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b895b5356fc36103d0f64dd1e94dfa7ac5633f1c9dd6e80fe9ec4adef69e09d"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
 dependencies = [
  "windows-link",
 ]
 
 [[package]]
 name = "windows-strings"
-version = "0.4.1"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a7ab927b2637c19b3dbe0965e75d8f2d30bdd697a1516191cad2ec4df8fb28a"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
 dependencies = [
  "windows-link",
 ]

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

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

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/alt/attr.rs

@@ -1187,6 +1187,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::Type(box Type::ClassType(class)) => {
                 Some(AttributeBase::ClassObject(class.class_object().dupe()))
             }
+            Type::Type(box Type::Quantified(q)) if q.is_type_var() => match q.restriction() {
+                // TODO(#119): this is wrong, because we lose the information that this is a type var
+                Restriction::Bound(bound) => {
+                    self.as_attribute_base_no_union(Type::type_form(bound.clone()))
+                }
+                _ => Some(AttributeBase::TypeVar(q)),
+            },
             Type::Type(box Type::Quantified(q)) => Some(AttributeBase::TypeVar(q)),
             Type::Type(box Type::Any(style)) => Some(AttributeBase::TypeAny(style)),
             Type::Module(module) => Some(AttributeBase::Module(module)),
@@ -1241,6 +1248,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }
             Type::SuperInstance(box (cls, obj)) => Some(AttributeBase::SuperInstance(cls, obj)),
             Type::Quantified(q) if q.is_type_var() => match q.restriction() {
+                // TODO(#119): this is wrong, because we lose the information that this is a type var
                 Restriction::Bound(bound) => self.as_attribute_base_no_union(bound.clone()),
                 // TODO: handle constraints
                 Restriction::Constraints(_) => None,

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/alt/class/class_metadata.rs

@@ -114,6 +114,17 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 let metadata = self.get_metadata_for_class(c.class_object());
                 Some((c, metadata))
             }
+            Some((Type::Tuple(Tuple::Concrete(ts)), _)) => {
+                // TODO: we lose ordering/length information when we convert to the class representation
+                let class_ty = self.stdlib.tuple(self.unions(ts));
+                let metadata = self.get_metadata_for_class(class_ty.class_object());
+                Some((class_ty, metadata))
+            }
+            Some((Type::Tuple(Tuple::Unbounded(t)), _)) => {
+                let class_ty = self.stdlib.tuple(*t);
+                let metadata = self.get_metadata_for_class(class_ty.class_object());
+                Some((class_ty, metadata))
+            }
             Some((_, range)) => {
                 self.error(
                     errors,
@@ -239,6 +250,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             Some((c, base_class_metadata))
                         }
                         Some((Type::Tuple(Tuple::Concrete(ts)), _)) => {
+                            // TODO: we lose ordering/length information when we convert to the class representation
                             let class_ty = self.stdlib.tuple(self.unions(ts));
                             let metadata = self.get_metadata_for_class(class_ty.class_object());
                             Some((class_ty, metadata))

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

@@ -76,7 +76,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let mut types = Vec::new();
         let last_index = values.len() - 1;
         for (i, value) in values.iter().enumerate() {
-            let t = self.expr_infer(value, errors);
+            let mut t = self.expr_infer(value, errors);
+            self.expand_type_mut(&mut t);
             if should_shortcircuit(&t) {
                 types.push(t);
                 break;
@@ -957,6 +958,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     Some(&|| ErrorContext::Index(self.for_display(base.clone()))),
                 ),
                 Type::Any(style) => style.propagate(),
+                Type::Literal(Lit::Bytes(bytes)) => {
+                    self.index_bytes_literal(&bytes, slice, errors, range)
+                }
                 Type::LiteralString | Type::Literal(Lit::Str(_)) if xs.len() <= 3 => {
                     // We could have a more precise type here, but this matches Pyright.
                     self.stdlib.str().clone().to_type()
@@ -1246,10 +1250,22 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                 let ty = self.expr_infer(&x.value, errors);
                                 if let Some((key_t, value_t)) = self.unwrap_mapping(&ty) {
                                     if key_t != Type::any_error() {
-                                        key_tys.push(key_t);
+                                        if let Some(key_hint) = &key_hint
+                                            && self.is_subset_eq(&key_t, key_hint)
+                                        {
+                                            key_tys.push(key_hint.clone());
+                                        } else {
+                                            key_tys.push(key_t);
+                                        }
                                     }
                                     if value_t != Type::any_error() {
-                                        value_tys.push(value_t);
+                                        if let Some(value_hint) = &value_hint
+                                            && self.is_subset_eq(&value_t, value_hint)
+                                        {
+                                            value_tys.push(value_hint.clone());
+                                        } else {
+                                            value_tys.push(value_t);
+                                        }
                                     }
                                 } else {
                                     self.error(
@@ -1586,6 +1602,39 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }
         }
     }
+
+    fn index_bytes_literal(
+        &self,
+        bytes: &[u8],
+        index_expr: &Expr,
+        errors: &ErrorCollector,
+        range: TextRange,
+    ) -> Type {
+        match index_expr {
+            // TODO: add support for negative indices case which should match `Expr::UnaryOp(...)`
+            Expr::NumberLiteral(ExprNumberLiteral { value, .. }) => {
+                if let Number::Int(int_value) = value {
+                    if let Some(byte) = bytes.get(int_value.as_usize().unwrap_or_default()) {
+                        Type::Literal(Lit::Bytes(Box::new([*byte])))
+                    } else {
+                        self.error(
+                            errors,
+                            range,
+                            ErrorKind::IndexError,
+                            None,
+                            format!(
+                                "Index {int_value} out of range bytes with {} elements",
+                                bytes.len()
+                            ),
+                        )
+                    }
+                } else {
+                    self.stdlib.bytes().clone().to_type()
+                }
+            }
+            _ => self.stdlib.bytes().clone().to_type(),
+        }
+    }
 }
 
 /// Match on an expression by name. Should be used only for special names that we essentially treat like keywords,

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/alt/narrow.rs

@@ -71,8 +71,16 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         )
     }
 
-    fn intersect(&self, left: &Type, right: &Type) -> Type {
-        // Get our best approximation of ty & right.
+    /// Get our best approximation of ty & right.
+    ///
+    /// If the intersection is empty - which does not necessarily indicate
+    /// an actual empty set because of multiple inheritance - use `fallback`
+    fn intersect_with_fallback(
+        &self,
+        left: &Type,
+        right: &Type,
+        fallback: impl Fn() -> Type,
+    ) -> Type {
         self.distribute_over_union(left, |l| {
             self.distribute_over_union(right, |r| {
                 if self.is_subset_eq(r, l) {
@@ -80,12 +88,16 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 } else if self.is_subset_eq(l, r) {
                     l.clone()
                 } else {
-                    Type::never()
+                    fallback()
                 }
             })
         })
     }
 
+    fn intersect(&self, left: &Type, right: &Type) -> Type {
+        self.intersect_with_fallback(left, right, Type::never)
+    }
+
     fn intersects(&self, ts: &[Type]) -> Type {
         match ts {
             [] => Type::ClassType(self.stdlib.object().clone()),
@@ -141,7 +153,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         if let Some(ts) = right.as_decomposed_tuple_or_union() {
             self.unions(ts.iter().map(|t| self.narrow_isinstance(left, t)).collect())
         } else if let Some(right) = self.unwrap_class_object_silently(right) {
-            self.intersect(left, &right)
+            self.intersect_with_fallback(left, &right, || right.clone())
         } else {
             left.clone()
         }

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/alt/solve.rs

@@ -431,7 +431,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         ErrorKind::InvalidAnnotation,
                         None,
                         format!(
-                            "Expected 1 type argument for {}, got {}",
+                            "Expected 1 type argument for `{}`, got {}",
                             qualifier,
                             unpacked_slice.len()
                         ),
@@ -764,7 +764,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 range,
                 ErrorKind::TypeAliasError,
                 None,
-                format!("Expected `{name}` to be a type alias, got {ty}"),
+                format!("Expected `{name}` to be a type alias, got `{ty}`"),
             );
             return Type::any_error();
         };
@@ -1590,7 +1590,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             subscript.range(),
                             ErrorKind::BadAssignment,
                             None,
-                            format!("Expected {}, got {}", field.ty, value),
+                            format!("Expected `{}`, got `{}`", field.ty, value),
                         )
                     } else {
                         Type::None
@@ -1781,7 +1781,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                     ErrorKind::MatchError,
                                     Some(&context),
                                     format!(
-                                        "Expected literal string in `__match_args__`, got {}",
+                                        "Expected literal string in `__match_args__`, got `{}`",
                                         ts[*idx]
                                     ),
                                 )
@@ -1803,7 +1803,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         ErrorKind::MatchError,
                         Some(&context),
                         format!(
-                            "Expected concrete tuple for `__match_args__`, got {}",
+                            "Expected concrete tuple for `__match_args__`, got `{}`",
                             match_args
                         ),
                     ),
@@ -2277,6 +2277,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             },
             Binding::Type(x) => x.clone(),
             Binding::StrType => self.stdlib.str().clone().to_type(),
+            Binding::BoolType => self.stdlib.bool().clone().to_type(),
             Binding::TypeParameter(box TypeParameter {
                 name,
                 unique,

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/alt/special_calls.rs

@@ -100,7 +100,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         if args.len() == 1 {
             let mut type_info = self.expr_infer_type_info(&args[0], errors);
             type_info.visit_mut(&mut |ty| {
-                *ty = self.for_display(self.solver().deep_force(ty.clone()));
+                *ty = self.for_display(self.solver().expand(ty.clone()));
             });
             self.error(
                 errors,

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/alt/unwrap.rs

@@ -19,10 +19,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         self.solver().fresh_unwrap(self.uniques)
     }
 
-    fn expand_var_opt(&self, var: Var) -> Option<Type> {
+    /// Resolve a var to a type, but only if it was pinned by the subtype
+    /// check we just ran. If it was not, return `None`.
+    fn resolve_var_opt(&self, ty: &Type, var: Var) -> Option<Type> {
+        let res = self.resolve_var(ty, var);
         // TODO: Really want to check if the Var is constrained in any way.
         // No way to do that currently, but this is close.
-        let res = self.expand_var(var);
         if matches!(res, Type::Var(..)) {
             None
         } else {
@@ -30,8 +32,35 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
-    fn expand_var(&self, var: Var) -> Type {
-        self.solver().expand(var.to_type())
+    /// Resolve a var to a type. This function assumes that the caller has just
+    /// run a successful subtype check of `ty` against a type we are trying to
+    /// decompose (for example `Awaitable[_]` or `Iterable[_]`).
+    ///
+    /// It is an error to call this if the subtype check failed. If the subtype
+    /// check succeeded, in most cases the solver will have pinned the Var to
+    /// the correct type argument.
+    ///
+    /// One tricky issue is that there are some scenarios where a subtype
+    /// check can pass without pinning vars; this function needs to handle
+    /// those as edge cases.
+    ///
+    /// As an example of how this works, if `x` is `CustomSubtypeOfAwaitable[int]`,
+    /// we will synthesize an `Awaitable[@v]` and when we do a subtype check of
+    /// `x`, the solver will pin `@v` to `int` and we will use that.
+    ///
+    /// Special cases we handle thus far (there may be bugs where we need more):
+    /// - if `ty` is `Any`, the stubtype check passes without pinning, and the
+    ///   right thing to do is propagate the `Any`, preserving its `AnyStyle`.
+    /// - TODO: if `ty` is bottom (`Never` or `NoReturn`), the subtype check
+    ///   will pass and we should propagate the type.
+    /// - TODO: all edge cases probably need to also be handled when they are
+    ///   the first entry in a union.
+    fn resolve_var(&self, ty: &Type, var: Var) -> Type {
+        match ty {
+            Type::Any(style) => Type::Any(*style),
+            Type::Never(style) => Type::Never(*style),
+            _ => self.solver().expand(var.to_type()),
+        }
     }
 
     pub fn is_async_generator(&self, ty: &Type) -> bool {
@@ -54,7 +83,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .mapping(key.to_type(), value.to_type())
             .to_type();
         if self.is_subset_eq(ty, &dict_type) {
-            Some((self.expand_var(key), self.expand_var(value)))
+            Some((self.resolve_var(ty, key), self.resolve_var(ty, value)))
         } else {
             None
         }
@@ -64,7 +93,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let var = self.fresh_var();
         let awaitable_ty = self.stdlib.awaitable(var.to_type()).to_type();
         if self.is_subset_eq(ty, &awaitable_ty) {
-            Some(self.expand_var(var))
+            Some(self.resolve_var(ty, var))
         } else {
             None
         }
@@ -79,9 +108,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .generator(yield_ty.to_type(), send_ty.to_type(), return_ty.to_type())
             .to_type();
         if self.is_subset_eq(ty, &generator_ty) {
-            let yield_ty: Type = self.expand_var(yield_ty);
-            let send_ty = self.expand_var(send_ty);
-            let return_ty = self.expand_var(return_ty);
+            let yield_ty: Type = self.resolve_var(ty, yield_ty);
+            let send_ty = self.resolve_var(ty, send_ty);
+            let return_ty = self.resolve_var(ty, return_ty);
             Some((yield_ty, send_ty, return_ty))
         } else {
             None
@@ -92,7 +121,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let iter_ty = self.fresh_var();
         let iterable_ty = self.stdlib.iterable(iter_ty.to_type()).to_type();
         if self.is_subset_eq(ty, &iterable_ty) {
-            Some(self.expand_var(iter_ty))
+            Some(self.resolve_var(ty, iter_ty))
         } else {
             None
         }
@@ -102,7 +131,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let iter_ty = self.fresh_var();
         let iterable_ty = self.stdlib.async_iterable(iter_ty.to_type()).to_type();
         if self.is_subset_eq(ty, &iterable_ty) {
-            Some(self.expand_var(iter_ty))
+            Some(self.resolve_var(ty, iter_ty))
         } else {
             None
         }
@@ -113,8 +142,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let value = self.fresh_var();
         let dict_type = self.stdlib.dict(key.to_type(), value.to_type()).to_type();
         if self.is_subset_eq(&dict_type, ty) {
-            let key = self.expand_var_opt(key);
-            let value = self.expand_var_opt(value);
+            let key = self.resolve_var_opt(ty, key);
+            let value = self.resolve_var_opt(ty, value);
             (key, value)
         } else {
             (None, None)
@@ -125,7 +154,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let elem = self.fresh_var();
         let set_type = self.stdlib.set(elem.to_type()).to_type();
         if self.is_subset_eq(&set_type, ty) {
-            self.expand_var_opt(elem)
+            self.resolve_var_opt(ty, elem)
         } else {
             None
         }
@@ -135,7 +164,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let elem = self.fresh_var();
         let list_type = self.stdlib.list(elem.to_type()).to_type();
         if self.is_subset_eq(&list_type, ty) {
-            self.expand_var_opt(elem)
+            self.resolve_var_opt(ty, elem)
         } else {
             None
         }
@@ -150,7 +179,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let callable_ty = Type::callable(params, return_ty.to_type());
 
         if self.is_subset_eq(&callable_ty, ty) {
-            self.expand_var_opt(return_ty)
+            self.resolve_var_opt(ty, return_ty)
         } else {
             None
         }
@@ -167,7 +196,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             )
             .to_type();
         if self.is_subset_eq(&generator_ty, ty) {
-            self.expand_var_opt(yield_ty)
+            self.resolve_var_opt(ty, yield_ty)
         } else {
             None
         }
@@ -182,16 +211,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .generator(yield_ty.to_type(), send_ty.to_type(), return_ty.to_type())
             .to_type();
         if self.is_subset_eq(&generator_ty, ty) {
-            let yield_ty: Type = self.expand_var_opt(yield_ty)?;
-            let send_ty = self.expand_var_opt(send_ty).unwrap_or(Type::None);
-            let return_ty = self.expand_var_opt(return_ty).unwrap_or(Type::None);
+            let yield_ty: Type = self.resolve_var_opt(ty, yield_ty)?;
+            let send_ty = self.resolve_var_opt(ty, send_ty).unwrap_or(Type::None);
+            let return_ty = self.resolve_var_opt(ty, return_ty).unwrap_or(Type::None);
             Some((yield_ty, send_ty, return_ty))
-        } else if ty.is_any() {
-            Some((
-                Type::any_explicit(),
-                Type::any_explicit(),
-                Type::any_explicit(),
-            ))
         } else {
             None
         }
@@ -205,8 +228,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .async_generator(yield_ty.to_type(), send_ty.to_type())
             .to_type();
         if self.is_subset_eq(&async_generator_ty, ty) {
-            let yield_ty: Type = self.expand_var_opt(yield_ty)?;
-            let send_ty = self.expand_var_opt(send_ty).unwrap_or(Type::None);
+            let yield_ty: Type = self.resolve_var_opt(ty, yield_ty)?;
+            let send_ty = self.resolve_var_opt(ty, send_ty).unwrap_or(Type::None);
             Some((yield_ty, send_ty))
         } else if ty.is_any() {
             Some((Type::any_explicit(), Type::any_explicit()))

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/binding/binding.rs

@@ -729,6 +729,8 @@ pub enum Binding {
     Type(Type),
     /// The str type.
     StrType,
+    /// The bool type.
+    BoolType,
     /// A type parameter.
     TypeParameter(Box<TypeParameter>),
     /// The type of a function. The fields are:
@@ -869,6 +871,7 @@ impl DisplayWith<Bindings> for Binding {
             Self::AugAssign(_, s) => write!(f, "augmented_assign {:?}", s),
             Self::Type(t) => write!(f, "type {t}"),
             Self::StrType => write!(f, "strtype"),
+            Self::BoolType => write!(f, "booltype"),
             Self::TypeParameter(box TypeParameter { unique, kind, .. }) => {
                 write!(f, "type_parameter({unique}, {kind})")
             }

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/binding/bindings.rs

@@ -21,6 +21,7 @@ use ruff_python_ast::ExprName;
 use ruff_python_ast::ExprYield;
 use ruff_python_ast::ExprYieldFrom;
 use ruff_python_ast::Identifier;
+use ruff_python_ast::ModModule;
 use ruff_python_ast::Stmt;
 use ruff_python_ast::StmtReturn;
 use ruff_python_ast::TypeParam;
@@ -78,6 +79,7 @@ use crate::graph::index_map::IndexMap;
 use crate::module::module_info::ModuleInfo;
 use crate::module::module_name::ModuleName;
 use crate::module::short_identifier::ShortIdentifier;
+use crate::ruff::ast::Ast;
 use crate::solver::solver::Solver;
 use crate::state::loader::FindError;
 use crate::sys_info::SysInfo;
@@ -138,6 +140,7 @@ pub struct BindingsBuilder<'a> {
     errors: &'a ErrorCollector,
     solver: &'a Solver,
     uniques: &'a UniqueFactory,
+    pub has_docstring: bool,
     pub scopes: Scopes,
     pub function_yields_and_returns: Vec1<FuncYieldsAndReturns>,
     pub table: BindingTable,
@@ -287,8 +290,7 @@ impl Bindings {
     }
 
     pub fn new(
-        module_scope_range: TextRange,
-        x: Vec<Stmt>,
+        x: ModModule,
         module_info: ModuleInfo,
         exports: Exports,
         solver: &Solver,
@@ -308,16 +310,17 @@ impl Bindings {
             uniques,
             loop_depth: 0,
             class_count: 0,
-            scopes: Scopes::module(module_scope_range, enable_trace),
+            has_docstring: Ast::has_docstring(&x),
+            scopes: Scopes::module(x.range, enable_trace),
             function_yields_and_returns: Vec1::new(FuncYieldsAndReturns::default()),
             table: Default::default(),
             untyped_def_behavior,
         };
-        builder.init_static_scope(&x, true);
+        builder.init_static_scope(&x.body, true);
         if module_info.name() != ModuleName::builtins() {
             builder.inject_builtins();
         }
-        builder.stmts(x);
+        builder.stmts(x.body);
         // Create dummy bindings for any invalid yield/yield from expressions.
         let (top_level_yields_and_returns, _) =
             builder.function_yields_and_returns.split_off_first();
@@ -1026,6 +1029,7 @@ impl<'a> BindingsBuilder<'a> {
 
         // We normally go through the visible branches, but if nothing is visible no one is going to
         // fill in the Phi keys we promised. So just give up and use the hidden branches instead.
+        let no_next = visible_branches.is_empty();
         if visible_branches.is_empty() {
             visible_branches = hidden_branches;
         }
@@ -1080,10 +1084,7 @@ impl<'a> BindingsBuilder<'a> {
                 },
             );
         }
-        Flow {
-            info: res,
-            no_next: false,
-        }
+        Flow { info: res, no_next }
     }
 
     fn merge_loop_into_current(&mut self, mut branches: Vec<Flow>, range: TextRange) {

{pyrefly-0.16.0 → pyrefly-0.16.1}/pyrefly/lib/binding/class.rs

@@ -166,7 +166,7 @@ impl<'a> BindingsBuilder<'a> {
 
         let last_scope = self.scopes.pop();
         self.scopes.pop(); // annotation scope
-        let mut fields = SmallMap::with_capacity(last_scope.stat.0.len());
+        let mut fields_defined_in_this_class = SmallMap::with_capacity(last_scope.stat.0.len());
         for (name, info) in last_scope.flow.info.iter_hashed() {
             let is_function_without_return_annotation =
                 if let FlowStyle::FunctionDef(_, has_return_annotation) = info.style {
@@ -191,7 +191,7 @@ impl<'a> BindingsBuilder<'a> {
                     initial_value,
                     is_function_without_return_annotation,
                 };
-                fields.insert_hashed(
+                fields_defined_in_this_class.insert_hashed(
                     name.cloned(),
                     ClassFieldProperties::new(stat_info.annot.is_some(), stat_info.loc),
                 );
@@ -209,14 +209,14 @@ impl<'a> BindingsBuilder<'a> {
                 InstanceAttribute(value, annotation, range),
             ) in body.method_defined_attributes()
             {
-                if !fields.contains_key_hashed(name.as_ref()) {
+                if !fields_defined_in_this_class.contains_key_hashed(name.as_ref()) {
                     if !recognized_attribute_defining_method {
                         self.error(
                         range,
                         format!("Attribute `{}` is implicitly defined by assignment in method `{method_name}`, which is not a constructor", &name),
                         ErrorKind::ImplicitlyDefinedAttribute)
                     }
-                    fields.insert_hashed(
+                    fields_defined_in_this_class.insert_hashed(
                         name.clone(),
                         ClassFieldProperties::new(annotation.is_some(), range),
                     );
@@ -249,13 +249,13 @@ impl<'a> BindingsBuilder<'a> {
             Binding::ClassDef(definition_key, decorators.into_boxed_slice()),
             FlowStyle::None,
         );
-        fields.reserve(0); // Attempt to shrink to capacity
+        fields_defined_in_this_class.reserve(0); // Attempt to shrink to capacity
         self.table.insert_idx(
             definition_key,
             BindingClass::ClassDef(ClassBinding {
                 index: class_index,
                 def: x,
-                fields,
+                fields: fields_defined_in_this_class,
                 bases: bases.into_boxed_slice(),
                 legacy_tparams: legacy_tparams.into_boxed_slice(),
             }),