redscript-mc 2.6.2 → 3.0.0

package/src/typechecker/index.ts

@@ -5,9 +5,10 @@
  * Collects errors but doesn't block compilation (warn mode).
  */
 
-import type { Program, FnDecl, Stmt, Expr, TypeNode, Block, EntityTypeName, EntitySelector } from '../ast/types'
+import type { Program, FnDecl, Stmt, Expr, TypeNode, Block, EntityTypeName, EntitySelector, InterfaceDecl, InterfaceMethod } from '../ast/types'
 import { DiagnosticError, DiagnosticCollector } from '../diagnostics'
 import { getEventParamSpecs, isEventTypeName } from '../events/types'
+import { expandStructDeclarations } from '../structs/expand'
 
 interface ScopeSymbol {
   type: TypeNode
@@ -107,6 +108,10 @@ const STRING_TYPE: TypeNode = { kind: 'named', name: 'string' }
 const FORMAT_STRING_TYPE: TypeNode = { kind: 'named', name: 'format_string' }
 
 const BUILTIN_SIGNATURES: Record<string, BuiltinSignature> = {
+  assert: {
+    params: [{ kind: 'named', name: 'bool' }],
+    return: VOID_TYPE,
+  },
   setTimeout: {
     params: [INT_TYPE, { kind: 'function_type', params: [], return: VOID_TYPE }],
     return: VOID_TYPE,
@@ -119,6 +124,14 @@ const BUILTIN_SIGNATURES: Record<string, BuiltinSignature> = {
     params: [INT_TYPE],
     return: VOID_TYPE,
   },
+  int_to_str: {
+    params: [INT_TYPE],
+    return: STRING_TYPE,
+  },
+  bool_to_str: {
+    params: [{ kind: 'named', name: 'bool' }],
+    return: STRING_TYPE,
+  },
 }
 
 // ---------------------------------------------------------------------------
@@ -133,6 +146,8 @@ export class TypeChecker {
   private implMethods: Map<string, Map<string, FnDecl>> = new Map()
   private structs: Map<string, Map<string, TypeNode>> = new Map()
   private enums: Map<string, Map<string, number>> = new Map()
+  // enumName → variantName → field list (for payload variants)
+  private enumPayloads: Map<string, Map<string, { name: string; type: TypeNode }[]>> = new Map()
   private consts: Map<string, TypeNode> = new Map()
   private globals: Map<string, TypeNode> = new Map()
   private currentFn: FnDecl | null = null
@@ -144,6 +159,9 @@ export class TypeChecker {
   private loopDepth = 0
   private condDepth = 0
 
+  // interface name → InterfaceDecl
+  private interfaces: Map<string, InterfaceDecl> = new Map()
+
   private readonly richTextBuiltins = new Map<string, { messageIndex: number }>([
     ['say', { messageIndex: 0 }],
     ['announce', { messageIndex: 0 }],
@@ -194,6 +212,11 @@ export class TypeChecker {
       this.functions.set(fn.name, fn)
     }
 
+    // Register interface declarations
+    for (const iface of program.interfaces ?? []) {
+      this.interfaces.set(iface.name, iface)
+    }
+
     // Register global variables (mutable) so functions can reference and assign them
     for (const global of program.globals ?? []) {
       this.globals.set(global.name, this.normalizeType(global.type))
@@ -221,20 +244,62 @@ export class TypeChecker {
       }
     }
 
-    for (const struct of program.structs ?? []) {
+    const expandedStructs = expandStructDeclarations(program.structs ?? [], ({ message, node }) => {
+      this.report(message, node)
+    })
+
+    for (const struct of expandedStructs) {
       const fields = new Map<string, TypeNode>()
       for (const field of struct.fields) {
         fields.set(field.name, field.type)
       }
       this.structs.set(struct.name, fields)
+
+      // @singleton structs get synthetic static get() and set(gs) methods
+      if (struct.isSingleton) {
+        const structType: TypeNode = { kind: 'struct', name: struct.name }
+        let singletonMethods = this.implMethods.get(struct.name)
+        if (!singletonMethods) {
+          singletonMethods = new Map()
+          this.implMethods.set(struct.name, singletonMethods)
+        }
+        const voidType: TypeNode = { kind: 'named', name: 'void' }
+        // Synthetic get() — no params, returns struct
+        singletonMethods.set('get', {
+          name: 'get',
+          params: [],
+          returnType: structType,
+          decorators: [],
+          body: [],
+          typeParams: undefined,
+          isLibraryFn: true,
+        })
+        // Synthetic set(gs: StructName) — takes struct, returns void
+        singletonMethods.set('set', {
+          name: 'set',
+          params: [{ name: 'gs', type: structType }],
+          returnType: voidType,
+          decorators: [],
+          body: [],
+          typeParams: undefined,
+          isLibraryFn: true,
+        })
+      }
     }
 
     for (const enumDecl of program.enums ?? []) {
       const variants = new Map<string, number>()
+      const payloads = new Map<string, { name: string; type: TypeNode }[]>()
       for (const variant of enumDecl.variants) {
         variants.set(variant.name, variant.value ?? 0)
+        if (variant.fields && variant.fields.length > 0) {
+          payloads.set(variant.name, variant.fields)
+        }
       }
       this.enums.set(enumDecl.name, variants)
+      if (payloads.size > 0) {
+        this.enumPayloads.set(enumDecl.name, payloads)
+      }
     }
 
     for (const constDecl of program.consts ?? []) {
@@ -249,6 +314,24 @@ export class TypeChecker {
       this.consts.set(constDecl.name, constType)
     }
 
+    // Verify that each `impl <Interface> for <Struct>` satisfies all interface methods
+    for (const implBlock of program.implBlocks ?? []) {
+      if (!implBlock.traitName) continue
+      const iface = this.interfaces.get(implBlock.traitName)
+      if (!iface) continue  // Unknown trait — not our concern here (could be built-in like Display)
+
+      const implementedMethods = new Set(implBlock.methods.map(m => m.name))
+      for (const required of iface.methods) {
+        if (!implementedMethods.has(required.name)) {
+          const span = implBlock.span ?? required.span
+          this.report(
+            `Struct '${implBlock.typeName}' does not implement required method '${required.name}' from interface '${implBlock.traitName}'`,
+            span ?? { line: 1, col: 1 }
+          )
+        }
+      }
+    }
+
     // Second pass: type check function bodies
     for (const fn of program.declarations) {
       this.checkFunction(fn)
@@ -310,6 +393,76 @@ export class TypeChecker {
   }
 
   private checkFunctionDecorators(fn: FnDecl): void {
+    const watchDecorators = fn.decorators.filter(decorator => decorator.name === 'watch')
+    if (watchDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @watch decorators`, fn)
+      return
+    }
+
+    if (watchDecorators.length === 1) {
+      const objective = watchDecorators[0].args?.objective
+      if (!objective) {
+        this.report(`Function '${fn.name}' is missing a scoreboard objective in @watch("...")`, fn)
+        return
+      }
+
+      if (fn.params.length > 0) {
+        this.report(`@watch handler '${fn.name}' cannot declare parameters`, fn)
+      }
+    }
+
+    const throttleDecorators = fn.decorators.filter(decorator => decorator.name === 'throttle')
+    if (throttleDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @throttle decorators`, fn)
+      return
+    }
+    if (throttleDecorators.length === 1) {
+      const ticks = throttleDecorators[0].args?.ticks
+      if (ticks === undefined || ticks <= 0) {
+        this.report(`@throttle on '${fn.name}' requires ticks=N (positive integer)`, fn)
+      }
+    }
+
+    const retryDecorators = fn.decorators.filter(decorator => decorator.name === 'retry')
+    if (retryDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @retry decorators`, fn)
+      return
+    }
+    if (retryDecorators.length === 1) {
+      const max = retryDecorators[0].args?.max
+      if (max === undefined || max <= 0) {
+        this.report(`@retry on '${fn.name}' requires max=N (positive integer)`, fn)
+      }
+    }
+
+    const profileDecorators = fn.decorators.filter(decorator => decorator.name === 'profile')
+    if (profileDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @profile decorators`, fn)
+      return
+    }
+
+    if (profileDecorators.length === 1 && (profileDecorators[0].rawArgs?.length || profileDecorators[0].args && Object.keys(profileDecorators[0].args).length > 0)) {
+      this.report(`@profile decorator on '${fn.name}' does not accept arguments`, fn)
+      return
+    }
+
+    const memoizeDecorators = fn.decorators.filter(decorator => decorator.name === 'memoize')
+    if (memoizeDecorators.length > 1) {
+      this.report(`Function '${fn.name}' cannot have multiple @memoize decorators`, fn)
+      return
+    }
+    if (memoizeDecorators.length === 1) {
+      if (fn.params.length !== 1) {
+        this.report(`@memoize on '${fn.name}' requires exactly one parameter`, fn)
+      } else {
+        const paramType = fn.params[0].type
+        const isInt = paramType.kind === 'named' && paramType.name === 'int'
+        if (!isInt) {
+          this.report(`@memoize on '${fn.name}' only supports int parameters (got '${paramType.kind === 'named' ? paramType.name : paramType.kind}')`, fn)
+        }
+      }
+    }
+
     const eventDecorators = fn.decorators.filter(decorator => decorator.name === 'on')
     if (eventDecorators.length === 0) {
       return
@@ -430,9 +583,23 @@ export class TypeChecker {
                 !this.typesMatch(subjectType, patternType)) {
               this.report('Match arm pattern type must match subject type', arm.pattern.expr)
             }
+            this.checkBlock(arm.body)
+          } else if (arm.pattern.kind === 'PatEnum') {
+            const pat = arm.pattern
+            const variantPayloads = this.enumPayloads.get(pat.enumName)?.get(pat.variant) ?? []
+            // Bind pattern variables to their declared field types in arm scope
+            const savedScope = new Map(this.scope)
+            for (let i = 0; i < pat.bindings.length; i++) {
+              const fieldDef = variantPayloads[i]
+              const bindingType: TypeNode = fieldDef ? fieldDef.type : { kind: 'named', name: 'int' }
+              this.scope.set(pat.bindings[i], { type: bindingType, mutable: false })
+            }
+            this.checkBlock(arm.body)
+            this.scope = savedScope
+          } else {
+            // PatSome / PatNone / PatInt / PatWild are structurally typed — no extra scope needed
+            this.checkBlock(arm.body)
           }
-          // PatSome / PatNone / PatInt / PatWild are structurally typed — no expr to check
-          this.checkBlock(arm.body)
         }
         break
       case 'as_block': {
@@ -477,6 +644,22 @@ export class TypeChecker {
       case 'raw':
         // Raw commands are not type checked
         break
+      case 'break':
+      case 'continue':
+      case 'break_label':
+      case 'continue_label':
+        // Control flow — no sub-expressions to check
+        break
+      case 'labeled_loop':
+        // Recurse into the labeled loop body
+        this.loopDepth++
+        this.checkStmt(stmt.body)
+        this.loopDepth--
+        break
+      case 'const_decl':
+        // Local const: register in scope as immutable with its declared type
+        this.scope.set(stmt.name, { type: stmt.type, mutable: false })
+        break
     }
   }
 
@@ -625,8 +808,8 @@ export class TypeChecker {
         if (arithmeticOps.includes(expr.op)) {
           const leftType = this.inferType(expr.left)
           const rightType = this.inferType(expr.right)
-          const leftIsString = leftType.kind === 'named' && (leftType.name === 'string' || leftType.name === 'format_string')
-          const rightIsString = rightType.kind === 'named' && (rightType.name === 'string' || rightType.name === 'format_string')
+          const leftIsString = leftType.kind === 'named' && (leftType.name === 'string' || leftType.name === 'format_string')  // format_string kept for legacy type annotations
+          const rightIsString = rightType.kind === 'named' && (rightType.name === 'string' || rightType.name === 'format_string')  // format_string kept for legacy type annotations
           if (leftIsString || rightIsString) {
             // String concatenation with + is not supported. Use f-strings instead.
             this.report(
@@ -691,7 +874,35 @@ export class TypeChecker {
 
       case 'struct_lit':
         for (const field of expr.fields) {
-          this.checkExpr(field.value)
+          let fieldType: TypeNode | undefined
+          if (expectedType) {
+            const normalized = this.normalizeType(expectedType)
+            if (normalized.kind === 'struct') {
+              const structFields = this.structs.get(normalized.name)
+              if (structFields && !structFields.has(field.name)) {
+                this.report(`Struct '${normalized.name}' has no field '${field.name}'`, expr)
+              } else {
+                fieldType = structFields?.get(field.name)
+              }
+            }
+          }
+
+          this.checkExpr(field.value, fieldType)
+
+          if (fieldType) {
+            const actualType = this.inferType(field.value, fieldType)
+            if (this.isNumericMismatch(fieldType, actualType)) {
+              this.report(
+                `Field '${field.name}' of struct expects ${this.typeToString(fieldType)}, got ${this.typeToString(actualType)}`,
+                field.value
+              )
+            } else if (!this.typesMatch(fieldType, actualType)) {
+              this.report(
+                `Field '${field.name}' of struct expects ${this.typeToString(fieldType)}, got ${this.typeToString(actualType)}`,
+                field.value
+              )
+            }
+          }
         }
         break
 
@@ -754,6 +965,32 @@ export class TypeChecker {
         }
         break
 
+      case 'enum_construct': {
+        if (!this.enums.has(expr.enumName)) {
+          this.report(`Unknown enum '${expr.enumName}'`, expr)
+          break
+        }
+        const variants = this.enums.get(expr.enumName)!
+        if (!variants.has(expr.variant)) {
+          this.report(`Enum '${expr.enumName}' has no variant '${expr.variant}'`, expr)
+          break
+        }
+        const variantPayloads = this.enumPayloads.get(expr.enumName)?.get(expr.variant) ?? []
+        if (variantPayloads.length === 0 && expr.args.length > 0) {
+          this.report(`Enum variant '${expr.enumName}::${expr.variant}' has no payload fields`, expr)
+          break
+        }
+        for (const arg of expr.args) {
+          const fieldDef = variantPayloads.find(f => f.name === arg.name)
+          if (!fieldDef) {
+            this.report(`Unknown field '${arg.name}' for enum variant '${expr.enumName}::${expr.variant}'`, expr)
+          } else {
+            this.checkExpr(arg.value, fieldDef.type)
+          }
+        }
+        break
+      }
+
       case 'blockpos':
         break
 
@@ -883,7 +1120,7 @@ export class TypeChecker {
     const messageType = this.inferType(message)
     if (
       messageType.kind !== 'named' ||
-      (messageType.name !== 'string' && messageType.name !== 'format_string')
+      messageType.name !== 'string'
     ) {
       this.report(
         `Argument ${messageIndex + 1} of '${expr.fn}' expects string or format_string, got ${this.typeToString(messageType)}`,
@@ -1147,7 +1384,7 @@ export class TypeChecker {
             this.checkExpr(part.expr)
           }
         }
-        return FORMAT_STRING_TYPE
+        return STRING_TYPE
       case 'blockpos':
         return { kind: 'named', name: 'BlockPos' }
       case 'ident':
@@ -1209,6 +1446,11 @@ export class TypeChecker {
           return { kind: 'enum', name: expr.enumName }
         }
         return { kind: 'named', name: 'void' }
+      case 'enum_construct':
+        if (this.enums.has(expr.enumName)) {
+          return { kind: 'enum', name: expr.enumName }
+        }
+        return { kind: 'named', name: 'void' }
       case 'member':
         if (expr.obj.kind === 'ident' && this.enums.has(expr.obj.name)) {
           return { kind: 'enum', name: expr.obj.name }
@@ -1336,6 +1578,20 @@ export class TypeChecker {
     return 'entity'
   }
 
+  // Reverse map: parser sometimes remaps method names (e.g. add→set_add) for builtins.
+  // When the receiver is a struct with an impl method matching the original name, use that.
+  private static readonly PARSER_METHOD_REMAP: Record<string, string> = {
+    'set_add': 'add',
+    'set_contains': 'contains',
+    'set_remove': 'remove',
+    'set_clear': 'clear',
+    '__array_push': 'push',
+    '__array_pop': 'pop',
+    '__entity_tag': 'tag',
+    '__entity_untag': 'untag',
+    '__entity_has_tag': 'has_tag',
+  }
+
   private resolveInstanceMethod(expr: Extract<Expr, { kind: 'call' }>): FnDecl | null {
     const receiver = expr.args[0]
     if (!receiver) {
@@ -1347,7 +1603,10 @@ export class TypeChecker {
       return null
     }
 
+    // Try the method name as-is first, then try the original (pre-remap) name
+    const methodName = TypeChecker.PARSER_METHOD_REMAP[expr.fn] ?? expr.fn
     const method = this.implMethods.get(receiverType.name)?.get(expr.fn)
+      ?? this.implMethods.get(receiverType.name)?.get(methodName)
     if (!method || method.params[0]?.name !== 'self') {
       return null
     }
@@ -1422,6 +1681,11 @@ export class TypeChecker {
     if (expected.kind === 'selector' && actual.kind === 'selector') {
       return true  // any entity subtype is compatible
     }
+    // Fake player names (#name) are mc_name tokens typed as string — allow them
+    // where a selector is expected, since MC scoreboards accept fake player names.
+    if (expected.kind === 'selector' && actual.kind === 'named' && actual.name === 'string') {
+      return true
+    }
 
     if (expected.kind !== actual.kind) return false