[syntax-errors] Name is parameter and nonlocal (astral-sh#27628)

## Summary
Part of astral-sh#17412
Detects semantic syntax error where name is parameter and nonlocal

## Test Plan
Added tests in `nonlocal_parameter.py`

Author: WhiteFox0-0

crates/ruff_linter/resources/test/fixtures/semantic_errors/nonlocal_parameter.py

@@ -0,0 +1,33 @@
+def f(a):
+    nonlocal a
+
+def g(a):
+    if True:
+        nonlocal a
+
+def h(a):
+    def inner():
+        nonlocal a
+
+def i(a):
+    try:
+        nonlocal a
+    except Exception:
+        pass
+
+def f(a):
+    a = 1
+    a = 2
+    nonlocal a
+
+def f(a):
+    class Inner:
+        nonlocal a   # ok
+
+def f(a):
+    def inner(a):
+        nonlocal a
+
+def f(a=1):
+    def inner():
+        nonlocal a   # ok

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

@@ -810,6 +810,7 @@ impl SemanticSyntaxContext for Checker<'_> {
             | SemanticSyntaxErrorKind::DifferentMatchPatternBindings
             | SemanticSyntaxErrorKind::InvalidExpression(..)
             | SemanticSyntaxErrorKind::GlobalParameter(_)
+            | SemanticSyntaxErrorKind::NonlocalParameter(_)
             | SemanticSyntaxErrorKind::DuplicateMatchKey(_)
             | SemanticSyntaxErrorKind::DuplicateMatchClassAttribute(_)
             | SemanticSyntaxErrorKind::InvalidStarExpression

crates/ruff_linter/src/linter.rs

@@ -1032,6 +1032,7 @@ mod tests {
     #[test_case(Path::new("write_to_debug.py"), PythonVersion::PY310)]
     #[test_case(Path::new("invalid_expression.py"), PythonVersion::PY312)]
     #[test_case(Path::new("global_parameter.py"), PythonVersion::PY310)]
+    #[test_case(Path::new("nonlocal_parameter.py"), PythonVersion::PY310)]
     #[test_case(Path::new("annotated_global.py"), PythonVersion::PY314)]
     #[test_case(Path::new("lazy_future_import.py"), PythonVersion::PY315)]
     fn test_semantic_errors(path: &Path, python_version: PythonVersion) -> Result<()> {

crates/ruff_linter/src/snapshots/ruff_linter__linter__tests__semantic_syntax_error_nonlocal_parameter.py_3.10.snap

@@ -0,0 +1,56 @@
+---
+source: crates/ruff_linter/src/linter.rs
+---
+invalid-syntax: name `a` cannot refer to a parameter and a nonlocal variable
+ --> resources/test/fixtures/semantic_errors/nonlocal_parameter.py:2:14
+  |
+1 | def f(a):
+2 |     nonlocal a
+  |              ^
+3 |
+4 | def g(a):
+  |
+
+invalid-syntax: name `a` cannot refer to a parameter and a nonlocal variable
+ --> resources/test/fixtures/semantic_errors/nonlocal_parameter.py:6:18
+  |
+4 | def g(a):
+5 |     if True:
+6 |         nonlocal a
+  |                  ^
+7 |
+8 | def h(a):
+  |
+
+invalid-syntax: name `a` cannot refer to a parameter and a nonlocal variable
+  --> resources/test/fixtures/semantic_errors/nonlocal_parameter.py:14:18
+   |
+12 | def i(a):
+13 |     try:
+14 |         nonlocal a
+   |                  ^
+15 |     except Exception:
+16 |         pass
+   |
+
+invalid-syntax: name `a` cannot refer to a parameter and a nonlocal variable
+  --> resources/test/fixtures/semantic_errors/nonlocal_parameter.py:21:14
+   |
+19 |     a = 1
+20 |     a = 2
+21 |     nonlocal a
+   |              ^
+22 |
+23 | def f(a):
+   |
+
+invalid-syntax: name `a` cannot refer to a parameter and a nonlocal variable
+  --> resources/test/fixtures/semantic_errors/nonlocal_parameter.py:29:18
+   |
+27 | def f(a):
+28 |     def inner(a):
+29 |         nonlocal a
+   |                  ^
+30 |
+31 | def f(a=1):
+   |

crates/ruff_python_parser/src/semantic_errors.rs

@@ -324,7 +324,13 @@ impl SemanticSyntaxChecker {
 
                 if !ctx.in_module_scope() {
                     for name in names {
-                        if !ctx.has_nonlocal_binding(name) {
+                        if ctx.is_bound_parameter(name) {
+                            Self::add_error(
+                                ctx,
+                                SemanticSyntaxErrorKind::NonlocalParameter(name.to_string()),
+                                name.range,
+                            );
+                        } else if !ctx.has_nonlocal_binding(name) {
                             Self::add_error(
                                 ctx,
                                 SemanticSyntaxErrorKind::NonlocalWithoutBinding(name.to_string()),
@@ -1432,6 +1438,12 @@ impl Display for SemanticSyntaxError {
                     "name `{name}` cannot refer to a parameter and a global variable"
                 )
             }
+            SemanticSyntaxErrorKind::NonlocalParameter(name) => {
+                write!(
+                    f,
+                    "name `{name}` cannot refer to a parameter and a nonlocal variable"
+                )
+            }
             SemanticSyntaxErrorKind::DifferentMatchPatternBindings => {
                 write!(f, "alternative patterns bind different names")
             }
@@ -1871,6 +1883,13 @@ pub enum SemanticSyntaxErrorKind {
     /// ambiguity and will result in a `SyntaxError`.
     GlobalParameter(String),
 
+    /// Represents a function parameter that is also declared as `nonlocal`.
+    ///
+    /// Declaring a parameter as `nonlocal` is invalid, since parameters are already
+    /// bound in a local scope of the function. using `nonlocal` on them introduces
+    /// ambiguity and will result in a `SyntaxError`.
+    NonlocalParameter(String),
+
     /// Represents the use of alternative patterns in a `match` statement that bind different names.
     ///
     /// Python requires all alternatives in an OR pattern (`|`) to bind the same set of names.

crates/ty_python_core/src/builder.rs

@@ -4589,7 +4589,9 @@ impl<'db, 'ast> SemanticIndexBuilder<'db, 'ast> {
                     let symbol_id = self.add_symbol(name.id.clone());
                     let symbol = self.current_place_table().symbol(symbol_id);
                     // Check whether the variable has already been accessed in this scope.
-                    if symbol.is_bound() || symbol.is_declared() || symbol.is_used() {
+                    if (symbol.is_bound() || symbol.is_declared() || symbol.is_used())
+                        && !symbol.is_parameter()
+                    {
                         self.report_semantic_error(SemanticSyntaxError {
                             kind: SemanticSyntaxErrorKind::LoadBeforeNonlocalDeclaration {
                                 name: name.to_string(),

crates/ty_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md

@@ -603,3 +603,59 @@ error[invalid-syntax]: name `a` cannot refer to a parameter and a global variabl
 27 |     global a  # snapshot: invalid-syntax
    |            ^
 ```
+
+## name cannot refer to a parameter and a nonlocal variable
+
+```py
+a = None
+
+def outer():
+    a = None
+    def f(a):
+        nonlocal a  # snapshot: invalid-syntax
+
+def outer():
+    a = None
+    def g(a):
+        if True:
+            nonlocal a  # error: [invalid-syntax]
+
+def h(a):
+    def inner():
+        nonlocal a
+
+def outer():
+    a = None
+    def i(a):
+        try:
+            nonlocal a  # error: [invalid-syntax]
+        except Exception:
+            pass
+
+def outer():
+    a = None
+    def f(a):
+        a = 1
+        a = 2
+        nonlocal a  # error: [invalid-syntax]
+
+def f(a):
+    class Inner:
+        nonlocal a
+
+def f(a):
+    def inner(a):
+        nonlocal a  # error: [invalid-syntax]
+
+def f(a=1):
+    def inner():
+        nonlocal a
+```
+
+```snapshot
+error[invalid-syntax]: name `a` cannot refer to a parameter and a nonlocal variable
+ --> src/mdtest_snippet.py:6:18
+  |
+6 |         nonlocal a  # snapshot: invalid-syntax
+  |                  ^
+```