pyrefly 0.11.1__tar.gz → 0.12.0__tar.gz

{pyrefly-0.11.1 → pyrefly-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefly
-Version: 0.11.1
+Version: 0.12.0
 Author: Meta
 License: MIT
 Project-URL: Source Code, https://github.com/facebook/pyrefly

{pyrefly-0.11.1 → pyrefly-0.12.0}/pyrefly/Cargo.lock

@@ -327,9 +327,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.36"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2df961d8c8a0d08aa9945718ccf584145eee3f3aa06cddbeac12933781102e04"
+checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -337,9 +337,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.36"
+version = "4.5.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "132dbda40fb6753878316a489d5a1242a8ef2f0d9e47ba01c951ea8aa7d013a5"
+checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1659,7 +1659,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.11.1"
+version = "0.12.0"
 dependencies = [
  "anyhow",
  "append-only-vec",

{pyrefly-0.11.1 → pyrefly-0.12.0}/pyrefly/Cargo.toml

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

{pyrefly-0.11.1 → pyrefly-0.12.0}/pyrefly/bin/main.rs

@@ -18,19 +18,20 @@ use clap::Parser;
 use clap::Subcommand;
 use dupe::Dupe;
 use path_absolutize::Absolutize;
-use pyrefly::ConfigFile;
-use pyrefly::NotifyWatcher;
-use pyrefly::clap_env;
-use pyrefly::finder::ConfigFinder;
-use pyrefly::get_args_expanded;
-use pyrefly::globs::FilteredGlobs;
-use pyrefly::globs::Globs;
-use pyrefly::run::BuckCheckArgs;
-use pyrefly::run::CheckArgs;
-use pyrefly::run::CommandExitStatus;
-use pyrefly::run::CommonGlobalArgs;
-use pyrefly::run::ConfigMigrationArgs;
-use pyrefly::run::LspArgs;
+use pyrefly::exported::ArcId;
+use pyrefly::exported::ConfigFile;
+use pyrefly::exported::NotifyWatcher;
+use pyrefly::exported::clap_env;
+use pyrefly::exported::finder::ConfigFinder;
+use pyrefly::exported::get_args_expanded;
+use pyrefly::exported::globs::FilteredGlobs;
+use pyrefly::exported::globs::Globs;
+use pyrefly::exported::run::BuckCheckArgs;
+use pyrefly::exported::run::CheckArgs;
+use pyrefly::exported::run::CommandExitStatus;
+use pyrefly::exported::run::CommonGlobalArgs;
+use pyrefly::exported::run::ConfigMigrationArgs;
+use pyrefly::exported::run::LspArgs;
 use tracing::debug;
 use tracing::info;
 
@@ -100,7 +101,7 @@ fn exit_on_panic() {
 }
 
 async fn run_check(
-    args: pyrefly::run::CheckArgs,
+    args: pyrefly::exported::run::CheckArgs,
     watch: bool,
     files_to_check: FilteredGlobs,
     config_finder: ConfigFinder,
@@ -119,14 +120,14 @@ async fn run_check(
     }
 }
 
-fn config_finder(args: pyrefly::run::CheckArgs) -> ConfigFinder {
+fn config_finder(args: pyrefly::exported::run::CheckArgs) -> ConfigFinder {
     let args = Arc::new(args);
     let args2 = args.dupe();
-    let default = move || Arc::new(args.override_config(ConfigFile::default()));
+    let default = move || ArcId::new(args.override_config(ConfigFile::default()));
     // The Box is a bit annoying here, but otherwise I can't persuade it that the `&Path` has a good enough lifetime.
-    let load: Box<dyn Fn(&Path) -> anyhow::Result<Arc<ConfigFile>>> =
+    let load: Box<dyn Fn(&Path) -> anyhow::Result<ArcId<ConfigFile>> + Send + Sync> =
         Box::new(move |config_path| {
-            Ok(Arc::new(args2.override_config(ConfigFile::from_file(
+            Ok(ArcId::new(args2.override_config(ConfigFile::from_file(
                 config_path,
                 true,
             )?)))
@@ -138,7 +139,7 @@ async fn run_check_on_project(
     watch: bool,
     config: Option<PathBuf>,
     project_excludes: Option<Vec<String>>,
-    args: pyrefly::run::CheckArgs,
+    args: pyrefly::exported::run::CheckArgs,
     allow_forget: bool,
 ) -> anyhow::Result<CommandExitStatus> {
     let config = match config {
@@ -148,7 +149,7 @@ async fn run_check_on_project(
                 explicit.display()
             );
             // We deliberately don't use the cached object, since we want errors in an explicit config to be fatal
-            Arc::new(args.override_config(ConfigFile::from_file(&explicit, true)?))
+            ArcId::new(args.override_config(ConfigFile::from_file(&explicit, true)?))
         }
         None => {
             let current_dir = std::env::current_dir().context("cannot identify current dir")?;
@@ -176,7 +177,7 @@ async fn run_check_on_files(
     files_to_check: Globs,
     project_excludes: Option<Vec<String>>,
     watch: bool,
-    args: pyrefly::run::CheckArgs,
+    args: pyrefly::exported::run::CheckArgs,
     allow_forget: bool,
 ) -> anyhow::Result<CommandExitStatus> {
     let project_excludes =

{pyrefly-0.11.1 → pyrefly-0.12.0}/pyrefly/lib/alt/answers.rs

@@ -16,6 +16,7 @@ use dupe::OptionDupedExt;
 use ruff_text_size::TextRange;
 use starlark_map::Hashed;
 use starlark_map::small_map::SmallMap;
+use starlark_map::small_set::SmallSet;
 
 use crate::alt::traits::Solve;
 use crate::alt::traits::SolveRecursive;
@@ -81,7 +82,7 @@ pub type AnswerEntry<K> =
 
 table!(
     #[derive(Debug, Default)]
-    pub struct AnswerTable(AnswerEntry)
+    pub struct AnswerTable(pub AnswerEntry)
 );
 
 impl DisplayWith<Bindings> for Answers {
@@ -176,7 +177,7 @@ impl Display for SolutionsDifference<'_> {
         // However, we do know it is exported, and exported things can't rely on locations, so regardless
         // of the ModuleInfo, it should display the same. Therefore, we fake one up.
         let fake_module_info = ModuleInfo::new(
-            ModuleName::builtins(),
+            ModuleName::from_str("Fake.Module.For.SolutionsDifference.Display"),
             ModulePath::memory(PathBuf::new()),
             Default::default(),
         );
@@ -192,10 +193,6 @@ impl Display for SolutionsDifference<'_> {
 }
 
 impl Solutions {
-    pub fn table(&self) -> &SolutionsTable {
-        &self.0
-    }
-
     #[allow(dead_code)] // Used in tests.
     pub fn get<K: Keyed<EXPORTED = true>>(&self, key: &K) -> Option<&Arc<<K as Keyed>::Answer>>
     where
@@ -227,6 +224,11 @@ impl Solutions {
         where
             SolutionsTable: TableKeyed<K, Value = SolutionsEntry<K>>,
         {
+            if !K::EXPORTED {
+                assert_eq!(x.len(), 0, "Expect no non-exported keys in Solutions");
+                return None;
+            }
+
             let y = y.0.get::<K>();
             if y.len() > x.len() {
                 for (k, v) in y {
@@ -304,6 +306,10 @@ pub trait LookupAnswer: Sized {
 }
 
 impl Answers {
+    pub fn table(&self) -> &AnswerTable {
+        &self.table
+    }
+
     pub fn new(bindings: &Bindings, solver: Solver, enable_trace: bool) -> Self {
         fn presize<K: SolveRecursive>(items: &mut AnswerEntry<K>, bindings: &Bindings)
         where
@@ -670,27 +676,53 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         self.unions(res)
     }
 
-    pub fn map_over_union(&self, ty: &Type, mut f: impl FnMut(&Type)) {
-        fn recurse<Ans: LookupAnswer>(
-            me: &AnswersSolver<Ans>,
-            ty: &Type,
-            f: &mut impl FnMut(&Type),
-            in_type: bool,
-        ) {
-            match ty {
-                Type::Never(_) if !in_type => (),
-                Type::Union(tys) => tys.iter().for_each(|ty| recurse(me, ty, f, in_type)),
-                Type::Type(box Type::Union(tys)) if !in_type => {
-                    tys.iter().for_each(|ty| recurse(me, ty, f, true))
-                }
-                Type::Var(v) if let Some(_guard) = me.recurser.recurse(*v) => {
-                    recurse(me, &me.solver().force_var(*v), f, in_type)
+    pub fn map_over_union(&self, ty: &Type, f: impl FnMut(&Type)) {
+        struct Data<'a, 'b, Ans: LookupAnswer, F: FnMut(&Type)> {
+            /// The `self` of `AnswersSolver`
+            me: &'b AnswersSolver<'a, Ans>,
+            /// The function to apply on each call
+            f: F,
+            /// Arguments we have already used for the function.
+            /// If we see the same element twice in a union (perhaps due to nested Var expansion),
+            /// we only need to process it once. Aviods O(n^2) for certain flow patterns.
+            done: SmallSet<Type>,
+            /// Have we seen a union node? If not, we can skip the cache
+            /// as there will only be exactly one call to `f` (the common case).
+            seen_union: bool,
+        }
+
+        impl<Ans: LookupAnswer, F: FnMut(&Type)> Data<'_, '_, Ans, F> {
+            fn go(&mut self, ty: &Type, in_type: bool) {
+                match ty {
+                    Type::Never(_) if !in_type => (),
+                    Type::Union(tys) => {
+                        self.seen_union = true;
+                        tys.iter().for_each(|ty| self.go(ty, in_type))
+                    }
+                    Type::Type(box Type::Union(tys)) if !in_type => {
+                        tys.iter().for_each(|ty| self.go(ty, true))
+                    }
+                    Type::Var(v) if let Some(_guard) = self.me.recurser.recurse(*v) => {
+                        self.go(&self.me.solver().force_var(*v), in_type)
+                    }
+                    _ if in_type => (self.f)(&Type::Type(Box::new(ty.clone()))),
+                    _ => {
+                        // If we haven't encountered a union this must be the only type, no need to cache it.
+                        // Otherwise, if inserting succeeds (we haven't processed this type before) actually do it.
+                        if !self.seen_union || self.done.insert(ty.clone()) {
+                            (self.f)(ty)
+                        }
+                    }
                 }
-                _ if in_type => f(&Type::Type(Box::new(ty.clone()))),
-                _ => f(ty),
             }
         }
-        recurse(self, ty, &mut f, false)
+        Data {
+            me: self,
+            f,
+            done: SmallSet::new(),
+            seen_union: false,
+        }
+        .go(ty, false)
     }
 
     pub fn unions(&self, xs: Vec<Type>) -> Type {

{pyrefly-0.11.1 → pyrefly-0.12.0}/pyrefly/lib/alt/attr.rs

@@ -41,6 +41,7 @@ use crate::types::module::Module;
 use crate::types::quantified::Quantified;
 use crate::types::tuple::Tuple;
 use crate::types::type_var::Restriction;
+use crate::types::typed_dict::TypedDict;
 use crate::types::types::AnyStyle;
 use crate::types::types::Overload;
 use crate::types::types::SuperObj;
@@ -133,7 +134,7 @@ pub enum DescriptorBase {
 
 #[derive(Debug)]
 pub enum NotFound {
-    Attribute(ClassType),
+    Attribute(Class),
     ClassAttribute(Class),
     ModuleExport(Module),
 }
@@ -265,8 +266,8 @@ impl LookupResult {
 impl NotFound {
     pub fn to_error_msg(self, attr_name: &Name) -> String {
         match self {
-            NotFound::Attribute(class_type) => {
-                let class_name = class_type.name();
+            NotFound::Attribute(class) => {
+                let class_name = class.name();
                 format!("Object of class `{class_name}` has no attribute `{attr_name}`",)
             }
             NotFound::ClassAttribute(class) => {
@@ -311,6 +312,8 @@ enum AttributeBase {
     Property(Type),
     /// Result of a super() call. See Type::SuperInstance for details on what these fields are.
     SuperInstance(ClassType, SuperObj),
+    /// Typed dictionaries have similar properties to dict and Mapping, with some exceptions
+    TypedDict(TypedDict),
 }
 
 impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
@@ -867,7 +870,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     None if self.extends_any(class.class_object()) => {
                         LookupResult::found_type(Type::Any(AnyStyle::Implicit))
                     }
-                    None => LookupResult::NotFound(NotFound::Attribute(class)),
+                    None => {
+                        LookupResult::NotFound(NotFound::Attribute(class.class_object().dupe()))
+                    }
                 }
             }
             AttributeBase::SuperInstance(cls, obj) => {
@@ -883,7 +888,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     {
                         LookupResult::found_type(Type::Any(AnyStyle::Implicit))
                     }
-                    None => LookupResult::NotFound(NotFound::Attribute(cls)),
+                    None => LookupResult::NotFound(NotFound::Attribute(cls.class_object().dupe())),
                 }
             }
             AttributeBase::ClassObject(class) => {
@@ -927,7 +932,9 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     let class = q.as_value(self.stdlib);
                     match self.get_instance_attribute(class, attr_name) {
                         Some(attr) => LookupResult::Found(attr),
-                        None => LookupResult::NotFound(NotFound::Attribute(class.clone())),
+                        None => {
+                            LookupResult::NotFound(NotFound::Attribute(class.class_object().dupe()))
+                        }
                     }
                 }
             }
@@ -963,10 +970,25 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     let class = self.stdlib.property();
                     match self.get_instance_attribute(class, attr_name) {
                         Some(attr) => LookupResult::Found(attr),
-                        None => LookupResult::NotFound(NotFound::Attribute(class.clone())),
+                        None => {
+                            LookupResult::NotFound(NotFound::Attribute(class.class_object().dupe()))
+                        }
                     }
                 }
             }
+            AttributeBase::TypedDict(typed_dict) => {
+                if attr_name == "clear" {
+                    LookupResult::NotFound(NotFound::Attribute(typed_dict.class_object().dupe()))
+                } else {
+                    self.lookup_attr_from_attribute_base(
+                        AttributeBase::ClassInstance(self.stdlib.dict(
+                            self.stdlib.str().clone().to_type(),
+                            self.stdlib.object().clone().to_type(),
+                        )),
+                        attr_name,
+                    )
+                }
+            }
         }
     }
 
@@ -1074,10 +1096,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::Type(box Type::SelfType(class_type)) => {
                 Some(AttributeBase::ClassObject(class_type.class_object().dupe()))
             }
-            Type::TypedDict(_) => Some(AttributeBase::ClassInstance(self.stdlib.mapping(
-                self.stdlib.str().clone().to_type(),
-                self.stdlib.object().clone().to_type(),
-            ))),
+            Type::TypedDict(typed_dict) => Some(AttributeBase::TypedDict(typed_dict.clone())),
             Type::Tuple(Tuple::Unbounded(box element)) => {
                 Some(AttributeBase::ClassInstance(self.stdlib.tuple(element)))
             }
@@ -1334,6 +1353,13 @@ impl<'a, Ans: LookupAnswer + LookupExport> AnswersSolver<'a, Ans> {
         if let Some(base) = self.as_attribute_base_no_union(base) {
             match &base {
                 AttributeBase::ClassInstance(class) => self.completions_class_type(class, &mut res),
+                AttributeBase::TypedDict(_) => self.completions_class_type(
+                    &self.stdlib.dict(
+                        self.stdlib.str().clone().to_type(),
+                        self.stdlib.object().clone().to_type(),
+                    ),
+                    &mut res,
+                ),
                 AttributeBase::SuperInstance(class, _) => {
                     self.completions_class_type(class, &mut res)
                 }

{pyrefly-0.11.1 → pyrefly-0.12.0}/pyrefly/lib/alt/call.rs

@@ -27,6 +27,7 @@ use crate::types::callable::FuncFlags;
 use crate::types::callable::FuncMetadata;
 use crate::types::callable::Function;
 use crate::types::callable::FunctionKind;
+use crate::types::callable::Params;
 use crate::types::class::ClassType;
 use crate::types::literal::Lit;
 use crate::types::type_var::Restriction;
@@ -160,6 +161,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::Type(box Type::ClassType(cls))
             | Type::Type(box Type::SelfType(cls))
             | Type::SelfType(cls) => Some(CallTarget::new(Target::Class(cls))),
+            Type::Type(box Type::Quantified(quantified)) => {
+                Some(CallTarget::new(Target::Callable(Callable {
+                    // TODO: use upper bound to determine input parameters
+                    params: Params::Ellipsis,
+                    ret: Type::Quantified(quantified),
+                })))
+            }
             Type::Forall(forall) => {
                 let (qs, t) = self.solver().fresh_quantified(
                     &forall.tparams,
@@ -189,7 +197,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 .instance_to_method(&cls)
                 .and_then(|ty| self.as_call_target(ty)),
             Type::Type(box Type::TypedDict(typed_dict)) => {
-                Some(CallTarget::new(Target::TypedDict(*typed_dict)))
+                Some(CallTarget::new(Target::TypedDict(typed_dict)))
             }
             Type::Quantified(q) if q.is_type_var() => match q.restriction() {
                 Restriction::Bound(bound) => self.as_call_target(bound.clone()),
@@ -443,7 +451,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             errors,
             context,
         );
-        Type::TypedDict(Box::new(typed_dict))
+        Type::TypedDict(typed_dict)
     }
 
     pub fn call_infer(

{pyrefly-0.11.1 → pyrefly-0.12.0}/pyrefly/lib/alt/callable.rs

@@ -538,53 +538,47 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 None => {
                     let ty = self.expr_infer(&kw.value, arg_errors);
                     if let Type::TypedDict(typed_dict) = ty {
-                        self.typed_dict_fields(&typed_dict)
-                            .iter()
-                            .for_each(|(name, field)| {
-                                let mut hint = kwargs.as_ref().map(|(_, ty)| ty.clone());
-                                if let Some(ty) = seen_names.get(name) {
-                                    error(
-                                        call_errors,
-                                        kw.range,
-                                        ErrorKind::BadKeywordArgument,
-                                        format!("Multiple values for argument `{}`", name),
-                                    );
-                                    hint = Some(ty.clone());
-                                } else if let Some((ty, required)) = kwparams.get(name) {
-                                    seen_names.insert(name.clone(), ty.clone());
-                                    if *required && !field.required {
-                                        error(
-                                            call_errors,
-                                            kw.range,
-                                            ErrorKind::MissingArgument,
-                                            format!("Expected key `{}` to be required", name),
-                                        );
-                                    }
-                                    hint = Some(ty.clone())
-                                } else if kwargs.is_none() && !kwargs_is_unpack {
+                        for (name, field) in self.typed_dict_fields(&typed_dict).iter() {
+                            let mut hint = kwargs.as_ref().map(|(_, ty)| ty.clone());
+                            if let Some(ty) = seen_names.get(name) {
+                                error(
+                                    call_errors,
+                                    kw.range,
+                                    ErrorKind::BadKeywordArgument,
+                                    format!("Multiple values for argument `{}`", name),
+                                );
+                                hint = Some(ty.clone());
+                            } else if let Some((ty, required)) = kwparams.get(name) {
+                                seen_names.insert(name.clone(), ty.clone());
+                                if *required && !field.required {
                                     error(
                                         call_errors,
                                         kw.range,
-                                        ErrorKind::UnexpectedKeyword,
-                                        format!("Unexpected keyword argument `{}`", name),
+                                        ErrorKind::MissingArgument,
+                                        format!("Expected key `{}` to be required", name),
                                     );
                                 }
-                                hint.iter().for_each(|want| {
-                                    self.check_type(
-                                        want,
-                                        &field.ty,
-                                        kw.range,
-                                        call_errors,
-                                        &|| TypeCheckContext {
-                                            kind: TypeCheckKind::CallArgument(
-                                                Some(name.clone()),
-                                                callable_name.clone(),
-                                            ),
-                                            context: context.map(|ctx| ctx()),
-                                        },
-                                    );
+                                hint = Some(ty.clone())
+                            } else if kwargs.is_none() && !kwargs_is_unpack {
+                                error(
+                                    call_errors,
+                                    kw.range,
+                                    ErrorKind::UnexpectedKeyword,
+                                    format!("Unexpected keyword argument `{}`", name),
+                                );
+                            }
+                            if let Some(want) = &hint {
+                                self.check_type(want, &field.ty, kw.range, call_errors, &|| {
+                                    TypeCheckContext {
+                                        kind: TypeCheckKind::CallArgument(
+                                            Some(name.clone()),
+                                            callable_name.clone(),
+                                        ),
+                                        context: context.map(|ctx| ctx()),
+                                    }
                                 });
-                            })
+                            }
+                        }
                     } else {
                         match self.unwrap_mapping(&ty) {
                             Some((key, value)) => {