redscript-mc 1.2.0 → 1.2.2

package/src/parser/index.ts

@@ -965,6 +965,18 @@ export class Parser {
       return this.withLoc({ kind: 'float_lit', value: parseFloat(token.value) }, token)
     }
 
+    // Relative coordinate: ~  ~5  ~-3  ~0.5
+    if (token.kind === 'rel_coord') {
+      this.advance()
+      return this.withLoc({ kind: 'rel_coord', value: token.value }, token)
+    }
+
+    // Local coordinate: ^  ^5  ^-3  ^0.5
+    if (token.kind === 'local_coord') {
+      this.advance()
+      return this.withLoc({ kind: 'local_coord', value: token.value }, token)
+    }
+
     // NBT suffix literals
     if (token.kind === 'byte_lit') {
       this.advance()
@@ -989,6 +1001,11 @@ export class Parser {
       return this.parseStringExpr(token)
     }
 
+    if (token.kind === 'f_string') {
+      this.advance()
+      return this.parseFStringExpr(token)
+    }
+
     // MC name literal: #health → mc_name node (value = "health", without #)
     if (token.kind === 'mc_name') {
       this.advance()
@@ -1169,6 +1186,67 @@ export class Parser {
     return this.withLoc({ kind: 'str_interp', parts }, token)
   }
 
+  private parseFStringExpr(token: Token): Expr {
+    const parts: Array<{ kind: 'text'; value: string } | { kind: 'expr'; expr: Expr }> = []
+    let current = ''
+    let index = 0
+
+    while (index < token.value.length) {
+      if (token.value[index] === '{') {
+        if (current) {
+          parts.push({ kind: 'text', value: current })
+          current = ''
+        }
+
+        index++
+        let depth = 1
+        let exprSource = ''
+        let inString = false
+
+        while (index < token.value.length && depth > 0) {
+          const char = token.value[index]
+
+          if (char === '"' && token.value[index - 1] !== '\\') {
+            inString = !inString
+          }
+
+          if (!inString) {
+            if (char === '{') {
+              depth++
+            } else if (char === '}') {
+              depth--
+              if (depth === 0) {
+                index++
+                break
+              }
+            }
+          }
+
+          if (depth > 0) {
+            exprSource += char
+          }
+          index++
+        }
+
+        if (depth !== 0) {
+          this.error('Unterminated f-string interpolation')
+        }
+
+        parts.push({ kind: 'expr', expr: this.parseEmbeddedExpr(exprSource) })
+        continue
+      }
+
+      current += token.value[index]
+      index++
+    }
+
+    if (current) {
+      parts.push({ kind: 'text', value: current })
+    }
+
+    return this.withLoc({ kind: 'f_string', parts }, token)
+  }
+
   private parseEmbeddedExpr(source: string): Expr {
     const tokens = new Lexer(source, this.filePath).tokenize()
     const parser = new Parser(tokens, source, this.filePath)
@@ -1343,20 +1421,11 @@ export class Parser {
       return this.peek(offset + 1).kind === 'int_lit' ? 2 : 0
     }
 
-    if (token.kind !== '~' && token.kind !== '^') {
-      return 0
-    }
-
-    const next = this.peek(offset + 1)
-    if (next.kind === ',' || next.kind === ')') {
+    // rel_coord (~, ~5, ~-3) and local_coord (^, ^5, ^-3) are single tokens now
+    if (token.kind === 'rel_coord' || token.kind === 'local_coord') {
       return 1
     }
-    if (next.kind === 'int_lit') {
-      return 2
-    }
-    if (next.kind === '-' && this.peek(offset + 2).kind === 'int_lit') {
-      return 3
-    }
+
     return 0
   }
 
@@ -1374,17 +1443,28 @@ export class Parser {
   private parseCoordComponent(): CoordComponent {
     const token = this.peek()
 
-    if (token.kind === '~' || token.kind === '^') {
+    // Handle rel_coord (~, ~5, ~-3) and local_coord (^, ^5, ^-3) tokens
+    if (token.kind === 'rel_coord') {
       this.advance()
-      const offset = this.parseSignedCoordOffset()
-      return token.kind === '~'
-        ? { kind: 'relative', offset }
-        : { kind: 'local', offset }
+      // Parse the offset from the token value (e.g., "~5" -> 5, "~" -> 0, "~-3" -> -3)
+      const offset = this.parseCoordOffsetFromValue(token.value.slice(1))
+      return { kind: 'relative', offset }
+    }
+
+    if (token.kind === 'local_coord') {
+      this.advance()
+      const offset = this.parseCoordOffsetFromValue(token.value.slice(1))
+      return { kind: 'local', offset }
     }
 
     return { kind: 'absolute', value: this.parseSignedCoordOffset(true) }
   }
 
+  private parseCoordOffsetFromValue(value: string): number {
+    if (value === '' || value === undefined) return 0
+    return parseFloat(value)
+  }
+
   private parseSignedCoordOffset(requireValue = false): number {
     let sign = 1
     if (this.match('-')) {

package/src/typechecker/index.ts

@@ -73,6 +73,8 @@ const MC_TYPE_TO_ENTITY: Record<string, EntityTypeName> = {
 
 const VOID_TYPE: TypeNode = { kind: 'named', name: 'void' }
 const INT_TYPE: TypeNode = { kind: 'named', name: 'int' }
+const STRING_TYPE: TypeNode = { kind: 'named', name: 'string' }
+const FORMAT_STRING_TYPE: TypeNode = { kind: 'named', name: 'format_string' }
 
 const BUILTIN_SIGNATURES: Record<string, BuiltinSignature> = {
   setTimeout: {
@@ -106,6 +108,16 @@ export class TypeChecker {
   // Stack for tracking @s type in different contexts
   private selfTypeStack: EntityTypeName[] = ['entity']
 
+  private readonly richTextBuiltins = new Map<string, { messageIndex: number }>([
+    ['say', { messageIndex: 0 }],
+    ['announce', { messageIndex: 0 }],
+    ['tell', { messageIndex: 1 }],
+    ['tellraw', { messageIndex: 1 }],
+    ['title', { messageIndex: 1 }],
+    ['actionbar', { messageIndex: 1 }],
+    ['subtitle', { messageIndex: 1 }],
+  ])
+
   constructor(source?: string, filePath?: string) {
     this.collector = new DiagnosticCollector(source, filePath)
   }
@@ -510,6 +522,24 @@ export class TypeChecker {
         }
         break
 
+      case 'f_string':
+        for (const part of expr.parts) {
+          if (part.kind !== 'expr') {
+            continue
+          }
+          this.checkExpr(part.expr)
+          const partType = this.inferType(part.expr)
+          if (
+            !(partType.kind === 'named' && (partType.name === 'int' || partType.name === 'string' || partType.name === 'format_string'))
+          ) {
+            this.report(
+              `f-string placeholder must be int or string, got ${this.typeToString(partType)}`,
+              part.expr
+            )
+          }
+        }
+        break
+
       case 'array_lit':
         for (const elem of expr.elements) {
           this.checkExpr(elem)
@@ -544,6 +574,12 @@ export class TypeChecker {
       this.checkTpCall(expr)
     }
 
+    const richTextBuiltin = this.richTextBuiltins.get(expr.fn)
+    if (richTextBuiltin) {
+      this.checkRichTextBuiltinCall(expr, richTextBuiltin.messageIndex)
+      return
+    }
+
     const builtin = BUILTIN_SIGNATURES[expr.fn]
     if (builtin) {
       this.checkFunctionCallArgs(expr.args, builtin.params, expr.fn, expr)
@@ -602,6 +638,28 @@ export class TypeChecker {
     // Built-in functions are not checked for arg count
   }
 
+  private checkRichTextBuiltinCall(expr: Extract<Expr, { kind: 'call' }>, messageIndex: number): void {
+    for (let i = 0; i < expr.args.length; i++) {
+      this.checkExpr(expr.args[i], i === messageIndex ? undefined : STRING_TYPE)
+    }
+
+    const message = expr.args[messageIndex]
+    if (!message) {
+      return
+    }
+
+    const messageType = this.inferType(message)
+    if (
+      messageType.kind !== 'named' ||
+      (messageType.name !== 'string' && messageType.name !== 'format_string')
+    ) {
+      this.report(
+        `Argument ${messageIndex + 1} of '${expr.fn}' expects string or format_string, got ${this.typeToString(messageType)}`,
+        message
+      )
+    }
+  }
+
   private checkInvokeExpr(expr: Extract<Expr, { kind: 'invoke' }>): void {
     this.checkExpr(expr.callee)
     const calleeType = this.inferType(expr.callee)
@@ -838,6 +896,13 @@ export class TypeChecker {
           }
         }
         return { kind: 'named', name: 'string' }
+      case 'f_string':
+        for (const part of expr.parts) {
+          if (part.kind === 'expr') {
+            this.checkExpr(part.expr)
+          }
+        }
+        return FORMAT_STRING_TYPE
       case 'blockpos':
         return { kind: 'named', name: 'BlockPos' }
       case 'ident':