[syntax-errors]: import from * only allowed at module scope (F406) (#20166)

<!--
Thank you for contributing to Ruff/ty! To help us out with reviewing,
please consider the following:

- Does this pull request include a summary of the change? (See below.)
- Does this pull request include a descriptive title? (Please prefix
with `[ty]` for ty pull
  requests.)
- Does this pull request include references to any relevant issues?
-->

## Summary

This PR implements F406
https://docs.astral.sh/ruff/rules/undefined-local-with-nested-import-star-usage/
as a semantic syntax error

## Test Plan

I have written inline tests as directed in #17412

---------

Signed-off-by: 11happy <soni5happy@gmail.com>

Author: 11happy

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -1,7 +1,6 @@
 use ruff_python_ast::helpers;
 use ruff_python_ast::types::Node;
 use ruff_python_ast::{self as ast, Expr, Stmt};
-use ruff_python_semantic::ScopeKind;
 use ruff_text_size::Ranged;
 
 use crate::checkers::ast::Checker;
@@ -809,17 +808,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                         pyflakes::rules::future_feature_not_defined(checker, alias);
                     }
                 } else if &alias.name == "*" {
-                    // F406
-                    if checker.is_rule_enabled(Rule::UndefinedLocalWithNestedImportStarUsage) {
-                        if !matches!(checker.semantic.current_scope().kind, ScopeKind::Module) {
-                            checker.report_diagnostic(
-                                pyflakes::rules::UndefinedLocalWithNestedImportStarUsage {
-                                    name: helpers::format_import_from(level, module).to_string(),
-                                },
-                                stmt.range(),
-                            );
-                        }
-                    }
                     // F403
                     checker.report_diagnostic_if_enabled(
                         pyflakes::rules::UndefinedLocalWithImportStar {

crates/ruff_linter/src/checkers/ast/analyze/unresolved_references.rs

@@ -13,7 +13,7 @@ pub(crate) fn unresolved_references(checker: &Checker) {
 
     for reference in checker.semantic.unresolved_references() {
         if reference.is_wildcard_import() {
-            // F406
+            // F405
             checker.report_diagnostic_if_enabled(
                 pyflakes::rules::UndefinedLocalWithImportStarUsage {
                     name: reference.name(checker.source()).to_string(),

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

@@ -69,7 +69,8 @@ use crate::package::PackageRoot;
 use crate::preview::is_undefined_export_in_dunder_init_enabled;
 use crate::registry::Rule;
 use crate::rules::pyflakes::rules::{
-    LateFutureImport, ReturnOutsideFunction, YieldOutsideFunction,
+    LateFutureImport, ReturnOutsideFunction, UndefinedLocalWithNestedImportStarUsage,
+    YieldOutsideFunction,
 };
 use crate::rules::pylint::rules::{
     AwaitOutsideAsync, LoadBeforeGlobalDeclaration, YieldFromInAsyncFunction,
@@ -659,6 +660,14 @@ impl SemanticSyntaxContext for Checker<'_> {
                     self.report_diagnostic(YieldOutsideFunction::new(kind), error.range);
                 }
             }
+            SemanticSyntaxErrorKind::NonModuleImportStar(name) => {
+                if self.is_rule_enabled(Rule::UndefinedLocalWithNestedImportStarUsage) {
+                    self.report_diagnostic(
+                        UndefinedLocalWithNestedImportStarUsage { name },
+                        error.range,
+                    );
+                }
+            }
             SemanticSyntaxErrorKind::ReturnOutsideFunction => {
                 // F706
                 if self.is_rule_enabled(Rule::ReturnOutsideFunction) {

crates/ruff_python_parser/resources/inline/err/import_from_star.py

@@ -0,0 +1,8 @@
+def f1():
+    from module import *
+class C:
+    from module import *
+def f2():
+    from ..module import *
+def f3():
+    from module import *, *

crates/ruff_python_parser/resources/inline/ok/import_from_star.py

@@ -0,0 +1 @@
+from module import *

crates/ruff_python_parser/src/semantic_errors.rs

@@ -3,16 +3,16 @@
 //! This checker is not responsible for traversing the AST itself. Instead, its
 //! [`SemanticSyntaxChecker::visit_stmt`] and [`SemanticSyntaxChecker::visit_expr`] methods should
 //! be called in a parent `Visitor`'s `visit_stmt` and `visit_expr` methods, respectively.
-use std::fmt::Display;
-
 use ruff_python_ast::{
     self as ast, Expr, ExprContext, IrrefutablePatternKind, Pattern, PythonVersion, Stmt, StmtExpr,
     StmtImportFrom,
     comparable::ComparableExpr,
+    helpers,
     visitor::{Visitor, walk_expr},
 };
 use ruff_text_size::{Ranged, TextRange, TextSize};
 use rustc_hash::{FxBuildHasher, FxHashSet};
+use std::fmt::Display;
 
 #[derive(Debug, Default)]
 pub struct SemanticSyntaxChecker {
@@ -58,10 +58,40 @@ impl SemanticSyntaxChecker {
 
     fn check_stmt<Ctx: SemanticSyntaxContext>(&mut self, stmt: &ast::Stmt, ctx: &Ctx) {
         match stmt {
-            Stmt::ImportFrom(StmtImportFrom { range, module, .. }) => {
+            Stmt::ImportFrom(StmtImportFrom {
+                range,
+                module,
+                level,
+                names,
+                ..
+            }) => {
                 if self.seen_futures_boundary && matches!(module.as_deref(), Some("__future__")) {
                     Self::add_error(ctx, SemanticSyntaxErrorKind::LateFutureImport, *range);
                 }
+                for alias in names {
+                    if alias.name.as_str() == "*" && !ctx.in_module_scope() {
+                        // test_err import_from_star
+                        // def f1():
+                        //     from module import *
+                        // class C:
+                        //     from module import *
+                        // def f2():
+                        //     from ..module import *
+                        // def f3():
+                        //     from module import *, *
+
+                        // test_ok import_from_star
+                        // from module import *
+                        Self::add_error(
+                            ctx,
+                            SemanticSyntaxErrorKind::NonModuleImportStar(
+                                helpers::format_import_from(*level, module.as_deref()).to_string(),
+                            ),
+                            *range,
+                        );
+                        break;
+                    }
+                }
             }
             Stmt::Match(match_stmt) => {
                 Self::irrefutable_match_case(match_stmt, ctx);
@@ -1002,6 +1032,9 @@ impl Display for SemanticSyntaxError {
             SemanticSyntaxErrorKind::YieldFromInAsyncFunction => {
                 f.write_str("`yield from` statement in async function; use `async for` instead")
             }
+            SemanticSyntaxErrorKind::NonModuleImportStar(name) => {
+                write!(f, "`from {name} import *` only allowed at module level")
+            }
         }
     }
 }
@@ -1362,6 +1395,9 @@ pub enum SemanticSyntaxErrorKind {
 
     /// Represents the use of `yield from` inside an asynchronous function.
     YieldFromInAsyncFunction,
+
+    /// Represents the use of `from <module> import *` outside module scope.
+    NonModuleImportStar(String),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, get_size2::GetSize)]