[IMP] gotodef display_name to compute methods

mmahrouss · mmahrouss · commit de0acbc780be · 2025-10-29T13:59:18.000+01:00
diff --git a/server/src/core/evaluation.rs b/server/src/core/evaluation.rs
@@ -75,13 +75,13 @@ pub struct Evaluation {
 }
 
 #[derive(Debug)]
-pub enum ExprOrIdent<'a> {
-    Expr(&'a Expr),
-    Ident(&'a Identifier),
-    Parameter(&'a Parameter),
+pub enum ExprOrIdent {
+    Expr(Expr),
+    Ident(Identifier),
+    Parameter(Parameter),
 }
 
-impl ExprOrIdent<'_> {
+impl ExprOrIdent {
 
     pub fn range(&self) -> TextRange{
         match self {
@@ -575,7 +575,7 @@ impl Evaluation {
             (S!("module"), from_module),
             (S!("range"), ContextValue::RANGE(ast.range()))
         ]));
-        let analyze_result = Evaluation::analyze_ast(session, &ExprOrIdent::Expr(ast), parent, max_infer, &mut context, for_annotation, required_dependencies);
+        let analyze_result = Evaluation::analyze_ast(session, &ExprOrIdent::Expr(ast.clone()), parent, max_infer, &mut context, for_annotation, required_dependencies);
         return (analyze_result.evaluations, analyze_result.diagnostics)
     }
 
@@ -591,7 +591,7 @@ impl Evaluation {
             (S!("module"), from_module),
             (S!("range"), ContextValue::RANGE(ast.range()))
         ]));
-        let value = Evaluation::analyze_ast(session, &ExprOrIdent::Expr(ast), parent, max_infer, &mut context, for_annotation, &mut vec![]);
+        let value = Evaluation::analyze_ast(session, &ExprOrIdent::Expr(ast.clone()), parent, max_infer, &mut context, for_annotation, &mut vec![]);
         if value.evaluations.len() == 1 { //only handle strict evaluations
             let eval = &value.evaluations[0];
             let v = eval.follow_ref_and_get_value(session, &mut None, diagnostics);
@@ -624,7 +624,7 @@ impl Evaluation {
             (S!("module"), from_module),
             (S!("range"), ContextValue::RANGE(ast.range()))
         ]));
-        let value = Evaluation::analyze_ast(session, &ExprOrIdent::Expr(ast), parent, max_infer, &mut context, for_annotation, &mut vec![]);
+        let value = Evaluation::analyze_ast(session, &ExprOrIdent::Expr(ast.clone()), parent, max_infer, &mut context, for_annotation, &mut vec![]);
         if value.evaluations.len() == 1 { //only handle strict evaluations
             let eval = &value.evaluations[0];
             let v = eval.follow_ref_and_get_value(session, &mut None, diagnostics);
diff --git a/server/src/features/ast_utils.rs b/server/src/features/ast_utils.rs
@@ -17,7 +17,7 @@ pub struct AstUtils {}
 
 impl AstUtils {
 
-    pub fn get_symbols(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, file_info: &Rc<RefCell<FileInfo>>, offset: u32) -> (AnalyzeAstResult, Option<TextRange>, Option<ExprCall>) {
+    pub fn get_expr(file_info: &Rc<RefCell<FileInfo>>, offset: u32) -> (Option<ExprOrIdent>, Option<ExprCall>) {
         let mut expr: Option<ExprOrIdent> = None;
         let mut call_expr: Option<ExprCall> = None;
         let file_info_ast = file_info.borrow().file_info_ast.clone();
@@ -28,10 +28,13 @@ impl AstUtils {
                 break;
             }
         }
-        let Some(expr) = expr else {
+        if expr.is_none() {
             warn!("expr not found");
-            return (AnalyzeAstResult::default(), None, None);
-        };
+        }
+        (expr, call_expr)
+    }
+
+    pub fn get_symbols(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, offset: u32, expr: &ExprOrIdent) -> (AnalyzeAstResult, Option<TextRange>) {
         let parent_symbol = Symbol::get_scope_symbol(file_symbol.clone(), offset, matches!(expr, ExprOrIdent::Parameter(_)));
         AstUtils::build_scope(session, &parent_symbol);
         let from_module;
@@ -45,7 +48,7 @@ impl AstUtils {
             (S!("range"), ContextValue::RANGE(expr.range()))
         ]));
         let analyse_ast_result: AnalyzeAstResult = Evaluation::analyze_ast(session, &expr, parent_symbol.clone(), &expr.range().end(), &mut context,false, &mut vec![]);
-        (analyse_ast_result, Some(expr.range()), call_expr)
+        (analyse_ast_result, Some(expr.range()))
 
     }
 
@@ -80,7 +83,7 @@ impl AstUtils {
 
 pub struct ExprFinderVisitor<'a> {
     offset: TextSize,
-    expr: Option<ExprOrIdent<'a>>,
+    expr: Option<ExprOrIdent>,
     last_call_expr: Option<&'a ExprCall>,
 }
 
@@ -91,7 +94,7 @@ impl<'a> ExprFinderVisitor<'a> {
         expr: the expr being searched for
         last_call_expr: The last call expr preceding the expr we are searching for
      */
-    pub fn find_expr_at(stmt: &'a Stmt, offset: u32) -> (Option<ExprOrIdent<'a>>, Option<ExprCall>) {
+    pub fn find_expr_at(stmt: &'a Stmt, offset: u32) -> (Option<ExprOrIdent>, Option<ExprCall>) {
         let mut visitor = Self {
             offset: TextSize::new(offset),
             expr: None,
@@ -114,7 +117,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
             }
             walk_expr(self, expr);
             if self.expr.is_none() {
-                self.expr = Some(ExprOrIdent::Expr(expr));
+                self.expr = Some(ExprOrIdent::Expr(expr.clone()));
             }
         } else {
             walk_expr(self, expr);
@@ -125,10 +128,10 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
         walk_alias(self, alias);
         if self.expr.is_none() {
             if alias.name.range().contains(self.offset) {
-                self.expr = Some(ExprOrIdent::Ident(&alias.name));
+                self.expr = Some(ExprOrIdent::Ident(alias.name.clone()));
             } else if let Some(ref asname) = alias.asname {
                 if asname.range().contains(self.offset) {
-                    self.expr = Some(ExprOrIdent::Ident(asname))
+                    self.expr = Some(ExprOrIdent::Ident(asname.clone()))
                 }
             }
         }
@@ -140,7 +143,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
             let ExceptHandler::ExceptHandler(ref handler) = *except_handler;
             if let Some(ref ident) = handler.name {
                 if ident.clone().range().contains(self.offset) {
-                    self.expr = Some(ExprOrIdent::Ident(ident));
+                    self.expr = Some(ExprOrIdent::Ident(ident.clone()));
                 }
             }
         } else {
@@ -151,7 +154,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
     fn visit_parameter(&mut self, parameter: &'a Parameter) {
         walk_parameter(self, parameter);
         if self.expr.is_none() && parameter.name.range().contains(self.offset) {
-            self.expr = Some(ExprOrIdent::Parameter(parameter));
+            self.expr = Some(ExprOrIdent::Parameter(parameter.clone()));
         }
     }
 
@@ -161,7 +164,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
         if self.expr.is_none() {
             if let Some(ref ident) = keyword.arg {
                 if ident.range().contains(self.offset) {
-                    self.expr = Some(ExprOrIdent::Ident(ident));
+                    self.expr = Some(ExprOrIdent::Ident(ident.clone()));
                 }
             }
         } else {
@@ -173,7 +176,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
         walk_pattern_keyword(self, pattern_keyword);
 
         if self.expr.is_none() && pattern_keyword.clone().attr.range().contains(self.offset) {
-            self.expr = Some(ExprOrIdent::Ident(&pattern_keyword.attr));
+            self.expr = Some(ExprOrIdent::Ident(pattern_keyword.attr.clone()));
         } else {
             walk_pattern_keyword(self, pattern_keyword);
         }
@@ -190,7 +193,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
                 };
 
                 if ident.is_some() && ident.unwrap().range().contains(self.offset) {
-                    self.expr = Some(ExprOrIdent::Ident(ident.unwrap()));
+                    self.expr = Some(ExprOrIdent::Ident(ident.unwrap().clone()));
                 }
 
             }
@@ -212,7 +215,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
 
                 if let Some(ident) = ident {
                     if ident.range().contains(self.offset) {
-                        self.expr = Some(ExprOrIdent::Ident(ident));
+                        self.expr = Some(ExprOrIdent::Ident(ident.clone()));
                     }
                 }
             }
@@ -233,7 +236,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {
 
             for ident in idents {
                 if ident.range().contains(self.offset) {
-                    self.expr = Some(ExprOrIdent::Ident(ident));
+                    self.expr = Some(ExprOrIdent::Ident(ident.clone()));
                     break;
                 }
             }
diff --git a/server/src/features/definition.rs b/server/src/features/definition.rs
@@ -5,15 +5,15 @@ use std::path::PathBuf;
 use std::{cell::RefCell, rc::Rc};
 
 use crate::constants::SymType;
-use crate::core::evaluation::{Evaluation, EvaluationValue};
+use crate::core::evaluation::{Evaluation, EvaluationValue, ExprOrIdent};
 use crate::core::file_mgr::{FileInfo, FileMgr};
 use crate::core::odoo::SyncOdoo;
 use crate::core::python_odoo_builder::MAGIC_FIELDS;
 use crate::core::symbols::symbol::Symbol;
 use crate::features::ast_utils::AstUtils;
 use crate::features::features_utils::FeaturesUtils;
 use crate::features::xml_ast_utils::{XmlAstResult, XmlAstUtils};
-use crate::oyarn;
+use crate::{S, oyarn};
 use crate::threads::SessionInfo;
 use crate::utils::PathSanitizer as _;
 
@@ -149,33 +149,86 @@ impl DefinitionFeature {
         compute_symbols.len() > 0
     }
 
+    pub fn add_display_name_compute_methods(session: &mut SessionInfo, links: &mut Vec<LocationLink>, expr: ExprOrIdent, file_symbol: &Rc<RefCell<Symbol>>, offset: usize) {
+        // now we want `_compute_display_name` definition(s)
+        // we need the symbol of the model/ then we run get member symbol
+        // to do that, we need the expr, match it to attribute, get the value, get its evals
+        // with those evals, we run get_member_symbol on `_compute_display_name`
+        let crate::core::evaluation::ExprOrIdent::Expr(Expr::Attribute(attr_expr)) = expr else {
+            return;
+        };
+        let (analyse_ast_result, _range) = AstUtils::get_symbols(session, file_symbol, offset as u32, &crate::core::evaluation::ExprOrIdent::Expr(*attr_expr.value));
+        let eval_ptrs = analyse_ast_result.evaluations.iter().flat_map(|eval| Symbol::follow_ref(eval.symbol.get_symbol_ptr(), session, &mut None, false, false, None)).collect::<Vec<_>>();
+        let symbols = eval_ptrs.iter().flat_map(|eval_ptr| {
+            let Some(symbol) = eval_ptr.upgrade_weak() else {
+                return  vec![];
+            };
+            symbol.borrow().get_member_symbol(session, &S!("_compute_display_name"), None/*TODO */, false, false, true, false).0
+        }).collect::<Vec<_>>();
+        for symbol in symbols {
+            if let Some(file) = symbol.borrow().get_file() {
+                for path in file.upgrade().unwrap().borrow().paths().iter() {
+                    let full_path = match file.upgrade().unwrap().borrow().typ() {
+                        SymType::PACKAGE(_) => PathBuf::from(path).join(format!("__init__.py{}", file.upgrade().unwrap().borrow().as_package().i_ext())).sanitize(),
+                        _ => path.clone()
+                    };
+                    let range = if symbol.borrow().has_range() {
+                        if symbol.borrow().range().contains(TextSize::new(offset as u32)) {
+                            continue; //skip if we are already on the definition
+                        }
+                        session.sync_odoo.get_file_mgr().borrow().text_range_to_range(session, &full_path, &symbol.borrow().range())
+                    } else {
+                        Range::default()
+                    };
+                    links.push(LocationLink{
+                        origin_selection_range: None,
+                        target_uri: FileMgr::pathname2uri(&full_path),
+                        target_selection_range: range,
+                        target_range: range,
+                    });
+                }
+            }
+        }
+    }
+
     pub fn get_location(session: &mut SessionInfo,
         file_symbol: &Rc<RefCell<Symbol>>,
         file_info: &Rc<RefCell<FileInfo>>,
         line: u32,
         character: u32
     ) -> Option<GotoDefinitionResponse> {
         let offset = file_info.borrow().position_to_offset(line, character);
-        let (analyse_ast_result, _range, call_expr) = AstUtils::get_symbols(session, file_symbol, file_info, offset as u32);
+        let (expr, call_expr) = AstUtils::get_expr(file_info, offset as u32);
+        let Some(expr) = expr else  {
+            return None;
+        };
+        let (analyse_ast_result, _range) = AstUtils::get_symbols(session, file_symbol, offset as u32, &expr);
         if analyse_ast_result.evaluations.is_empty() {
             return None;
         }
         let mut links = vec![];
         let mut evaluations = analyse_ast_result.evaluations.clone();
         // Filter out magic fields
+        let mut dislay_name_found = false;
         evaluations.retain(|eval| {
             // Filter out, variables, whose parents are a class, whose name is one of the magic fields, and have the same range as their parent
             let eval_sym = eval.symbol.get_symbol(session, &mut None, &mut vec![], None);
             let Some(eval_sym) = eval_sym.upgrade_weak() else { return true; };
             if !MAGIC_FIELDS.contains(&eval_sym.borrow().name().as_str()) || eval_sym.borrow().typ() != SymType::VARIABLE || !eval_sym.borrow().is_field(session) {
                 return true;
             }
+            if eval_sym.borrow().name() == "display_name" {
+                dislay_name_found = true;
+            }
             let Some(parent_sym) = eval_sym.borrow().parent().and_then(|parent| parent.upgrade()) else { return true; };
             if parent_sym.borrow().typ() != SymType::CLASS {
                 return true;
             }
             eval_sym.borrow().range() != parent_sym.borrow().range()
         });
+        if dislay_name_found {
+            DefinitionFeature::add_display_name_compute_methods(session, &mut links, expr, file_symbol, offset);
+        }
         let mut index = 0;
         while index < evaluations.len() {
             let eval = evaluations[index].clone();
diff --git a/server/src/features/hover.rs b/server/src/features/hover.rs
@@ -16,7 +16,11 @@ impl HoverFeature {
 
     pub fn hover_python(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, file_info: &Rc<RefCell<FileInfo>>, line: u32, character: u32) -> Option<Hover> {
         let offset = file_info.borrow().position_to_offset(line, character);
-        let (analyse_ast_result, range, call_expr) = AstUtils::get_symbols(session, file_symbol, file_info, offset as u32);
+        let (expr, call_expr) = AstUtils::get_expr(file_info, offset as u32);
+        let Some(expr) = expr else  {
+            return None;
+        };
+        let (analyse_ast_result, range) = AstUtils::get_symbols(session, file_symbol, offset as u32, &expr);
         let evals = analyse_ast_result.evaluations;
         if evals.is_empty() {
             return None;

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ pub struct AstUtils {}`
`17`	`17`
`18`	`18`	`impl AstUtils {`
`19`	`19`
`20`		`- pub fn get_symbols(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, file_info: &Rc<RefCell<FileInfo>>, offset: u32) -> (AnalyzeAstResult, Option<TextRange>, Option<ExprCall>) {`
	`20`	`+ pub fn get_expr(file_info: &Rc<RefCell<FileInfo>>, offset: u32) -> (Option<ExprOrIdent>, Option<ExprCall>) {`
`21`	`21`	`let mut expr: Option<ExprOrIdent> = None;`
`22`	`22`	`let mut call_expr: Option<ExprCall> = None;`
`23`	`23`	`let file_info_ast = file_info.borrow().file_info_ast.clone();`
`@@ -28,10 +28,13 @@ impl AstUtils {`
`28`	`28`	`break;`
`29`	`29`	`}`
`30`	`30`	`}`
`31`		`- let Some(expr) = expr else {`
	`31`	`+ if expr.is_none() {`
`32`	`32`	`warn!("expr not found");`
`33`		`- return (AnalyzeAstResult::default(), None, None);`
`34`		`- };`
	`33`	`+ }`
	`34`	`+ (expr, call_expr)`
	`35`	`+ }`
	`36`	`+`
	`37`	`+ pub fn get_symbols(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, offset: u32, expr: &ExprOrIdent) -> (AnalyzeAstResult, Option<TextRange>) {`
`35`	`38`	`let parent_symbol = Symbol::get_scope_symbol(file_symbol.clone(), offset, matches!(expr, ExprOrIdent::Parameter(_)));`
`36`	`39`	`AstUtils::build_scope(session, &parent_symbol);`
`37`	`40`	`let from_module;`
`@@ -45,7 +48,7 @@ impl AstUtils {`
`45`	`48`	`(S!("range"), ContextValue::RANGE(expr.range()))`
`46`	`49`	`]));`
`47`	`50`	`let analyse_ast_result: AnalyzeAstResult = Evaluation::analyze_ast(session, &expr, parent_symbol.clone(), &expr.range().end(), &mut context,false, &mut vec![]);`
`48`		`- (analyse_ast_result, Some(expr.range()), call_expr)`
	`51`	`+ (analyse_ast_result, Some(expr.range()))`
`49`	`52`
`50`	`53`	`}`
`51`	`54`
`@@ -80,7 +83,7 @@ impl AstUtils {`
`80`	`83`
`81`	`84`	`pub struct ExprFinderVisitor<'a> {`
`82`	`85`	`offset: TextSize,`
`83`		`- expr: Option<ExprOrIdent<'a>>,`
	`86`	`+ expr: Option<ExprOrIdent>,`
`84`	`87`	`last_call_expr: Option<&'a ExprCall>,`
`85`	`88`	`}`
`86`	`89`
`@@ -91,7 +94,7 @@ impl<'a> ExprFinderVisitor<'a> {`
`91`	`94`	`expr: the expr being searched for`
`92`	`95`	`last_call_expr: The last call expr preceding the expr we are searching for`
`93`	`96`	`*/`
`94`		`- pub fn find_expr_at(stmt: &'a Stmt, offset: u32) -> (Option<ExprOrIdent<'a>>, Option<ExprCall>) {`
	`97`	`+ pub fn find_expr_at(stmt: &'a Stmt, offset: u32) -> (Option<ExprOrIdent>, Option<ExprCall>) {`
`95`	`98`	`let mut visitor = Self {`
`96`	`99`	`offset: TextSize::new(offset),`
`97`	`100`	`expr: None,`
`@@ -114,7 +117,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`114`	`117`	`}`
`115`	`118`	`walk_expr(self, expr);`
`116`	`119`	`if self.expr.is_none() {`
`117`		`- self.expr = Some(ExprOrIdent::Expr(expr));`
	`120`	`+ self.expr = Some(ExprOrIdent::Expr(expr.clone()));`
`118`	`121`	`}`
`119`	`122`	`} else {`
`120`	`123`	`walk_expr(self, expr);`
`@@ -125,10 +128,10 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`125`	`128`	`walk_alias(self, alias);`
`126`	`129`	`if self.expr.is_none() {`
`127`	`130`	`if alias.name.range().contains(self.offset) {`
`128`		`- self.expr = Some(ExprOrIdent::Ident(&alias.name));`
	`131`	`+ self.expr = Some(ExprOrIdent::Ident(alias.name.clone()));`
`129`	`132`	`} else if let Some(ref asname) = alias.asname {`
`130`	`133`	`if asname.range().contains(self.offset) {`
`131`		`- self.expr = Some(ExprOrIdent::Ident(asname))`
	`134`	`+ self.expr = Some(ExprOrIdent::Ident(asname.clone()))`
`132`	`135`	`}`
`133`	`136`	`}`
`134`	`137`	`}`
`@@ -140,7 +143,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`140`	`143`	`let ExceptHandler::ExceptHandler(ref handler) = *except_handler;`
`141`	`144`	`if let Some(ref ident) = handler.name {`
`142`	`145`	`if ident.clone().range().contains(self.offset) {`
`143`		`- self.expr = Some(ExprOrIdent::Ident(ident));`
	`146`	`+ self.expr = Some(ExprOrIdent::Ident(ident.clone()));`
`144`	`147`	`}`
`145`	`148`	`}`
`146`	`149`	`} else {`
`@@ -151,7 +154,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`151`	`154`	`fn visit_parameter(&mut self, parameter: &'a Parameter) {`
`152`	`155`	`walk_parameter(self, parameter);`
`153`	`156`	`if self.expr.is_none() && parameter.name.range().contains(self.offset) {`
`154`		`- self.expr = Some(ExprOrIdent::Parameter(parameter));`
	`157`	`+ self.expr = Some(ExprOrIdent::Parameter(parameter.clone()));`
`155`	`158`	`}`
`156`	`159`	`}`
`157`	`160`
`@@ -161,7 +164,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`161`	`164`	`if self.expr.is_none() {`
`162`	`165`	`if let Some(ref ident) = keyword.arg {`
`163`	`166`	`if ident.range().contains(self.offset) {`
`164`		`- self.expr = Some(ExprOrIdent::Ident(ident));`
	`167`	`+ self.expr = Some(ExprOrIdent::Ident(ident.clone()));`
`165`	`168`	`}`
`166`	`169`	`}`
`167`	`170`	`} else {`
`@@ -173,7 +176,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`173`	`176`	`walk_pattern_keyword(self, pattern_keyword);`
`174`	`177`
`175`	`178`	`if self.expr.is_none() && pattern_keyword.clone().attr.range().contains(self.offset) {`
`176`		`- self.expr = Some(ExprOrIdent::Ident(&pattern_keyword.attr));`
	`179`	`+ self.expr = Some(ExprOrIdent::Ident(pattern_keyword.attr.clone()));`
`177`	`180`	`} else {`
`178`	`181`	`walk_pattern_keyword(self, pattern_keyword);`
`179`	`182`	`}`
`@@ -190,7 +193,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`190`	`193`	`};`
`191`	`194`
`192`	`195`	`if ident.is_some() && ident.unwrap().range().contains(self.offset) {`
`193`		`- self.expr = Some(ExprOrIdent::Ident(ident.unwrap()));`
	`196`	`+ self.expr = Some(ExprOrIdent::Ident(ident.unwrap().clone()));`
`194`	`197`	`}`
`195`	`198`
`196`	`199`	`}`
`@@ -212,7 +215,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`212`	`215`
`213`	`216`	`if let Some(ident) = ident {`
`214`	`217`	`if ident.range().contains(self.offset) {`
`215`		`- self.expr = Some(ExprOrIdent::Ident(ident));`
	`218`	`+ self.expr = Some(ExprOrIdent::Ident(ident.clone()));`
`216`	`219`	`}`
`217`	`220`	`}`
`218`	`221`	`}`
`@@ -233,7 +236,7 @@ impl<'a> Visitor<'a> for ExprFinderVisitor<'a> {`
`233`	`236`
`234`	`237`	`for ident in idents {`
`235`	`238`	`if ident.range().contains(self.offset) {`
`236`		`- self.expr = Some(ExprOrIdent::Ident(ident));`
	`239`	`+ self.expr = Some(ExprOrIdent::Ident(ident.clone()));`
`237`	`240`	`break;`
`238`	`241`	`}`
`239`	`242`	`}`