I still haven't looked too closely at this, but I agree that it's unfortunate not to flag this case. It might be worth looking into how ty handles this since it seems to get the expected result in both cases:

https://play.ty.dev/c6f45910-a2bd-4745-827b-f29a148f4e63

It doesn't seem to be related to nonlocal, though, because commenting it out doesn't change ty's diagnostics.

One option to do this is then something like

                    BindingKind::Annotation if !self.in_stub_file() => {
                        if self.scopes[self.bindings[binding_id].scope]
                            .kind
                            .is_function()
                        {
                            // If we're in a function scope, and the annotation is local to that scope,
                            // treat it as unbound (since it's not assigned).
                            // If it's an enclosing scope, we treat it as resolved (to support closures).
                            if index == 0 {
                                self.unresolved_references.push(
                                    name.range,
                                    self.exceptions(),
                                    UnresolvedReferenceFlags::empty(),
                                );
                                return ReadResult::UnboundLocal(binding_id);
                            }
                            
                            self.resolved_names.insert(name.into(), binding_id);
                            return ReadResult::Resolved(binding_id);
                        
                        }
                        continue;
                    }

if we do this then both the cases will be handled i.e. error in this case

def demonstrate_bare_local_annotation():
    x: int
    print(x)

and no error in the closure cases i.e. the setter,getter example

but then again we will have edge cases like these where no error will be reported [although even ty doesn't report them]

def demo_closure():
    x: int
    def func():
        return x

What do you think about this

Thanks for looking into this, and sorry for the delay! I've looked at this a bit today, and yes, I think your suggestion here is a good idea that should handle both the existing test case and the new closure case from the issue. I'm okay with the false negative in demo_closure as it seems like a better trade-off.

Hey @ntBre, I have a different approach for this, which also handles the edge case. Instead of resolving closure reads as Resolved, both same-scope and closure reads of bare function-scope annotations are treated as unresolved.

To handle the nonlocal case, unresolved references now carry an annotation_binding_id. In the F821 lint phase, we use rebinding_scopes to check if any nested scope declared nonlocal on that annotation binding — if so, we suppress F821.

F821 - UnboundLocalError at runtime

  def f():
      x: int
      print(x)

No F821 - nonlocal rebinding exists (getter/setter pattern)

  def make_closure_pair():
      x: int
      def get_value():
          return x
      def set_value(new_value):
          nonlocal x
          x = new_value
      return get_value, set_value

F821 — no nonlocal, previously a false negative

  def demo_closure():
      x: int
      def func():
          return x

This eliminates the demo_closure false negative from the previous approach. The only heuristic is that we trust nonlocal presence without verifying an actual assignment - matching Pyflakes' behavior.

Have updated the PR.