count bare Final as typed in pyrefly report #3172

Author: jorenham

pyrefly/lib/commands/report.rs

@@ -411,13 +411,13 @@ impl ReportArgs {
     }
 
     /// Classify a single annotation slot: is it typed, any, or untyped?
-    fn classify_slot(has_annotation: bool, is_type_known: bool) -> SlotCounts {
-        if !has_annotation {
-            SlotCounts::untyped()
-        } else if is_type_known {
-            SlotCounts::typed()
-        } else {
-            SlotCounts::any()
+    /// Bare qualifiers (e.g. `Final`) resolve to `None` but are treated as typed (i.e. the type is
+    /// inferred from the value).
+    fn classify_slot(is_type_known: Option<bool>) -> SlotCounts {
+        match is_type_known {
+            Some(true) => SlotCounts::typed(),
+            Some(false) => SlotCounts::any(),
+            None => SlotCounts::untyped(),
         }
     }
 
@@ -519,12 +519,12 @@ impl ReportArgs {
                         }
                         _ => None,
                     };
-                    let is_type_known = annotation_text.is_some()
-                        && answers
-                            .get_idx(*annot_idx)
-                            .and_then(|awt| awt.annotation.ty.as_ref().map(Self::is_type_known))
-                            .unwrap_or(false);
-                    let slots = Self::classify_slot(annotation_text.is_some(), is_type_known);
+                    let resolved_ty = answers
+                        .get_idx(*annot_idx)
+                        .and_then(|awt| awt.annotation.ty.as_ref().map(Self::is_type_known));
+                    let slots = Self::classify_slot(
+                        resolved_ty.or(annotation_text.is_some().then_some(true)),
+                    );
                     variables.push(Variable {
                         name: qualified_name,
                         annotation: annotation_text,
@@ -711,15 +711,13 @@ impl ReportArgs {
                 }
                 _ => None,
             });
-            let is_type_known = annotation_text.is_some()
-                && annotation_idx
-                    .and_then(|idx| {
-                        answers
-                            .get_idx(idx)
-                            .and_then(|awt| awt.annotation.ty.as_ref().map(Self::is_type_known))
-                    })
-                    .unwrap_or(false);
-            let slots = Self::classify_slot(annotation_text.is_some(), is_type_known);
+            let resolved_ty = annotation_idx.and_then(|idx| {
+                answers
+                    .get_idx(idx)
+                    .and_then(|awt| awt.annotation.ty.as_ref().map(Self::is_type_known))
+            });
+            let slots =
+                Self::classify_slot(resolved_ty.or(annotation_text.is_some().then_some(true)));
 
             attrs.push(Variable {
                 name: qualified_name,
@@ -841,7 +839,7 @@ impl ReportArgs {
                 let return_slot = if has_implicit_return {
                     SlotCounts::default()
                 } else {
-                    Self::classify_slot(return_annotation.is_some(), is_return_type_known)
+                    Self::classify_slot(return_annotation.is_some().then_some(is_return_type_known))
                 };
                 let mut func_slots = return_slot;
                 let mut n_params = 0usize;
@@ -882,8 +880,9 @@ impl ReportArgs {
                     }
 
                     if !is_self && !is_implicit_param {
-                        let param_slot =
-                            Self::classify_slot(param_annotation.is_some(), is_param_type_known);
+                        let param_slot = Self::classify_slot(
+                            param_annotation.is_some().then_some(is_param_type_known),
+                        );
                         func_slots = func_slots.merge(param_slot);
                         n_params += 1;
                     }
@@ -2255,6 +2254,36 @@ mod tests {
         compare_snapshot("partial_any.expected.json", &report);
     }
 
+    /// Bare `Final` should be typed, not `Any`
+    #[test]
+    fn test_report_bare_final() {
+        let report = build_module_report_for_test("bare_final.py");
+        let attr_slots = |name: &str| {
+            report
+                .symbol_reports
+                .iter()
+                .find_map(|s| match s {
+                    SymbolReport::Attr { name: n, slots, .. } if n == name => Some(*slots),
+                    _ => None,
+                })
+                .unwrap_or_else(|| panic!("no attr symbol named {name}"))
+        };
+
+        for name in [
+            "test.golden",
+            "test.golden_ratio",
+            "test.pi",
+            "test.name",
+            "test.Constants.rate",
+            "test.Constants.count",
+        ] {
+            let slots = attr_slots(name);
+            assert_eq!(slots.n_typable, 1, "{name} should have 1 typable slot");
+            assert_eq!(slots.n_typed, 1, "{name} should be typed");
+            assert_eq!(slots.n_any, 0, "{name} should not be any");
+        }
+    }
+
     #[test]
     fn test_full_report_has_schema_version() {
         let report = build_module_report_for_test("functions.py");

pyrefly/lib/test/report/test_files/bare_final.py

@@ -0,0 +1,21 @@
+# 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.
+
+# Bare `Final` should be typed: https://github.com/facebook/pyrefly/issues/3172
+
+from typing import Final
+
+golden: Final = 1.618033988749895
+golden_ratio: Final = golden
+
+pi: Final[float] = 3.14159
+
+name: Final = "hello"
+
+
+class Constants:
+    def __init__(self):
+        self.rate: Final = 0.05
+        self.count: Final[int] = 10