teascade/reid-llvm
1
1
Fork 0
Code Issues Pull Requests Packages Releases 5 Wiki Activity

Refactor analysis a little bit

Browse Source
This commit is contained in:
Sofia 2025-08-03 16:21:10 +03:00
parent dbc43f51ee
commit 3537318466
2 changed files with 134 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

203
reid-lsp/src/analysis.rs
View File

@ -12,19 +12,18 @@ use reid::{
perform_all_passes, perform_all_passes,
}; };
type TokenAnalysisMap = HashMap<usize, SemanticAnalysis>;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct StaticAnalysis { pub struct StaticAnalysis {
pub tokens: Vec<FullToken>, pub tokens: Vec<FullToken>,
pub token_analysis: TokenAnalysisMap, pub token_analysis: AnalysisState,
pub error: Option<ReidError>, pub error: Option<ReidError>,
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct SemanticAnalysis { pub struct TokenAnalysis {
pub ty: Option<TypeKind>, pub ty: Option<TypeKind>,
pub autocomplete: Vec<Autocomplete>, pub autocomplete: Vec<Autocomplete>,
pub symbol: Option<SymbolId>,
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@ -56,6 +55,84 @@ impl ToString for AutocompleteKind {
} }
} }
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct SymbolId(usize);
#[derive(Debug, Clone)]
pub struct AnalysisState {
pub map: HashMap<usize, TokenAnalysis>,
pub symbol_table: Vec<SymbolKind>,
}
impl AnalysisState {
pub fn init_types(&mut self, meta: &mir::Metadata, ty: Option<TypeKind>) {
for token in meta.range.start..=meta.range.end {
self.map.insert(
token,
TokenAnalysis {
ty: ty.clone(),
autocomplete: Vec::new(),
symbol: Default::default(),
},
);
}
}
pub fn set_autocomplete(&mut self, token_idx: usize, autocomplete: Vec<Autocomplete>) {
if let Some(token) = self.map.get_mut(&token_idx) {
token.autocomplete = autocomplete.clone();
} else {
self.map.insert(
token_idx,
TokenAnalysis {
ty: None,
autocomplete: autocomplete.clone(),
symbol: Default::default(),
},
);
}
}
pub fn set_symbol(&mut self, token_idx: usize, symbol: SymbolId) {
if let Some(token) = self.map.get_mut(&token_idx) {
token.symbol = Some(symbol);
} else {
self.map.insert(
token_idx,
TokenAnalysis {
ty: None,
autocomplete: Vec::new(),
symbol: Some(symbol),
},
);
}
}
pub fn new_symbol(&mut self, kind: SymbolKind) -> SymbolId {
let id = SymbolId(self.symbol_table.len());
self.symbol_table.push(kind);
id
}
}
pub struct AnalysisScope<'a> {
state: &'a mut AnalysisState,
variables: HashMap<String, SymbolId>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum SymbolKind {
Default,
}
impl Default for SymbolKind {
fn default() -> Self {
SymbolKind::Default
}
}
type TokenAnalysisMap = HashMap<usize, TokenAnalysis>;
pub fn analyze( pub fn analyze(
module_id: SourceModuleId, module_id: SourceModuleId,
tokens: Vec<FullToken>, tokens: Vec<FullToken>,
@ -89,36 +166,18 @@ pub fn analyze(
return Ok(None); return Ok(None);
} }
pub fn init_types(map: &mut TokenAnalysisMap, meta: &mir::Metadata, ty: Option<TypeKind>) {
for token in meta.range.start..=meta.range.end {
map.insert(
token,
SemanticAnalysis {
ty: ty.clone(),
autocomplete: Vec::new(),
},
);
}
}
pub fn set_autocomplete(map: &mut TokenAnalysisMap, token_idx: usize, autocomplete: Vec<Autocomplete>) {
if let Some(token) = map.get_mut(&token_idx) {
token.autocomplete = autocomplete.clone();
} else {
map.insert(
token_idx,
SemanticAnalysis {
ty: None,
autocomplete: autocomplete.clone(),
},
);
}
}
pub fn analyze_context(context: &mir::Context, module: &mir::Module, error: Option<ReidError>) -> StaticAnalysis { pub fn analyze_context(context: &mir::Context, module: &mir::Module, error: Option<ReidError>) -> StaticAnalysis {
let mut map = HashMap::new(); let mut state = AnalysisState {
map: HashMap::new(),
symbol_table: Vec::new(),
};
let mut scope = AnalysisScope {
state: &mut state,
variables: HashMap::new(),
};
for import in &module.imports { for import in &module.imports {
init_types(&mut map, &import.1, None); scope.state.init_types(&import.1, None);
if let Some((module_name, _)) = import.0.get(0) { if let Some((module_name, _)) = import.0.get(0) {
let (import_name, import_meta) = import.0.get(1).cloned().unwrap_or(( let (import_name, import_meta) = import.0.get(1).cloned().unwrap_or((
String::new(), String::new(),
@ -154,7 +213,7 @@ pub fn analyze_context(context: &mir::Context, module: &mir::Module, error: Opti
} }
} }
} }
set_autocomplete(&mut map, import_meta.range.end, autocompletes); scope.state.set_autocomplete(import_meta.range.end, autocompletes);
} }
} }
@ -162,7 +221,7 @@ pub fn analyze_context(context: &mir::Context, module: &mir::Module, error: Opti
match &typedef.kind { match &typedef.kind {
mir::TypeDefinitionKind::Struct(StructType(fields)) => { mir::TypeDefinitionKind::Struct(StructType(fields)) => {
for field in fields { for field in fields {
init_types(&mut map, &field.2, Some(field.1.clone())); scope.state.init_types(&field.2, Some(field.1.clone()));
} }
} }
} }
@ -170,7 +229,7 @@ pub fn analyze_context(context: &mir::Context, module: &mir::Module, error: Opti
for binop in &module.binop_defs { for binop in &module.binop_defs {
match &binop.fn_kind { match &binop.fn_kind {
mir::FunctionDefinitionKind::Local(block, _) => analyze_block(context, module, block, &mut map), mir::FunctionDefinitionKind::Local(block, _) => analyze_block(context, module, block, &mut scope),
mir::FunctionDefinitionKind::Extern(_) => {} mir::FunctionDefinitionKind::Extern(_) => {}
mir::FunctionDefinitionKind::Intrinsic(_) => {} mir::FunctionDefinitionKind::Intrinsic(_) => {}
}; };
@ -178,11 +237,11 @@ pub fn analyze_context(context: &mir::Context, module: &mir::Module, error: Opti
for (_, function) in &module.associated_functions { for (_, function) in &module.associated_functions {
for param in &function.parameters { for param in &function.parameters {
init_types(&mut map, &param.meta, Some(param.ty.clone())); scope.state.init_types(&param.meta, Some(param.ty.clone()));
} }
match &function.kind { match &function.kind {
mir::FunctionDefinitionKind::Local(block, _) => analyze_block(context, module, block, &mut map), mir::FunctionDefinitionKind::Local(block, _) => analyze_block(context, module, block, &mut scope),
mir::FunctionDefinitionKind::Extern(_) => {} mir::FunctionDefinitionKind::Extern(_) => {}
mir::FunctionDefinitionKind::Intrinsic(_) => {} mir::FunctionDefinitionKind::Intrinsic(_) => {}
}; };
@ -190,11 +249,11 @@ pub fn analyze_context(context: &mir::Context, module: &mir::Module, error: Opti
for function in &module.functions { for function in &module.functions {
for param in &function.parameters { for param in &function.parameters {
init_types(&mut map, &param.meta, Some(param.ty.clone())); scope.state.init_types(&param.meta, Some(param.ty.clone()));
} }
match &function.kind { match &function.kind {
mir::FunctionDefinitionKind::Local(block, _) => analyze_block(context, module, block, &mut map), mir::FunctionDefinitionKind::Local(block, _) => analyze_block(context, module, block, &mut scope),
mir::FunctionDefinitionKind::Extern(_) => {} mir::FunctionDefinitionKind::Extern(_) => {}
mir::FunctionDefinitionKind::Intrinsic(_) => {} mir::FunctionDefinitionKind::Intrinsic(_) => {}
}; };
@ -202,7 +261,7 @@ pub fn analyze_context(context: &mir::Context, module: &mir::Module, error: Opti
StaticAnalysis { StaticAnalysis {
tokens: module.tokens.clone(), tokens: module.tokens.clone(),
token_analysis: map, token_analysis: state,
error, error,
} }
} }
@ -211,13 +270,12 @@ pub fn analyze_block(
context: &mir::Context, context: &mir::Context,
source_module: &mir::Module, source_module: &mir::Module,
block: &mir::Block, block: &mir::Block,
map: &mut TokenAnalysisMap, scope: &mut AnalysisScope,
) { ) {
for statement in &block.statements { for statement in &block.statements {
match &statement.0 { match &statement.0 {
mir::StmtKind::Let(named_variable_ref, _, expression) => { mir::StmtKind::Let(named_variable_ref, _, expression) => {
init_types( scope.state.init_types(
map,
&named_variable_ref.2, &named_variable_ref.2,
expression expression
.return_type(&TypeRefs::unknown(), source_module.module_id) .return_type(&TypeRefs::unknown(), source_module.module_id)
@ -227,22 +285,22 @@ pub fn analyze_block(
// return analyze_in_expr(&expression, module_id, token_idx); // return analyze_in_expr(&expression, module_id, token_idx);
} }
mir::StmtKind::Set(lhs, rhs) => { mir::StmtKind::Set(lhs, rhs) => {
analyze_expr(context, source_module, lhs, map); analyze_expr(context, source_module, lhs, scope);
analyze_expr(context, source_module, rhs, map); analyze_expr(context, source_module, rhs, scope);
} }
mir::StmtKind::Import(_) => {} mir::StmtKind::Import(_) => {}
mir::StmtKind::Expression(expression) => { mir::StmtKind::Expression(expression) => {
analyze_expr(context, source_module, expression, map); analyze_expr(context, source_module, expression, scope);
} }
mir::StmtKind::While(WhileStatement { condition, block, .. }) => { mir::StmtKind::While(WhileStatement { condition, block, .. }) => {
analyze_expr(context, source_module, condition, map); analyze_expr(context, source_module, condition, scope);
analyze_block(context, source_module, block, map); analyze_block(context, source_module, block, scope);
} }
} }
} }
if let Some((_, Some(return_exp))) = &block.return_expression { if let Some((_, Some(return_exp))) = &block.return_expression {
analyze_expr(context, source_module, return_exp, map) analyze_expr(context, source_module, return_exp, scope)
} }
} }
@ -250,10 +308,9 @@ pub fn analyze_expr(
context: &mir::Context, context: &mir::Context,
source_module: &mir::Module, source_module: &mir::Module,
expr: &mir::Expression, expr: &mir::Expression,
map: &mut TokenAnalysisMap, scope: &mut AnalysisScope,
) { ) {
init_types( scope.state.init_types(
map,
&expr.1, &expr.1,
expr.return_type(&TypeRefs::unknown(), source_module.module_id) expr.return_type(&TypeRefs::unknown(), source_module.module_id)
.ok() .ok()
@ -263,11 +320,11 @@ pub fn analyze_expr(
match &expr.0 { match &expr.0 {
mir::ExprKind::Variable(_) => {} mir::ExprKind::Variable(_) => {}
mir::ExprKind::Indexed(value, _, index_expr) => { mir::ExprKind::Indexed(value, _, index_expr) => {
analyze_expr(context, source_module, &value, map); analyze_expr(context, source_module, &value, scope);
analyze_expr(context, source_module, &index_expr, map); analyze_expr(context, source_module, &index_expr, scope);
} }
mir::ExprKind::Accessed(expression, _, name, meta) => { mir::ExprKind::Accessed(expression, _, name, meta) => {
analyze_expr(context, source_module, &expression, map); analyze_expr(context, source_module, &expression, scope);
let accessed_type = expression.return_type(&TypeRefs::unknown(), source_module.module_id); let accessed_type = expression.return_type(&TypeRefs::unknown(), source_module.module_id);
@ -307,26 +364,26 @@ pub fn analyze_expr(
_ => {} _ => {}
} }
set_autocomplete(map, meta.range.end, autocompletes); scope.state.set_autocomplete(meta.range.end, autocompletes);
} }
mir::ExprKind::Array(expressions) => { mir::ExprKind::Array(expressions) => {
for expr in expressions { for expr in expressions {
analyze_expr(context, source_module, expr, map); analyze_expr(context, source_module, expr, scope);
} }
} }
mir::ExprKind::Struct(_, items) => { mir::ExprKind::Struct(_, items) => {
for (_, expr, _) in items { for (_, expr, _) in items {
analyze_expr(context, source_module, expr, map); analyze_expr(context, source_module, expr, scope);
} }
} }
mir::ExprKind::Literal(_) => {} mir::ExprKind::Literal(_) => {}
mir::ExprKind::BinOp(_, lhs, rhs, _) => { mir::ExprKind::BinOp(_, lhs, rhs, _) => {
analyze_expr(context, source_module, &lhs, map); analyze_expr(context, source_module, &lhs, scope);
analyze_expr(context, source_module, &rhs, map); analyze_expr(context, source_module, &rhs, scope);
} }
mir::ExprKind::FunctionCall(FunctionCall { parameters, .. }) => { mir::ExprKind::FunctionCall(FunctionCall { parameters, .. }) => {
for expr in parameters { for expr in parameters {
analyze_expr(context, source_module, expr, map); analyze_expr(context, source_module, expr, scope);
} }
} }
mir::ExprKind::AssociatedFunctionCall( mir::ExprKind::AssociatedFunctionCall(
@ -336,7 +393,7 @@ pub fn analyze_expr(
}, },
) => { ) => {
for expr in parameters { for expr in parameters {
analyze_expr(context, source_module, expr, map); analyze_expr(context, source_module, expr, scope);
} }
let mut function_autocomplete = source_module let mut function_autocomplete = source_module
.associated_functions .associated_functions
@ -358,25 +415,29 @@ pub fn analyze_expr(
}) })
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
); );
set_autocomplete(map, meta.range.start, function_autocomplete.clone()); scope
set_autocomplete(map, meta.range.end, function_autocomplete.clone()); .state
.set_autocomplete(meta.range.start, function_autocomplete.clone());
scope
.state
.set_autocomplete(meta.range.end, function_autocomplete.clone());
} }
mir::ExprKind::If(IfExpression(cond, then_e, else_e)) => { mir::ExprKind::If(IfExpression(cond, then_e, else_e)) => {
analyze_expr(context, source_module, &cond, map); analyze_expr(context, source_module, &cond, scope);
analyze_expr(context, source_module, &then_e, map); analyze_expr(context, source_module, &then_e, scope);
if let Some(else_e) = else_e.as_ref() { if let Some(else_e) = else_e.as_ref() {
analyze_expr(context, source_module, &else_e, map); analyze_expr(context, source_module, &else_e, scope);
} }
} }
mir::ExprKind::Block(block) => analyze_block(context, source_module, block, map), mir::ExprKind::Block(block) => analyze_block(context, source_module, block, scope),
mir::ExprKind::Borrow(expression, _) => { mir::ExprKind::Borrow(expression, _) => {
analyze_expr(context, source_module, &expression, map); analyze_expr(context, source_module, &expression, scope);
} }
mir::ExprKind::Deref(expression) => { mir::ExprKind::Deref(expression) => {
analyze_expr(context, source_module, &expression, map); analyze_expr(context, source_module, &expression, scope);
} }
mir::ExprKind::CastTo(expression, _) => { mir::ExprKind::CastTo(expression, _) => {
analyze_expr(context, source_module, &expression, map); analyze_expr(context, source_module, &expression, scope);
} }
mir::ExprKind::GlobalRef(_, _) => {} mir::ExprKind::GlobalRef(_, _) => {}
} }

4
reid-lsp/src/main.rs
View File

@ -85,7 +85,7 @@ impl LanguageServer for Backend {
dbg!(position, token); dbg!(position, token);
let list = if let Some((idx, _)) = token { let list = if let Some((idx, _)) = token {
if let Some(analysis) = self.analysis.get(&file_name).unwrap().token_analysis.get(&idx) { if let Some(analysis) = self.analysis.get(&file_name).unwrap().token_analysis.map.get(&idx) {
dbg!(&analysis); dbg!(&analysis);
analysis analysis
.autocomplete .autocomplete
@ -120,7 +120,7 @@ impl LanguageServer for Backend {
}; };
let (range, ty) = if let Some((idx, token)) = token { let (range, ty) = if let Some((idx, token)) = token {
if let Some(analysis) = self.analysis.get(&file_name).unwrap().token_analysis.get(&idx) { if let Some(analysis) = self.analysis.get(&file_name).unwrap().token_analysis.map.get(&idx) {
let start = token.position; let start = token.position;
let end = token.position.add(token.token.len() as u32); let end = token.position.add(token.token.len() as u32);
let range = Range { let range = Range {