Special-case logging.Logger and re.Pattern in pyrefly coverage (#5552)

Summary:
I noticed in several projects now that they tend to leave a module-level `logger = logging.getLogger()` unannotated in modules without `__all__`, and don't consider it to be public API. But `pyrefly coverage check`, due to `logger` not having a leading underscore, will consider it as untyped typable regardless. This is a common enough pattern that I think it's worth special-casing `logging.getLogger` to count it as implicitly typed when unannotated.

To confirm my assumptions,I had an agent do a quick code survey (on my local `uv cache`), and it found 4,204 `logging.getLogger` calls of which only 108 were annotated and public.
For `re.compile` it's very similar, with 137 annotated public module-level `re.compile` names out of 3,902 total `re.compile` calls, so I think that one is also worth special-casing.
I had the agent look for other similar module-level constructor calls, but these two were by far the most common.

- [x] I am a human, and I fully understand the code I am submitting.

Pull Request resolved: #5552

Test Plan: Integration tests added

Reviewed By: stroxler

Differential Revision: D129909548

Pulled By: rchen152

fbshipit-source-id: 7aec2051bd093ed9e3b278b079a0b3cf58bd8ff6

Author: jorenham

crates/pyrefly_types/src/known_class.rs

@@ -171,6 +171,7 @@ known_classes! {
     FastApi => ("fastapi", "FastAPI"),
     FastApiApplications => ("fastapi.applications", "FastAPI"),
     FastApiTestClient => ("fastapi.testclient", "TestClient"),
+    LoggingLogger => ("logging", "Logger"),
     MarshmallowSchema => ("marshmallow.schema", "Schema"),
     NarwhalsDataFrame => ("narwhals.dataframe", "DataFrame"),
     NarwhalsLazyFrame => ("narwhals.dataframe", "LazyFrame"),

pyrefly/lib/commands/coverage/collect.rs

@@ -466,6 +466,9 @@ const IMPLICIT_BUILTIN_CONSTRUCTORS: &[KnownClass] = &[
     KnownClass::Tuple,
 ];
 
+/// Stdlib classes whose instances are conventionally left unannotated, as `(module, class)`.
+const IMPLICIT_STDLIB_CLASSES: &[KnownClass] = &[KnownClass::LoggingLogger, KnownClass::RePattern];
+
 fn parse_variables(
     module: &Module,
     answers: &Answers,
@@ -478,7 +481,7 @@ fn parse_variables(
 
     /// Only a call hides its type at the assignment site, unless the callee names the class it
     /// yields: a builtin constructor like `list()`, or an explicitly specialized class like
-    /// `Spam[int]()`.
+    /// `Spam[int]()`. Instances of `IMPLICIT_STDLIB_CLASSES` are exempt whatever the call.
     fn untyped_if_call(answers: &Answers, idx: Idx<Key>, expr: &Expr) -> SlotCounts {
         let Expr::Call(call) = expr else {
             return SlotCounts::default();
@@ -498,10 +501,11 @@ fn parse_variables(
             _ => false,
         };
 
-        if answers
-            .get_idx(idx)
-            .is_some_and(|t| matches!(t.ty(), Type::ClassType(cls) if callee_names(cls)))
-        {
+        let is_implicit_stdlib =
+            |cls: &ClassType| IMPLICIT_STDLIB_CLASSES.iter().any(|class| cls.is(*class));
+        if answers.get_idx(idx).is_some_and(|t| {
+            matches!(t.ty(), Type::ClassType(cls) if callee_names(cls) || is_implicit_stdlib(cls))
+        }) {
             SlotCounts::default()
         } else {
             SlotCounts::untyped()
@@ -2326,6 +2330,14 @@ mod tests {
         compare_snapshot("variables.expected.json", &report);
     }
 
+    /// Calls returning a `logging.Logger` or `re.Pattern` have 0 slots, whatever the callee is.
+    /// Other calls count, even when the callee has the name of a stdlib factory.
+    #[test]
+    fn test_report_implicit_stdlib_classes() {
+        let report = build_module_report_for_test("implicit_stdlib_classes.py");
+        compare_snapshot("implicit_stdlib_classes.expected.json", &report);
+    }
+
     /// gh-3773: optional imports must not be reported as untyped variables.
     #[test]
     fn test_report_optional_imports() {

pyrefly/lib/test/coverage/test_files/implicit_stdlib_classes.expected.json

@@ -0,0 +1,115 @@
+{
+  "name": "test",
+  "path": "test.py",
+  "names": [
+    "test.logger",
+    "test.wrapped_logger",
+    "test.PATTERN",
+    "test.lookalike",
+    "test.make_logger",
+    "test.Lookalike.getLogger",
+    "test.Lookalike"
+  ],
+  "line_count": 24,
+  "symbol_reports": [
+    {
+      "kind": "attr",
+      "name": "test.logger",
+      "n_typable": 0,
+      "n_typed": 0,
+      "n_any": 0,
+      "n_untyped": 0,
+      "location": {
+        "line": 19,
+        "column": 1
+      }
+    },
+    {
+      "kind": "attr",
+      "name": "test.wrapped_logger",
+      "n_typable": 0,
+      "n_typed": 0,
+      "n_any": 0,
+      "n_untyped": 0,
+      "location": {
+        "line": 20,
+        "column": 1
+      }
+    },
+    {
+      "kind": "attr",
+      "name": "test.PATTERN",
+      "n_typable": 0,
+      "n_typed": 0,
+      "n_any": 0,
+      "n_untyped": 0,
+      "location": {
+        "line": 21,
+        "column": 1
+      }
+    },
+    {
+      "kind": "attr",
+      "name": "test.lookalike",
+      "n_typable": 1,
+      "n_typed": 0,
+      "n_any": 0,
+      "n_untyped": 1,
+      "location": {
+        "line": 23,
+        "column": 1
+      }
+    },
+    {
+      "kind": "function",
+      "name": "test.make_logger",
+      "n_typable": 1,
+      "n_typed": 1,
+      "n_any": 0,
+      "n_untyped": 0,
+      "location": {
+        "line": 10,
+        "column": 1
+      }
+    },
+    {
+      "kind": "function",
+      "name": "test.Lookalike.getLogger",
+      "n_typable": 1,
+      "n_typed": 1,
+      "n_any": 0,
+      "n_untyped": 0,
+      "location": {
+        "line": 15,
+        "column": 5
+      }
+    },
+    {
+      "kind": "class",
+      "name": "test.Lookalike",
+      "n_typable": 0,
+      "n_typed": 0,
+      "n_any": 0,
+      "n_untyped": 0,
+      "location": {
+        "line": 14,
+        "column": 1
+      }
+    }
+  ],
+  "type_ignores": [],
+  "n_typable": 3,
+  "n_typed": 2,
+  "n_any": 0,
+  "n_untyped": 1,
+  "coverage": 66.66666666666666,
+  "strict_coverage": 66.66666666666666,
+  "n_functions": 1,
+  "n_methods": 1,
+  "n_function_params": 0,
+  "n_method_params": 0,
+  "n_classes": 1,
+  "n_attrs": 4,
+  "n_properties": 0,
+  "n_type_ignores": 0
+}

pyrefly/lib/test/coverage/test_files/implicit_stdlib_classes.py

@@ -0,0 +1,23 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import logging
+import re
+
+
+def make_logger() -> logging.Logger:
+    return logging.getLogger(__name__)
+
+
+class Lookalike:
+    def getLogger(self) -> int:
+        return 0
+
+
+logger = logging.getLogger(__name__)
+wrapped_logger = make_logger()
+PATTERN = re.compile("a+")
+
+lookalike = Lookalike().getLogger()

website/docs/report.mdx

@@ -35,6 +35,16 @@ Only public symbols count: names without a leading underscore, plus anything in
 stub is also analyzed (`--prefer-stubs=false` disables this). With `--public-only`, only symbols
 reachable from public modules via re-export chains count: the library's public API.
 
+A simple unannotated assignment to a module-level variable only counts as a typable if the value is
+a call, since a call hides the type at the assignment site. Three kinds of call are exempt:
+
+- Some builtin constructors, like `list()`.
+- Explicitly specialized classes, like `Spam[int]()`.
+- Anything that returns a `logging.Logger` or `re.Pattern`, since those are conventionally left
+  unannotated.
+
+A variable assigned in both branches of an `if`/`else` counts whatever the values.
+
 ### Cython
 
 In [Cython pure Python mode](https://cython.readthedocs.io/en/latest/src/tutorial/pure.html),