pyrefly 0.17.1__tar.gz → 0.18.0__tar.gz

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

@@ -296,9 +296,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.24"
+version = "1.2.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16595d3be041c03b09d08d0858631facccee9221e579704070e6e9e4915d3bc7"
+checksum = "d0fc897dc1e865cc67c0e05a836d9d3f1df3cbe442aa4a9473b18e12624a4951"
 dependencies = [
  "jobserver",
  "libc",
@@ -548,7 +548,7 @@ dependencies = [
  "hashbrown 0.14.5",
  "lock_api",
  "once_cell",
- "parking_lot_core 0.9.10",
+ "parking_lot_core 0.9.11",
 ]
 
 [[package]]
@@ -1274,9 +1274,9 @@ checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
 
 [[package]]
 name = "lock_api"
-version = "0.4.12"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
 dependencies = [
  "autocfg",
  "scopeguard",
@@ -1290,7 +1290,7 @@ checksum = "fc989b5e3e04411250b5d1ce0d880e5de77b36703f3012d56acb43e6ff07f31b"
 dependencies = [
  "allocative",
  "atomic",
- "parking_lot 0.12.3",
+ "parking_lot 0.12.4",
 ]
 
 [[package]]
@@ -1524,12 +1524,12 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.12.3"
+version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
 dependencies = [
  "lock_api",
- "parking_lot_core 0.9.10",
+ "parking_lot_core 0.9.11",
 ]
 
 [[package]]
@@ -1548,9 +1548,9 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.10"
+version = "0.9.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
 dependencies = [
  "cfg-if",
  "libc",
@@ -1754,7 +1754,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.17.1"
+version = "0.18.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1819,7 +1819,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.17.1"
+version = "0.18.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2597,7 +2597,7 @@ dependencies = [
  "bytes",
  "libc",
  "mio 1.0.4",
- "parking_lot 0.12.3",
+ "parking_lot 0.12.4",
  "pin-project-lite",
  "signal-hook-registry",
  "socket2",
@@ -2736,7 +2736,7 @@ dependencies = [
  "matchers",
  "nu-ansi-term",
  "once_cell",
- "parking_lot 0.12.3",
+ "parking_lot 0.12.4",
  "regex",
  "serde",
  "serde_json",

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

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

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

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

{pyrefly-0.17.1 → pyrefly-0.18.0}/pyrefly/lib/alt/callable.rs

@@ -246,13 +246,19 @@ impl PosParam {
 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, _) => self.expr_infer(x, errors) == Type::Args(q),
+            CallArg::Star(x, _) => {
+                let mut ty = self.expr_infer(x, errors);
+                self.expand_type_mut(&mut ty);
+                ty == Type::Args(q)
+            }
             _ => false,
         }
     }
 
     fn is_param_spec_kwargs(&self, x: &Keyword, q: Quantified, errors: &ErrorCollector) -> bool {
-        self.expr_infer(&x.value, errors) == Type::Kwargs(q)
+        let mut ty = self.expr_infer(&x.value, errors);
+        self.expand_type_mut(&mut ty);
+        ty == Type::Kwargs(q)
     }
 
     // See comment on `callable_infer` about `arg_errors` and `call_errors`.

{pyrefly-0.17.1 → pyrefly-0.18.0}/pyrefly/lib/alt/class/class_metadata.rs

@@ -43,7 +43,7 @@ use crate::types::special_form::SpecialForm;
 use crate::types::tuple::Tuple;
 use crate::types::types::AnyStyle;
 use crate::types::types::CalleeKind;
-use crate::types::types::TParamInfo;
+use crate::types::types::TParam;
 use crate::types::types::Type;
 
 /// Private helper type used to share part of the logic needed for the
@@ -168,6 +168,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let mut protocol_metadata = if bases.iter().any(|x| matches!(x, BaseClass::Protocol(_))) {
             Some(ProtocolMetadata {
                 members: cls.fields().cloned().collect(),
+                is_runtime_checkable: false,
             })
         } else {
             None
@@ -237,6 +238,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             if let Some(proto) = &mut protocol_metadata {
                                 if let Some(base_proto) = base_class_metadata.protocol_metadata() {
                                     proto.members.extend(base_proto.members.iter().cloned());
+                                    if base_proto.is_runtime_checkable {
+                                        proto.is_runtime_checkable = true;
+                                    }
                                 } else {
                                     self.error(errors,
                                         range,
@@ -398,6 +402,19 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 Some(CalleeKind::Function(FunctionKind::Final)) => {
                     is_final = true;
                 }
+                Some(CalleeKind::Function(FunctionKind::RuntimeCheckable)) => {
+                    if let Some(proto) = &mut protocol_metadata {
+                        proto.is_runtime_checkable = true;
+                    } else {
+                        self.error(
+                            errors,
+                            cls.range(),
+                            ErrorKind::InvalidArgument,
+                            None,
+                            "@runtime_checkable can only be applied to Protocol classes".to_owned(),
+                        );
+                    }
+                }
                 _ => {}
             }
         }
@@ -528,11 +545,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     pub fn class_tparams(
         &self,
         name: &Identifier,
-        scoped_tparams: Vec<TParamInfo>,
+        scoped_tparams: Vec<TParam>,
         bases: Vec<BaseClass>,
         legacy: &[Idx<KeyLegacyTypeParam>],
         errors: &ErrorCollector,
-    ) -> Vec<TParamInfo> {
+    ) -> Vec<TParam> {
         let legacy_tparams = legacy
             .iter()
             .filter_map(|key| self.get_idx(*key).deref().parameter().cloned())

{pyrefly-0.17.1 → pyrefly-0.18.0}/pyrefly/lib/alt/class/classdef.rs

@@ -63,9 +63,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let scoped_tparams = self.scoped_type_params(x.type_params.as_deref(), errors);
         let bases = bases.map(|x| self.base_class_of(x, errors));
         let name = &x.name;
-        let tparams_info = self.class_tparams(name, scoped_tparams, bases, legacy_tparams, errors);
+        let class_tparams = self.class_tparams(name, scoped_tparams, bases, legacy_tparams, errors);
 
-        let tparams = self.type_params(name.range, tparams_info, errors);
+        let tparams = self.type_params(name.range, class_tparams, errors);
 
         Class::new(
             def_index,

{pyrefly-0.17.1 → pyrefly-0.18.0}/pyrefly/lib/alt/class/dataclass.rs

@@ -31,6 +31,7 @@ use crate::types::class::Class;
 use crate::types::class::ClassType;
 use crate::types::literal::Lit;
 use crate::types::tuple::Tuple;
+use crate::types::types::AnyStyle;
 use crate::types::types::Type;
 
 impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
@@ -68,6 +69,15 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 ),
             );
         }
+        let dataclass_fields_type = self.stdlib.dict(
+            self.stdlib.str().clone().to_type(),
+            Type::Any(AnyStyle::Implicit),
+        );
+        fields.insert(
+            dunder::DATACLASS_FIELDS,
+            ClassSynthesizedField::new(dataclass_fields_type.to_type()),
+        );
+
         if dataclass.kws.is_set(&DataclassKeywords::ORDER) {
             fields.extend(self.get_dataclass_rich_comparison_methods(cls));
         }

pyrefly-0.18.0/pyrefly/lib/alt/class/variance_inference.rs

@@ -0,0 +1,44 @@
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::fmt::Result as FmtResult;
+
+use pyrefly_derive::TypeEq;
+use pyrefly_util::visit::VisitMut;
+use starlark_map::small_map::SmallMap;
+
+use crate::types::type_var::PreInferenceVariance;
+use crate::types::type_var::Variance;
+use crate::types::types::Type;
+
+#[derive(Debug, Clone, PartialEq, Eq, TypeEq)]
+pub struct VarianceMap(pub SmallMap<String, Variance>);
+
+impl VisitMut<Type> for VarianceMap {
+    fn visit_mut(&mut self, _visitor: &mut dyn FnMut(&mut Type)) {
+        // No-op: VarianceMap does not contain any Type
+    }
+
+    fn recurse_mut(&mut self, _visitor: &mut dyn FnMut(&mut Type)) {
+        // No-op: VarianceMap does not contain any Type
+    }
+}
+
+impl Display for VarianceMap {
+    fn fmt(&self, f: &mut Formatter) -> FmtResult {
+        write!(f, "{{")?;
+        for (key, value) in self.0.iter() {
+            write!(f, "{}: {}, ", key, value)?;
+        }
+        write!(f, "}}")
+    }
+}
+
+pub fn pre_to_post_variance(pre_variance: PreInferenceVariance) -> Variance {
+    match pre_variance {
+        PreInferenceVariance::PCovariant => Variance::Covariant,
+        PreInferenceVariance::PContravariant => Variance::Contravariant,
+        PreInferenceVariance::PInvariant => Variance::Invariant,
+        // TODO: we should infer variance for this case
+        PreInferenceVariance::PUndefined => Variance::Invariant,
+    }
+}

{pyrefly-0.17.1 → pyrefly-0.18.0}/pyrefly/lib/alt/expr.rs

@@ -48,6 +48,7 @@ use crate::types::callable::Param;
 use crate::types::callable::ParamList;
 use crate::types::callable::Params;
 use crate::types::callable::Required;
+use crate::types::class::Class;
 use crate::types::lit_int::LitInt;
 use crate::types::literal::Lit;
 use crate::types::param_spec::ParamSpec;
@@ -661,23 +662,52 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         ty: Type,
         contains_subscript: bool,
         range: TextRange,
+        func_kind: &FunctionKind,
         errors: &ErrorCollector,
     ) {
         if let Some(ts) = ty.as_decomposed_tuple_or_union() {
             for t in ts {
-                self.check_type_is_class_object(t, contains_subscript, range, errors);
+                self.check_type_is_class_object(t, contains_subscript, range, func_kind, errors);
             }
         } else if let Type::ClassDef(cls) = &ty {
             let metadata = self.get_metadata_for_class(cls);
+            let func_display = || {
+                format!(
+                    "{}()",
+                    func_kind.as_func_id().format(self.module_info().name())
+                )
+            };
             if metadata.is_new_type() {
                 self.error(
                     errors,
                     range,
                     ErrorKind::InvalidArgument,
                     None,
-                    format!("NewType `{}` not allowed in isinstance", cls.name()),
+                    format!("NewType `{}` not allowed in {}", cls.name(), func_display(),),
                 );
             }
+            // Check if this is a protocol that needs @runtime_checkable
+            if metadata.is_protocol() && !metadata.is_runtime_checkable_protocol() {
+                self.error(
+                    errors,
+                    range,
+                    ErrorKind::InvalidArgument,
+                    None,
+                    format!("Protocol `{}` is not decorated with @runtime_checkable and cannot be used with {}", cls.name(), func_display()),
+                );
+            } else if metadata.is_protocol() && metadata.is_runtime_checkable_protocol() {
+                // Additional validation for runtime checkable protocols:
+                // issubclass() can only be used with non-data protocols
+                if *func_kind == FunctionKind::IsSubclass && self.is_data_protocol(cls, range) {
+                    self.error(
+                        errors,
+                        range,
+                        ErrorKind::InvalidArgument,
+                        None,
+                        format!("Protocol `{}` has non-method members and cannot be used with issubclass()", cls.name()),
+                    );
+                }
+            }
         } else if contains_subscript
             && matches!(&ty, Type::Type(box Type::ClassType(cls)) if !cls.targs().is_empty())
         {
@@ -705,20 +735,58 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
-    fn check_second_arg_is_class_object(&self, x: &ExprCall, errors: &ErrorCollector) {
-        if x.arguments.args.len() == 2 {
-            let arg_expr = &x.arguments.args[1];
-            let isinstance_class_type = self.expr_infer(arg_expr, errors);
+    /// Check if a protocol is a data protocol (has non-method members)
+    fn is_data_protocol(&self, cls: &Class, range: TextRange) -> bool {
+        // A data protocol has at least one non-method member
+        // Use protocol metadata to get the member names
+        let metadata = self.get_metadata_for_class(cls);
+        if let Some(protocol_metadata) = metadata.protocol_metadata() {
+            for field_name in &protocol_metadata.members {
+                // Use the class type to access the field
+                let class_type = cls.as_class_type();
+                let ty = self.type_of_attr_get(
+                    &class_type.to_type(),
+                    field_name,
+                    range,
+                    &self.error_swallower(),
+                    None,
+                    "is_data_protocol",
+                );
+
+                // If it's not a callable type, it's a data member
+                if !matches!(
+                    ty,
+                    Type::Callable(_) | Type::Function(_) | Type::BoundMethod(_)
+                ) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
+    fn check_second_arg_is_class_object(
+        &self,
+        args: &[Expr],
+        func_kind: &FunctionKind,
+        range: TextRange,
+        errors: &ErrorCollector,
+    ) {
+        if args.len() == 2 {
+            let arg_expr = &args[1];
+            let arg_class_type = self.expr_infer(arg_expr, errors);
             let mut contains_subscript = false;
             arg_expr.visit(&mut |e| {
                 if matches!(e, Expr::Subscript(_)) {
                     contains_subscript = true;
                 }
             });
+
             self.check_type_is_class_object(
-                isinstance_class_type,
+                arg_class_type,
                 contains_subscript,
-                x.range,
+                range,
+                func_kind,
                 errors,
             );
         }
@@ -788,7 +856,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     ) -> TypeInfo {
         let res = match x {
             Expr::Name(x) => self
-                .get(&Key::Usage(ShortIdentifier::expr_name(x)))
+                .get(&Key::BoundName(ShortIdentifier::expr_name(x)))
                 .arc_clone(),
             Expr::Attribute(x) => {
                 let base = self.expr_infer_type_info(&x.value, errors);
@@ -1371,13 +1439,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                                 errors,
                             ),
                         _ => {
-                            if matches!(
-                                ty_fun.callee_kind(),
-                                Some(CalleeKind::Function(
+                            if let Some(CalleeKind::Function(func_kind)) = ty_fun.callee_kind()
+                                && matches!(
+                                    func_kind,
                                     FunctionKind::IsInstance | FunctionKind::IsSubclass
-                                ))
-                            ) {
-                                self.check_second_arg_is_class_object(x, errors);
+                                )
+                            {
+                                self.check_second_arg_is_class_object(
+                                    &x.arguments.args,
+                                    &func_kind,
+                                    x.range,
+                                    errors,
+                                );
                             }
                             let args = x.arguments.args.map(|arg| match arg {
                                 Expr::Starred(x) => CallArg::Star(&x.value, x.range),

{pyrefly-0.17.1 → pyrefly-0.18.0}/pyrefly/lib/alt/function.rs

@@ -151,27 +151,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         legacy_tparams: &[Idx<KeyLegacyTypeParam>],
         errors: &ErrorCollector,
     ) -> Arc<DecoratedFunction> {
-        let check_default = |name: &Identifier, default: &Option<Box<Expr>>, ty: &Type| {
-            let mut required = Required::Required;
-            if let Some(default) = default {
-                required = Required::Optional;
-                if stub_or_impl != FunctionStubOrImpl::Stub
-                    || !matches!(default.as_ref(), Expr::EllipsisLiteral(_))
-                {
-                    self.expr(
-                        default,
-                        Some((ty, &|| {
-                            TypeCheckContext::of_kind(TypeCheckKind::FunctionParameterDefault(
-                                name.id.clone(),
-                            ))
-                        })),
-                        errors,
-                    );
-                }
-            }
-            required
-        };
-
         let defining_cls = class_key.and_then(|k| self.get_idx(*k).0.dupe());
         let mut self_type = if def.name.id == dunder::NEW || def.name.id == dunder::INIT_SUBCLASS {
             // __new__ and __init_subclass__ are staticmethods, and do not take a self parameter.
@@ -244,18 +223,46 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             self_type = self_type.map(Type::type_form);
         }
 
-        let mut get_param_ty = |name: &Identifier| {
+        // Determine the type of the parameter based on its binding. Left is annotated parameter, right is unannotated
+        let mut get_param_ty = |name: &Identifier, default: Option<&Expr>| {
             let ty = match self.bindings().get_function_param(name) {
-                Either::Left(idx) => self.get_idx(idx).annotation.get_type().clone(),
+                Either::Left(idx) => {
+                    // If the parameter is annotated, we check the default value against the annotation
+                    let param_ty = self.get_idx(idx).annotation.get_type().clone();
+                    if let Some(default) = default
+                        && (stub_or_impl != FunctionStubOrImpl::Stub
+                            || !matches!(default, Expr::EllipsisLiteral(_)))
+                    {
+                        self.expr(
+                            default,
+                            Some((&param_ty, &|| {
+                                TypeCheckContext::of_kind(TypeCheckKind::FunctionParameterDefault(
+                                    name.id.clone(),
+                                ))
+                            })),
+                            errors,
+                        );
+                    }
+                    param_ty
+                }
                 Either::Right(var) => {
                     // If this is the first parameter and there is a self type, solve to `Self`.
                     // We only try to solve the first param for now. Other unannotated params
-                    // are also Var, but will always be forced to Any. In the future, we might
-                    // consider contextual information to infer parameter types, like decorator
-                    // applications.
+                    // are also Var. If a default value of type T is provided, it will resolve to Any | T.
+                    // Otherwise, it will be forced to Any
                     if let Some(ty) = &self_type {
                         self.solver()
                             .is_subset_eq(&var.to_type(), ty, self.type_order());
+                    } else if let Some(default) = default
+                        && (stub_or_impl != FunctionStubOrImpl::Stub
+                            || !matches!(default, Expr::EllipsisLiteral(_)))
+                    {
+                        let default_ty = self.expr(default, None, errors);
+                        self.solver().is_subset_eq(
+                            &self.union(Type::any_implicit(), default_ty),
+                            &var.to_type(),
+                            self.type_order(),
+                        );
                     }
                     self.solver().force_var(var)
                 }
@@ -267,17 +274,25 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         let mut paramspec_kwargs = None;
         let mut params = Vec::with_capacity(def.parameters.len());
         params.extend(def.parameters.posonlyargs.iter().map(|x| {
-            let ty = get_param_ty(&x.parameter.name);
-            let required = check_default(&x.parameter.name, &x.default, &ty);
+            let ty = get_param_ty(&x.parameter.name, x.default.as_deref());
+            let required = if x.default.is_some() {
+                Required::Optional
+            } else {
+                Required::Required
+            };
             Param::PosOnly(ty, required)
         }));
         params.extend(def.parameters.args.iter().map(|x| {
-            let ty = get_param_ty(&x.parameter.name);
-            let required = check_default(&x.parameter.name, &x.default, &ty);
+            let ty = get_param_ty(&x.parameter.name, x.default.as_deref());
+            let required = if x.default.is_some() {
+                Required::Optional
+            } else {
+                Required::Required
+            };
             Param::Pos(x.parameter.name.id.clone(), ty, required)
         }));
         params.extend(def.parameters.vararg.iter().map(|x| {
-            let ty = get_param_ty(&x.name);
+            let ty = get_param_ty(&x.name, None);
             if let Type::Args(q) = &ty {
                 paramspec_args = Some(q.clone());
             }
@@ -298,8 +313,12 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             );
         }
         params.extend(def.parameters.kwonlyargs.iter().map(|x| {
-            let ty = get_param_ty(&x.parameter.name);
-            let required = check_default(&x.parameter.name, &x.default, &ty);
+            let ty = get_param_ty(&x.parameter.name, x.default.as_deref());
+            let required = if x.default.is_some() {
+                Required::Optional
+            } else {
+                Required::Required
+            };
             Param::KwOnly(x.parameter.name.id.clone(), ty, required)
         }));
         params.extend(def.parameters.kwarg.iter().map(|x| {
@@ -319,13 +338,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .get(&Key::ReturnType(ShortIdentifier::new(&def.name)))
             .arc_clone_ty();
 
-        let ret = if def.is_async && !self.is_async_generator(&ret) {
-            self.stdlib
-                .coroutine(Type::any_implicit(), Type::any_implicit(), ret)
-                .to_type()
-        } else {
-            ret
-        };
         let mut tparams = self.scoped_type_params(def.type_params.as_deref(), errors);
         let legacy_tparams = legacy_tparams
             .iter()