refactor: binary expr type error message locations

kclvm/sema/src/resolver/calculation.rs

@@ -249,6 +249,7 @@ impl<'ctx> Resolver<'ctx> {
     /// float               # as defined by IEEE 754  1.0 < 2.0
     /// list/config/schema  # lexicographical         [1] == [2]
     /// iterable            # 1 in [1, 2, 3], "s" in "ss", "key" in Schema
+    /// relation            # a is True, b is Undefined
     pub fn compare(
         &mut self,
         left: TypeRef,
@@ -264,11 +265,11 @@ impl<'ctx> Resolver<'ctx> {
         if self
             .ctx
             .ty_ctx
-            .is_number_type_or_number_union_type(t1.clone())
+            .is_number_bool_type_or_number_bool_union_type(t1.clone())
             && self
                 .ctx
                 .ty_ctx
-                .is_number_type_or_number_union_type(t2.clone())
+                .is_number_bool_type_or_number_bool_union_type(t2.clone())
             && !matches!(op, ast::CmpOp::In | ast::CmpOp::NotIn)
         {
             return self.bool_ty();

kclvm/sema/src/resolver/node.rs

@@ -462,6 +462,7 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
     fn walk_binary_expr(&mut self, binary_expr: &'ctx ast::BinaryExpr) -> Self::Result {
         let left_ty = self.expr(&binary_expr.left);
         let mut right_ty = self.expr(&binary_expr.right);
+        let range = (binary_expr.left.get_pos(), binary_expr.right.get_end_pos());
         match &binary_expr.op {
             ast::BinOp::As => {
                 if let ast::Expr::Identifier(identifier) = &binary_expr.right.node {
@@ -480,25 +481,13 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
                         &ty_str_replace_pkgpath(&ty_annotation_str, &self.ctx.pkgpath),
                     );
                 } else {
-                    self.handler.add_compile_error(
-                        "keyword 'as' right operand must be a type",
-                        binary_expr.left.get_span_pos(),
-                    );
+                    self.handler
+                        .add_compile_error("keyword 'as' right operand must be a type", range);
                     return left_ty;
                 }
-                self.binary(
-                    left_ty,
-                    right_ty,
-                    &binary_expr.op,
-                    binary_expr.left.get_span_pos(),
-                )
+                self.binary(left_ty, right_ty, &binary_expr.op, range)
             }
-            _ => self.binary(
-                left_ty,
-                right_ty,
-                &binary_expr.op,
-                binary_expr.left.get_span_pos(),
-            ),
+            _ => self.binary(left_ty, right_ty, &binary_expr.op, range),
         }
     }
 
@@ -1060,7 +1049,7 @@ impl<'ctx> MutSelfTypedResultWalker<'ctx> for Resolver<'ctx> {
             t1.clone(),
             t2.clone(),
             &compare.ops[0],
-            compare.comparators[0].get_span_pos(),
+            (compare.left.get_pos(), compare.comparators[0].get_end_pos()),
         );
         for i in 1..compare.comparators.len() - 1 {
             let op = &compare.ops[i + 1];

kclvm/sema/src/ty/context.rs

@@ -101,6 +101,14 @@ impl TypeContext {
         self.is_kind_type_or_kind_union_type(ty, &[TypeFlags::INT, TypeFlags::FLOAT])
     }
 
+    #[inline]
+    pub fn is_number_bool_type_or_number_bool_union_type(&self, ty: TypeRef) -> bool {
+        self.is_kind_type_or_kind_union_type(
+            ty,
+            &[TypeFlags::INT, TypeFlags::FLOAT, TypeFlags::BOOL],
+        )
+    }
+
     #[inline]
     pub fn is_config_type_or_config_union_type(&self, ty: TypeRef) -> bool {
         self.is_kind_type_or_kind_union_type(ty, &[TypeFlags::DICT, TypeFlags::SCHEMA])

test/grammar/types/binary_expr/binary_expr_3/main.k

@@ -0,0 +1,4 @@
+a: bool = True
+b: bool = a is True
+c: bool = a is not True
+d: bool = a is not False

test/grammar/types/binary_expr/binary_expr_3/stdout.golden

@@ -0,0 +1,4 @@
+a: true
+b: true
+c: false
+d: true