pyrefly 0.10.0__tar.gz → 0.10.2__tar.gz

pyrefly-0.10.2/PKG-INFO

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

{pyrefly-0.10.0 → pyrefly-0.10.2}/pyrefly/Cargo.lock

@@ -223,9 +223,9 @@ checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
 
 [[package]]
 name = "bstr"
-version = "1.11.3"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"
+checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
 dependencies = [
  "memchr",
  "regex-automata 0.4.9",
@@ -401,9 +401,9 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.14"
+version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ba6d68e24814cb8de6bb986db8222d3a027d15872cabc0d18817bc3c0e4471"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -1125,9 +1125,9 @@ checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"
+checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
 [[package]]
 name = "litemap"
@@ -1215,9 +1215,9 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.7"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff70ce3e48ae43fa075863cef62e8b43b71a4f2382229920e0df362592919430"
+checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a"
 dependencies = [
  "adler2",
 ]
@@ -1576,7 +1576,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.10.0"
+version = "0.10.2"
 dependencies = [
  "anyhow",
  "append-only-vec",
@@ -1882,7 +1882,7 @@ dependencies = [
  "bitflags 2.9.0",
  "errno",
  "libc",
- "linux-raw-sys 0.9.3",
+ "linux-raw-sys 0.9.4",
  "windows-sys 0.59.0",
 ]
 
@@ -2900,9 +2900,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e97b544156e9bebe1a0ffbc03484fc1ffe3100cbce3ffb17eac35f7cdd7ab36"
+checksum = "63d3fcd9bba44b03821e7d699eeee959f3126dcc4aa8e4ae18ec617c2a5cea10"
 dependencies = [
  "memchr",
 ]

{pyrefly-0.10.0 → pyrefly-0.10.2}/pyrefly/Cargo.toml

@@ -2,10 +2,10 @@
 
 [package]
 name = "pyrefly"
-version = "0.10.0"
+version = "0.10.2"
 authors = ["Meta"]
 edition = "2021"
-repository = "https://github.com/facebook/pyre-check/tree/main/pyre2"
+repository = "https://github.com/facebook/pyrefly"
 license = "MIT"
 build = "build.rs"
 

{pyrefly-0.10.0 → pyrefly-0.10.2}/pyrefly/bin/main.rs

@@ -12,12 +12,13 @@ use std::path::PathBuf;
 use std::process::ExitCode;
 
 use anyhow::anyhow;
-use anyhow::Context as _;
 use clap::Parser;
 use clap::Subcommand;
 use path_absolutize::Absolutize;
 use pyrefly::clap_env;
-use pyrefly::fs_upward_search::first_match;
+use pyrefly::finder::get_implicit_config_for_file;
+use pyrefly::finder::get_implicit_config_for_project;
+use pyrefly::finder::get_open_source_config;
 use pyrefly::get_args_expanded;
 use pyrefly::globs::FilteredGlobs;
 use pyrefly::globs::Globs;
@@ -29,6 +30,8 @@ use pyrefly::run::ConfigMigrationArgs;
 use pyrefly::run::LspArgs;
 use pyrefly::ConfigFile;
 use pyrefly::NotifyWatcher;
+use tracing::debug;
+use tracing::info;
 
 #[derive(Debug, Parser)]
 #[command(name = "pyrefly")]
@@ -95,38 +98,11 @@ fn exit_on_panic() {
     }));
 }
 
-fn get_open_source_config(file: &Path) -> anyhow::Result<ConfigFile> {
-    ConfigFile::from_file(file, true).map_err(|err| {
-        let file_str = file.display();
-        anyhow!("Failed to parse configuration at {file_str}: {err}")
-    })
-}
-
-fn get_implicit_config_path_from(path: &Path) -> anyhow::Result<PathBuf> {
-    if let Some(search_result) = first_match(path, &ConfigFile::CONFIG_FILE_NAMES) {
-        Ok(search_result.to_path_buf())
-    } else {
-        Err(anyhow!(
-            "Cannot locate a config file using upward-searching heuristics from `{}`",
-            path.display()
-        ))
-    }
-}
-
-fn to_exit_code(status: CommandExitStatus) -> ExitCode {
-    match status {
-        CommandExitStatus::Success => ExitCode::SUCCESS,
-        CommandExitStatus::UserError => ExitCode::FAILURE,
-        // Exit code 2 is reserved for Meta-internal usages
-        CommandExitStatus::InfraError => ExitCode::from(3),
-    }
-}
-
 async fn run_check(
     args: pyrefly::run::CheckArgs,
     watch: bool,
     files_to_check: FilteredGlobs,
-    config_finder: &impl Fn(&Path) -> ConfigFile,
+    config_finder: impl Fn(&Path) -> ConfigFile,
     allow_forget: bool,
 ) -> anyhow::Result<CommandExitStatus> {
     if watch {
@@ -142,18 +118,6 @@ async fn run_check(
     }
 }
 
-fn get_implicit_config_for_project() -> ConfigFile {
-    fn get_config_path() -> anyhow::Result<ConfigFile> {
-        let current_dir = std::env::current_dir().context("cannot identify current dir")?;
-        let config_path = get_implicit_config_path_from(&current_dir)?;
-        get_open_source_config(&config_path)
-    }
-    get_config_path().unwrap_or_else(|err| {
-        tracing::debug!("{err}. Default configuration will be used as fallback.");
-        ConfigFile::default()
-    })
-}
-
 async fn run_check_on_project(
     watch: bool,
     config: Option<PathBuf>,
@@ -162,42 +126,27 @@ async fn run_check_on_project(
     allow_forget: bool,
 ) -> anyhow::Result<CommandExitStatus> {
     let config = if let Some(explicit_config_path) = config {
-        tracing::info!(
+        info!(
             "Using config file explicitly provided at `{}`",
             explicit_config_path.display()
         );
-        get_open_source_config(&explicit_config_path)?
+        args.override_config(get_open_source_config(&explicit_config_path)?)
     } else {
-        get_implicit_config_for_project()
+        get_implicit_config_for_project(|c| args.override_config(c))
     };
+    debug!("Config is: {}", config);
     let project_excludes =
         project_excludes.map_or_else(|| config.project_excludes.clone(), Globs::new);
     run_check(
         args,
         watch,
         FilteredGlobs::new(config.project_includes.clone(), project_excludes),
-        &|_| config.clone(),
+        |_| config.clone(),
         allow_forget,
     )
     .await
 }
 
-fn get_implicit_config_for_file(path: &Path) -> ConfigFile {
-    fn get_implicit_config_path(path: &Path) -> anyhow::Result<ConfigFile> {
-        let parent_dir = path
-            .parent()
-            .with_context(|| format!("Path `{}` has no parent directory", path.display()))?
-            .absolutize()
-            .with_context(|| format!("Path `{}` cannot be absolutized", path.display()))?;
-        let config_path = get_implicit_config_path_from(parent_dir.as_ref())?;
-        get_open_source_config(&config_path)
-    }
-    get_implicit_config_path(path).unwrap_or_else(|err| {
-        tracing::debug!("{err}. Default configuration will be used as fallback.");
-        ConfigFile::default()
-    })
-}
-
 async fn run_check_on_files(
     files_to_check: Globs,
     project_excludes: Option<Vec<String>>,
@@ -209,10 +158,10 @@ async fn run_check_on_files(
         project_excludes.map_or_else(ConfigFile::default_project_excludes, Globs::new);
     let files_to_check = files_to_check.from_root(PathBuf::new().absolutize()?.as_ref());
     run_check(
-        args,
+        args.clone(),
         watch,
         FilteredGlobs::new(files_to_check, project_excludes),
-        &|path| get_implicit_config_for_file(path),
+        &get_implicit_config_for_file(&|c| args.override_config(c)),
         allow_forget,
     )
     .await
@@ -228,7 +177,9 @@ async fn run_command(command: Command, allow_forget: bool) -> anyhow::Result<Com
             args,
         } => {
             if !files.is_empty() && config.is_some() {
-                anyhow::bail!("Can either supply `FILES...` OR `--config/-c`, not both.")
+                return Err(anyhow!(
+                    "Can either supply `FILES...` OR `--config/-c`, not both."
+                ));
             }
             if files.is_empty() {
                 run_check_on_project(watch, config, project_excludes, args, allow_forget).await
@@ -258,7 +209,7 @@ async fn run() -> anyhow::Result<ExitCode> {
             let _ = run_command(args.command.clone(), false).await;
         }
     } else {
-        run_command(args.command, true).await.map(to_exit_code)
+        Ok(run_command(args.command, true).await?.to_exit_code())
     }
 }
 

{pyrefly-0.10.0 → pyrefly-0.10.2}/pyrefly/lib/alt/answers.rs

@@ -49,7 +49,6 @@ use crate::types::equality::TypeEq;
 use crate::types::equality::TypeEqCtx;
 use crate::types::stdlib::Stdlib;
 use crate::types::type_info::TypeInfo;
-use crate::types::types::AnyStyle;
 use crate::types::types::NeverStyle;
 use crate::types::types::Type;
 use crate::types::types::Var;
@@ -298,6 +297,7 @@ pub trait LookupAnswer: Sized {
     fn get<K: Solve<Self> + Keyed<EXPORTED = true>>(
         &self,
         module: ModuleName,
+        path: Option<&ModulePath>,
         k: &K,
     ) -> Arc<K::Answer>
     where
@@ -495,6 +495,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     pub fn get_from_module<K: Solve<Ans> + Keyed<EXPORTED = true>>(
         &self,
         module: ModuleName,
+        path: Option<&ModulePath>,
         k: &K,
     ) -> Arc<K::Answer>
     where
@@ -505,7 +506,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         if module == self.module_info().name() {
             self.get(k)
         } else {
-            self.answers.get(module, k)
+            self.answers.get(module, path, k)
         }
     }
 
@@ -519,7 +520,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         BindingTable: TableKeyed<K, Value = BindingEntry<K>>,
         SolutionsTable: TableKeyed<K, Value = SolutionsEntry<K>>,
     {
-        self.get_from_module(cls.module_name(), k)
+        self.get_from_module(cls.module_name(), Some(cls.module_info().path()), k)
     }
 
     pub fn type_order(&self) -> TypeOrder<Ans> {
@@ -656,9 +657,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         errors: &ErrorCollector,
         tcc: &dyn Fn() -> TypeCheckContext,
     ) -> bool {
-        if matches!(got, Type::Any(AnyStyle::Error))
-            || self.solver().is_subset_eq(got, want, self.type_order())
-        {
+        if got.is_error() || self.solver().is_subset_eq(got, want, self.type_order()) {
             true
         } else {
             self.solver().error(want, got, errors, loc, tcc);

{pyrefly-0.10.0 → pyrefly-0.10.2}/pyrefly/lib/alt/attr.rs

@@ -1014,7 +1014,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     fn get_exported_type(&self, exports: &Exports, from: ModuleName, name: &Name) -> Option<Type> {
         if exports.exports(self.exports).contains_key(name) {
             Some(
-                self.get_from_module(from, &KeyExport(name.clone()))
+                self.get_from_module(from, None, &KeyExport(name.clone()))
                     .arc_clone(),
             )
         } else {
@@ -1184,7 +1184,7 @@ impl<'a, Ans: LookupAnswer + LookupExport> AnswersSolver<'a, Ans> {
                     res.push(AttrInfo {
                         name: fld.clone(),
                         ty: None,
-                        module: Some(c.module_info()),
+                        module: Some(c.module_info().dupe()),
                         range: c.field_decl_range(fld),
                     });
                 }

{pyrefly-0.10.0 → pyrefly-0.10.2}/pyrefly/lib/alt/call.rs

@@ -8,7 +8,6 @@
 use dupe::Dupe;
 use ruff_python_ast::name::Name;
 use ruff_python_ast::Keyword;
-use ruff_python_ast::Operator;
 use ruff_text_size::TextRange;
 use starlark_map::small_set::SmallSet;
 use vec1::Vec1;
@@ -41,7 +40,6 @@ use crate::types::types::Var;
 use crate::util::visit::VisitMut;
 pub enum CallStyle<'a> {
     Method(&'a Name),
-    BinaryOp(Operator),
     FreeForm,
 }
 
@@ -218,9 +216,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     CallStyle::Method(method) => {
                         format!("Expected `{}` to be a callable", method)
                     }
-                    CallStyle::BinaryOp(op) => {
-                        format!("Expected `{}` to be a callable", op.dunder())
-                    }
                     CallStyle::FreeForm => "Expected a callable".to_owned(),
                 };
                 self.error_call_target(

{pyrefly-0.10.0 → pyrefly-0.10.2}/pyrefly/lib/alt/class/class_field.rs

@@ -27,10 +27,13 @@ use crate::alt::attr::DescriptorBase;
 use crate::alt::attr::NoAccessReason;
 use crate::alt::types::class_metadata::ClassMetadata;
 use crate::binding::binding::ClassFieldInitialValue;
+use crate::binding::binding::ExprOrBinding;
 use crate::binding::binding::KeyClassField;
 use crate::binding::binding::KeyClassSynthesizedFields;
 use crate::dunder;
 use crate::error::collector::ErrorCollector;
+use crate::error::context::TypeCheckContext;
+use crate::error::context::TypeCheckKind;
 use crate::error::kind::ErrorKind;
 use crate::error::style::ErrorStyle;
 use crate::types::annotation::Annotation;
@@ -217,7 +220,7 @@ impl ClassField {
         match &self.0 {
             ClassFieldInner::Simple { ty, .. } => ty.collect_quantifieds(&mut qs),
         };
-        tparams.quantified().any(|q| qs.contains(&q))
+        tparams.quantified().any(|q| qs.contains(q))
     }
 
     fn as_raw_special_method_type(self, cls: &ClassType) -> Option<Type> {
@@ -289,7 +292,7 @@ impl ClassField {
         }
     }
 
-    pub fn is_dataclass_kwonly_marker(&self) -> bool {
+    fn is_dataclass_kwonly_marker(&self) -> bool {
         match &self.0 {
             ClassFieldInner::Simple { ty, .. } => {
                 matches!(ty, Type::ClassType(cls) if cls.class_object().has_qname("dataclasses", "KW_ONLY"))
@@ -328,18 +331,9 @@ impl ClassField {
         }
     }
 
-    pub fn dataclass_flags_of(&self, kw_only: bool) -> Option<BoolKeywords> {
+    fn dataclass_flags_of(&self, kw_only: bool) -> BoolKeywords {
         match &self.0 {
-            ClassFieldInner::Simple {
-                initialization,
-                annotation,
-                ..
-            } => {
-                if let Some(annot) = annotation
-                    && annot.qualifiers.contains(&Qualifier::ClassVar)
-                {
-                    return None; // Class variables are not dataclass fields
-                }
+            ClassFieldInner::Simple { initialization, .. } => {
                 let mut flags = match initialization {
                     ClassFieldInitialization::Class(Some(field_flags)) => field_flags.clone(),
                     ClassFieldInitialization::Class(None) => {
@@ -352,7 +346,7 @@ impl ClassField {
                 if kw_only {
                     flags.set(DataclassKeywords::KW_ONLY.0, true);
                 }
-                Some(flags)
+                flags
             }
         }
     }
@@ -443,11 +437,21 @@ impl<T> WithDefiningClass<T> {
     }
 }
 
+/// The result of processing a raw dataclass member (any annotated assignment in its body).
+pub enum DataclassMember {
+    /// A dataclass field
+    Field(ClassField, BoolKeywords),
+    /// A pseudo-field annotated with KW_ONLY
+    KwOnlyMarker,
+    /// Anything else
+    NotAField,
+}
+
 impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     pub fn calculate_class_field(
         &self,
         name: &Name,
-        value_ty: &Type,
+        value: &ExprOrBinding,
         annotation: Option<&Annotation>,
         initial_value: &ClassFieldInitialValue,
         class: &Class,
@@ -455,6 +459,28 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         range: TextRange,
         errors: &ErrorCollector,
     ) -> ClassField {
+        let value_ty = match value {
+            ExprOrBinding::Expr(e) => {
+                let inherited_annot = if annotation.is_some() {
+                    None
+                } else {
+                    self.get_inherited_annotation(class, name)
+                };
+                let mut ty = if let Some(annot) = inherited_annot {
+                    let ctx: &dyn Fn() -> TypeCheckContext =
+                        &|| TypeCheckContext::of_kind(TypeCheckKind::Attribute(name.clone()));
+                    let hint = Some((annot.get_type(), ctx));
+                    self.expr(e, hint, errors)
+                } else {
+                    self.expr_infer(e, errors)
+                };
+                self.expand_type_mut(&mut ty);
+                ty
+            }
+            ExprOrBinding::Binding(b) => {
+                Arc::unwrap_or_clone(self.solve_binding(b, errors)).into_ty()
+            }
+        };
         let metadata = self.get_metadata_for_class(class);
         let initialization = self.get_class_field_initialization(&metadata, initial_value);
 
@@ -598,11 +624,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             Type::ClassType(c) => {
                 if c.class_object().contains(&dunder::GET) {
                     descriptor_getter =
-                        Some(self.attr_infer(&ty, &dunder::GET, range, errors, None));
+                        Some(self.attr_infer_for_type(&ty, &dunder::GET, range, errors, None));
                 }
                 if c.class_object().contains(&dunder::SET) {
                     descriptor_setter =
-                        Some(self.attr_infer(&ty, &dunder::SET, range, errors, None));
+                        Some(self.attr_infer_for_type(&ty, &dunder::SET, range, errors, None));
                 }
             }
             _ => {}
@@ -629,6 +655,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         class_field
     }
 
+    fn get_inherited_annotation(&self, class: &Class, name: &Name) -> Option<Annotation> {
+        self.get_metadata_for_class(class)
+            .ancestors(self.stdlib)
+            .find_map(|parent| {
+                let parent_field = self
+                    .get_field_from_current_class_only(parent.class_object(), name)
+                    .map(Arc::unwrap_or_clone)?;
+                let ClassField(ClassFieldInner::Simple { annotation, .. }) = parent_field;
+                annotation
+            })
+    }
+
     fn get_class_field_initialization(
         &self,
         metadata: &ClassMetadata,
@@ -678,6 +716,29 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         }
     }
 
+    pub fn get_dataclass_member(&self, cls: &Class, name: &Name, kw_only: bool) -> DataclassMember {
+        // Even though we check that the class member exists before calling this function,
+        // it can be None if the class has an invalid MRO.
+        let Some(member) = self.get_class_member(cls, name) else {
+            return DataclassMember::NotAField;
+        };
+        let field = &*member.value;
+        // A field with type KW_ONLY is a sentinel value that indicates that the remaining
+        // fields should be keyword-only params in the generated `__init__`.
+        if field.is_dataclass_kwonly_marker() {
+            DataclassMember::KwOnlyMarker
+        } else if field.is_class_var()
+            || (!field.has_explicit_annotation()
+                && self
+                    .get_inherited_annotation(cls, name)
+                    .is_some_and(|annot| annot.has_qualifier(&Qualifier::ClassVar)))
+        {
+            DataclassMember::NotAField // Class variables are not dataclass fields
+        } else {
+            DataclassMember::Field(field.clone(), field.dataclass_flags_of(kw_only))
+        }
+    }
+
     fn check_and_sanitize_method_scope_type_parameters(
         &self,
         class: &Class,
@@ -687,13 +748,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         range: TextRange,
         errors: &ErrorCollector,
     ) -> Type {
-        let mut qs = SmallSet::new();
-        ty.collect_quantifieds(&mut qs);
         if let Some(method_field) =
             self.get_non_synthesized_field_from_current_class_only(class, method_name)
         {
             match &method_field.raw_type() {
                 Type::Forall(box Forall { tparams, .. }) => {
+                    let mut qs = SmallSet::new();
+                    ty.collect_quantifieds(&mut qs);
                     let gradual_fallbacks: SmallMap<_, _> = tparams
                         .iter()
                         .filter_map(|param| {
@@ -716,6 +777,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             }
                         })
                         .collect();
+                    drop(qs);
                     ty.subst(&gradual_fallbacks)
                 }
                 _ => ty,