[flake8-gettext] Resolve qualified names and built-in bindings (INT001, INT002, INT003)

crates/ruff_linter/resources/test/fixtures/flake8_gettext/INT001.py

@@ -1 +1,49 @@
 _(f"{'value'}")
+gettext(f"{'value'}")
+ngettext(f"{'value'}", f"{'values'}", 2)
+
+_gettext(f"{'value'}")  # no lint
+gettext_fn(f"{'value'}")  # no lint
+
+
+# https://github.com/astral-sh/ruff/issues/19028 - import aliases
+import gettext as gettext_mod
+from gettext import (
+    gettext as gettext_fn,
+    ngettext as ngettext_fn,
+)
+
+name = "Guido"
+
+gettext_mod.gettext(f"Hello, {name}!")
+gettext_mod.ngettext(f"Hello, {name}!", f"Hello, {name}s!", 2)
+gettext_fn(f"Hello, {name}!")
+ngettext_fn(f"Hello, {name}!", f"Hello, {name}s!", 2)
+
+
+# https://github.com/astral-sh/ruff/issues/19028 - deferred translations
+def _(message): return message
+
+animals = [_(f"{'mollusk'}"),
+           _(f"{'albatross'}"),
+           _(f"{'rat'}"),
+           _(f"{'penguin'}"),
+           _(f"{'python'}"),]
+
+del _
+
+for a in animals:
+    print(_(a))
+    print(_(f"{a}"))
+
+
+# https://github.com/astral-sh/ruff/issues/19028
+#  - installed translations/i18n functions dynamically assigned to builtins
+import builtins
+
+gettext_mod.install("domain")
+builtins.__dict__["gettext"] = gettext_fn
+
+builtins._(f"{'value'}")
+builtins.gettext(f"{'value'}")
+builtins.ngettext(f"{'value'}", f"{'values'}", 2)

crates/ruff_linter/resources/test/fixtures/flake8_gettext/INT002.py

@@ -1 +1,49 @@
 _("{}".format("line"))
+gettext("{}".format("line"))
+ngettext("{}".format("line"), "{}".format("lines"), 2)
+
+_gettext("{}".format("line"))  # no lint
+gettext_fn("{}".format("line"))  # no lint
+
+
+# https://github.com/astral-sh/ruff/issues/19028
+import gettext as gettext_mod
+from gettext import (
+    gettext as gettext_fn,
+    ngettext as ngettext_fn,
+)
+
+name = "Guido"
+
+gettext_mod.gettext("Hello, {}!".format(name))
+gettext_mod.ngettext("Hello, {}!".format(name), "Hello, {}s!".format(name), 2)
+gettext_fn("Hello, {}!".format(name))
+ngettext_fn("Hello, {}!".format(name), "Hello, {}s!".format(name), 2)
+
+
+# https://github.com/astral-sh/ruff/issues/19028 - deferred translations
+def _(message): return message
+
+animals = [_("{}".format("mollusk")),
+           _("{}".format("albatross")),
+           _("{}".format("rat")),
+           _("{}".format("penguin")),
+           _("{}".format("python")),]
+
+del _
+
+for a in animals:
+    print(_(a))
+    print(_("{}".format(a)))
+
+
+# https://github.com/astral-sh/ruff/issues/19028
+#  - installed translations/i18n functions dynamically assigned to builtins
+import builtins
+
+gettext_mod.install("domain")
+builtins.__dict__["gettext"] = gettext_fn
+
+builtins._("{}".format("line"))
+builtins.gettext("{}".format("line"))
+builtins.ngettext("{}".format("line"), "{}".format("lines"), 2)

crates/ruff_linter/resources/test/fixtures/flake8_gettext/INT003.py

@@ -1 +1,49 @@
 _("%s" % "line")
+gettext("%s" % "line")
+ngettext("%s" % "line", "%s" % "lines", 2)
+
+_gettext("%s" % "line")  # no lint
+gettext_fn("%s" % "line")  # no lint
+
+
+# https://github.com/astral-sh/ruff/issues/19028
+import gettext as gettext_mod
+from gettext import (
+    gettext as gettext_fn,
+    ngettext as ngettext_fn,
+)
+
+name = "Guido"
+
+gettext_mod.gettext("Hello, %s!" % name)
+gettext_mod.ngettext("Hello, %s!" % name, "Hello, %ss!" % name, 2)
+gettext_fn("Hello, %s!" % name)
+ngettext_fn("Hello, %s!" % name, "Hello, %ss!" % name, 2)
+
+
+# https://github.com/astral-sh/ruff/issues/19028 - deferred translations
+def _(message): return message
+
+animals = [_("%s" %"mollusk"),
+           _("%s" %"albatross"),
+           _("%s" %"rat"),
+           _("%s" %"penguin"),
+           _("%s" %"python"),]
+
+del _
+
+for a in animals:
+    print(_(a))
+    print(_("%s" % a))
+
+
+# https://github.com/astral-sh/ruff/issues/19028
+#  - installed translations/i18n functions dynamically assigned to builtins
+import builtins
+
+gettext_mod.install("domain")
+builtins.__dict__["gettext"] = gettext_fn
+
+builtins._("%s" % "line")
+builtins.gettext("%s" % "line")
+builtins.ngettext("%s" % "line", "%s" % "lines", 2)

crates/ruff_linter/src/checkers/ast/analyze/expression.rs

@@ -1011,6 +1011,7 @@ pub(crate) fn expression(expr: &Expr, checker: &Checker) {
                 Rule::FormatInGetTextFuncCall,
                 Rule::PrintfInGetTextFuncCall,
             ]) && flake8_gettext::is_gettext_func_call(
+                checker,
                 func,
                 &checker.settings().flake8_gettext.functions_names,
             ) {

crates/ruff_linter/src/preview.rs

@@ -111,3 +111,8 @@ pub(crate) const fn is_safe_super_call_with_parameters_fix_enabled(
 ) -> bool {
     settings.preview.is_enabled()
 }
+
+// https://github.com/astral-sh/ruff/pull/19045
+pub(crate) const fn is_extended_i18n_function_matching_enabled(settings: &LinterSettings) -> bool {
+    settings.preview.is_enabled()
+}

crates/ruff_linter/src/rules/flake8_gettext/mod.rs

@@ -1,17 +1,50 @@
 //! Rules from [flake8-gettext](https://pypi.org/project/flake8-gettext/).
+use crate::checkers::ast::Checker;
+use crate::preview::is_extended_i18n_function_matching_enabled;
 use ruff_python_ast::name::Name;
 use ruff_python_ast::{self as ast, Expr};
+use ruff_python_semantic::Modules;
 
 pub(crate) mod rules;
 pub mod settings;
 
 /// Returns true if the [`Expr`] is an internationalization function call.
-pub(crate) fn is_gettext_func_call(func: &Expr, functions_names: &[Name]) -> bool {
-    if let Expr::Name(ast::ExprName { id, .. }) = func {
-        functions_names.contains(id)
-    } else {
-        false
+pub(crate) fn is_gettext_func_call(
+    checker: &Checker,
+    func: &Expr,
+    functions_names: &[Name],
+) -> bool {
+    if func
+        .as_name_expr()
+        .map(ast::ExprName::id)
+        .is_some_and(|id| functions_names.contains(id))
+    {
+        return true;
     }
+
+    if !is_extended_i18n_function_matching_enabled(checker.settings()) {
+        return false;
+    }
+
+    let semantic = checker.semantic();
+
+    let Some(qualified_name) = semantic.resolve_qualified_name(func) else {
+        return false;
+    };
+
+    if semantic.seen_module(Modules::BUILTINS)
+        && matches!(
+            qualified_name.segments(),
+            ["" | "builtins", id] if functions_names.contains(&Name::new(id)),
+        )
+    {
+        return true;
+    }
+
+    matches!(
+        qualified_name.segments(),
+        ["gettext", "gettext" | "ngettext"]
+    )
 }
 
 #[cfg(test)]
@@ -22,6 +55,7 @@ mod tests {
     use test_case::test_case;
 
     use crate::registry::Rule;
+    use crate::settings::types::PreviewMode;
     use crate::test::test_path;
     use crate::{assert_diagnostics, settings};
 
@@ -37,4 +71,20 @@ mod tests {
         assert_diagnostics!(snapshot, diagnostics);
         Ok(())
     }
+
+    #[test_case(Rule::FStringInGetTextFuncCall, Path::new("INT001.py"))]
+    #[test_case(Rule::FormatInGetTextFuncCall, Path::new("INT002.py"))]
+    #[test_case(Rule::PrintfInGetTextFuncCall, Path::new("INT003.py"))]
+    fn rules_preview(rule_code: Rule, path: &Path) -> Result<()> {
+        let snapshot = format!("preview__{}_{}", rule_code.name(), path.to_string_lossy());
+        let diagnostics = test_path(
+            Path::new("flake8_gettext").join(path).as_path(),
+            &settings::LinterSettings {
+                preview: PreviewMode::Enabled,
+                ..settings::LinterSettings::for_rule(rule_code)
+            },
+        )?;
+        assert_diagnostics!(snapshot, diagnostics);
+        Ok(())
+    }
 }

crates/ruff_linter/src/rules/flake8_gettext/snapshots/ruff_linter__rules__flake8_gettext__tests__f-string-in-get-text-func-call_INT001.py.snap

@@ -1,9 +1,84 @@
 ---
 source: crates/ruff_linter/src/rules/flake8_gettext/mod.rs
-snapshot_kind: text
 ---
 INT001.py:1:3: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
   |
 1 | _(f"{'value'}")
   |   ^^^^^^^^^^^^ INT001
+2 | gettext(f"{'value'}")
+3 | ngettext(f"{'value'}", f"{'values'}", 2)
   |
+
+INT001.py:2:9: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
+  |
+1 | _(f"{'value'}")
+2 | gettext(f"{'value'}")
+  |         ^^^^^^^^^^^^ INT001
+3 | ngettext(f"{'value'}", f"{'values'}", 2)
+  |
+
+INT001.py:3:10: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
+  |
+1 | _(f"{'value'}")
+2 | gettext(f"{'value'}")
+3 | ngettext(f"{'value'}", f"{'values'}", 2)
+  |          ^^^^^^^^^^^^ INT001
+4 |
+5 | _gettext(f"{'value'}")  # no lint
+  |
+
+INT001.py:27:14: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
+   |
+25 | def _(message): return message
+26 |
+27 | animals = [_(f"{'mollusk'}"),
+   |              ^^^^^^^^^^^^^^ INT001
+28 |            _(f"{'albatross'}"),
+29 |            _(f"{'rat'}"),
+   |
+
+INT001.py:28:14: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
+   |
+27 | animals = [_(f"{'mollusk'}"),
+28 |            _(f"{'albatross'}"),
+   |              ^^^^^^^^^^^^^^^^ INT001
+29 |            _(f"{'rat'}"),
+30 |            _(f"{'penguin'}"),
+   |
+
+INT001.py:29:14: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
+   |
+27 | animals = [_(f"{'mollusk'}"),
+28 |            _(f"{'albatross'}"),
+29 |            _(f"{'rat'}"),
+   |              ^^^^^^^^^^ INT001
+30 |            _(f"{'penguin'}"),
+31 |            _(f"{'python'}"),]
+   |
+
+INT001.py:30:14: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
+   |
+28 |            _(f"{'albatross'}"),
+29 |            _(f"{'rat'}"),
+30 |            _(f"{'penguin'}"),
+   |              ^^^^^^^^^^^^^^ INT001
+31 |            _(f"{'python'}"),]
+   |
+
+INT001.py:31:14: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
+   |
+29 |            _(f"{'rat'}"),
+30 |            _(f"{'penguin'}"),
+31 |            _(f"{'python'}"),]
+   |              ^^^^^^^^^^^^^ INT001
+32 |
+33 | del _
+   |
+
+INT001.py:37:13: INT001 f-string is resolved before function call; consider `_("string %s") % arg`
+   |
+35 | for a in animals:
+36 |     print(_(a))
+37 |     print(_(f"{a}"))
+   |             ^^^^^^ INT001
+   |