improve behaviour on encountering invalid syntax and add more tests

Author: AlexWaygood

crates/red_knot_python_semantic/resources/mdtest/import/star.md

@@ -134,6 +134,81 @@ reveal_type(X)  # revealed: Unknown | Literal[7]
 reveal_type(Y)  # revealed: Unknown | Literal[3]
 ```
 
+### Global-scope symbols defined in many other ways
+
+`a.py`:
+
+```py
+import typing
+from collections import OrderedDict
+from collections import OrderedDict as Foo
+
+A, B = 1, (C := 2)
+D: (E := 4) = (F := 5)  # error: [invalid-type-form]
+
+for G in [1]:
+    ...
+
+for (H := 4).whatever in [2]:
+    ...  # error: [unresolved-attribute]
+
+class I: ...
+
+def J(): ...
+
+type K = int
+
+with () as L:
+    ...  # error: [invalid-context-manager]
+
+match 42:
+    case {"something": M}:
+        ...
+    case [*N]:
+        ...
+    case [O]:
+        ...
+    case P | Q:
+        ...
+    case object(foo=R):
+        ...
+    case object(S):
+        ...
+    case T:
+        ...
+```
+
+`b.py`:
+
+```py
+from a import *
+
+# fmt: off
+
+print((
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    G,  # TODO: could emit diagnostic about being possibly unbound
+    H,
+    I,
+    J,
+    K,
+    L,
+    M,  # TODO: could emit diagnostic about being possibly unbound
+    N,  # TODO: could emit diagnostic about being possibly unbound
+    O,  # TODO: could emit diagnostic about being possibly unbound
+    P,  # TODO: could emit diagnostic about being possibly unbound
+    Q,  # TODO: could emit diagnostic about being possibly unbound
+    R,  # TODO: could emit diagnostic about being possibly unbound
+    S,  # TODO: could emit diagnostic about being possibly unbound
+    T,  # TODO: could emit diagnostic about being possibly unbound
+))
+```
+
 ### Global-scope names starting with underscores
 
 Global-scope names starting with underscores are not imported from a `*` import (unless the module
@@ -657,5 +732,30 @@ def f():
     reveal_type(X)  # revealed: Unknown
 ```
 
+### `*` combined with other aliases in the list
+
+`a.py`:
+
+```py
+X: bool = True
+_Y: bool = False
+```
+
+`b.py`:
+
+<!-- blacken-docs:off -->
+
+```py
+from a import *, _Y  # error: [invalid-syntax]
+
+# The import statement above is invalid syntax,
+# but it's pretty obvious that the user wanted to do a `*` import,
+# so we import all public names from `a` anyway, to minimize cascading errors
+reveal_type(X)  # revealed: bool
+reveal_type(_Y)  # revealed: bool
+```
+
+<!-- blacken-docs:on -->
+
 [python language reference for import statements]: https://docs.python.org/3/reference/simple_stmts.html#the-import-statement
 [typing spec]: https://typing.python.org/en/latest/spec/distributing.html#library-interface-public-and-private-symbols

crates/red_knot_python_semantic/src/semantic_index/builder.rs

@@ -998,40 +998,41 @@ where
                 }
             }
             ast::Stmt::ImportFrom(node) => {
-                if node.is_wildcard_import() {
-                    // Wildcard imports are invalid syntax everywhere except the top-level scope,
-                    // and thus do not bind any definitions anywhere else
-                    if self.current_scope() == self.scope_stack[0].file_scope_id {
-                        if let Ok(module_name) =
-                            module_name_from_import_statement(self.db, self.file, node)
-                        {
-                            if let Some(module) = resolve_module(self.db, &module_name) {
-                                let exported_names = find_exports(self.db, module.file());
-                                if !exported_names.is_empty() {
-                                    for export in find_exports(self.db, module.file()) {
-                                        let symbol_id = self.add_symbol(export.clone());
-                                        let node_ref =
-                                            StarImportDefinitionNodeRef { node, symbol_id };
-                                        self.add_definition(symbol_id, node_ref);
+                for (alias_index, alias) in node.names.iter().enumerate() {
+                    if &alias.name == "*" {
+                        // Wildcard imports are invalid syntax everywhere except the top-level scope,
+                        // and thus do not bind any definitions anywhere else
+                        if self.current_scope() == self.scope_stack[0].file_scope_id {
+                            if let Ok(module_name) =
+                                module_name_from_import_statement(self.db, self.file, node)
+                            {
+                                if let Some(module) = resolve_module(self.db, &module_name) {
+                                    let exported_names = find_exports(self.db, module.file());
+                                    if !exported_names.is_empty() {
+                                        for export in find_exports(self.db, module.file()) {
+                                            let symbol_id = self.add_symbol(export.clone());
+                                            let node_ref =
+                                                StarImportDefinitionNodeRef { node, symbol_id };
+                                            self.add_definition(symbol_id, node_ref);
+                                        }
+                                        continue;
                                     }
-                                    return;
                                 }
                             }
                         }
+
+                        let symbol = self.add_symbol(Name::new_static("*"));
+                        self.add_definition(
+                            symbol,
+                            ImportFromDefinitionNodeRef {
+                                node,
+                                alias_index: 0,
+                                is_reexported: false,
+                            },
+                        );
+                        continue;
                     }
-                    let symbol = self.add_symbol(Name::new_static("*"));
-                    self.add_definition(
-                        symbol,
-                        ImportFromDefinitionNodeRef {
-                            node,
-                            alias_index: 0,
-                            is_reexported: false,
-                        },
-                    );
-                    return;
-                }
 
-                for (alias_index, alias) in node.names.iter().enumerate() {
                     let (symbol_name, is_reexported) = if let Some(asname) = &alias.asname {
                         (&asname.id, asname.id == alias.name.id)
                     } else {

crates/red_knot_python_semantic/src/semantic_index/definition.rs

@@ -430,10 +430,7 @@ impl<'db> DefinitionNodeRef<'db> {
                 alias_index,
                 is_reexported: _,
             }) => (&node.names[alias_index]).into(),
-            Self::ImportStar(StarImportDefinitionNodeRef { node, .. }) => {
-                debug_assert_eq!(node.names.len(), 1);
-                (&node.names[0]).into()
-            }
+            Self::ImportStar(StarImportDefinitionNodeRef { node, .. }) => (&node.names[0]).into(),
             Self::Function(node) => node.into(),
             Self::Class(node) => node.into(),
             Self::TypeAlias(node) => node.into(),