redscript-mc 1.2.30 → 2.1.0

package/src/typechecker/index.ts

@@ -132,6 +132,7 @@ export class TypeChecker {
   private structs: Map<string, Map<string, TypeNode>> = new Map()
   private enums: Map<string, Map<string, number>> = new Map()
   private consts: Map<string, TypeNode> = new Map()
+  private globals: Map<string, TypeNode> = new Map()
   private currentFn: FnDecl | null = null
   private currentReturnType: TypeNode | null = null
   private scope: Map<string, ScopeSymbol> = new Map()
@@ -174,6 +175,11 @@ export class TypeChecker {
       this.functions.set(fn.name, fn)
     }
 
+    // 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))
+    }
+
     for (const implBlock of program.implBlocks ?? []) {
       let methods = this.implMethods.get(implBlock.typeName)
       if (!methods) {
@@ -239,6 +245,10 @@ export class TypeChecker {
   }
 
   private checkFunction(fn: FnDecl): void {
+    // Generic functions (with type params like <T>) are checked after monomorphization.
+    // Skip body checking here to avoid false errors for unresolved type params.
+    if (fn.typeParams && fn.typeParams.length > 0) return
+
     this.currentFn = fn
     this.currentReturnType = this.normalizeType(fn.returnType)
     this.scope = new Map()
@@ -250,6 +260,10 @@ export class TypeChecker {
       this.scope.set(name, { type, mutable: false })
     }
 
+    for (const [name, type] of this.globals.entries()) {
+      this.scope.set(name, { type, mutable: true })
+    }
+
     // Add parameters to scope
     for (const param of fn.params) {
       this.scope.set(param.name, { type: this.normalizeType(param.type), mutable: true })
@@ -330,6 +344,9 @@ export class TypeChecker {
       case 'let':
         this.checkLetStmt(stmt)
         break
+      case 'let_destruct':
+        this.checkLetDestructStmt(stmt)
+        break
       case 'return':
         this.checkReturnStmt(stmt)
         break
@@ -375,7 +392,12 @@ export class TypeChecker {
         for (const arm of stmt.arms) {
           if (arm.pattern) {
             this.checkExpr(arm.pattern)
-            if (!this.typesMatch(this.inferType(stmt.expr), this.inferType(arm.pattern))) {
+            const subjectType = this.inferType(stmt.expr)
+            const patternType = this.inferType(arm.pattern)
+            // Skip check if either type is unknown (void) — struct field access not yet inferred
+            const isUnknown = (t: TypeNode) => t.kind === 'named' && t.name === 'void'
+            if (!isUnknown(subjectType) && !isUnknown(patternType) &&
+                !this.typesMatch(subjectType, patternType)) {
               this.report('Match arm pattern type must match subject type', arm.pattern)
             }
           }
@@ -427,6 +449,46 @@ export class TypeChecker {
     }
   }
 
+  private checkLetDestructStmt(stmt: Extract<Stmt, { kind: 'let_destruct' }>): void {
+    this.checkExpr(stmt.init)
+    const initType = this.inferType(stmt.init)
+    if (stmt.type) {
+      // Type annotation must be a tuple
+      const normalized = this.normalizeType(stmt.type)
+      if (normalized.kind !== 'tuple') {
+        this.report(`Destructuring type annotation must be a tuple type`, stmt)
+        return
+      }
+      if (normalized.elements.length !== stmt.names.length) {
+        this.report(
+          `Destructuring pattern has ${stmt.names.length} bindings but type has ${normalized.elements.length} elements`,
+          stmt
+        )
+      }
+      for (let i = 0; i < stmt.names.length; i++) {
+        const elemType = normalized.elements[i] ?? { kind: 'named', name: 'int' } as TypeNode
+        this.scope.set(stmt.names[i], { type: elemType, mutable: true })
+      }
+    } else if (initType.kind === 'tuple') {
+      // Infer element types from tuple literal type
+      if (initType.elements.length !== stmt.names.length) {
+        this.report(
+          `Destructuring pattern has ${stmt.names.length} bindings but tuple has ${initType.elements.length} elements`,
+          stmt
+        )
+      }
+      for (let i = 0; i < stmt.names.length; i++) {
+        const elemType = initType.elements[i] ?? { kind: 'named', name: 'int' } as TypeNode
+        this.scope.set(stmt.names[i], { type: elemType, mutable: true })
+      }
+    } else {
+      // Can't infer element types — use int as fallback (tuple returns inferred as int from scoreboard)
+      for (const name of stmt.names) {
+        this.scope.set(name, { type: INT_TYPE, mutable: true })
+      }
+    }
+  }
+
   private checkLetStmt(stmt: Extract<Stmt, { kind: 'let' }>): void {
     // Check initializer
     const expectedType = stmt.type ? this.normalizeType(stmt.type) : undefined
@@ -441,13 +503,21 @@ export class TypeChecker {
       expectedType &&
       stmt.init.kind !== 'struct_lit' &&
       stmt.init.kind !== 'array_lit' &&
-      !(actualType.kind === 'named' && actualType.name === 'void') &&
-      !this.typesMatch(expectedType, actualType)
+      !(actualType.kind === 'named' && actualType.name === 'void')
     ) {
-      this.report(
-        `Type mismatch: expected ${this.typeToString(expectedType)}, got ${this.typeToString(actualType)}`,
-        stmt
-      )
+      if (this.isNumericMismatch(expectedType, actualType)) {
+        // Explicit numeric conversion required for let assignments
+        this.report(
+          `Type mismatch: cannot implicitly convert ${this.typeToString(actualType)} to ${this.typeToString(expectedType)}` +
+          ` (use an explicit cast: 'as ${this.typeToString(expectedType)}')`,
+          stmt
+        )
+      } else if (!this.typesMatch(expectedType, actualType)) {
+        this.report(
+          `Type mismatch: expected ${this.typeToString(expectedType)}, got ${this.typeToString(actualType)}`,
+          stmt
+        )
+      }
     }
   }
 
@@ -460,7 +530,14 @@ export class TypeChecker {
       const actualType = this.inferType(stmt.value, expectedType)
       this.checkExpr(stmt.value, expectedType)
       
-      if (!this.typesMatch(expectedType, actualType)) {
+      if (this.isNumericMismatch(expectedType, actualType)) {
+        // Explicit numeric conversion required for return statements
+        this.report(
+          `Return type mismatch: cannot implicitly convert ${this.typeToString(actualType)} to ${this.typeToString(expectedType)}` +
+          ` (use an explicit cast: 'as ${this.typeToString(expectedType)}')`,
+          stmt
+        )
+      } else if (!this.typesMatch(expectedType, actualType)) {
         this.report(
           `Return type mismatch: expected ${this.typeToString(expectedType)}, got ${this.typeToString(actualType)}`,
           stmt
@@ -559,7 +636,10 @@ export class TypeChecker {
           }
           this.checkExpr(part.expr)
           const partType = this.inferType(part.expr)
+          // Skip check if type is unknown (void) — struct field access not yet fully inferred
+          const isUnknown = partType.kind === 'named' && partType.name === 'void'
           if (
+            !isUnknown &&
             !(partType.kind === 'named' && (partType.name === 'int' || partType.name === 'string' || partType.name === 'format_string'))
           ) {
             this.report(
@@ -576,10 +656,30 @@ export class TypeChecker {
         }
         break
 
+      case 'tuple_lit':
+        if (expr.elements.length < 2 || expr.elements.length > 8) {
+          this.report(`Tuple must have 2-8 elements, got ${expr.elements.length}`, expr)
+        }
+        for (const elem of expr.elements) {
+          this.checkExpr(elem)
+        }
+        break
+
       case 'lambda':
         this.checkLambdaExpr(expr, expectedType)
         break
 
+      case 'path_expr':
+        if (!this.enums.has(expr.enumName)) {
+          this.report(`Unknown enum '${expr.enumName}'`, expr)
+        } else {
+          const variants = this.enums.get(expr.enumName)!
+          if (!variants.has(expr.variant)) {
+            this.report(`Enum '${expr.enumName}' has no variant '${expr.variant}'`, expr)
+          }
+        }
+        break
+
       case 'blockpos':
         break
 
@@ -619,6 +719,18 @@ export class TypeChecker {
     // Check if function exists and arg count matches
     const fn = this.functions.get(expr.fn)
     if (fn) {
+      // Generic functions: skip param-type checking (monomorphizer handles it)
+      if (fn.typeParams && fn.typeParams.length > 0) {
+        const requiredParams = fn.params.filter(param => !param.default).length
+        if (expr.args.length < requiredParams || expr.args.length > fn.params.length) {
+          this.report(
+            `Function '${expr.fn}' expects ${requiredParams}-${fn.params.length} arguments, got ${expr.args.length}`,
+            expr
+          )
+        }
+        for (const arg of expr.args) this.checkExpr(arg)
+        return
+      }
       const requiredParams = fn.params.filter(param => !param.default).length
       if (expr.args.length < requiredParams || expr.args.length > fn.params.length) {
         const expectedRange = requiredParams === fn.params.length
@@ -968,7 +1080,15 @@ export class TypeChecker {
           return this.normalizeType(implMethod.returnType)
         }
         const fn = this.functions.get(expr.fn)
-        return fn?.returnType ?? INT_TYPE
+        if (fn) {
+          // For generic functions, the return type may be a type param (e.g. T).
+          // If we have an expected type from context, trust it; otherwise return int as default.
+          if (fn.typeParams && fn.typeParams.length > 0) {
+            return expectedType ?? INT_TYPE
+          }
+          return this.normalizeType(fn.returnType)
+        }
+        return INT_TYPE
       }
       case 'static_call': {
         const method = this.implMethods.get(expr.type)?.get(expr.method)
@@ -981,6 +1101,11 @@ export class TypeChecker {
         }
         return { kind: 'named', name: 'void' }
       }
+      case 'path_expr':
+        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 }
@@ -1007,6 +1132,11 @@ export class TypeChecker {
       case 'unary':
         if (expr.op === '!') return { kind: 'named', name: 'bool' }
         return this.inferType(expr.operand)
+      case 'selector': {
+        // Infer entity type from the selector
+        const entityType = this.inferEntityTypeFromSelector(expr.sel)
+        return { kind: 'selector', entityType: entityType ?? undefined }
+      }
       case 'array_lit':
         if (expr.elements.length > 0) {
           return { kind: 'array', elem: this.inferType(expr.elements[0]) }
@@ -1020,6 +1150,22 @@ export class TypeChecker {
           }
         }
         return { kind: 'named', name: 'void' }
+      case 'tuple_lit':
+        return {
+          kind: 'tuple',
+          elements: expr.elements.map(e => this.inferType(e)),
+        }
+      case 'some_lit': {
+        // Some(expr) → Option<T> where T is inferred from inner value
+        const innerType = this.inferType(expr.value,
+          expectedType?.kind === 'option' ? expectedType.inner : undefined)
+        return { kind: 'option', inner: innerType }
+      }
+      case 'none_lit': {
+        // None → Option<T>, use expected type if available
+        if (expectedType?.kind === 'option') return expectedType
+        return { kind: 'option', inner: { kind: 'named', name: 'void' } }
+      }
       case 'lambda':
         return this.inferLambdaType(
           expr,
@@ -1132,13 +1278,53 @@ export class TypeChecker {
     return this.selfTypeStack[this.selfTypeStack.length - 1]
   }
 
+  /** Returns true if expected/actual are a numeric type mismatch (int vs float). */
+  private isNumericMismatch(expected: TypeNode, actual: TypeNode): boolean {
+    if (expected.kind !== 'named' || actual.kind !== 'named') return false
+    const numericPairs = [
+      ['int', 'float'], ['float', 'int'],
+      ['int', 'double'], ['double', 'int'],
+      ['float', 'double'], ['double', 'float'],
+    ]
+    return numericPairs.some(([e, a]) => expected.name === e && actual.name === a)
+  }
+
   private typesMatch(expected: TypeNode, actual: TypeNode): boolean {
+    // Enum values are backed by int — allow enum where int is expected and vice versa
+    if (expected.kind === 'named' && expected.name === 'int' && actual.kind === 'enum') {
+      return true
+    }
+    if (expected.kind === 'enum' && actual.kind === 'named' && actual.name === 'int') {
+      return true
+    }
+
+    // Selector/entity cross-kind compatibility (must come before kind guard)
+    if (expected.kind === 'selector' && actual.kind === 'entity') {
+      return true  // entity is a valid selector
+    }
+    if (expected.kind === 'entity' && actual.kind === 'selector') {
+      return true  // selector is a valid entity context
+    }
+    if (expected.kind === 'entity' && actual.kind === 'entity') {
+      return this.isEntitySubtype(actual.entityType, expected.entityType)
+    }
+    if (expected.kind === 'selector' && actual.kind === 'selector') {
+      return true  // any entity subtype is compatible
+    }
+
     if (expected.kind !== actual.kind) return false
 
     if (expected.kind === 'named' && actual.kind === 'named') {
       // void matches anything (for inferred types)
       if (actual.name === 'void') return true
-      return expected.name === actual.name
+      if (expected.name === actual.name) return true
+      // int→float/double implicit promotion in function calls (not for let/return — handled separately)
+      const numericPromotion = [
+        ['int', 'float'], ['int', 'double'], ['float', 'double'],
+        ['float', 'int'], ['double', 'int'], ['double', 'float'],
+      ]
+      if (numericPromotion.some(([e, a]) => expected.name === e && actual.name === a)) return true
+      return false
     }
 
     if (expected.kind === 'array' && actual.kind === 'array') {
@@ -1159,13 +1345,17 @@ export class TypeChecker {
         this.typesMatch(expected.return, actual.return)
     }
 
-    // Entity type matching with subtype support
-    if (expected.kind === 'entity' && actual.kind === 'entity') {
-      return this.isEntitySubtype(actual.entityType, expected.entityType)
+    if (expected.kind === 'tuple' && actual.kind === 'tuple') {
+      return expected.elements.length === actual.elements.length &&
+        expected.elements.every((elem, i) => this.typesMatch(elem, actual.elements[i]))
     }
 
-    // Selector matches any entity type
-    if (expected.kind === 'selector' && actual.kind === 'entity') {
+    if (expected.kind === 'option' && actual.kind === 'option') {
+      return this.typesMatch(expected.inner, actual.inner)
+    }
+
+    // Option<T> is compatible with None (void inner) or partially inferred types
+    if (expected.kind === 'option' && actual.kind === 'named' && actual.name === 'void') {
       return true
     }
 
@@ -1188,6 +1378,10 @@ export class TypeChecker {
         return type.entityType
       case 'selector':
         return 'selector'
+      case 'tuple':
+        return `(${type.elements.map(e => this.typeToString(e)).join(', ')})`
+      case 'option':
+        return `Option<${this.typeToString(type.inner)}>`
       default:
         return 'unknown'
     }
@@ -1197,6 +1391,12 @@ export class TypeChecker {
     if (type.kind === 'array') {
       return { kind: 'array', elem: this.normalizeType(type.elem) }
     }
+    if (type.kind === 'option') {
+      return { kind: 'option', inner: this.normalizeType(type.inner) }
+    }
+    if (type.kind === 'tuple') {
+      return { kind: 'tuple', elements: type.elements.map(e => this.normalizeType(e)) }
+    }
     if (type.kind === 'function_type') {
       return {
         kind: 'function_type',

package/src/types/mc-version.ts

@@ -0,0 +1,46 @@
+/**
+ * Minecraft version target enumeration.
+ *
+ * Encoded as: major * 1000 + minor (patch is ignored for feature gating).
+ * e.g., 1.20.2 → 20002, 1.21 → 21000, 1.21.4 → 21004
+ */
+
+export enum McVersion {
+  v1_19   = 19000,
+  v1_20   = 20000,
+  v1_20_2 = 20002,
+  v1_20_4 = 20004,
+  v1_21   = 21000,
+  v1_21_4 = 21004,
+}
+
+/**
+ * Parse a version string like "1.20.2" or "1.21" into a McVersion number.
+ * Throws if the string is not a valid Minecraft version.
+ */
+export function parseMcVersion(s: string): McVersion {
+  const parts = s.trim().split('.')
+  if (parts.length < 2 || parts.length > 3) {
+    throw new Error(`Invalid MC version: "${s}" — expected format "1.20" or "1.20.2"`)
+  }
+  const [majorStr, minorStr, patchStr = '0'] = parts
+  const major = parseInt(majorStr, 10)
+  const minor = parseInt(minorStr, 10)
+  const patch = parseInt(patchStr, 10)
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    throw new Error(`Invalid MC version: "${s}" — non-numeric component`)
+  }
+  if (major !== 1) {
+    throw new Error(`Invalid MC version: "${s}" — only Minecraft 1.x is supported`)
+  }
+  return minor * 1000 + patch as McVersion
+}
+
+/**
+ * Compare two McVersion values. Returns negative if a < b, 0 if equal, positive if a > b.
+ */
+export function compareMcVersion(a: McVersion, b: McVersion): number {
+  return a - b
+}
+
+export const DEFAULT_MC_VERSION = McVersion.v1_21

package/tsconfig.json

@@ -4,7 +4,7 @@
     "module": "commonjs",
     "lib": ["ES2021"],
     "outDir": "dist",
-    "rootDir": "src",
+    "rootDir": ".",
     "declaration": true,
     "sourceMap": true,
     "strict": true,