Enhance type checking: Introduce is keyword for type checks, update parser and type checker, and add documentation examples.

Author: forge1818

.spec/language/syntax.md

@@ -484,6 +484,7 @@ func attack(target: enemy::Enemy) {
 | `..`     | String concatenation |
 | `...`    | Spread               |
 | `as`     | Type casting         |
+| `is`     | Type check → `bool`  |
 | `? :`    | Ternary              |
 
 ### Ranges
@@ -525,13 +526,31 @@ The method is dispatched at runtime. If no matching method is found, a runtime e
 
 ---
 
-## 16. Type Casting
+## 16. Type Casting and Type Checking
+
+### Casting (`as`)
 
 ```writ
 let x = someValue as float
 let n = health as int
 ```
 
+### Type checking (`is`)
+
+`expr is TypeName` evaluates to `bool`. Valid in any expression position, including `if` conditions:
+
+```writ
+if entity is Player {
+    entity.takeDamage(10.0)
+}
+
+let isEnemy = obj is Enemy
+let either = a is Player || a is NPC
+
+// Namespace-qualified types are supported
+let check = obj is enemy::Enemy
+```
+
 ---
 
 ## 17. Comments

crates/writ-lsp/src/references.rs

@@ -280,7 +280,9 @@ fn collect_from_expr(
                 }
             }
         }
-        ExprKind::ErrorPropagate(inner) | ExprKind::Cast { expr: inner, .. } => {
+        ExprKind::ErrorPropagate(inner)
+        | ExprKind::Cast { expr: inner, .. }
+        | ExprKind::TypeCheck { expr: inner, .. } => {
             collect_from_expr(inner, name, uri, locations);
         }
         ExprKind::StringInterpolation(segments) => {

crates/writ-lsp/src/rename.rs

@@ -270,7 +270,9 @@ fn collect_from_expr(
                 }
             }
         }
-        ExprKind::ErrorPropagate(inner) | ExprKind::Cast { expr: inner, .. } => {
+        ExprKind::ErrorPropagate(inner)
+        | ExprKind::Cast { expr: inner, .. }
+        | ExprKind::TypeCheck { expr: inner, .. } => {
             collect_from_expr(inner, old_name, new_name, edits);
         }
         ExprKind::StringInterpolation(segments) => {

docs/src/content/docs/language/control-flow.md

@@ -15,6 +15,19 @@ if health <= 0 {
 }
 ```
 
+### Type checking with `is`
+
+Use `expr is TypeName` as a boolean condition:
+
+```writ
+if entity is Player {
+    entity.takeDamage(10.0)
+}
+
+let isEnemy = obj is Enemy
+let either = a is Player || a is NPC
+```
+
 ---
 
 ## Ternary

extensions/vscode-writ/bin/writ-lsp

@@ -106,6 +106,13 @@ pub enum ExprKind {
         target_type: TypeExpr,
     },
 
+    /// Type check: `expr is Type` — evaluates to `bool`.
+    /// Type may be simple (`Player`) or namespace-qualified (`enemy::Enemy`).
+    TypeCheck {
+        expr: Box<Expr>,
+        target_type: TypeExpr,
+    },
+
     /// String interpolation: sequence of literal and expression segments.
     StringInterpolation(Vec<InterpolationSegment>),
 

src/parser/ast.rs

@@ -42,7 +42,7 @@ fn infix_precedence(kind: &TokenKind) -> Option<Precedence> {
         TokenKind::QuestionQuestion => Some(Precedence::NullCoalesce),
         TokenKind::Plus | TokenKind::Minus => Some(Precedence::Addition),
         TokenKind::Star | TokenKind::Slash | TokenKind::Percent => Some(Precedence::Multiplication),
-        TokenKind::As => Some(Precedence::Cast),
+        TokenKind::As | TokenKind::Is => Some(Precedence::Cast),
         TokenKind::Dot
         | TokenKind::QuestionDot
         | TokenKind::LeftParen
@@ -316,6 +316,34 @@ impl Parser {
         Ok(left)
     }
 
+    /// Like `parse_expr` but does not cross newline boundaries.
+    /// Used for single-expression `when` arm bodies to prevent the Pratt loop
+    /// from consuming the `is` keyword of the next arm as an infix type-check.
+    fn parse_expr_line(&mut self) -> Result<Expr, ParseError> {
+        let mut left = self.parse_prefix()?;
+
+        loop {
+            if matches!(
+                self.peek(),
+                TokenKind::Newline | TokenKind::Semicolon | TokenKind::Eof | TokenKind::RightBrace
+            ) {
+                break;
+            }
+
+            let Some(prec) = infix_precedence(self.peek()) else {
+                break;
+            };
+
+            if prec <= Precedence::Lowest {
+                break;
+            }
+
+            left = self.parse_infix(left, prec)?;
+        }
+
+        Ok(left)
+    }
+
     // --- Prefix parsing (atoms + unary) ---
 
     fn parse_prefix(&mut self) -> Result<Expr, ParseError> {
@@ -616,6 +644,18 @@ impl Parser {
                 })
             }
 
+            // Type check: expr is Type
+            TokenKind::Is => {
+                let target_type = self.parse_type_expr()?;
+                Ok(Expr {
+                    kind: ExprKind::TypeCheck {
+                        expr: Box::new(left),
+                        target_type,
+                    },
+                    span,
+                })
+            }
+
             // Call: callee(arg1, name: arg2, ...)
             TokenKind::LeftParen => {
                 self.skip_newlines();
@@ -1251,7 +1291,7 @@ impl Parser {
         let body = if self.peek() == &TokenKind::LeftBrace {
             WhenBody::Block(self.parse_block()?)
         } else {
-            WhenBody::Expr(self.parse_expr()?)
+            WhenBody::Expr(self.parse_expr_line()?)
         };
 
         self.consume_stmt_terminator();
@@ -2164,4 +2204,74 @@ mod tests {
             panic!("expected func decl");
         }
     }
+
+    #[test]
+    fn parse_is_expression_simple() {
+        let tokens = Lexer::new("let x = obj is Player").tokenize().unwrap();
+        let mut parser = Parser::new(tokens);
+        let stmts = parser.parse_program().unwrap();
+        if let StmtKind::Let { initializer, .. } = &stmts[0].kind {
+            assert!(matches!(
+                &initializer.kind,
+                ExprKind::TypeCheck {
+                    target_type: TypeExpr::Simple(name),
+                    ..
+                } if name == "Player"
+            ));
+        } else {
+            panic!("expected let stmt");
+        }
+    }
+
+    #[test]
+    fn parse_is_expression_qualified() {
+        let tokens = Lexer::new("let x = obj is enemy::Enemy")
+            .tokenize()
+            .unwrap();
+        let mut parser = Parser::new(tokens);
+        let stmts = parser.parse_program().unwrap();
+        if let StmtKind::Let { initializer, .. } = &stmts[0].kind {
+            assert!(matches!(
+                &initializer.kind,
+                ExprKind::TypeCheck {
+                    target_type: TypeExpr::Qualified { namespace, name },
+                    ..
+                } if namespace == "enemy" && name == "Enemy"
+            ));
+        } else {
+            panic!("expected let stmt");
+        }
+    }
+
+    #[test]
+    fn when_type_match_two_arms_no_infix_consumed() {
+        let src = "when result {\n    is Success(v) => print(v)\n    is Error(e) => print(e)\n}";
+        let tokens = Lexer::new(src).tokenize().unwrap();
+        let mut parser = Parser::new(tokens);
+        let stmts = parser.parse_program().unwrap();
+        if let StmtKind::When { arms, .. } = &stmts[0].kind {
+            assert_eq!(arms.len(), 2);
+            // Second arm must be a TypeMatch, not consumed by first arm's body expression
+            assert!(
+                matches!(arms[1].pattern, WhenPattern::TypeMatch { .. }),
+                "second arm pattern was {:?}, expected TypeMatch",
+                arms[1].pattern
+            );
+        } else {
+            panic!("expected when stmt");
+        }
+    }
+
+    #[test]
+    fn type_check_expr_is_still_valid() {
+        // `obj is Player` must still parse as a TypeCheck expression (not broken by the fix)
+        let tokens = Lexer::new("let x = obj is Player").tokenize().unwrap();
+        let mut parser = Parser::new(tokens);
+        let stmts = parser.parse_program().unwrap();
+        if let StmtKind::Let { initializer, .. } = &stmts[0].kind {
+            assert!(matches!(initializer.kind, ExprKind::TypeCheck { .. }));
+        } else {
+            panic!("expected let stmt");
+        }
+    }
 }

src/parser/parser.rs

@@ -121,6 +121,15 @@ impl TypeChecker {
                 }
             }
 
+            ExprKind::TypeCheck {
+                expr: inner,
+                target_type,
+            } => {
+                self.infer_expr(inner)?;
+                self.resolve_type_expr(target_type, &expr.span)?;
+                Ok(Type::Bool)
+            }
+
             ExprKind::Call { callee, args } => self.infer_call(callee, args, &expr.span),
 
             ExprKind::Lambda { params, body } => self.infer_lambda(params, body, &expr.span),