Add dedicated structs for BindingKind variants (#3672)

crates/ruff_python_ast/src/context.rs

@@ -10,8 +10,8 @@ use ruff_python_stdlib::typing::TYPING_EXTENSIONS;
 
 use crate::helpers::{collect_call_path, from_relative_import};
 use crate::scope::{
-    Binding, BindingId, BindingKind, Bindings, Exceptions, ExecutionContext, Scope, ScopeId,
-    ScopeKind, ScopeStack, Scopes,
+    Binding, BindingId, BindingKind, Bindings, Exceptions, ExecutionContext, FromImportation,
+    Importation, Scope, ScopeId, ScopeKind, ScopeStack, Scopes, SubmoduleImportation,
 };
 use crate::types::{CallPath, RefEquality};
 use crate::typing::AnnotationKind;
@@ -156,7 +156,10 @@ impl<'a> Context<'a> {
             return None;
         };
         match &binding.kind {
-            BindingKind::Importation(.., name) | BindingKind::SubmoduleImportation(name, ..) => {
+            BindingKind::Importation(Importation {
+                full_name: name, ..
+            })
+            | BindingKind::SubmoduleImportation(SubmoduleImportation { name, .. }) => {
                 if name.starts_with('.') {
                     if let Some(module) = &self.module_path {
                         let mut source_path = from_relative_import(module, name);
@@ -171,7 +174,9 @@ impl<'a> Context<'a> {
                     Some(source_path)
                 }
             }
-            BindingKind::FromImportation(.., name) => {
+            BindingKind::FromImportation(FromImportation {
+                full_name: name, ..
+            }) => {
                 if name.starts_with('.') {
                     if let Some(module) = &self.module_path {
                         let mut source_path = from_relative_import(module, name);

crates/ruff_python_ast/src/operations.rs

@@ -5,7 +5,7 @@ use rustpython_parser::{lexer, Mode, Tok};
 
 use crate::context::Context;
 use crate::helpers::any_over_expr;
-use crate::scope::{BindingKind, Scope};
+use crate::scope::{BindingKind, Export, Scope};
 use crate::visitor;
 use crate::visitor::Visitor;
 
@@ -96,7 +96,7 @@ pub fn extract_all_names(
     // Grab the existing bound __all__ values.
     if let StmtKind::AugAssign { .. } = &stmt.node {
         if let Some(index) = scope.get("__all__") {
-            if let BindingKind::Export(existing) = &ctx.bindings[*index].kind {
+            if let BindingKind::Export(Export { names: existing }) = &ctx.bindings[*index].kind {
                 names.extend_from_slice(existing);
             }
         }

crates/ruff_python_ast/src/scope.rs

@@ -284,26 +284,45 @@ impl<'a> Binding<'a> {
 
     pub fn redefines(&self, existing: &'a Binding) -> bool {
         match &self.kind {
-            BindingKind::Importation(.., full_name) => {
-                if let BindingKind::SubmoduleImportation(.., existing) = &existing.kind {
+            BindingKind::Importation(Importation { full_name, .. }) => {
+                if let BindingKind::SubmoduleImportation(SubmoduleImportation {
+                    full_name: existing,
+                    ..
+                }) = &existing.kind
+                {
                     return full_name == existing;
                 }
             }
-            BindingKind::FromImportation(.., full_name) => {
-                if let BindingKind::SubmoduleImportation(.., existing) = &existing.kind {
+            BindingKind::FromImportation(FromImportation { full_name, .. }) => {
+                if let BindingKind::SubmoduleImportation(SubmoduleImportation {
+                    full_name: existing,
+                    ..
+                }) = &existing.kind
+                {
                     return full_name == existing;
                 }
             }
-            BindingKind::SubmoduleImportation(.., full_name) => match &existing.kind {
-                BindingKind::Importation(.., existing)
-                | BindingKind::SubmoduleImportation(.., existing) => {
-                    return full_name == existing;
+            BindingKind::SubmoduleImportation(SubmoduleImportation { full_name, .. }) => {
+                match &existing.kind {
+                    BindingKind::Importation(Importation {
+                        full_name: existing,
+                        ..
+                    })
+                    | BindingKind::SubmoduleImportation(SubmoduleImportation {
+                        full_name: existing,
+                        ..
+                    }) => {
+                        return full_name == existing;
+                    }
+                    BindingKind::FromImportation(FromImportation {
+                        full_name: existing,
+                        ..
+                    }) => {
+                        return full_name == existing;
+                    }
+                    _ => {}
                 }
-                BindingKind::FromImportation(.., existing) => {
-                    return full_name == existing;
-                }
-                _ => {}
-            },
+            }
             BindingKind::Annotation => {
                 return false;
             }
@@ -366,6 +385,54 @@ impl nohash_hasher::IsEnabled for BindingId {}
 //        StarImportation
 //        FutureImportation
 
+#[derive(Clone, Debug)]
+pub struct Export {
+    /// The names of the bindings exported via `__all__`.
+    pub names: Vec<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct StarImportation {
+    /// The level of the import. `None` or `Some(0)` indicate an absolute import.
+    pub level: Option<usize>,
+    /// The module being imported. `None` indicates a wildcard import.
+    pub module: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct Importation<'a> {
+    /// The name to which the import is bound.
+    /// Given `import foo`, `name` would be "foo".
+    /// Given `import foo as bar`, `name` would be "bar".
+    pub name: &'a str,
+    /// The full name of the module being imported.
+    /// Given `import foo`, `full_name` would be "foo".
+    /// Given `import foo as bar`, `full_name` would be "foo".
+    pub full_name: &'a str,
+}
+
+#[derive(Clone, Debug)]
+pub struct FromImportation<'a> {
+    /// The name to which the import is bound.
+    /// Given `from foo import bar`, `name` would be "bar".
+    /// Given `from foo import bar as baz`, `name` would be "baz".
+    pub name: &'a str,
+    /// The full name of the module being imported.
+    /// Given `from foo import bar`, `full_name` would be "foo.bar".
+    /// Given `from foo import bar as baz`, `full_name` would be "foo.bar".
+    pub full_name: String,
+}
+
+#[derive(Clone, Debug)]
+pub struct SubmoduleImportation<'a> {
+    /// The parent module imported by the submodule import.
+    /// Given `import foo.bar`, `module` would be "foo".
+    pub name: &'a str,
+    /// The full name of the submodule being imported.
+    /// Given `import foo.bar`, `full_name` would be "foo.bar".
+    pub full_name: &'a str,
+}
+
 #[derive(Clone, Debug, is_macro::Is)]
 pub enum BindingKind<'a> {
     Annotation,
@@ -378,12 +445,12 @@ pub enum BindingKind<'a> {
     Builtin,
     ClassDefinition,
     FunctionDefinition,
-    Export(Vec<String>),
+    Export(Export),
     FutureImportation,
-    StarImportation(Option<usize>, Option<String>),
-    Importation(&'a str, &'a str),
-    FromImportation(&'a str, String),
-    SubmoduleImportation(&'a str, &'a str),
+    StarImportation(StarImportation),
+    Importation(Importation<'a>),
+    FromImportation(FromImportation<'a>),
+    SubmoduleImportation(SubmoduleImportation<'a>),
 }
 
 /// The bindings in a program.