pyrefly 0.22.1__tar.gz → 0.23.0__tar.gz

{pyrefly-0.22.1 → pyrefly-0.23.0}/Cargo.lock

@@ -1872,7 +1872,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.22.1"
+version = "0.23.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -1930,7 +1930,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.22.1"
+version = "0.23.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1939,7 +1939,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.22.1"
+version = "0.23.0"
 dependencies = [
  "anyhow",
  "dupe",
@@ -1953,6 +1953,7 @@ dependencies = [
  "ruff_python_parser",
  "ruff_text_size",
  "serde",
+ "starlark_map",
  "static_interner",
  "thiserror 2.0.12",
  "toml",
@@ -1960,7 +1961,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.22.1"
+version = "0.23.0"
 dependencies = [
  "anstream",
  "anyhow",

{pyrefly-0.22.1 → pyrefly-0.23.0}/PKG-INFO

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

{pyrefly-0.22.1 → pyrefly-0.23.0}/crates/pyrefly_python/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_python"
-version = "0.22.1"
+version = "0.23.0"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"
@@ -21,6 +21,7 @@ ruff_python_ast = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c
 ruff_python_parser = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
 ruff_text_size = { git = "https://github.com/astral-sh/ruff/", rev = "6e785867c3a97691972e8a49c372b3effba90032" }
 serde = { version = "1.0.185", features = ["derive", "rc"] }
+starlark_map = "0.13.0"
 static_interner = "0.1.1"
 thiserror = "2.0.12"
 

{pyrefly-0.22.1 → pyrefly-0.23.0}/crates/pyrefly_python/src/dunder.rs

@@ -11,6 +11,7 @@ use ruff_python_ast::name::Name;
 pub const AENTER: Name = Name::new_static("__aenter__");
 pub const AEXIT: Name = Name::new_static("__aexit__");
 pub const ALL: Name = Name::new_static("__all__");
+pub const BOOL: Name = Name::new_static("__bool__");
 pub const CALL: Name = Name::new_static("__call__");
 pub const CONTAINS: Name = Name::new_static("__contains__");
 pub const DATACLASS_FIELDS: Name = Name::new_static("__dataclass_fields__");
@@ -41,7 +42,7 @@ pub const POS: Name = Name::new_static("__pos__");
 pub const SET: Name = Name::new_static("__set__");
 pub const SETATTR: Name = Name::new_static("__setattr__");
 pub const SETITEM: Name = Name::new_static("__setitem__");
-pub const BOOL: Name = Name::new_static("__bool__");
+pub const SLOTS: Name = Name::new_static("__slots__");
 
 pub const RICH_CMPS: &[Name] = &[LT, LE, EQ, NE, GT, GE];
 /// Rich comparison methods supplied by the `functools.total_ordering` decorator

{pyrefly-0.22.1/pyrefly/lib/module → pyrefly-0.23.0/crates/pyrefly_python/src}/ignore.rs

@@ -26,15 +26,11 @@
 //! We are permissive with whitespace, allowing `#type:ignore[code]` and
 //! `#  type:  ignore  [  code  ]`, but do not allow a space after the colon.
 
-use std::str::FromStr;
-
 use dupe::Dupe;
 use pyrefly_util::lined_buffer::LineNumber;
 use starlark_map::small_map::SmallMap;
 use starlark_map::small_set::SmallSet;
 
-use crate::error::kind::ErrorKind;
-
 /// The name of the tool that is being suppressed.
 #[derive(PartialEq, Debug, Clone, Hash, Eq, Dupe, Copy)]
 pub enum Tool {
@@ -96,20 +92,38 @@ impl<'a> Lexer<'a> {
     }
 
     /// Trim whitespace from the start of the string.
-    fn trim_start(&mut self) {
+    /// Return `true` if the string was changed.
+    fn trim_start(&mut self) -> bool {
+        let before = self.0;
         self.0 = self.0.trim_start();
+        self.0.len() != before.len()
     }
 
     /// Return `true` if the string is empty or only whitespace.
     fn blank(&mut self) -> bool {
         self.0.trim_start().is_empty()
     }
+
+    /// Return `true` if the string is at the start of a word boundary.
+    /// That means the next char is not something that continues an identifier.
+    fn word_boundary(&mut self) -> bool {
+        self.0
+            .chars()
+            .next()
+            .is_none_or(|c| !c.is_alphanumeric() && c != '-' && c != '_')
+    }
+
+    /// Finish and return the rest of the string.
+    fn rest(self) -> &'a str {
+        self.0
+    }
 }
 
-#[derive(PartialEq, Debug, Clone, Hash, Eq, Dupe, Copy)]
+#[derive(PartialEq, Debug, Clone, Hash, Eq)]
 pub struct Suppression {
     tool: Tool,
-    kind: Option<ErrorKind>,
+    /// The permissible error kinds, use empty Vec to many any are allowed
+    kind: Vec<String>,
 }
 
 /// Record the position of `# type: ignore[valid-type]` statements.
@@ -180,19 +194,22 @@ impl Ignore {
         // If we see a comment on a non-code line, move it to the next non-comment line.
         let mut pending = Vec::new();
         let mut line = LineNumber::default();
-        for (idx, x) in code.lines().enumerate() {
+        for (idx, line_str) in code.lines().enumerate() {
             line = LineNumber::from_zero_indexed(idx as u32);
-            let mut xs = x.split('#');
+            let mut xs = line_str.split('#');
             let first = xs.next().unwrap_or("");
-            if let Some(supp) = Self::get_suppression_kind(x) {
-                if first.trim_start().is_empty() {
-                    pending.push(supp);
-                } else {
-                    ignores.entry(line).or_default().push(supp);
-                }
-            } else if !pending.is_empty() && (x.is_empty() || !first.trim_start().is_empty()) {
+            if !pending.is_empty() && (line_str.is_empty() || !first.trim_start().is_empty()) {
                 ignores.entry(line).or_default().append(&mut pending);
             }
+            for x in xs {
+                if let Some(supp) = Self::parse_ignore_comment(x) {
+                    if first.trim_start().is_empty() {
+                        pending.push(supp);
+                    } else {
+                        ignores.entry(line).or_default().push(supp);
+                    }
+                }
+            }
         }
         if !pending.is_empty() {
             ignores
@@ -203,50 +220,36 @@ impl Ignore {
         ignores
     }
 
-    fn get_suppression_kind(line: &str) -> Option<Suppression> {
-        fn match_pyrefly_ignore(line: &str) -> Option<Suppression> {
-            let mut words = line.split_whitespace();
-            if let Some("pyrefly:") = words.next() {
-                if let Some(word) = words.next() {
-                    if word == "ignore" {
-                        return Some(Suppression {
-                            tool: Tool::Pyrefly,
-                            kind: None,
-                        });
-                    }
+    /// Given the content of a comment, parse it as a suppression.
+    fn parse_ignore_comment(l: &str) -> Option<Suppression> {
+        let mut lex = Lexer(l);
+        lex.trim_start();
 
-                    if let Some(word) = word.strip_prefix("ignore[")
-                        && let Some(word) = word.strip_suffix(']')
-                    {
-                        if let Ok(kind) = ErrorKind::from_str(word) {
-                            return Some(Suppression {
-                                tool: Tool::Pyrefly,
-                                kind: Some(kind),
-                            });
-                        }
-                    }
-                }
+        let mut tool = None;
+        if let Some(t) = lex.starts_with_tool() {
+            lex.trim_start();
+            if lex.starts_with("ignore") {
+                tool = Some(t);
             }
-            None
+        } else if lex.starts_with("pyre-ignore") || lex.starts_with("pyre-fixme") {
+            tool = Some(Tool::Pyre);
         }
+        let tool = tool?;
 
-        for l in line.split("#").skip(1) {
-            let l = l.trim_start();
-            if let Some(l) = l.strip_prefix("type:")
-                && l.trim_start().starts_with("ignore")
-            {
-                return Some(Suppression {
-                    tool: Tool::Any,
-                    kind: None,
-                });
-            } else if let Some(value) = match_pyrefly_ignore(l) {
-                return Some(value);
-            } else if l.starts_with("pyre-ignore") || l.starts_with("pyre-fixme") {
-                return Some(Suppression {
-                    tool: Tool::Pyre,
-                    kind: None,
-                });
-            }
+        // We have seen `type: ignore` or `pyre-ignore`. Now look for `[code]` or the end.
+        let gap = lex.trim_start();
+        if lex.starts_with("[") {
+            let rest = lex.rest();
+            let inside = rest.split_once(']').map_or(rest, |x| x.0);
+            return Some(Suppression {
+                tool,
+                kind: inside.split(',').map(|x| x.trim().to_owned()).collect(),
+            });
+        } else if gap || lex.word_boundary() {
+            return Some(Suppression {
+                tool,
+                kind: Vec::new(),
+            });
         }
         None
     }
@@ -255,7 +258,7 @@ impl Ignore {
         &self,
         start_line: LineNumber,
         end_line: LineNumber,
-        kind: ErrorKind,
+        kind: &str,
         permissive_ignores: bool,
     ) -> bool {
         if self.ignore_all_strict || (permissive_ignores && self.ignore_all_permissive) {
@@ -268,7 +271,7 @@ impl Ignore {
             if let Some(suppressions) = self.ignores.get(&LineNumber::from_zero_indexed(line)) {
                 if suppressions.iter().any(|supp| match supp.tool {
                     // We only check the subkind if they do `# ignore: pyrefly`
-                    Tool::Pyrefly => supp.kind.is_none_or(|x| x == kind),
+                    Tool::Pyrefly => supp.kind.is_empty() || supp.kind.iter().any(|x| x == kind),
                     Tool::Any => true,
                     _ => permissive_ignores,
                 }) {
@@ -288,7 +291,7 @@ impl Ignore {
                 ignore
                     .1
                     .iter()
-                    .any(|s| s.tool == Tool::Pyrefly && s.kind.is_none())
+                    .any(|s| s.tool == Tool::Pyrefly && s.kind.is_empty())
             })
             .map(|(line, _)| *line)
             .collect()
@@ -297,115 +300,127 @@ impl Ignore {
 
 #[cfg(test)]
 mod tests {
-    use starlark_map::smallmap;
+    use pyrefly_util::prelude::SliceExt;
 
     use super::*;
 
     #[test]
-    fn test_get_suppression_kind() {
-        assert!(Ignore::get_suppression_kind("stuff # type: ignore # and then stuff").is_some());
-        assert!(Ignore::get_suppression_kind("more # stuff # type: ignore[valid-type]").is_some());
-        assert!(Ignore::get_suppression_kind("# ignore: pyrefly").is_none());
-        assert!(Ignore::get_suppression_kind(" pyrefly: ignore").is_none());
-        assert!(Ignore::get_suppression_kind("normal line").is_none());
-        assert!(
-            Ignore::get_suppression_kind("# pyrefly: ignore")
-                == Some(Suppression {
-                    tool: Tool::Pyrefly,
-                    kind: None
-                })
+    fn test_parse_ignores() {
+        fn f(x: &str, expect: &[(Tool, u32)]) {
+            assert_eq!(
+                &Ignore::parse_ignores(x)
+                    .into_iter()
+                    .flat_map(|(line, xs)| xs.map(|x| (x.tool, line.get())))
+                    .collect::<Vec<_>>(),
+                expect,
+                "{x:?}"
+            );
+        }
+
+        f("stuff # type: ignore # and then stuff", &[(Tool::Any, 1)]);
+        f("more # stuff # type: ignore", &[(Tool::Any, 1)]);
+        f(" pyrefly: ignore", &[]);
+        f("normal line", &[]);
+        f(
+            "code # mypy: ignore\n# pyre-fixme\nmore code",
+            &[(Tool::Mypy, 1), (Tool::Pyre, 3)],
         );
-        assert!(
-            Ignore::get_suppression_kind("# pyrefly: ignore[bad-return]")
-                == Some(Suppression {
-                    tool: Tool::Pyrefly,
-                    kind: Some(ErrorKind::BadReturn)
-                })
+        f(
+            "# type: ignore\n# mypy: ignore\n# bad\n\ncode",
+            &[(Tool::Any, 4), (Tool::Mypy, 4)],
         );
-        assert!(Ignore::get_suppression_kind("# pyrefly: ignore[]").is_none());
-        assert!(Ignore::get_suppression_kind("# pyrefly: ignore[bad-]").is_none());
     }
 
     #[test]
-    fn test_parse_ignore_all() {
-        assert_eq!(
-            Ignore::parse_ignore_all(
-                r#"
-# pyrefly: ignore-errors
-x = 5
-"#
-            ),
-            smallmap! {Tool::Pyrefly => LineNumber::from_zero_indexed(1)}
-        );
-        assert_eq!(
-            Ignore::parse_ignore_all(
-                r#"
-# comment
-# pyrefly: ignore-errors
-x = 5
-"#
-            ),
-            smallmap! {Tool::Pyrefly => LineNumber::from_zero_indexed(2)}
+    fn test_parse_ignore_comment() {
+        fn f(x: &str, tool: Option<Tool>, kind: &[&str]) {
+            assert_eq!(
+                Ignore::parse_ignore_comment(x),
+                tool.map(|tool| Suppression {
+                    tool,
+                    kind: kind.map(|x| (*x).to_owned()),
+                }),
+                "{x:?}"
+            );
+        }
+
+        f("ignore: pyrefly", None, &[]);
+        f("pyrefly: ignore", Some(Tool::Pyrefly), &[]);
+        f(
+            "pyrefly: ignore[bad-return]",
+            Some(Tool::Pyrefly),
+            &["bad-return"],
         );
-        assert_eq!(
-            Ignore::parse_ignore_all(
-                r#"
-# comment
-  # indented comment
-# pyrefly: ignore-errors
-x = 5
-"#
-            ),
-            smallmap! {Tool::Pyrefly => LineNumber::from_zero_indexed(3)}
+        f("pyrefly: ignore[]", Some(Tool::Pyrefly), &[""]);
+        f("pyrefly: ignore[bad-]", Some(Tool::Pyrefly), &["bad-"]);
+
+        // Check spacing
+        f(" type: ignore ", Some(Tool::Any), &[]);
+        f("type:ignore", Some(Tool::Any), &[]);
+        f("type :ignore", None, &[]);
+
+        // Check extras
+        // Mypy rejects that, Pyright accepts it
+        f("type: ignore because it is wrong", Some(Tool::Any), &[]);
+        f("type: ignore_none", None, &[]);
+        f("type: ignore1", None, &[]);
+        f("type: ignore?", Some(Tool::Any), &[]);
+
+        f("mypy: ignore", Some(Tool::Mypy), &[]);
+        f("mypy: ignore[something]", Some(Tool::Mypy), &["something"]);
+
+        f("pyre-ignore", Some(Tool::Pyre), &[]);
+        f("pyre-ignore[7]", Some(Tool::Pyre), &["7"]);
+        f("pyre-fixme[7]", Some(Tool::Pyre), &["7"]);
+        f(
+            "pyre-fixme[61]: `x` may not be initialized here.",
+            Some(Tool::Pyre),
+            &["61"],
         );
-        assert_eq!(
-            Ignore::parse_ignore_all(
-                r#"
-x = 5
-# pyrefly: ignore-errors
-"#
-            ),
-            smallmap! {}
+        f("pyre-fixme: core type error", Some(Tool::Pyre), &[]);
+
+        // For a malformed comment, at least do something with it (works well incrementally)
+        f("type: ignore[hello", Some(Tool::Any), &["hello"]);
+    }
+
+    #[test]
+    fn test_parse_ignore_all() {
+        fn f(x: &str, ignores: &[(Tool, u32)]) {
+            assert_eq!(
+                Ignore::parse_ignore_all(x),
+                ignores
+                    .iter()
+                    .map(|x| (x.0, LineNumber::new(x.1).unwrap()))
+                    .collect(),
+                "{x:?}"
+            );
+        }
+
+        f("# pyrefly: ignore-errors\nx = 5", &[(Tool::Pyrefly, 1)]);
+        f(
+            "# comment\n# pyrefly: ignore-errors\nx = 5",
+            &[(Tool::Pyrefly, 2)],
         );
-        assert_eq!(
-            Ignore::parse_ignore_all(
-                r#"
-# type: ignore
-
-x = 5
-"#
-            ),
-            smallmap! {Tool::Any => LineNumber::from_zero_indexed(1)}
+        f(
+            "#comment\n  # indent\n# pyrefly: ignore-errors\nx = 5",
+            &[(Tool::Pyrefly, 3)],
         );
-        assert_eq!(
-            Ignore::parse_ignore_all(
-                r#"
-# comment
-# type: ignore
-# comment
-x = 5
-"#
-            ),
-            smallmap! {Tool::Any => LineNumber::from_zero_indexed(2)}
+        f("x = 5\n# pyrefly: ignore-errors", &[]);
+        f("# type: ignore\n\nx = 5", &[(Tool::Any, 1)]);
+        f(
+            "# comment\n# type: ignore\n# comment\nx = 5",
+            &[(Tool::Any, 2)],
         );
-        assert_eq!(
-            Ignore::parse_ignore_all(
-                r#"
-# type: ignore
-x = 5
-"#
-            ),
-            smallmap! {}
+        f("# type: ignore\nx = 5", &[]);
+        f("# pyre-ignore-all-errors\nx = 5", &[(Tool::Pyre, 1)]);
+        f(
+            "# mypy: ignore-errors\n#pyrefly:ignore-errors",
+            &[(Tool::Mypy, 1), (Tool::Pyrefly, 2)],
         );
 
-        assert_eq!(
-            Ignore::parse_ignore_all(
-                r#"
-# pyre-ignore-all-errors
-x = 5
-"#
-            ),
-            smallmap! {Tool::Pyre => LineNumber::from_zero_indexed(1)}
-        );
+        // Anything else on the line (other than space) makes it invalid
+        f("# pyrefly: ignore-errors because I want to\nx = 5", &[]);
+        f("# pyrefly: ignore-errors # because I want to\nx = 5", &[]);
+        f("# pyrefly: ignore-errors \nx = 5", &[(Tool::Pyrefly, 1)]);
     }
 }

{pyrefly-0.22.1 → pyrefly-0.23.0}/crates/pyrefly_python/src/lib.rs

@@ -21,6 +21,8 @@
 
 pub mod ast;
 pub mod dunder;
+pub mod ignore;
 pub mod module_name;
+pub mod module_path;
 pub mod symbol_kind;
 pub mod sys_info;

{pyrefly-0.22.1/pyrefly/lib/module → pyrefly-0.23.0/crates/pyrefly_python/src}/module_path.rs

@@ -12,12 +12,13 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use dupe::Dupe;
-use pyrefly_python::dunder;
-use pyrefly_python::module_name::ModuleName;
 use pyrefly_util::with_hash::WithHash;
 use serde::Serialize;
 use serde::Serializer;
 
+use crate::dunder;
+use crate::module_name::ModuleName;
+
 #[derive(Debug, Clone, Dupe, Copy, PartialEq, Eq, Hash, Default)]
 pub enum ModuleStyle {
     /// .py - executable code.

{pyrefly-0.22.1 → pyrefly-0.23.0}/crates/pyrefly_python/src/sys_info.rs

@@ -226,18 +226,22 @@ impl SysInfo {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, PartialEq, PartialOrd)]
 enum Value {
     Tuple(Vec<Value>),
     String(String),
     Int(i64),
     Bool(bool),
+    /// I know what the value evaluates to when considered truthy, but not it's precise outcome.
+    /// We make sure below that it never compares equal to itself
+    Truthiness(bool),
 }
 
 impl Value {
     fn to_bool(&self) -> bool {
         match self {
             Value::Bool(x) => *x,
+            Value::Truthiness(x) => *x,
             Value::Int(x) => *x != 0,
             Value::String(x) => !x.is_empty(),
             Value::Tuple(x) => !x.is_empty(),
@@ -250,13 +254,14 @@ impl Value {
             (Value::String(_), Value::String(_)) => true,
             (Value::Int(_), Value::Int(_)) => true,
             (Value::Bool(_), Value::Bool(_)) => true,
+            (Value::Truthiness(_), Value::Truthiness(_)) => false, // We don't know if they are the same ype
             _ => false,
         }
     }
 
     fn compare(&self, op: CmpOp, other: &Value) -> Option<bool> {
         if !self.same_type(other) {
-            return None; // Someone got confused
+            return None; // Someone got confused, or we are working with Truthiness
         }
         Some(match op {
             CmpOp::Eq => self == other,
@@ -339,24 +344,34 @@ impl SysInfo {
             Expr::StringLiteral(x) => Some(Value::String(x.value.to_str().to_owned())),
             Expr::BoolOp(x) => match x.op {
                 BoolOp::And => {
-                    let mut last = Value::Bool(true);
+                    let mut res = Some(Value::Bool(true));
                     for x in &x.values {
-                        last = self.evaluate(x)?;
-                        if !last.to_bool() {
-                            break;
+                        match self.evaluate(x) {
+                            None => res = None,
+                            Some(x) => match (x.to_bool(), res.is_none()) {
+                                (false, false) => return Some(x),
+                                (false, true) => return Some(Value::Truthiness(false)),
+                                (true, false) => res = Some(x),
+                                (true, true) => res = None,
+                            },
                         }
                     }
-                    Some(last)
+                    res
                 }
                 BoolOp::Or => {
-                    let mut last = Value::Bool(false);
+                    let mut res = Some(Value::Bool(false));
                     for x in &x.values {
-                        last = self.evaluate(x)?;
-                        if last.to_bool() {
-                            break;
+                        match self.evaluate(x) {
+                            None => res = None,
+                            Some(x) => match (x.to_bool(), res.is_none()) {
+                                (false, false) => res = Some(x),
+                                (false, true) => res = None,
+                                (true, false) => return Some(x),
+                                (true, true) => return Some(Value::Truthiness(true)),
+                            },
                         }
                     }
-                    Some(last)
+                    res
                 }
             },
             Expr::UnaryOp(x) => match x.op {

{pyrefly-0.22.1 → pyrefly-0.23.0}/pyrefly/Cargo.toml

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

{pyrefly-0.22.1 → pyrefly-0.23.0}/pyrefly/lib/alt/answers.rs

@@ -14,6 +14,7 @@ use std::sync::Arc;
 use dupe::Dupe;
 use dupe::OptionDupedExt;
 use pyrefly_python::module_name::ModuleName;
+use pyrefly_python::module_path::ModulePath;
 use pyrefly_util::display::DisplayWith;
 use pyrefly_util::display::DisplayWithCtx;
 use pyrefly_util::gas::Gas;
@@ -47,7 +48,6 @@ use crate::graph::index::Idx;
 use crate::graph::index_map::IndexMap;
 use crate::module::module_info::ModuleInfo;
 use crate::module::module_info::TextRangeWithModuleInfo;
-use crate::module::module_path::ModulePath;
 use crate::solver::solver::Solver;
 use crate::state::ide::IntermediateDefinition;
 use crate::state::ide::key_to_intermediate_definition;
@@ -478,6 +478,7 @@ impl Answers {
                 }
             }
         }
+        answers_solver.validate_final_thread_state();
 
         // Now force all types to be fully resolved.
         fn post_solve<K: Keyed>(items: &mut SolutionsEntry<K>, solver: &Solver) {