From e7237652a9048e5fa0e6ec002855d89f9554833b Mon Sep 17 00:00:00 2001
From: Andrew Gallant <andrew@astral.sh>
Date: Sat, 23 Aug 2025 08:33:59 -0400
Subject: [PATCH] [ty] Lightly refactor document symbols AST visitor

This makes use of early continue/return to keep rightward drift under
control. (I also find it easier to read.)
---
 crates/ty_ide/src/symbols.rs | 94 ++++++++++++++++++------------------
 1 file changed, 47 insertions(+), 47 deletions(-)

diff --git a/crates/ty_ide/src/symbols.rs b/crates/ty_ide/src/symbols.rs
index e787a0c0c0..646c89537b 100644
--- a/crates/ty_ide/src/symbols.rs
+++ b/crates/ty_ide/src/symbols.rs
@@ -456,60 +456,60 @@ impl SourceOrderVisitor<'_> for SymbolVisitor {
 
             Stmt::Assign(assign) => {
                 // Include assignments only when we're in global or class scope
-                if !self.in_function {
-                    for target in &assign.targets {
-                        if let Expr::Name(name) = target {
-                            let kind = if Self::is_constant_name(name.id.as_str()) {
-                                SymbolKind::Constant
-                            } else if self
-                                .iter_symbol_stack()
-                                .any(|s| s.kind == SymbolKind::Class)
-                            {
-                                SymbolKind::Field
-                            } else {
-                                SymbolKind::Variable
-                            };
+                if self.in_function {
+                    return;
+                }
+                for target in &assign.targets {
+                    let Expr::Name(name) = target else { continue };
+                    let kind = if Self::is_constant_name(name.id.as_str()) {
+                        SymbolKind::Constant
+                    } else if self
+                        .iter_symbol_stack()
+                        .any(|s| s.kind == SymbolKind::Class)
+                    {
+                        SymbolKind::Field
+                    } else {
+                        SymbolKind::Variable
+                    };
 
-                            let symbol = SymbolTree {
-                                parent: None,
-                                name: name.id.to_string(),
-                                kind,
-                                name_range: name.range(),
-                                full_range: stmt.range(),
-                            };
-
-                            self.add_symbol(symbol);
-                        }
-                    }
+                    let symbol = SymbolTree {
+                        parent: None,
+                        name: name.id.to_string(),
+                        kind,
+                        name_range: name.range(),
+                        full_range: stmt.range(),
+                    };
+                    self.add_symbol(symbol);
                 }
             }
 
             Stmt::AnnAssign(ann_assign) => {
                 // Include assignments only when we're in global or class scope
-                if !self.in_function {
-                    if let Expr::Name(name) = &*ann_assign.target {
-                        let kind = if Self::is_constant_name(name.id.as_str()) {
-                            SymbolKind::Constant
-                        } else if self
-                            .iter_symbol_stack()
-                            .any(|s| s.kind == SymbolKind::Class)
-                        {
-                            SymbolKind::Field
-                        } else {
-                            SymbolKind::Variable
-                        };
-
-                        let symbol = SymbolTree {
-                            parent: None,
-                            name: name.id.to_string(),
-                            kind,
-                            name_range: name.range(),
-                            full_range: stmt.range(),
-                        };
-
-                        self.add_symbol(symbol);
-                    }
+                if self.in_function {
+                    return;
                 }
+                let Expr::Name(name) = &*ann_assign.target else {
+                    return;
+                };
+                let kind = if Self::is_constant_name(name.id.as_str()) {
+                    SymbolKind::Constant
+                } else if self
+                    .iter_symbol_stack()
+                    .any(|s| s.kind == SymbolKind::Class)
+                {
+                    SymbolKind::Field
+                } else {
+                    SymbolKind::Variable
+                };
+
+                let symbol = SymbolTree {
+                    parent: None,
+                    name: name.id.to_string(),
+                    kind,
+                    name_range: name.range(),
+                    full_range: stmt.range(),
+                };
+                self.add_symbol(symbol);
             }
 
             _ => {