kirigaya/digital-lsp-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

optimize code style | remove content

Browse Source
This commit is contained in:
light-ly 2024-10-29 23:58:03 +08:00
parent e31f8ec8ac
commit 23816af899
2 changed files with 102 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
src/core/hdlparam.rs
View File

@ -1,6 +1,5 @@
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::RwLock; use std::sync::RwLock;
use std::sync::RwLockReadGuard;
use log::info; use log::info;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -92,6 +91,18 @@ impl Range {
self 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<Range> {
if self.is_empty() {
None
} else {
Some(self.clone())
}
}
} }
/// 比较两个 pos 的位置关系 /// 比较两个 pos 的位置关系
@ -131,19 +142,6 @@ pub struct Parameter {
pub range: Range 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)] #[derive(Debug, Serialize, PartialEq, PartialOrd, Eq, Ord, Deserialize, Clone)]
pub enum AssignType { pub enum AssignType {
Named, Named,
@ -202,6 +200,7 @@ impl Instance {
self.range.clone() self.range.clone()
} }
#[allow(unused)]
pub fn gen_dot_completion_param_range(&self) -> Range { pub fn gen_dot_completion_param_range(&self) -> Range {
// TODO: 精心调制这个方法 // TODO: 精心调制这个方法
if let Some(param_range) = &self.instparams { if let Some(param_range) = &self.instparams {
@ -272,34 +271,23 @@ pub struct FastHdlparam {
} }
impl FastHdlparam { impl FastHdlparam {
pub fn add_define(&mut self, name: &str, replacement: &str, start_line: u32, start_character: u32, pub fn add_define(&mut self, name: &str, replacement: &str, range: Range, params: Vec<DefineParam>) {
end_line: u32, end_character: u32, params: Vec<DefineParam>) {
let define = Define { let define = Define {
name: name.to_string(), name: name.to_string(),
replacement: replacement.to_string(), replacement: replacement.to_string(),
range: Range { range,
start: Position { line: start_line, character: start_character },
end: Position { line: end_line, character: end_character }
},
params params
}; };
self.fast_macro.defines.push(define); 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 { let module = Module {
name: name.to_string(), name: name.to_string(),
params: Vec::new(), params: Vec::new(),
ports: Vec::new(), ports: Vec::new(),
instances: Vec::new(), instances: Vec::new(),
range: Range { range
start: Position {
line: start_line, character: start_character
},
end: Position {
line: end_line, character: end_character
}
}
}; };
self.content.push(module); self.content.push(module);
} }
@ -311,29 +299,20 @@ impl FastHdlparam {
} }
} }
pub fn add_parameter(&mut self, name: &str, net_type: &str, init: &str, pub fn add_parameter(&mut self, name: &str, net_type: &str, init: &str, range: Range) {
start_line: u32, start_character: u32, end_line: u32, end_character: u32) {
if let Some(last_module) = self.content.last_mut() { if let Some(last_module) = self.content.last_mut() {
let parameter = Parameter { let parameter = Parameter {
name: name.to_string(), name: name.to_string(),
net_type: net_type.to_string(), net_type: net_type.to_string(),
init: init.to_string(), init: init.to_string(),
range: Range { range
start: Position {
line: start_line, character: start_character
},
end: Position {
line:end_line, character: end_character
}
}
}; };
last_module.params.push(parameter); last_module.params.push(parameter);
last_module.params.dedup(); last_module.params.dedup();
} }
} }
pub fn add_port(&mut self, name: &str, dir_type: &str, net_type: &str, width: &str, pub fn add_port(&mut self, name: &str, dir_type: &str, net_type: &str, width: &str, range: Range) {
start_line: u32, start_character: u32, end_line: u32, end_character: u32) {
if let Some(last_module) = self.content.last_mut() { if let Some(last_module) = self.content.last_mut() {
let port = Port { let port = Port {
name: name.to_string(), name: name.to_string(),
@ -341,65 +320,24 @@ impl FastHdlparam {
net_type: net_type.to_string(), net_type: net_type.to_string(),
width: width.to_string(), width: width.to_string(),
signed: "unsigned".to_string(), signed: "unsigned".to_string(),
range: Range { range
start: Position {
line: start_line, character: start_character
},
end: Position {
line:end_line, character: end_character
}
}
}; };
last_module.ports.push(port); last_module.ports.push(port);
last_module.ports.dedup(); last_module.ports.dedup();
} }
} }
pub fn add_instance(&mut self, name: &str, inst_type: &str, params_assign: Vec<InstParameter>, ports_assign: Vec<InstPort>, start_line: u32, start_character: u32, end_line: u32, end_character: u32, pub fn add_instance(&mut self, name: &str, inst_type: &str, range: Range,
param_start_line: u32, param_start_character: u32, param_end_line: u32, param_end_character: u32, param_range: Option<Range>, params_assign: Vec<InstParameter>, port_range: Option<Range>, ports_assign: Vec<InstPort>) {
port_start_line: u32, port_start_character: u32, port_end_line: u32, port_end_character: u32 ) {
if let Some(last_module) = self.content.last_mut() { if let Some(last_module) = self.content.last_mut() {
let instance = Instance { let instance = Instance {
name: name.to_string(), name: name.to_string(),
inst_type: inst_type.to_string(), inst_type: inst_type.to_string(),
instparams: if param_start_line == 0 { instparams: param_range,
None
} else {
Some(
Range {
start: Position {
line: param_start_line, character: param_start_character
},
end: Position {
line: param_end_line, character: param_end_character
}
}
)
},
intstparams_assignment: params_assign, intstparams_assignment: params_assign,
instports: if port_start_line == 0 { instports: port_range,
None
} else {
Some(
Range {
start: Position {
line: port_start_line, character: port_start_character
},
end: Position {
line: port_end_line, character: port_end_character
}
}
)
},
intstport_assignment: ports_assign, intstport_assignment: ports_assign,
range: Range { range
start: Position {
line: start_line, character: start_character
},
end: Position {
line: end_line, character: end_character
}
}
}; };
last_module.instances.push(instance); last_module.instances.push(instance);
} }

209
src/core/sv_parser.rs
View File

@ -6,7 +6,7 @@ use log::info;
use regex::Regex; use regex::Regex;
use ropey::Rope; use ropey::Rope;
use tower_lsp::lsp_types::Url; 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::core::hdlparam::{AssignType, Position, Range};
use crate::sources::{recovery_sv_parse_with_retry, LSPSupport}; 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)] #[allow(unused)]
pub fn sv_parser(path: &str) -> Option<FastHdlparam> { pub fn sv_parser(path: &str) -> Option<FastHdlparam> {
// The path of SystemVerilog source file // 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 = ""; let mut ansi_port_last_dir = "";
// TODO: 删除这个 content
let content = syntax_tree.text.text().split('\n')
.map(|s| s.to_string())
.collect::<Vec<String>>();
// println!("{:?}", syntax_tree); // println!("{:?}", syntax_tree);
// &SyntaxTree is iterable // &SyntaxTree is iterable
let doc = Rope::from_str(syntax_tree.text.text()); 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) => { RefNode::TextMacroDefinition(x) => {
if let Some(start) = unwrap_node!(x, TextMacroDefinition) { if let Some(start) = unwrap_node!(x, TextMacroDefinition) {
let start = get_identifier(start).unwrap(); 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 = if let Some(name) = unwrap_node!(x, TextMacroName) {
let name = get_identifier(name).unwrap(); 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; 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 { } 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) => { RefNode::ModuleDeclaration(x) => {
let start_keyword = unwrap_node!(x, Keyword).unwrap(); let start_keyword = unwrap_node!(x, Keyword).unwrap();
let start_keyword = get_identifier(start_keyword).unwrap(); let start_keyword = get_identifier(start_keyword).unwrap();
let start_pos = get_position(&doc, start_keyword); let start_pos = get_position(&doc, start_keyword, 0);
let (start_line, start_character) = (start_pos.line, start_pos.character); let module_range = get_pp_range(&doc, RefNode::ModuleDeclaration(x));
let (_, _, end_line, end_character) = 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 = unwrap_node!(x, ModuleIdentifier).unwrap();
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&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) => { RefNode::ParameterDeclaration(param_dec) => {
let mut event_iter = param_dec.into_iter().event(); 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) => { ParameterDeclaration::Param(x) => {
let keyword_locate = &x.nodes.0.nodes.0; let keyword_locate = &x.nodes.0.nodes.0;
// println!("keyword {:#?}", keyword_locate); // 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) { let net_type = match unwrap_node!(RefNode::ParameterDeclarationParam(x), DataType) {
Some(RefNode::DataType(data_type)) => { Some(RefNode::DataType(data_type)) => {
let id = unwrap_node!(data_type, SimpleIdentifier, Keyword); 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() { 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 { let start_pos = if index != 0 {
(loc.line as u32, get_column_by_offset(&content, loc.offset) as u32) get_position(&doc, loc.clone(), 0)
} else { } 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); let end_pos = get_position(&doc, loc.clone(), loc.len);
hdlparam.add_parameter(name, net_type, init, start_line, start_character, end_line, end_character); 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) { if let Some(id) = unwrap_node!(x, InputDeclaration, OutputDeclaration, InoutDeclaration) {
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let dir_type = syntax_tree.get_str(&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) { let net_type = match unwrap_node!(x, DataType, ImplicitDataType) {
Some(RefNode::DataType(x)) => { 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 = unwrap_node!(x, Identifier).unwrap();
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&id).unwrap(); let name = syntax_tree.get_str(&id).unwrap();
let (start_line, start_character, end_line, end_character) = let port_range = Range { start: start_pos.clone(), end: get_position(&doc, id, id.len) };
(dir_line, dir_character, id.line, (get_column_by_offset(&content, id.offset) + id.len) as u32);
hdlparam.add_port(name, dir_type, net_type, width.as_str(), start_line, start_character, hdlparam.add_port(name, dir_type, net_type, width.as_str(), port_range);
end_line, end_character);
} }
} }
} }
@ -259,17 +240,17 @@ pub fn make_fast_from_syntaxtree(syntax_tree: &SyntaxTree, path: &PathBuf) -> Re
if let Some(id) = unwrap_node!(x, PortIdentifier) { if let Some(id) = unwrap_node!(x, PortIdentifier) {
let name_locate = get_identifier(id).unwrap(); let name_locate = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&name_locate).unwrap(); let name = syntax_tree.get_str(&name_locate).unwrap();
let character = get_column_by_offset(&content, name_locate.offset); // 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 end_pos = get_position(&doc, name_locate, name_locate.len);
let id = unwrap_node!(x, PortDirection); 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 id = id.unwrap();
let dir_locate = get_identifier(id).unwrap(); let dir_locate = get_identifier(id).unwrap();
ansi_port_last_dir = syntax_tree.get_str(&dir_locate).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 { } 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 { 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() _ => "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) => { RefNode::ModuleInstantiation(x) => {
if let Some(id) = unwrap_node!(x, ModuleIdentifier) { if let Some(id) = unwrap_node!(x, ModuleIdentifier) {
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let inst_type = syntax_tree.get_str(&id).unwrap(); let inst_type = syntax_tree.get_str(&id).unwrap();
let start_pos = get_position(&doc, id); let start_pos = get_position(&doc, id, 0);
let (start_line, start_character) = (start_pos.line, start_pos.character); let range = get_pp_range(&doc, RefNode::ModuleInstantiation(x));
let (_, _, end_line, end_character) = 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) { if let Some(id) = unwrap_node!(x, HierarchicalInstance) {
let hier_node = id.clone(); let hier_node = id.clone();
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&id).unwrap(); let name = syntax_tree.get_str(&id).unwrap();
let (param_start_line, param_start_character, let param_range = match unwrap_node!(x, ParameterValueAssignment) {
param_end_line, param_end_character) = match unwrap_node!(x, ParameterValueAssignment) {
Some(inst_node) => { 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) { 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 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, hdlparam.add_instance(
param_start_line, param_start_character, param_end_line, param_end_character, name, inst_type, inst_range,
port_start_line, port_start_character, port_end_line, port_end_character 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 = unwrap_node!(x, GateInstantiation).unwrap();
let id = get_identifier(id).unwrap(); let id = get_identifier(id).unwrap();
let inst_type = syntax_tree.get_str(&id).unwrap(); let inst_type = syntax_tree.get_str(&id).unwrap();
let start_pos = get_position(&doc, id); let start_pos = get_position(&doc, id, 0);
let (start_line, start_character) = (start_pos.line, start_pos.character); let range = get_pp_range(&doc, RefNode::GateInstantiation(x));
let (_, _, end_line, end_character) = get_pp_range(&doc, RefNode::GateInstantiation(x)); let inst_range = Range { start: start_pos, end: range.end };
match unwrap_node!(x, NInputGateInstance, NOutputGateInstance) { match unwrap_node!(x, NInputGateInstance, NOutputGateInstance) {
Some(id) => { 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 id = get_identifier(id).unwrap();
let name = syntax_tree.get_str(&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 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::<InstParameter>::new(), inst_port_assignments, start_line, start_character, end_line, end_character, hdlparam.add_instance(
param_start_line, param_start_character, param_end_line, param_end_character, name, inst_type, inst_range,
port_start_line, port_start_character, port_end_line, port_end_character param_range, Vec::<InstParameter>::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 // 获取 port 或者 param 的 range
/// 返回的四元组：(start_line, start_character, end_line, end_character) /// 返回的四元组：(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) { if let Some(locate) = get_first_last_locate(node) {
let start_byte = locate.0.offset; Range {
let end_byte = locate.1.offset + locate.1.len; start: get_position(doc, locate.0, 0),
let start_pos = doc.byte_to_pos(start_byte); end: get_position(doc, locate.1, locate.1.len)
let end_pos = doc.byte_to_pos(end_byte); }
( start_pos.line, start_pos.character, end_pos.line, end_pos.character )
} else { } 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)) => { Some(RefNode::ListOfParameterAssignmentsNamed(x)) => {
for assign in x { for assign in x {
if let RefNode::NamedParameterAssignment(ident) = assign { 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_locate = get_identifier(RefNode::ParameterIdentifier(&(ident.nodes.1)));
let param_name = syntax_tree.get_str(&param_name_locate).unwrap(); let param_name = syntax_tree.get_str(&param_name_locate).unwrap();
let name = if let (_, Some(name_expr), _) = ident.nodes.2.nodes.clone() { 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()), parameter: Some(param_name.to_string()),
assign_val: name, assign_val: name,
assign_type: AssignType::Named, assign_type: AssignType::Named,
range: Range { range: param_range
start: Position { line: start_line, character: start_character },
end: Position { line: end_line, character: end_character }
}
}; };
parameters.push(param); 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) { if let Some(RefNode::Expression(expr)) = unwrap_node!(expr.into_iter(), Expression) {
let start_locate = get_identifier(RefNode::Expression(expr)); let start_locate = get_identifier(RefNode::Expression(expr));
let expr = sv_parser::NeedParseExpression::Expression(expr.clone()); 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 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 { let param = InstParameter {
parameter: None, parameter: None,
assign_val: Some(expr), assign_val: Some(expr),
assign_type: AssignType::Ordered, assign_type: AssignType::Ordered,
range: Range { range: Range {
start: get_position(doc, start_locate), start: get_position(doc, start_locate, 0),
end: get_position(doc, Locate { end: get_position(doc, end_locate, end_locate.len)
offset: locate.offset + locate.len,
line: locate.line,
len: 0
})
} }
}; };
parameters.push(param); parameters.push(param);
@ -485,7 +459,7 @@ fn get_instance_ports(syntax_tree: &SyntaxTree, doc: &Rope, node: RefNode) -> Ve
Some(RefNode::ListOfPortConnectionsNamed(x)) => { Some(RefNode::ListOfPortConnectionsNamed(x)) => {
for connect in x { for connect in x {
if let RefNode::NamedPortConnectionIdentifier(ident) = connect { 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_locate = get_identifier(RefNode::PortIdentifier(&(ident.nodes.2)));
let port_name = syntax_tree.get_str(&port_name_locate).unwrap(); let port_name = syntax_tree.get_str(&port_name_locate).unwrap();
let name = if ident.nodes.3.is_some() { 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()), port: Some(port_name.to_string()),
assign_val: name, assign_val: name,
assign_type: AssignType::Named, assign_type: AssignType::Named,
range: Range { range: port_range
start: Position { line: start_line, character: start_character },
end: Position { line: end_line, character: end_character }
}
}; };
ports.push(port); 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() { if let Some(expr) = ident.nodes.1.clone() {
let start_locate = get_identifier(RefNode::Expression(&expr)); let start_locate = get_identifier(RefNode::Expression(&expr));
let expr = sv_parser::NeedParseExpression::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 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 { let port = InstPort {
port: None, port: None,
assign_val: Some(expr), assign_val: Some(expr),
assign_type: AssignType::Ordered, assign_type: AssignType::Ordered,
range: Range { range: Range {
start: get_position(doc, start_locate), start: get_position(doc, start_locate, 0),
end: get_position(doc, Locate { end: get_position(doc, end_locate, end_locate.len)
offset: locate.offset + locate.len,
line: locate.line,
len: 0
})
} }
}; };
ports.push(port); 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 expr = x.nodes.0.clone();
let start_locate = get_identifier(RefNode::Expression(&expr)); let start_locate = get_identifier(RefNode::Expression(&expr));
let expr = sv_parser::NeedParseExpression::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 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 { let port = InstPort {
port: None, port: None,
assign_val: Some(expr), assign_val: Some(expr),
assign_type: AssignType::Ordered, assign_type: AssignType::Ordered,
range: Range { range: Range {
start: get_position(doc, start_locate), start: get_position(doc, start_locate, 0),
end: get_position(doc, Locate { end: get_position(doc, end_locate, end_locate.len)
offset: locate.offset + locate.len,
line: locate.line,
len: 0
})
} }
}; };
ports.push(port); 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 expr = x.nodes.0.clone();
let start_locate = get_identifier(RefNode::NetLvalue(&expr)); let start_locate = get_identifier(RefNode::NetLvalue(&expr));
let expr = sv_parser::NeedParseExpression::NetValue(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 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 { let port = InstPort {
port: None, port: None,
assign_val: Some(expr), assign_val: Some(expr),
assign_type: AssignType::Ordered, assign_type: AssignType::Ordered,
range: Range { range: Range {
start: get_position(doc, start_locate), start: get_position(doc, start_locate, 0),
end: get_position(doc, Locate { end: get_position(doc, end_locate, end_locate.len)
offset: locate.offset + locate.len,
line: locate.line,
len: 0
})
} }
}; };
ports.push(port); ports.push(port);
@ -686,8 +645,8 @@ fn get_identifier(node: RefNode) -> Option<Locate> {
} }
} }
fn get_position(doc: &Rope, locate: Locate) -> Position { fn get_position(doc: &Rope, locate: Locate, offset: usize) -> Position {
let byte = locate.offset; let byte = locate.offset + offset;
let pos = doc.byte_to_pos(byte); let pos = doc.byte_to_pos(byte);
hdlparam::Position::from_lsp_position(&pos) 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( fn param_assignment(
tree: &SyntaxTree, tree: &SyntaxTree,
_: &ParamAssignment, _: &ParamAssignment,