From 23816af8995e694b0c562a62a2b5a0ae8ce6c0f3 Mon Sep 17 00:00:00 2001 From: light-ly Date: Tue, 29 Oct 2024 23:58:03 +0800 Subject: [PATCH] optimize code style | remove content --- src/core/hdlparam.rs | 114 ++++++----------------- src/core/sv_parser.rs | 209 +++++++++++++++--------------------------- 2 files changed, 102 insertions(+), 221 deletions(-) diff --git a/src/core/hdlparam.rs b/src/core/hdlparam.rs index 0b6450c..8bfc735 100644 --- a/src/core/hdlparam.rs +++ b/src/core/hdlparam.rs @@ -1,6 +1,5 @@ use std::collections::HashMap; use std::sync::RwLock; -use std::sync::RwLockReadGuard; use log::info; use serde::{Deserialize, Serialize}; @@ -92,6 +91,18 @@ impl Range { self } + + pub fn is_empty(&self) -> bool { + self.start.line == 0 && self.start.character == 0 && self.end.line == 0 && self.end.character == 0 + } + + pub fn to_option(&self) -> Option { + if self.is_empty() { + None + } else { + Some(self.clone()) + } + } } /// 比较两个 pos 的位置关系 @@ -131,19 +142,6 @@ pub struct Parameter { pub range: Range } -// #[derive(Debug, Serialize)] -// pub struct InstPort { -// pub name: String, -// pub range: Range -// } - -// #[derive(Debug, Serialize)] -// pub struct InstParameter { -// pub name: String, -// pub value: String, -// pub range: Range -// } - #[derive(Debug, Serialize, PartialEq, PartialOrd, Eq, Ord, Deserialize, Clone)] pub enum AssignType { Named, @@ -202,6 +200,7 @@ impl Instance { self.range.clone() } + #[allow(unused)] pub fn gen_dot_completion_param_range(&self) -> Range { // TODO: 精心调制这个方法 if let Some(param_range) = &self.instparams { @@ -272,34 +271,23 @@ pub struct FastHdlparam { } impl FastHdlparam { - pub fn add_define(&mut self, name: &str, replacement: &str, start_line: u32, start_character: u32, - end_line: u32, end_character: u32, params: Vec) { + pub fn add_define(&mut self, name: &str, replacement: &str, range: Range, params: Vec) { let define = Define { name: name.to_string(), replacement: replacement.to_string(), - range: Range { - start: Position { line: start_line, character: start_character }, - end: Position { line: end_line, character: end_character } - }, + range, params }; self.fast_macro.defines.push(define); } - pub fn new_module(&mut self, name: &str, start_line: u32, start_character: u32, end_line: u32, end_character: u32) { + pub fn new_module(&mut self, name: &str, range: Range) { let module = Module { name: name.to_string(), params: Vec::new(), ports: Vec::new(), instances: Vec::new(), - range: Range { - start: Position { - line: start_line, character: start_character - }, - end: Position { - line: end_line, character: end_character - } - } + range }; self.content.push(module); } @@ -311,29 +299,20 @@ impl FastHdlparam { } } - pub fn add_parameter(&mut self, name: &str, net_type: &str, init: &str, - start_line: u32, start_character: u32, end_line: u32, end_character: u32) { + pub fn add_parameter(&mut self, name: &str, net_type: &str, init: &str, range: Range) { if let Some(last_module) = self.content.last_mut() { let parameter = Parameter { name: name.to_string(), net_type: net_type.to_string(), init: init.to_string(), - range: Range { - start: Position { - line: start_line, character: start_character - }, - end: Position { - line:end_line, character: end_character - } - } + range }; last_module.params.push(parameter); last_module.params.dedup(); } } - pub fn add_port(&mut self, name: &str, dir_type: &str, net_type: &str, width: &str, - start_line: u32, start_character: u32, end_line: u32, end_character: u32) { + pub fn add_port(&mut self, name: &str, dir_type: &str, net_type: &str, width: &str, range: Range) { if let Some(last_module) = self.content.last_mut() { let port = Port { name: name.to_string(), @@ -341,65 +320,24 @@ impl FastHdlparam { net_type: net_type.to_string(), width: width.to_string(), signed: "unsigned".to_string(), - range: Range { - start: Position { - line: start_line, character: start_character - }, - end: Position { - line:end_line, character: end_character - } - } + range }; last_module.ports.push(port); last_module.ports.dedup(); } } - pub fn add_instance(&mut self, name: &str, inst_type: &str, params_assign: Vec, ports_assign: Vec, start_line: u32, start_character: u32, end_line: u32, end_character: u32, - param_start_line: u32, param_start_character: u32, param_end_line: u32, param_end_character: u32, - port_start_line: u32, port_start_character: u32, port_end_line: u32, port_end_character: u32 ) { + pub fn add_instance(&mut self, name: &str, inst_type: &str, range: Range, + param_range: Option, params_assign: Vec, port_range: Option, ports_assign: Vec) { if let Some(last_module) = self.content.last_mut() { let instance = Instance { name: name.to_string(), inst_type: inst_type.to_string(), - instparams: if param_start_line == 0 { - None - } else { - Some( - Range { - start: Position { - line: param_start_line, character: param_start_character - }, - end: Position { - line: param_end_line, character: param_end_character - } - } - ) - }, + instparams: param_range, intstparams_assignment: params_assign, - instports: if port_start_line == 0 { - None - } else { - Some( - Range { - start: Position { - line: port_start_line, character: port_start_character - }, - end: Position { - line: port_end_line, character: port_end_character - } - } - ) - }, + instports: port_range, intstport_assignment: ports_assign, - range: Range { - start: Position { - line: start_line, character: start_character - }, - end: Position { - line: end_line, character: end_character - } - } + range }; last_module.instances.push(instance); } diff --git a/src/core/sv_parser.rs b/src/core/sv_parser.rs index d648fab..5d9486b 100644 --- a/src/core/sv_parser.rs +++ b/src/core/sv_parser.rs @@ -6,7 +6,7 @@ use log::info; use regex::Regex; use ropey::Rope; use tower_lsp::lsp_types::Url; -use sv_parser::{unwrap_locate, unwrap_node, EventIter, ListOfParamAssignments, Locate, NodeEvent, ParamAssignment, ParameterDeclaration, RefNode, SpecifyBlock, SyntaxTree}; +use sv_parser::{unwrap_locate, unwrap_node, EventIter, ListOfParamAssignments, Locate, NodeEvent, ParamAssignment, ParameterDeclaration, RefNode, SyntaxTree}; use crate::core::hdlparam::{AssignType, Position, Range}; use crate::sources::{recovery_sv_parse_with_retry, LSPSupport}; @@ -56,22 +56,6 @@ macro_rules! skip_until_enter { }}; } -macro_rules! skip_until_leave { - ($tree:ident, $event_iter:ident, $node:path) => { - while let Some(event) = $event_iter.next() { - match event { - NodeEvent::Enter(_) => (), - NodeEvent::Leave(x) => match x { - $node(_) => { - break; - } - _ => (), - }, - } - } - }; -} - #[allow(unused)] pub fn sv_parser(path: &str) -> Option { // The path of SystemVerilog source file @@ -114,10 +98,6 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re }; let mut ansi_port_last_dir = ""; - // TODO: 删除这个 content - let content = syntax_tree.text.text().split('\n') - .map(|s| s.to_string()) - .collect::>(); // println!("{:?}", syntax_tree); // &SyntaxTree is iterable let doc = Rope::from_str(syntax_tree.text.text()); @@ -127,7 +107,7 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re RefNode::TextMacroDefinition(x) => { if let Some(start) = unwrap_node!(x, TextMacroDefinition) { let start = get_identifier(start).unwrap(); - let (start_line, start_character) = (start.line, get_column_by_offset(&content, start.offset)); + let start_pos = get_position(&doc, start, 0); let name = if let Some(name) = unwrap_node!(x, TextMacroName) { let name = get_identifier(name).unwrap(); @@ -155,27 +135,28 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re } } - let (end_line, end_character, replacement) = if let Some(RefNode::MacroText(x)) = unwrap_node!(x, MacroText) { + let (end_pos, replacement) = if let Some(RefNode::MacroText(x)) = unwrap_node!(x, MacroText) { let replacement = x.nodes.0; - (replacement.line, get_column_by_offset(&content, replacement.offset) + replacement.len, syntax_tree.get_str(&replacement).unwrap()) + (get_position(&doc, replacement,replacement.len), syntax_tree.get_str(&replacement).unwrap()) } else { - (start_line, start_character + start.len, "unknown") + (get_position(&doc, start, start.len), "unknown") }; + let define_range = Range { start: start_pos, end: end_pos }; - hdlparam.add_define(name, replacement, start_line, start_character as u32, end_line, end_character as u32, params_vec); + hdlparam.add_define(name, replacement, define_range, params_vec); } } RefNode::ModuleDeclaration(x) => { let start_keyword = unwrap_node!(x, Keyword).unwrap(); let start_keyword = get_identifier(start_keyword).unwrap(); - let start_pos = get_position(&doc, start_keyword); - let (start_line, start_character) = (start_pos.line, start_pos.character); - let (_, _, end_line, end_character) = get_pp_range(&doc, RefNode::ModuleDeclaration(x)); + let start_pos = get_position(&doc, start_keyword, 0); + let module_range = get_pp_range(&doc, RefNode::ModuleDeclaration(x)); + let module_range = Range { start: start_pos, end: module_range.end }; let id = unwrap_node!(x, ModuleIdentifier).unwrap(); let id = get_identifier(id).unwrap(); let name = syntax_tree.get_str(&id).unwrap(); - hdlparam.new_module(name, start_line, start_character, end_line, end_character); + hdlparam.new_module(name, module_range); } RefNode::ParameterDeclaration(param_dec) => { let mut event_iter = param_dec.into_iter().event(); @@ -183,7 +164,8 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re ParameterDeclaration::Param(x) => { let keyword_locate = &x.nodes.0.nodes.0; // println!("keyword {:#?}", keyword_locate); - let (start_line, start_character) = (keyword_locate.line, get_column_by_offset(&content, keyword_locate.offset) as u32); + let start_pos = get_position(&doc, keyword_locate.clone(), 0); + let net_type = match unwrap_node!(RefNode::ParameterDeclarationParam(x), DataType) { Some(RefNode::DataType(data_type)) => { let id = unwrap_node!(data_type, SimpleIdentifier, Keyword); @@ -198,13 +180,14 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re }; for (index, (name, loc, init)) in list_param_assignment(syntax_tree, &x.nodes.2, &mut event_iter).iter().enumerate() { - let (start_line, start_character) = if index != 0 { - (loc.line as u32, get_column_by_offset(&content, loc.offset) as u32) + let start_pos = if index != 0 { + get_position(&doc, loc.clone(), 0) } else { - (start_line, start_character) + start_pos.clone() }; - let (end_line, end_character) = (loc.line as u32, (get_column_by_offset(&content, loc.offset) + loc.len) as u32); - hdlparam.add_parameter(name, net_type, init, start_line, start_character, end_line, end_character); + let end_pos = get_position(&doc, loc.clone(), loc.len); + let param_range = Range { start: start_pos, end: end_pos }; + hdlparam.add_parameter(name, net_type, init, param_range); } } _ => () @@ -215,7 +198,7 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re if let Some(id) = unwrap_node!(x, InputDeclaration, OutputDeclaration, InoutDeclaration) { let id = get_identifier(id).unwrap(); let dir_type = syntax_tree.get_str(&id).unwrap(); - let (dir_line, dir_character) = (id.line, get_column_by_offset(&content, id.offset) as u32); + let start_pos = get_position(&doc, id, 0); let net_type = match unwrap_node!(x, DataType, ImplicitDataType) { Some(RefNode::DataType(x)) => { @@ -245,11 +228,9 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re let id = unwrap_node!(x, Identifier).unwrap(); let id = get_identifier(id).unwrap(); let name = syntax_tree.get_str(&id).unwrap(); - let (start_line, start_character, end_line, end_character) = - (dir_line, dir_character, id.line, (get_column_by_offset(&content, id.offset) + id.len) as u32); + let port_range = Range { start: start_pos.clone(), end: get_position(&doc, id, id.len) }; - hdlparam.add_port(name, dir_type, net_type, width.as_str(), start_line, start_character, - end_line, end_character); + hdlparam.add_port(name, dir_type, net_type, width.as_str(), port_range); } } } @@ -259,17 +240,17 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re if let Some(id) = unwrap_node!(x, PortIdentifier) { let name_locate = get_identifier(id).unwrap(); let name = syntax_tree.get_str(&name_locate).unwrap(); - let character = get_column_by_offset(&content, name_locate.offset); - let (end_line, end_character) = (name_locate.line, (character + name_locate.len) as u32); + // let character = get_column_by_offset(&content, name_locate.offset); + let end_pos = get_position(&doc, name_locate, name_locate.len); let id = unwrap_node!(x, PortDirection); - let (start_line, start_character) = if id != None { + let port_range = if id != None { let id = id.unwrap(); let dir_locate = get_identifier(id).unwrap(); ansi_port_last_dir = syntax_tree.get_str(&dir_locate).unwrap(); - (dir_locate.line, get_column_by_offset(&content, dir_locate.offset) as u32) + Range { start: get_position(&doc, dir_locate, 0), end: end_pos } } else { - (name_locate.line, character as u32) + Range { start: get_position(&doc, name_locate, 0), end: end_pos } }; let net_type = if unwrap_node!(x, AnsiPortDeclarationVariable) != None { @@ -298,28 +279,27 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re _ => "1".to_string() }; - hdlparam.add_port(name, ansi_port_last_dir, net_type, width.as_str(), start_line, start_character, end_line, end_character); + hdlparam.add_port(name, ansi_port_last_dir, net_type, width.as_str(), port_range); } } RefNode::ModuleInstantiation(x) => { if let Some(id) = unwrap_node!(x, ModuleIdentifier) { let id = get_identifier(id).unwrap(); let inst_type = syntax_tree.get_str(&id).unwrap(); - let start_pos = get_position(&doc, id); - let (start_line, start_character) = (start_pos.line, start_pos.character); - let (_, _, end_line, end_character) = get_pp_range(&doc, RefNode::ModuleInstantiation(x)); + let start_pos = get_position(&doc, id, 0); + let range = get_pp_range(&doc, RefNode::ModuleInstantiation(x)); + let inst_range = Range { start: start_pos, end: range.end }; if let Some(id) = unwrap_node!(x, HierarchicalInstance) { let hier_node = id.clone(); let id = get_identifier(id).unwrap(); let name = syntax_tree.get_str(&id).unwrap(); - let (param_start_line, param_start_character, - param_end_line, param_end_character) = match unwrap_node!(x, ParameterValueAssignment) { + let param_range = match unwrap_node!(x, ParameterValueAssignment) { Some(inst_node) => { - get_pp_range(&doc, inst_node) + get_pp_range(&doc, inst_node).to_option() } - _ => (0, 0, 0, 0) + _ => None }; let inst_param_assignments = if let Some(param_node) = unwrap_node!(x, ParameterValueAssignment) { @@ -329,11 +309,12 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re }; let inst_port_assignments = get_instance_ports(&syntax_tree, &doc, hier_node.clone()); - let (port_start_line, port_start_character, port_end_line, port_end_character) = get_pp_range(&doc, hier_node); + let port_range = get_pp_range(&doc, hier_node).to_option(); - hdlparam.add_instance(name, inst_type, inst_param_assignments, inst_port_assignments, start_line, start_character, end_line, end_character, - param_start_line, param_start_character, param_end_line, param_end_character, - port_start_line, port_start_character, port_end_line, port_end_character + hdlparam.add_instance( + name, inst_type, inst_range, + param_range, inst_param_assignments, + port_range, inst_port_assignments ); } } @@ -342,9 +323,9 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re let id = unwrap_node!(x, GateInstantiation).unwrap(); let id = get_identifier(id).unwrap(); let inst_type = syntax_tree.get_str(&id).unwrap(); - let start_pos = get_position(&doc, id); - let (start_line, start_character) = (start_pos.line, start_pos.character); - let (_, _, end_line, end_character) = get_pp_range(&doc, RefNode::GateInstantiation(x)); + let start_pos = get_position(&doc, id, 0); + let range = get_pp_range(&doc, RefNode::GateInstantiation(x)); + let inst_range = Range { start: start_pos, end: range.end }; match unwrap_node!(x, NInputGateInstance, NOutputGateInstance) { Some(id) => { @@ -352,13 +333,14 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re let id = get_identifier(id).unwrap(); let name = syntax_tree.get_str(&id).unwrap(); - let (param_start_line, param_start_character, param_end_line, param_end_character) = (0, 0, 0, 0); + let param_range = None; let inst_port_assignments = get_instance_ports(&syntax_tree, &doc, gate_node.clone()); - let (port_start_line, port_start_character, port_end_line, port_end_character) = get_pp_range(&doc, gate_node); + let port_range = get_pp_range(&doc, gate_node).to_option(); - hdlparam.add_instance(name, inst_type, Vec::::new(), inst_port_assignments, start_line, start_character, end_line, end_character, - param_start_line, param_start_character, param_end_line, param_end_character, - port_start_line, port_start_character, port_end_line, port_end_character + hdlparam.add_instance( + name, inst_type, inst_range, + param_range, Vec::::new(), + port_range, inst_port_assignments ); } _ => () @@ -375,15 +357,14 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re // 获取 port 或者 param 的 range /// 返回的四元组：(start_line, start_character, end_line, end_character) -fn get_pp_range(doc: &Rope, node: RefNode) -> (u32, u32, u32, u32) { +fn get_pp_range(doc: &Rope, node: RefNode) -> Range { if let Some(locate) = get_first_last_locate(node) { - let start_byte = locate.0.offset; - let end_byte = locate.1.offset + locate.1.len; - let start_pos = doc.byte_to_pos(start_byte); - let end_pos = doc.byte_to_pos(end_byte); - ( start_pos.line, start_pos.character, end_pos.line, end_pos.character ) + Range { + start: get_position(doc, locate.0, 0), + end: get_position(doc, locate.1, locate.1.len) + } } else { - ( 0, 0, 0, 0 ) + Range { start: Position { line: 0, character: 0}, end: Position { line: 0, character: 0} } } } @@ -414,7 +395,7 @@ fn get_instance_params(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> V Some(RefNode::ListOfParameterAssignmentsNamed(x)) => { for assign in x { if let RefNode::NamedParameterAssignment(ident) = assign { - let (start_line, start_character, end_line, end_character) = get_pp_range(doc, assign); + let param_range = get_pp_range(doc, assign); let param_name_locate = get_identifier(RefNode::ParameterIdentifier(&(ident.nodes.1))); let param_name = syntax_tree.get_str(¶m_name_locate).unwrap(); let name = if let (_, Some(name_expr), _) = ident.nodes.2.nodes.clone() { @@ -432,10 +413,7 @@ fn get_instance_params(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> V parameter: Some(param_name.to_string()), assign_val: name, assign_type: AssignType::Named, - range: Range { - start: Position { line: start_line, character: start_character }, - end: Position { line: end_line, character: end_character } - } + range: param_range }; parameters.push(param); }; @@ -448,20 +426,16 @@ fn get_instance_params(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> V if let Some(RefNode::Expression(expr)) = unwrap_node!(expr.into_iter(), Expression) { let start_locate = get_identifier(RefNode::Expression(expr)); let expr = sv_parser::NeedParseExpression::Expression(expr.clone()); - let (expr, locate) = parse_expression(syntax_tree, &expr); + let (expr, end_locate) = parse_expression(syntax_tree, &expr); let start_locate = start_locate.unwrap_or(Locate { offset: 0, line: 0, len: 0 }); - let locate = locate.unwrap_or(start_locate); + let end_locate = end_locate.unwrap_or(start_locate); let param = InstParameter { parameter: None, assign_val: Some(expr), assign_type: AssignType::Ordered, range: Range { - start: get_position(doc, start_locate), - end: get_position(doc, Locate { - offset: locate.offset + locate.len, - line: locate.line, - len: 0 - }) + start: get_position(doc, start_locate, 0), + end: get_position(doc, end_locate, end_locate.len) } }; parameters.push(param); @@ -485,7 +459,7 @@ fn get_instance_ports(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> Ve Some(RefNode::ListOfPortConnectionsNamed(x)) => { for connect in x { if let RefNode::NamedPortConnectionIdentifier(ident) = connect { - let (start_line, start_character, end_line, end_character) = get_pp_range(doc, connect); + let port_range = get_pp_range(doc, connect); let port_name_locate = get_identifier(RefNode::PortIdentifier(&(ident.nodes.2))); let port_name = syntax_tree.get_str(&port_name_locate).unwrap(); let name = if ident.nodes.3.is_some() { @@ -503,10 +477,7 @@ fn get_instance_ports(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> Ve port: Some(port_name.to_string()), assign_val: name, assign_type: AssignType::Named, - range: Range { - start: Position { line: start_line, character: start_character }, - end: Position { line: end_line, character: end_character } - } + range: port_range }; ports.push(port); }; @@ -518,20 +489,16 @@ fn get_instance_ports(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> Ve if let Some(expr) = ident.nodes.1.clone() { let start_locate = get_identifier(RefNode::Expression(&expr)); let expr = sv_parser::NeedParseExpression::Expression(expr); - let (expr, locate) = parse_expression(syntax_tree, &expr); + let (expr, end_locate) = parse_expression(syntax_tree, &expr); let start_locate = start_locate.unwrap_or(Locate { offset: 0, line: 0, len: 0 }); - let locate = locate.unwrap_or(start_locate); + let end_locate = end_locate.unwrap_or(start_locate); let port = InstPort { port: None, assign_val: Some(expr), assign_type: AssignType::Ordered, range: Range { - start: get_position(doc, start_locate), - end: get_position(doc, Locate { - offset: locate.offset + locate.len, - line: locate.line, - len: 0 - }) + start: get_position(doc, start_locate, 0), + end: get_position(doc, end_locate, end_locate.len) } }; ports.push(port); @@ -543,20 +510,16 @@ fn get_instance_ports(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> Ve let expr = x.nodes.0.clone(); let start_locate = get_identifier(RefNode::Expression(&expr)); let expr = sv_parser::NeedParseExpression::Expression(expr); - let (expr, locate) = parse_expression(syntax_tree, &expr); + let (expr, end_locate) = parse_expression(syntax_tree, &expr); let start_locate = start_locate.unwrap_or(Locate { offset: 0, line: 0, len: 0 }); - let locate = locate.unwrap_or(start_locate); + let end_locate = end_locate.unwrap_or(start_locate); let port = InstPort { port: None, assign_val: Some(expr), assign_type: AssignType::Ordered, range: Range { - start: get_position(doc, start_locate), - end: get_position(doc, Locate { - offset: locate.offset + locate.len, - line: locate.line, - len: 0 - }) + start: get_position(doc, start_locate, 0), + end: get_position(doc, end_locate, end_locate.len) } }; ports.push(port); @@ -565,20 +528,16 @@ fn get_instance_ports(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> Ve let expr = x.nodes.0.clone(); let start_locate = get_identifier(RefNode::NetLvalue(&expr)); let expr = sv_parser::NeedParseExpression::NetValue(expr); - let (expr, locate) = parse_expression(syntax_tree, &expr); + let (expr, end_locate) = parse_expression(syntax_tree, &expr); let start_locate = start_locate.unwrap_or(Locate { offset: 0, line: 0, len: 0 }); - let locate = locate.unwrap_or(start_locate); + let end_locate = end_locate.unwrap_or(start_locate); let port = InstPort { port: None, assign_val: Some(expr), assign_type: AssignType::Ordered, range: Range { - start: get_position(doc, start_locate), - end: get_position(doc, Locate { - offset: locate.offset + locate.len, - line: locate.line, - len: 0 - }) + start: get_position(doc, start_locate, 0), + end: get_position(doc, end_locate, end_locate.len) } }; ports.push(port); @@ -686,8 +645,8 @@ fn get_identifier(node: RefNode) -> Option { } } -fn get_position(doc: &Rope, locate: Locate) -> Position { - let byte = locate.offset; +fn get_position(doc: &Rope, locate: Locate, offset: usize) -> Position { + let byte = locate.offset + offset; let pos = doc.byte_to_pos(byte); hdlparam::Position::from_lsp_position(&pos) } @@ -771,22 +730,6 @@ fn update_module_range(path: &PathBuf, hdlparam: &mut FastHdlparam) { } } -fn get_column_by_offset(content: &[String], offset: usize) -> usize { - let mut current_offset = 0; - - for line_content in content { - let line_length = line_content.len() + 1; // +1 for newline character - // println!("now line {} len {}", line_content, line_length); - // println!("now offset {} offset {}", current_offset + line_length, offset); - if current_offset + line_length > offset { - return offset - current_offset + 1; - } - current_offset += line_length; - } - - 1 // if offset over the file lentgh，return 1 -} - fn param_assignment( tree: &SyntaxTree, _: &ParamAssignment,