pyrefly 0.16.1__tar.gz → 0.16.2__tar.gz

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

@@ -140,12 +140,12 @@ dependencies = [
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.7"
+version = "3.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+checksum = "6680de5231bd6ee4c6191b8a1325daa282b415391ec9d3a37bd34f2060dc73fa"
 dependencies = [
  "anstyle",
- "once_cell",
+ "once_cell_polyfill",
  "windows-sys 0.59.0",
 ]
 
@@ -848,8 +848,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -1488,6 +1490,12 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
+
 [[package]]
 name = "os_str_bytes"
 version = "6.6.1"
@@ -1746,7 +1754,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.16.1"
+version = "0.16.2"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1818,6 +1826,21 @@ dependencies = [
  "syn 2.0.101",
 ]
 
+[[package]]
+name = "pyrefly_wasm"
+version = "0.0.0"
+dependencies = [
+ "dupe",
+ "getrandom 0.2.16",
+ "pyrefly",
+ "serde",
+ "serde-wasm-bindgen",
+ "starlark_map",
+ "tar",
+ "wasm-bindgen",
+ "zstd",
+]
+
 [[package]]
 name = "quickcheck"
 version = "1.0.3"
@@ -2069,9 +2092,9 @@ dependencies = [
 
 [[package]]
 name = "rustversion"
-version = "1.0.20"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
 
 [[package]]
 name = "ryu"
@@ -2109,6 +2132,17 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-wasm-bindgen"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3b143e2833c57ab9ad3ea280d21fd34e285a42837aeb0ee301f4f41890fa00e"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "serde_bser"
 version = "0.4.0"

pyrefly-0.16.2/Cargo.toml

@@ -0,0 +1,11 @@
+[workspace]
+members = ["pyrefly", "pyrefly_derive"]
+resolver = "2"
+
+[workspace.package]
+license = "MIT"
+repository = "https://github.com/facebook/pyrefly"
+
+[profile.release]
+lto = true
+codegen-units = 1

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

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

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

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly"
-version = "0.16.1"
+version = "0.16.2"
 authors = ["Meta"]
 edition = "2021"
 repository = "https://github.com/facebook/pyrefly"
@@ -92,9 +92,5 @@ 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.16.1 → pyrefly-0.16.2}/pyrefly/lib/alt/attr.rs

@@ -1545,3 +1545,42 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         res
     }
 }
+
+impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
+    // When coercing an instance of condition_type to bool, check that either it does not override
+    // __bool__, or that condition_type.__bool__ is callable.
+    pub fn check_dunder_bool_is_callable(
+        &self,
+        condition_type: &Type,
+        range: TextRange,
+        errors: &ErrorCollector,
+    ) {
+        let cond_bool_ty = self.type_of_magic_dunder_attr(
+            condition_type,
+            &dunder::BOOL,
+            range,
+            errors,
+            None,
+            "__bool__",
+        );
+
+        // test::narrow::test_walrus_value is an example of a valid union type that
+        // as_call_target() does not handle.
+        if let Some(ty) = cond_bool_ty
+            && !matches!(ty, Type::Union(_) | Type::Never(_))
+            && self.as_call_target(ty.clone()).is_none()
+        {
+            self.error(
+                errors,
+                range,
+                ErrorKind::InvalidArgument,
+                None,
+                format!(
+                    "`{}.__bool__` has type `{}`, which is not callable",
+                    self.for_display(condition_type.clone()),
+                    self.for_display(ty.clone()),
+                ),
+            );
+        }
+    }
+}

{pyrefly-0.16.1 → pyrefly-0.16.2}/pyrefly/lib/alt/call.rs

@@ -458,6 +458,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         Type::TypedDict(typed_dict)
     }
 
+    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::Star(..) => None,
+            }
+        } else {
+            None
+        }
+    }
+
     pub fn call_infer(
         &self,
         call_target: CallTarget,
@@ -491,6 +503,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         ),
                     );
                 }
+                if cls.has_qname("builtins", "bool") {
+                    match self.first_arg_type(args, errors) {
+                        None => (),
+                        Some(ty) => self.check_dunder_bool_is_callable(&ty, range, errors),
+                    }
+                };
                 self.construct_class(cls, args, keywords, range, errors, context)
             }
             Target::TypedDict(td) => {
@@ -520,14 +538,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 // Most instances of typing.Self are replaced in as_call_target, but __new__ is a
                 // staticmethod, so we don't have access to the first argument until we get here.
                 let id = metadata.kind.as_func_id();
-                let first_arg_type = if id.func == dunder::NEW
-                    && 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::Star(..) => None,
-                    }
+                let first_arg_type = if id.func == dunder::NEW {
+                    self.first_arg_type(args, errors)
                 } else {
                     None
                 };

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

@@ -40,7 +40,7 @@ use crate::types::class::ClassType;
 use crate::types::literal::Lit;
 use crate::types::special_form::SpecialForm;
 use crate::types::tuple::Tuple;
-use crate::types::type_var::Variance;
+use crate::types::types::AnyStyle;
 use crate::types::types::CalleeKind;
 use crate::types::types::TParamInfo;
 use crate::types::types::TParams;
@@ -174,6 +174,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             None
         };
         let mut has_base_any = false;
+        let mut has_generic_base_class = false;
         let bases_with_metadata = bases
             .iter()
             .filter_map(|x| {
@@ -186,6 +187,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     BaseClass::CollectionsNamedTuple(range) => {
                         Some((self.stdlib.named_tuple_fallback().clone().to_type(), *range))
                     }
+                    BaseClass::Generic(ts) | BaseClass::Protocol(ts) if !ts.is_empty() => {
+                        has_generic_base_class = true;
+                        None
+                    }
                     _ => None,
                 };
                 if is_new_type {
@@ -420,6 +425,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         } else {
             bases_with_metadata
         };
+        // We didn't find any type parameters for this class, but it may have ones we don't know about if:
+        // - the class inherits from Any, or
+        // - the class inherits from Generic[...] or Protocol [...]. We probably dropped the type
+        //   arguments because we found an error in them.
+        let has_unknown_tparams =
+            cls.tparams().is_empty() && (has_base_any || has_generic_base_class);
         ClassMetadata::new(
             cls,
             bases_with_metadata,
@@ -433,6 +444,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             has_base_any,
             is_new_type,
             is_final,
+            has_unknown_tparams,
             errors,
         )
     }
@@ -532,18 +544,32 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .collect::<SmallMap<_, _>>();
 
         let lookup_tparam = |t: &Type| {
-            let q = t.as_quantified()?;
-            let p = legacy_map.get(&q);
-            if p.is_none() {
+            let q = t.as_quantified();
+            if q.is_none() && !matches!(t, Type::Any(AnyStyle::Error) | Type::Unpack(_)) {
                 self.error(
                     errors,
                     name.range,
                     ErrorKind::InvalidTypeVar,
                     None,
-                    "Redundant type parameter declaration".to_owned(),
+                    format!(
+                        "Expected a type variable, got `{}`",
+                        self.for_display(t.clone())
+                    ),
                 );
             }
-            p.map(|x| (*x).clone())
+            q.and_then(|q| {
+                let p = legacy_map.get(&q);
+                if p.is_none() {
+                    self.error(
+                        errors,
+                        name.range,
+                        ErrorKind::InvalidTypeVar,
+                        None,
+                        "Redundant type parameter declaration".to_owned(),
+                    );
+                }
+                p.map(|x| (*x).clone())
+            })
         };
 
         // TODO(stroxler): There are a lot of checks, such as that `Generic` only appears once
@@ -606,12 +632,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 tparams.insert(p.clone());
             }
         }
-        // TODO: This is a very bad variance inference algorithm.
-        for tparam in tparams.iter_mut_unchecked() {
-            if tparam.variance.is_none() {
-                tparam.variance = Some(Variance::Invariant);
-            }
-        }
         self.type_params(name.range, tparams.into_iter().collect(), errors)
     }
 

{pyrefly-0.16.1 → pyrefly-0.16.2}/pyrefly/lib/alt/class/classdef.rs

@@ -26,8 +26,8 @@ use crate::graph::index::Idx;
 use crate::types::callable::Param;
 use crate::types::callable::Required;
 use crate::types::class::Class;
+use crate::types::class::ClassDefIndex;
 use crate::types::class::ClassFieldProperties;
-use crate::types::class::ClassIndex;
 use crate::types::class::ClassType;
 use crate::types::class::TArgs;
 use crate::types::typed_dict::TypedDict;
@@ -56,7 +56,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     pub fn class_definition(
         &self,
-        index: ClassIndex,
+        def_index: ClassDefIndex,
         x: &StmtClassDef,
         fields: SmallMap<Name, ClassFieldProperties>,
         bases: &[Expr],
@@ -67,7 +67,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let bases = bases.map(|x| self.base_class_of(x, errors));
         let tparams = self.class_tparams(&x.name, scoped_tparams, bases, legacy_tparams, errors);
         Class::new(
-            index,
+            def_index,
             x.name.clone(),
             self.module_info().dupe(),
             tparams,
@@ -77,12 +77,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     pub fn functional_class_definition(
         &self,
-        index: ClassIndex,
+        def_index: ClassDefIndex,
         name: &Identifier,
         fields: &SmallMap<Name, ClassFieldProperties>,
     ) -> Class {
         Class::new(
-            index,
+            def_index,
             name.clone(),
             self.module_info().dupe(),
             TParams::default(),
@@ -160,9 +160,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         range: TextRange,
         errors: &ErrorCollector,
     ) -> Type {
-        let targs = if cls.tparams().is_empty() && self.get_metadata_for_class(cls).has_base_any() {
-            // If we didn't find type parameters for a class that inherits from Any, we don't know
-            // how many parameters it has. Accept any number of arguments (by ignoring them).
+        let targs = if !targs.is_empty() && self.get_metadata_for_class(cls).has_unknown_tparams() {
+            // Accept any number of arguments (by ignoring them).
             TArgs::default()
         } else {
             self.check_and_create_targs(cls.name(), cls.tparams(), targs, range, errors)
@@ -215,12 +214,15 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
 
     pub fn unwrap_class_object_silently(&self, ty: &Type) -> Option<Type> {
         match ty {
+            Type::ClassDef(c) if c.is_builtin("tuple") => Some(Type::any_tuple()),
             Type::ClassDef(c) => Some(self.instantiate_fresh(c)),
             Type::TypeAlias(ta) => self.unwrap_class_object_silently(&ta.as_value(self.stdlib)),
             // Note that for the purposes of type narrowing, we always unwrap Type::Type(Type::ClassType),
             // but it's not always a valid argument to isinstance/issubclass. expr_infer separately checks
             // whether the argument is valid.
             Type::Type(box ty @ (Type::ClassType(_) | Type::Quantified(_))) => Some(ty.clone()),
+            Type::Type(box Type::Tuple(_)) => Some(Type::any_tuple()),
+            Type::None | Type::Type(box Type::None) => Some(Type::None),
             Type::ClassType(cls) if cls.is_builtin("type") => Some(Type::any_implicit()),
             Type::Any(_) => Some(ty.clone()),
             _ => None,

{pyrefly-0.16.1 → pyrefly-0.16.2}/pyrefly/lib/alt/class/typed_dict.rs

@@ -37,6 +37,7 @@ use crate::types::class::Class;
 use crate::types::class::Substitution;
 use crate::types::literal::Lit;
 use crate::types::quantified::Quantified;
+use crate::types::type_var::PreInferenceVariance;
 use crate::types::type_var::Restriction;
 use crate::types::typed_dict::TypedDict;
 use crate::types::typed_dict::TypedDictField;
@@ -260,7 +261,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 literal_signatures.push(OverloadType::Forall(Forall {
                     tparams: TParams::new(vec![TParamInfo {
                         quantified: q.clone(),
-                        variance: None,
+                        variance: Self::pre_to_post_variance(PreInferenceVariance::PUndefined),
                     }])
                     .tparams,
                     body: Function {

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

@@ -6,6 +6,7 @@
  */
 
 use dupe::Dupe;
+use num_traits::ToPrimitive;
 use ruff_python_ast::BoolOp;
 use ruff_python_ast::Comprehension;
 use ruff_python_ast::Expr;
@@ -30,7 +31,7 @@ use crate::alt::solve::TypeFormContext;
 use crate::binding::binding::Key;
 use crate::binding::binding::KeyYield;
 use crate::binding::binding::KeyYieldFrom;
-use crate::binding::narrow::PropertyKind;
+use crate::binding::narrow::FacetKind;
 use crate::dunder;
 use crate::error::collector::ErrorCollector;
 use crate::error::context::ErrorContext;
@@ -52,9 +53,9 @@ use crate::types::quantified::QuantifiedKind;
 use crate::types::special_form::SpecialForm;
 use crate::types::tuple::Tuple;
 use crate::types::type_info::TypeInfo;
+use crate::types::type_var::PreInferenceVariance;
 use crate::types::type_var::Restriction;
 use crate::types::type_var::TypeVar;
-use crate::types::type_var::Variance;
 use crate::types::type_var_tuple::TypeVarTuple;
 use crate::types::types::AnyStyle;
 use crate::types::types::CalleeKind;
@@ -185,7 +186,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         errors: &ErrorCollector,
         context: Option<&dyn Fn() -> ErrorContext>,
     ) -> TypeInfo {
-        TypeInfo::at_property(base, &PropertyKind::Attribute(attr_name.clone()), || {
+        TypeInfo::at_facet(base, &FacetKind::Attribute(attr_name.clone()), || {
             self.attr_infer_for_type(base.ty(), attr_name, range, errors, context)
         })
     }
@@ -202,12 +203,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 value: Number::Int(idx),
                 ..
             }) if let Some(idx) = idx.as_usize() => {
-                TypeInfo::at_property(base, &PropertyKind::Index(idx), || {
+                TypeInfo::at_facet(base, &FacetKind::Index(idx), || {
                     self.subscript_infer_for_type(base.ty(), slice, range, errors)
                 })
             }
             Expr::StringLiteral(ExprStringLiteral { value: key, .. }) => {
-                TypeInfo::at_property(base, &PropertyKind::Key(key.to_string()), || {
+                TypeInfo::at_facet(base, &FacetKind::Key(key.to_string()), || {
                     self.subscript_infer_for_type(base.ty(), slice, range, errors)
                 })
             }
@@ -275,7 +276,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let mut arg_name = false;
         let mut restriction = None;
         let mut default = None;
-        let mut variance = None;
+        let mut variance = PreInferenceVariance::PUndefined;
 
         let check_name_arg = |arg: &Expr| {
             if let Expr::StringLiteral(lit) = arg {
@@ -302,9 +303,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             }
         };
 
-        let mut try_set_variance = |kw: &Keyword, v: Option<Variance>| {
+        let mut try_set_variance = |kw: &Keyword, v: PreInferenceVariance| {
             if self.literal_bool_infer(&kw.value, errors) {
-                if variance.is_some() {
+                if variance != PreInferenceVariance::PUndefined {
                     self.error(
                         errors,
                         kw.range,
@@ -313,7 +314,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         "Contradictory variance specifications".to_owned(),
                     );
                 } else {
-                    variance = Some(v);
+                    variance = v;
                 }
             }
         };
@@ -355,9 +356,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             kw.value.range(),
                         ))
                     }
-                    "covariant" => try_set_variance(kw, Some(Variance::Covariant)),
-                    "contravariant" => try_set_variance(kw, Some(Variance::Contravariant)),
-                    "infer_variance" => try_set_variance(kw, None),
+                    "covariant" => try_set_variance(kw, PreInferenceVariance::PCovariant),
+                    "contravariant" => try_set_variance(kw, PreInferenceVariance::PContravariant),
+                    "invariant" => try_set_variance(kw, PreInferenceVariance::PInvariant),
+                    "infer_variance" => try_set_variance(kw, PreInferenceVariance::PUndefined),
                     "name" => {
                         if arg_name {
                             self.error(
@@ -420,7 +422,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             self.module_info().dupe(),
             restriction,
             default_value,
-            variance.unwrap_or(Some(Variance::Invariant)),
+            variance,
         )
     }
 
@@ -958,9 +960,13 @@ 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::Literal(Lit::Bytes(ref bytes)) => self.subscript_bytes_literal(
+                    bytes,
+                    slice,
+                    errors,
+                    range,
+                    Some(&|| ErrorContext::Index(self.for_display(base.clone()))),
+                ),
                 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()
@@ -1055,6 +1061,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 let condition_type = self.expr_infer(&x.test, errors);
                 let body_type = self.expr_infer_type_no_trace(&x.body, hint, errors);
                 let orelse_type = self.expr_infer_type_no_trace(&x.orelse, hint, errors);
+                self.check_dunder_bool_is_callable(&condition_type, x.range(), errors);
                 match condition_type.as_bool() {
                     Some(true) => body_type,
                     Some(false) => orelse_type,
@@ -1527,7 +1534,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     Some(box expr) => {
                         let lower_type = self.expr_infer(expr, errors);
                         match &lower_type {
-                            Type::Literal(Lit::Int(idx)) => idx.as_i64(),
+                            Type::Literal(lit) => lit.as_index_i64(),
                             _ => None,
                         }
                     }
@@ -1537,7 +1544,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     Some(box expr) => {
                         let upper_type = self.expr_infer(expr, errors);
                         match &upper_type {
-                            Type::Literal(Lit::Int(idx)) => idx.as_i64(),
+                            Type::Literal(lit) => lit.as_index_i64(),
                             _ => None,
                         }
                     }
@@ -1568,7 +1575,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             _ => {
                 let idx_type = self.expr_infer(index, errors);
                 match &idx_type {
-                    Type::Literal(Lit::Int(idx)) if let Some(idx) = idx.as_i64() => {
+                    Type::Literal(lit) if let Some(idx) = lit.as_index_i64() => {
                         let elt_idx = if idx >= 0 {
                             idx
                         } else {
@@ -1603,19 +1610,27 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
-    fn index_bytes_literal(
+    fn subscript_bytes_literal(
         &self,
         bytes: &[u8],
         index_expr: &Expr,
         errors: &ErrorCollector,
         range: TextRange,
+        context: Option<&dyn Fn() -> ErrorContext>,
     ) -> 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])))
+        let index_ty = self.expr_infer(index_expr, errors);
+        match &index_ty {
+            Type::Literal(lit) => {
+                if let Some(int_value) = lit.as_index_i64() {
+                    if int_value >= 0
+                        && let Some(byte) = bytes.get(int_value.to_usize().unwrap_or_default())
+                    {
+                        Type::Literal(Lit::Int(LitInt::new((*byte).into())))
+                    } else if int_value < 0
+                        && let Some(byte) =
+                            bytes.get(bytes.len() - (-int_value).to_usize().unwrap_or_default())
+                    {
+                        Type::Literal(Lit::Int(LitInt::new((*byte).into())))
                     } else {
                         self.error(
                             errors,
@@ -1623,16 +1638,32 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             ErrorKind::IndexError,
                             None,
                             format!(
-                                "Index {int_value} out of range bytes with {} elements",
+                                "Index `{int_value}` out of range for bytes with {} elements",
                                 bytes.len()
                             ),
                         )
                     }
                 } else {
-                    self.stdlib.bytes().clone().to_type()
+                    self.call_method_or_error(
+                        &self.stdlib.bytes().clone().to_type(),
+                        &dunder::GETITEM,
+                        range,
+                        &[CallArg::Expr(index_expr)],
+                        &[],
+                        errors,
+                        context,
+                    )
                 }
             }
-            _ => self.stdlib.bytes().clone().to_type(),
+            _ => self.call_method_or_error(
+                &self.stdlib.bytes().clone().to_type(),
+                &dunder::GETITEM,
+                range,
+                &[CallArg::Expr(index_expr)],
+                &[],
+                errors,
+                context,
+            ),
         }
     }
 }