Method visit_expr

crates/ty_python_core/src/builder.rs:4348–4656

(&mut self, expr: &'ast ast::Expr)

    }

    fn visit_expr(&mut self, expr: &'ast ast::Expr) {
        self.with_semantic_checker(|semantic, context| semantic.visit_expr(expr, context));

        self.scopes_by_expression
            .record_expression(expr, self.current_scope());

        match expr {
            ast::Expr::Name(ast::ExprName { ctx, .. })
            | ast::Expr::Attribute(ast::ExprAttribute { ctx, .. })
            | ast::Expr::Subscript(ast::ExprSubscript { ctx, .. }) => {
                // Record place effects after walking the expression. For names, this is
                // equivalent because `walk_expr` is a no-op; for attribute/subscript places,
                // child evaluation can introduce bindings (for example via walrus operators),
                // and those bindings need to exist before we register parent/member associations.
                let mut deferred_effects = None;
                if let Some(mut place_expr) = PlaceExpr::try_from_expr(expr) {
                    if let Some(method_scope_id) = self.is_method_or_eagerly_executed_in_method()
                        && let PlaceExpr::Member(member) = &mut place_expr
                        && member.is_instance_attribute_candidate()
                        && let Some(attribute) = expr.as_attribute_expr()
                    {
                        // We specifically mark direct attribute assignments to the first
                        // parameter of a method, i.e. typically `self` or `cls`.
                        // However, we must check that the symbol hasn't been shadowed by an
                        // intermediate scope (e.g., a comprehension variable: `for self in [...]`)
                        // and that the AST base is still the original name rather than a
                        // rebinding expression such as `(self := other).x`.
                        let accessed_object_refers_to_first_parameter =
                            self.current_first_parameter_name.is_some_and(|first| {
                                attribute
                                    .value
                                    .as_name_expr()
                                    .is_some_and(|name| name.id == first)
                                    && !self.is_symbol_bound_in_intermediate_eager_scopes(
                                        first,
                                        method_scope_id,
                                    )
                            });

                        if accessed_object_refers_to_first_parameter {
                            member.mark_instance_attribute();
                        }
                    }

                    let (is_use, is_definition) = match (ctx, self.current_assignment()) {
                        (ast::ExprContext::Store, Some(CurrentAssignment::AugAssign(_))) => {
                            // For augmented assignment, the target expression is also used.
                            (true, true)
                        }
                        (ast::ExprContext::Load, _) => (true, false),
                        (ast::ExprContext::Store, _) => (false, true),
                        (ast::ExprContext::Del, _) => (true, true),
                        (ast::ExprContext::Invalid, _) => (false, false),
                    };
                    deferred_effects = Some((place_expr, is_use, is_definition));
                }

                walk_expr(self, expr);