Skip to content

Commit

Permalink
arch: migrate lsp hover to new sema model (#887)
Browse files Browse the repository at this point in the history 
* arch: migrate lsp hover to new sema model

Signed-off-by: Xiaok29 <1526783667@qq.com>

* fix: add correct ty to identifier

Signed-off-by: he1pa <18012015693@163.com>

---------

Signed-off-by: Xiaok29 <1526783667@qq.com>
Signed-off-by: he1pa <18012015693@163.com>
Co-authored-by: he1pa <18012015693@163.com>
  • Loading branch information
@XiaoK29 @He1pa
XiaoK29 and He1pa committed Nov 16, 2023
1 parent 90b92cb commit 45235ec
Show file tree
Hide file tree
Showing 7 changed files with 129 additions and 131 deletions.
28 changes: 21 additions & 7 deletions kclvm/sema/src/advanced_resolver/node.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -376,6 +376,19 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for AdvancedResolver<'ctx> {
.symbols_info
.ast_id_map
.get(&schema_attr.name.id)?;
let parent_scope = *self.ctx.scopes.last().unwrap();
let parent_scope = self.gs.get_scopes().get_scope(parent_scope).unwrap();
let mut doc = None;
if let Some(schema_symbol) = parent_scope.get_owner() {
let schema_symbol = self.gs.get_symbols().get_symbol(schema_symbol).unwrap();
if let Some(schema_ty) = schema_symbol.get_sema_info().ty.clone() {
let schema_ty = schema_ty.into_schema_type();
if let Some(attr) = schema_ty.attrs.get(&schema_attr.name.node) {
doc = attr.doc.clone()
}
}
};

if let Some(symbol) = self
.gs
.get_symbols_mut()
Expand All @@ -388,9 +401,9 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for AdvancedResolver<'ctx> {
.node_ty_map
.get(&schema_attr.name.id)
.map(|ty| ty.clone()),
doc: Some(schema_attr.doc.clone()),
doc,
};
}
};

self.walk_type_expr(Some(&schema_attr.ty));
if let Some(value) = &schema_attr.value {
Expand Down Expand Up @@ -861,12 +874,13 @@ impl<'ctx> AdvancedResolver<'ctx> {
.values
.get_mut(identifier_symbol.get_id())
{
let id = if identifier.node.names.is_empty() {
&identifier.id
} else {
&identifier.node.names.last().unwrap().id
};
symbol.sema_info = KCLSymbolSemanticInfo {
ty: self
.ctx
.node_ty_map
.get(&identifier.id)
.map(|ty| ty.clone()),
ty: self.ctx.node_ty_map.get(id).map(|ty| ty.clone()),
doc: None,
};
}
Expand Down
53 changes: 22 additions & 31 deletions kclvm/sema/src/resolver/loop.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,11 +7,8 @@ impl<'ctx> Resolver<'ctx> {
/// Do loop type check including quant and comp for expression.
pub(crate) fn do_loop_type_check(
&mut self,
first_node: &'ctx ast::NodeRef<ast::Identifier>,
second_node: Option<&'ctx ast::NodeRef<ast::Identifier>>,
target_node: &'ctx ast::NodeRef<ast::Identifier>,
first_var_name: Option<String>,
second_var_name: Option<String>,
first_var_name: Option<&ast::Node<String>>,
second_var_name: Option<&ast::Node<String>>,
iter_ty: TypeRef,
iter_range: Range,
) {
Expand All @@ -34,54 +31,54 @@ impl<'ctx> Resolver<'ctx> {
first_var_ty = sup(&[self.int_ty(), first_var_ty.clone()]);
second_var_ty = sup(&[item_ty.clone(), second_var_ty.clone()]);
self.set_type_to_scope(
first_var_name.as_ref().unwrap(),
&first_var_name.unwrap().node,
first_var_ty.clone(),
&target_node,
&first_var_name.unwrap(),
);
self.set_type_to_scope(
second_var_name.as_ref().unwrap(),
&second_var_name.unwrap().node,
second_var_ty.clone(),
&target_node,
&second_var_name.unwrap(),
);
} else {
first_var_ty = sup(&[item_ty.clone(), first_var_ty.clone()]);
self.set_type_to_scope(
first_var_name.as_ref().unwrap(),
&first_var_name.unwrap().node,
first_var_ty.clone(),
&target_node,
&first_var_name.unwrap(),
);
}
}
TypeKind::Dict(DictType { key_ty, val_ty, .. }) => {
first_var_ty = sup(&[key_ty.clone(), first_var_ty.clone()]);
self.set_type_to_scope(
first_var_name.as_ref().unwrap(),
&first_var_name.unwrap().node,
first_var_ty.clone(),
&target_node,
&first_var_name.unwrap(),
);
if second_var_name.is_some() {
second_var_ty = sup(&[val_ty.clone(), second_var_ty.clone()]);
self.set_type_to_scope(
second_var_name.as_ref().unwrap(),
&second_var_name.unwrap().node,
second_var_ty.clone(),
&target_node,
&second_var_name.unwrap(),
);
}
}
TypeKind::Schema(schema_ty) => {
let (key_ty, val_ty) = (schema_ty.key_ty(), schema_ty.val_ty());
first_var_ty = sup(&[key_ty, first_var_ty.clone()]);
self.set_type_to_scope(
first_var_name.as_ref().unwrap(),
&first_var_name.unwrap().node,
first_var_ty.clone(),
&target_node,
&first_var_name.unwrap(),
);
if second_var_name.is_some() {
second_var_ty = sup(&[val_ty, second_var_ty.clone()]);
self.set_type_to_scope(
second_var_name.as_ref().unwrap(),
&second_var_name.unwrap().node,
second_var_ty.clone(),
&target_node,
&second_var_name.unwrap(),
);
}
}
Expand All @@ -90,32 +87,26 @@ impl<'ctx> Resolver<'ctx> {
first_var_ty = sup(&[self.int_ty(), first_var_ty.clone()]);
second_var_ty = sup(&[self.str_ty(), second_var_ty.clone()]);
self.set_type_to_scope(
first_var_name.as_ref().unwrap(),
&first_var_name.unwrap().node,
first_var_ty.clone(),
&target_node,
&first_var_name.unwrap(),
);
self.set_type_to_scope(
second_var_name.as_ref().unwrap(),
&second_var_name.unwrap().node,
second_var_ty.clone(),
&target_node,
&second_var_name.unwrap(),
);
} else {
first_var_ty = sup(&[self.str_ty(), first_var_ty.clone()]);
self.set_type_to_scope(
first_var_name.as_ref().unwrap(),
&first_var_name.unwrap().node,
first_var_ty.clone(),
&target_node,
&first_var_name.unwrap(),
);
}
}
_ => {}
}
self.node_ty_map
.insert(first_node.id.clone(), first_var_ty.clone());
if let Some(second_node) = second_node {
self.node_ty_map
.insert(second_node.id.clone(), second_var_ty.clone());
}
}
}
}
55 changes: 16 additions & 39 deletions kclvm/sema/src/resolver/node.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -76,7 +76,7 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
None,
);
if !ty.is_any() && expected_ty.is_any() {
self.set_type_to_scope(&names[0].node, ty, &unification_stmt.target);
self.set_type_to_scope(&names[0].node, ty, &names[0]);
}
expected_ty
}
Expand Down Expand Up @@ -164,7 +164,7 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
// Check type annotation if exists.
self.check_assignment_type_annotation(assign_stmt, value_ty.clone());
}
self.set_type_to_scope(name, value_ty.clone(), &target);
self.set_type_to_scope(name, value_ty.clone(), &target.node.names[0]);
}
_ => {
value_ty = self.expr(&assign_stmt.value);
Expand All @@ -182,7 +182,7 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
&& expected_ty.is_any()
&& assign_stmt.type_annotation.is_none()
{
self.set_type_to_scope(name, value_ty.clone(), &target);
self.set_type_to_scope(name, value_ty.clone(), &target.node.names[0]);
if let Some(schema_ty) = &self.ctx.schema {
let mut schema_ty = schema_ty.borrow_mut();
schema_ty.set_type_of_attr(
Expand Down Expand Up @@ -299,9 +299,6 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
}
self.enter_scope(start, end, ScopeKind::Loop);
let (mut key_name, mut val_name) = (None, None);
let mut target_node = None;
let mut first_node = None;
let mut second_node = None;
for (i, target) in quant_expr.variables.iter().enumerate() {
if target.node.names.is_empty() {
continue;
Expand All @@ -312,14 +309,11 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
target.get_span_pos(),
);
}
target_node = Some(target);
let name = &target.node.names[0].node;
let name = &target.node.names[0];
if i == 0 {
first_node = Some(target);
key_name = Some(name.to_string());
key_name = Some(name);
} else if i == 1 {
second_node = Some(target);
val_name = Some(name.to_string())
val_name = Some(name)
} else {
self.handler.add_compile_error(
&format!(
Expand All @@ -330,12 +324,12 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
);
break;
}
self.ctx.local_vars.push(name.to_string());
self.ctx.local_vars.push(name.node.to_string());
let (start, end) = target.get_span_pos();
self.insert_object(
name,
&name.node,
ScopeObject {
name: name.to_string(),
name: name.node.to_string(),
start,
end,
ty: self.any_ty(),
Expand All @@ -345,9 +339,6 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
);
}
self.do_loop_type_check(
first_node.unwrap(),
second_node,
target_node.unwrap(),
key_name,
val_name,
iter_ty.clone(),
Expand Down Expand Up @@ -796,9 +787,6 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
fn walk_comp_clause(&mut self, comp_clause: &'ctx ast::CompClause) -> Self::Result {
let iter_ty = self.expr(&comp_clause.iter);
let (mut key_name, mut val_name) = (None, None);
let mut target_node = None;
let mut first_node = None;
let mut second_node = None;
for (i, target) in comp_clause.targets.iter().enumerate() {
if target.node.names.is_empty() {
continue;
Expand All @@ -809,14 +797,11 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
target.get_span_pos(),
);
}
target_node = Some(target);
let name = &target.node.names[0].node;
let name = &target.node.names[0];
if i == 0 {
first_node = Some(target);
key_name = Some(name.to_string());
key_name = Some(name);
} else if i == 1 {
second_node = Some(target);
val_name = Some(name.to_string())
val_name = Some(name);
} else {
self.handler.add_compile_error(
&format!(
Expand All @@ -827,12 +812,12 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
);
break;
}
self.ctx.local_vars.push(name.to_string());
self.ctx.local_vars.push(name.node.to_string());
let (start, end) = target.get_span_pos();
self.insert_object(
name,
&name.node,
ScopeObject {
name: name.to_string(),
name: name.node.to_string(),
start,
end,
ty: self.any_ty(),
Expand All @@ -844,15 +829,7 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
if iter_ty.is_any() {
iter_ty
} else {
self.do_loop_type_check(
first_node.unwrap(),
second_node,
target_node.unwrap(),
key_name,
val_name,
iter_ty,
comp_clause.iter.get_span_pos(),
);
self.do_loop_type_check(key_name, val_name, iter_ty, comp_clause.iter.get_span_pos());
self.exprs(&comp_clause.ifs);
self.any_ty()
}
Expand Down
2 changes: 1 addition & 1 deletion kclvm/sema/src/resolver/ty.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -187,7 +187,7 @@ impl<'ctx> Resolver<'ctx> {
annotation_ty
};

self.set_type_to_scope(name, target_ty.clone(), &target);
self.set_type_to_scope(name, target_ty.clone(), &target.node.names[0]);

// Check the type of value and the type annotation of target
self.must_assignable_to(value_ty.clone(), target_ty, target.get_span_pos(), None)
Expand Down

0 comments on commit 45235ec

Please sign in to comment.