[pylint] Detect global declarations in module scope (PLE0118) (#17411)

Summary
--

While going through the syntax errors in [this comment], I was surprised
to see the error `name 'x' is assigned to before global declaration`,
which corresponds to [load-before-global-declaration (PLE0118)] and has
also been reimplemented as a syntax error (#17135). However, it looks
like neither of the implementations consider `global` declarations in
the top-level module scope, which is a syntax error in CPython:

```python
# try.py
x = None
global x
```

```shell
> python -m compileall -f try.py
Compiling 'try.py'...
***   File "try.py", line 2
    global x
    ^^^^^^^^
SyntaxError: name 'x' is assigned to before global declaration
```

I'm not sure this is the best or most elegant solution, but it was a
quick fix that passed all of our tests.

Test Plan
--

New PLE0118 test case.

[this comment]:
#7633 (comment)
[load-before-global-declaration (PLE0118)]:
https://docs.astral.sh/ruff/rules/load-before-global-declaration/#load-before-global-declaration-ple0118

Author: ntBre

crates/ruff_linter/resources/test/fixtures/pylint/load_before_global_declaration.py

@@ -156,3 +156,8 @@ def f():
 def f():
     global x
     print(f"{x=}")
+
+
+# surprisingly still an error, global in module scope
+x = None
+global x

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -2067,8 +2067,12 @@ impl<'a> Visitor<'a> for Checker<'a> {
 }
 
 impl<'a> Checker<'a> {
-    /// Visit a [`Module`]. Returns `true` if the module contains a module-level docstring.
+    /// Visit a [`Module`].
     fn visit_module(&mut self, python_ast: &'a Suite) {
+        // Extract any global bindings from the module body.
+        if let Some(globals) = Globals::from_body(python_ast) {
+            self.semantic.set_globals(globals);
+        }
         analyze::module(python_ast, self);
     }
 

crates/ruff_linter/src/rules/pylint/snapshots/ruff_linter__rules__pylint__tests__PLE0118_load_before_global_declaration.py.snap

@@ -123,3 +123,11 @@ load_before_global_declaration.py:113:14: PLE0118 Name `x` is used prior to glob
     |              ^ PLE0118
 114 |     global x
     |
+
+load_before_global_declaration.py:162:1: PLE0118 Name `x` is used prior to global declaration on line 163
+    |
+161 | # surprisingly still an error, global in module scope
+162 | x = None
+    | ^ PLE0118
+163 | global x
+    |

crates/ruff_python_semantic/src/model.rs

@@ -1503,24 +1503,48 @@ impl<'a> SemanticModel<'a> {
 
     /// Set the [`Globals`] for the current [`Scope`].
     pub fn set_globals(&mut self, globals: Globals<'a>) {
-        // If any global bindings don't already exist in the global scope, add them.
-        for (name, range) in globals.iter() {
-            if self
-                .global_scope()
-                .get(name)
-                .is_none_or(|binding_id| self.bindings[binding_id].is_unbound())
-            {
-                let id = self.bindings.push(Binding {
-                    kind: BindingKind::Assignment,
-                    range: *range,
-                    references: Vec::new(),
-                    scope: ScopeId::global(),
-                    source: self.node_id,
-                    context: self.execution_context(),
-                    exceptions: self.exceptions(),
-                    flags: BindingFlags::empty(),
-                });
-                self.global_scope_mut().add(name, id);
+        // If any global bindings don't already exist in the global scope, add them, unless we are
+        // also in the global scope, where we don't want these to count as definitions for rules
+        // like `undefined-name` (F821). For example, adding bindings in the top-level scope causes
+        // a false negative in cases like this:
+        //
+        // ```python
+        // global x
+        //
+        // def f():
+        //     print(x)  # F821 false negative
+        // ```
+        //
+        // On the other hand, failing to add bindings in non-top-level scopes causes false
+        // positives:
+        //
+        // ```python
+        // def f():
+        //     global foo
+        //     import foo
+        //
+        // def g():
+        //     foo.is_used()  # F821 false positive
+        // ```
+        if !self.at_top_level() {
+            for (name, range) in globals.iter() {
+                if self
+                    .global_scope()
+                    .get(name)
+                    .is_none_or(|binding_id| self.bindings[binding_id].is_unbound())
+                {
+                    let id = self.bindings.push(Binding {
+                        kind: BindingKind::Assignment,
+                        range: *range,
+                        references: Vec::new(),
+                        scope: ScopeId::global(),
+                        source: self.node_id,
+                        context: self.execution_context(),
+                        exceptions: self.exceptions(),
+                        flags: BindingFlags::empty(),
+                    });
+                    self.global_scope_mut().add(name, id);
+                }
             }
         }