quick fixes for some compile errors using ast (#1369)

fixed range using ast

Signed-off-by: Shashank Mittal <shashank.mittal.mec22@itbhu.ac.in>

kclvm/sema/src/resolver/arg.rs

@@ -5,7 +5,6 @@ use indexmap::IndexSet;
 use kclvm_ast::ast;
 
 use kclvm_ast::pos::GetPos;
-use kclvm_error::Position;
 
 use crate::ty::TypeRef;
 
@@ -38,21 +37,20 @@ impl<'ctx> Resolver<'ctx> {
         let arg_types = self.exprs(args);
         let mut kwarg_types: Vec<(String, TypeRef)> = vec![];
         let mut check_table: IndexSet<String> = IndexSet::default();
+        let mut prev_kw_pos = None;
         for kw in kwargs {
             if !kw.node.arg.node.names.is_empty() {
-                let arg_name = &kw.node.arg.node.names[0].node;
-                let fix_range = kw.get_span_pos();
-                let (start_pos, end_pos) = fix_range;
-                let start_column = start_pos.column.map(|col| col.saturating_sub(2));
-                let modified_start_pos = Position {
-                    column: start_column,
-                    ..start_pos.clone()
+                let previous_pos = if let Some(prev_pos) = prev_kw_pos {
+                    prev_pos
+                } else {
+                    kw.get_end_pos()
                 };
-                let modified_fix_range = (modified_start_pos, end_pos);
+                let arg_name = &kw.node.arg.node.names[0].node;
+
                 if check_table.contains(arg_name) {
                     self.handler.add_compile_error_with_suggestions(
                         &format!("{} has duplicated keyword argument {}", func_name, arg_name),
-                        modified_fix_range,
+                        (previous_pos, kw.get_end_pos()),
                         Some(vec![]),
                     );
                 }
@@ -65,6 +63,7 @@ impl<'ctx> Resolver<'ctx> {
                 self.handler
                     .add_compile_error(&format!("missing argument"), kw.get_span_pos());
             }
+            prev_kw_pos = Some(kw.get_end_pos());
         }
         // Do few argument count check
         if !func_ty.is_variadic {

kclvm/sema/src/resolver/global.rs

@@ -481,19 +481,12 @@ impl<'ctx> Resolver<'ctx> {
             );
         }
         if schema_stmt.is_protocol && !name.ends_with(PROTOCOL_SUFFIX) {
-            let fix_range = schema_stmt.name.get_span_pos();
-            let (start_pos, end_pos) = fix_range;
-            let start_column = end_pos.column;
-
-            let modified_start_pos = Position {
-                column: start_column,
-                ..start_pos.clone()
-            };
-            let modified_fix_range = (modified_start_pos, end_pos);
-
             self.handler.add_compile_error_with_suggestions(
                 &format!("schema protocol name must end with '{}'", PROTOCOL_SUFFIX),
-                modified_fix_range,
+                (
+                    schema_stmt.name.get_end_pos(),
+                    schema_stmt.name.get_end_pos(),
+                ),
                 Some(vec![PROTOCOL_SUFFIX.to_string()]),
             );
         }

kclvm/sema/src/resolver/node.rs

@@ -528,28 +528,15 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
         let mut value_ty = self.expr(&selector_expr.value);
         if value_ty.is_module() && selector_expr.has_question {
             let attr = selector_expr.attr.node.get_name();
-            let fix_range = selector_expr.value.get_span_pos();
-            let (start_pos, end_pos) = fix_range;
-            let start_column = end_pos.column;
-            let end_column = end_pos.column.map(|col| col.saturating_add(1));
-            let modified_start_pos = Position {
-                column: start_column,
-                ..start_pos.clone()
-            };
-            let modified_end_pos = Position {
-                column: end_column,
-                ..end_pos.clone()
-            };
-            let modified_fix_range = (modified_start_pos, modified_end_pos);
 
             self.handler.add_compile_error_with_suggestions(
                 &format!(
                     "For the module type, the use of '?.{}' is unnecessary and it can be modified as '.{}'",
                     attr,
                     attr
                 ),
-                modified_fix_range,
-                Some(vec![])
+                (selector_expr.value.get_end_pos(), selector_expr.attr.get_pos()),
+                Some(vec![".".to_string()])
             );
         }
 
@@ -894,6 +881,7 @@ 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 prev_target_pos = None;
         for (i, target) in comp_clause.targets.iter().enumerate() {
             if target.node.names.is_empty() {
                 continue;
@@ -910,21 +898,17 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
             } else if i == 1 {
                 val_name = Some(name);
             } else {
-                let fix_range = target.get_span_pos();
-                let (start_pos, end_pos) = fix_range;
-                let start_column = start_pos.column.map(|col| col.saturating_sub(2));
-
-                let modified_start_pos = Position {
-                    column: start_column,
-                    ..start_pos.clone()
+                let previous_pos = if let Some(prev_pos) = prev_target_pos {
+                    prev_pos
+                } else {
+                    target.get_end_pos()
                 };
-                let modified_fix_range = (modified_start_pos, end_pos);
                 self.handler.add_compile_error_with_suggestions(
                     &format!(
                         "the number of loop variables is {}, which can only be 1 or 2",
                         comp_clause.targets.len()
                     ),
-                    modified_fix_range,
+                    (previous_pos, target.get_end_pos()),
                     Some(vec![]),
                 );
                 break;
@@ -942,6 +926,7 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
                     doc: None,
                 },
             );
+            prev_target_pos = Some(target.get_end_pos());
         }
         if iter_ty.is_any() {
             self.exprs(&comp_clause.ifs);