redscript-mc 1.1.0 → 1.2.0

package/src/lowering/index.ts

@@ -9,11 +9,14 @@ import type { IRBuilder } from '../ir/builder'
 import { buildModule } from '../ir/builder'
 import type { IRFunction, IRModule, Operand, BinOp, CmpOp } from '../ir/types'
 import { DiagnosticError } from '../diagnostics'
+import type { SourceRange } from '../compile'
 import type {
   Block, ConstDecl, Decorator, EntitySelector, Expr, FnDecl, GlobalDecl, Program, RangeExpr, Span, Stmt,
-  StructDecl, TypeNode, ExecuteSubcommand, BlockPosExpr, CoordComponent
+  StructDecl, TypeNode, ExecuteSubcommand, BlockPosExpr, CoordComponent, EntityTypeName
 } from '../ast/types'
 import type { GlobalVar } from '../ir/types'
+import * as path from 'path'
+import { EVENT_TYPES, getEventParamSpecs, isEventTypeName } from '../events/types'
 
 // ---------------------------------------------------------------------------
 // Builtin Functions
@@ -88,6 +91,9 @@ const BUILTINS: Record<string, (args: string[]) => string | null> = {
   set_contains: () => null, // Special handling (returns 1/0)
   set_remove: () => null, // Special handling
   set_clear: () => null, // Special handling
+  setTimeout: () => null, // Special handling
+  setInterval: () => null, // Special handling
+  clearInterval: () => null, // Special handling
 }
 
 export interface Warning {
@@ -97,6 +103,12 @@ export interface Warning {
   col?: number
 }
 
+interface StdlibCallSiteContext {
+  filePath?: string
+  line: number
+  col: number
+}
+
 function getSpan(node: unknown): Span | undefined {
   return (node as { span?: Span } | undefined)?.span
 }
@@ -104,6 +116,23 @@ function getSpan(node: unknown): Span | undefined {
 const NAMESPACED_ENTITY_TYPE_RE = /^[a-z0-9_.-]+:[a-z0-9_./-]+$/
 const BARE_ENTITY_TYPE_RE = /^[a-z0-9_./-]+$/
 
+const ENTITY_TO_MC_TYPE: Partial<Record<EntityTypeName, string>> = {
+  Player: 'player',
+  Zombie: 'zombie',
+  Skeleton: 'skeleton',
+  Creeper: 'creeper',
+  Spider: 'spider',
+  Enderman: 'enderman',
+  Pig: 'pig',
+  Cow: 'cow',
+  Sheep: 'sheep',
+  Chicken: 'chicken',
+  Villager: 'villager',
+  ArmorStand: 'armor_stand',
+  Item: 'item',
+  Arrow: 'arrow',
+}
+
 function normalizeSelector(selector: string, warnings: Warning[]): string {
   return selector.replace(/type=([^,\]]+)/g, (match, entityType) => {
     const trimmed = entityType.trim()
@@ -156,20 +185,27 @@ function emitBlockPos(pos: BlockPosExpr): string {
 
 export class Lowering {
   private namespace: string
+  private readonly sourceRanges: SourceRange[]
   private functions: IRFunction[] = []
   private globals: GlobalVar[] = []
   private globalNames: Map<string, { mutable: boolean }> = new Map()
   private fnDecls: Map<string, FnDecl> = new Map()
+  private implMethods: Map<string, Map<string, { fn: FnDecl; loweredName: string }>> = new Map()
   private specializedFunctions: Map<string, string> = new Map()
   private currentFn: string = ''
+  private currentStdlibCallSite?: StdlibCallSiteContext
   private foreachCounter: number = 0
   private lambdaCounter: number = 0
+  private timeoutCounter: number = 0
+  private intervalCounter: number = 0
   readonly warnings: Warning[] = []
 
   // Builder state for current function
   private builder!: LoweringBuilder
   private varMap: Map<string, string> = new Map()
   private lambdaBindings: Map<string, string> = new Map()
+  private intervalBindings: Map<string, string> = new Map()
+  private intervalFunctions: Map<number, string> = new Map()
   private currentCallbackBindings: Map<string, string> = new Map()
   private currentContext: { binding?: string } = {}
   private blockPosVars: Map<string, BlockPosExpr> = new Map()
@@ -187,8 +223,9 @@ export class Lowering {
   // World object counter for unique tags
   private worldObjCounter: number = 0
 
-  constructor(namespace: string) {
+  constructor(namespace: string, sourceRanges: SourceRange[] = []) {
     this.namespace = namespace
+    this.sourceRanges = sourceRanges
     LoweringBuilder.resetTempCounter()
   }
 
@@ -230,10 +267,31 @@ export class Lowering {
       this.functionDefaults.set(fn.name, fn.params.map(param => param.default))
     }
 
+    for (const implBlock of program.implBlocks ?? []) {
+      let methods = this.implMethods.get(implBlock.typeName)
+      if (!methods) {
+        methods = new Map()
+        this.implMethods.set(implBlock.typeName, methods)
+      }
+
+      for (const method of implBlock.methods) {
+        const loweredName = `${implBlock.typeName}_${method.name}`
+        methods.set(method.name, { fn: method, loweredName })
+        this.fnDecls.set(loweredName, method)
+        this.functionDefaults.set(loweredName, method.params.map(param => param.default))
+      }
+    }
+
     for (const fn of program.declarations) {
       this.lowerFn(fn)
     }
 
+    for (const implBlock of program.implBlocks ?? []) {
+      for (const method of implBlock.methods) {
+        this.lowerFn(method, { name: `${implBlock.typeName}_${method.name}` })
+      }
+    }
+
     return buildModule(this.namespace, this.functions, this.globals)
   }
 
@@ -246,16 +304,25 @@ export class Lowering {
     options: {
       name?: string
       callbackBindings?: Map<string, string>
+      stdlibCallSite?: StdlibCallSiteContext
     } = {}
   ): void {
     const loweredName = options.name ?? fn.name
     const callbackBindings = options.callbackBindings ?? new Map<string, string>()
-    const runtimeParams = fn.params.filter(param => !callbackBindings.has(param.name))
+    const stdlibCallSite = options.stdlibCallSite
+    const staticEventDec = fn.decorators.find(d => d.name === 'on')
+    const eventType = staticEventDec?.args?.eventType
+    const eventParamSpecs = eventType && isEventTypeName(eventType) ? getEventParamSpecs(eventType) : []
+    const runtimeParams = staticEventDec
+      ? []
+      : fn.params.filter(param => !callbackBindings.has(param.name))
 
     this.currentFn = loweredName
+    this.currentStdlibCallSite = stdlibCallSite
     this.foreachCounter = 0
     this.varMap = new Map()
     this.lambdaBindings = new Map()
+    this.intervalBindings = new Map()
     this.currentCallbackBindings = new Map(callbackBindings)
     this.currentContext = {}
     this.blockPosVars = new Map()
@@ -263,10 +330,31 @@ export class Lowering {
     this.builder = new LoweringBuilder()
 
     // Map parameters
-    for (const param of runtimeParams) {
-      const paramName = param.name
-      this.varMap.set(paramName, `$${paramName}`)
-      this.varTypes.set(paramName, this.normalizeType(param.type))
+    if (staticEventDec) {
+      for (let i = 0; i < fn.params.length; i++) {
+        const param = fn.params[i]
+        const expected = eventParamSpecs[i]
+        const normalizedType = this.normalizeType(param.type)
+        this.varTypes.set(param.name, normalizedType)
+
+        if (expected?.type.kind === 'entity') {
+          this.varMap.set(param.name, '@s')
+          continue
+        }
+
+        if (expected?.type.kind === 'named' && expected.type.name === 'string') {
+          this.stringValues.set(param.name, '')
+          continue
+        }
+
+        this.varMap.set(param.name, `$${param.name}`)
+      }
+    } else {
+      for (const param of runtimeParams) {
+        const paramName = param.name
+        this.varMap.set(paramName, `$${paramName}`)
+        this.varTypes.set(paramName, this.normalizeType(param.type))
+      }
     }
     for (const param of fn.params) {
       if (callbackBindings.has(param.name)) {
@@ -284,6 +372,16 @@ export class Lowering {
       this.builder.emitAssign(varName, { kind: 'var', name: `$p${i}` })
     }
 
+    if (staticEventDec) {
+      for (let i = 0; i < fn.params.length; i++) {
+        const param = fn.params[i]
+        const expected = eventParamSpecs[i]
+        if (expected?.type.kind === 'named' && expected.type.name !== 'string') {
+          this.builder.emitAssign(`$${param.name}`, { kind: 'const', value: 0 })
+        }
+      }
+    }
+
     // Lower body
     this.lowerBlock(fn.body)
 
@@ -336,6 +434,13 @@ export class Lowering {
       }
     }
 
+    if (eventType && isEventTypeName(eventType)) {
+      irFn.eventHandler = {
+        eventType,
+        tag: EVENT_TYPES[eventType].tag,
+      }
+    }
+
     // Check for @load decorator
     if (fn.decorators.some(d => d.name === 'load')) {
       irFn.isLoadInit = true
@@ -489,6 +594,16 @@ export class Lowering {
       return
     }
 
+    if (stmt.init.kind === 'call' && stmt.init.fn === 'setInterval') {
+      const value = this.lowerExpr(stmt.init)
+      const intervalFn = this.intervalFunctions.get(value.kind === 'const' ? value.value : NaN)
+      if (intervalFn) {
+        this.intervalBindings.set(stmt.name, intervalFn)
+      }
+      this.builder.emitAssign(varName, value)
+      return
+    }
+
     // Handle struct literal initialization
     if (stmt.init.kind === 'struct_lit' && stmt.type?.kind === 'struct') {
       const structName = stmt.type.name.toLowerCase()
@@ -567,6 +682,11 @@ export class Lowering {
   }
 
   private lowerIfStmt(stmt: Extract<Stmt, { kind: 'if' }>): void {
+    if (stmt.cond.kind === 'is_check') {
+      this.lowerIsCheckIfStmt(stmt)
+      return
+    }
+
     const condVar = this.lowerExpr(stmt.cond)
     const condName = this.operandToVar(condVar)
 
@@ -596,6 +716,66 @@ export class Lowering {
     this.builder.startBlock(mergeLabel)
   }
 
+  private lowerIsCheckIfStmt(stmt: Extract<Stmt, { kind: 'if' }>): void {
+    const cond = stmt.cond
+    if (cond.kind !== 'is_check') {
+      throw new DiagnosticError(
+        'LoweringError',
+        "Internal error: expected 'is' check condition",
+        stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+
+    if (stmt.else_) {
+      throw new DiagnosticError(
+        'LoweringError',
+        "'is' checks with else branches are not yet supported",
+        cond.span ?? stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+
+    const selector = this.exprToEntitySelector(cond.expr)
+    if (!selector) {
+      throw new DiagnosticError(
+        'LoweringError',
+        "'is' checks require an entity selector or entity binding",
+        cond.span ?? stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+
+    const mcType = ENTITY_TO_MC_TYPE[cond.entityType]
+    if (!mcType) {
+      throw new DiagnosticError(
+        'LoweringError',
+        `Cannot lower entity type check for '${cond.entityType}'`,
+        cond.span ?? stmt.span ?? { line: 0, col: 0 }
+      )
+    }
+
+    const thenFnName = `${this.currentFn}/then_${this.foreachCounter++}`
+    this.builder.emitRaw(`execute if entity ${this.appendTypeFilter(selector, mcType)} run function ${this.namespace}:${thenFnName}`)
+
+    const savedBuilder = this.builder
+    const savedVarMap = new Map(this.varMap)
+    const savedBlockPosVars = new Map(this.blockPosVars)
+
+    this.builder = new LoweringBuilder()
+    this.varMap = new Map(savedVarMap)
+    this.blockPosVars = new Map(savedBlockPosVars)
+
+    this.builder.startBlock('entry')
+    this.lowerBlock(stmt.then)
+    if (!this.builder.isBlockSealed()) {
+      this.builder.emitReturn()
+    }
+
+    this.functions.push(this.builder.build(thenFnName, [], false))
+
+    this.builder = savedBuilder
+    this.varMap = savedVarMap
+    this.blockPosVars = savedBlockPosVars
+  }
+
   private lowerWhileStmt(stmt: Extract<Stmt, { kind: 'while' }>): void {
     const checkLabel = this.builder.freshLabel('loop_check')
     const bodyLabel = this.builder.freshLabel('loop_body')
@@ -1098,6 +1278,13 @@ export class Lowering {
       case 'binary':
         return this.lowerBinaryExpr(expr)
 
+      case 'is_check':
+        throw new DiagnosticError(
+          'LoweringError',
+          "'is' checks are only supported as if conditions",
+          expr.span ?? { line: 0, col: 0 }
+        )
+
       case 'unary':
         return this.lowerUnaryExpr(expr)
 
@@ -1107,6 +1294,9 @@ export class Lowering {
       case 'call':
         return this.lowerCallExpr(expr)
 
+      case 'static_call':
+        return this.lowerStaticCallExpr(expr)
+
       case 'invoke':
         return this.lowerInvokeExpr(expr)
 
@@ -1454,6 +1644,11 @@ export class Lowering {
       return this.emitDirectFunctionCall(callbackTarget, expr.args)
     }
 
+    const implMethod = this.resolveInstanceMethod(expr)
+    if (implMethod) {
+      return this.emitMethodCall(implMethod.loweredName, implMethod.fn, expr.args)
+    }
+
     // Regular function call
     const fnDecl = this.fnDecls.get(expr.fn)
     const defaultArgs = this.functionDefaults.get(expr.fn) ?? []
@@ -1483,8 +1678,9 @@ export class Lowering {
         runtimeArgs.push(fullArgs[i])
       }
 
-      const targetFn = callbackBindings.size > 0
-        ? this.ensureSpecializedFunction(fnDecl, callbackBindings)
+      const stdlibCallSite = this.getStdlibCallSiteContext(fnDecl, getSpan(expr))
+      const targetFn = callbackBindings.size > 0 || stdlibCallSite
+        ? this.ensureSpecializedFunctionWithContext(fnDecl, callbackBindings, stdlibCallSite)
         : expr.fn
       return this.emitDirectFunctionCall(targetFn, runtimeArgs)
     }
@@ -1492,6 +1688,12 @@ export class Lowering {
     return this.emitDirectFunctionCall(expr.fn, fullArgs)
   }
 
+  private lowerStaticCallExpr(expr: Extract<Expr, { kind: 'static_call' }>): Operand {
+    const method = this.implMethods.get(expr.type)?.get(expr.method)
+    const targetFn = method?.loweredName ?? `${expr.type}_${expr.method}`
+    return this.emitMethodCall(targetFn, method?.fn, expr.args)
+  }
+
   private lowerInvokeExpr(expr: Extract<Expr, { kind: 'invoke' }>): Operand {
     if (expr.callee.kind === 'lambda') {
       if (!Array.isArray(expr.callee.body)) {
@@ -1543,6 +1745,19 @@ export class Lowering {
     return { kind: 'var', name: dst }
   }
 
+  private emitMethodCall(fn: string, fnDecl: FnDecl | undefined, args: Expr[]): Operand {
+    const defaultArgs = this.functionDefaults.get(fn) ?? fnDecl?.params.map(param => param.default) ?? []
+    const fullArgs = [...args]
+    for (let i = fullArgs.length; i < defaultArgs.length; i++) {
+      const defaultExpr = defaultArgs[i]
+      if (!defaultExpr) {
+        break
+      }
+      fullArgs.push(defaultExpr)
+    }
+    return this.emitDirectFunctionCall(fn, fullArgs)
+  }
+
   private resolveFunctionRefExpr(expr: Expr): string | null {
     if (expr.kind === 'lambda') {
       return this.lowerLambdaExpr(expr)
@@ -1558,9 +1773,21 @@ export class Lowering {
   }
 
   private ensureSpecializedFunction(fn: FnDecl, callbackBindings: Map<string, string>): string {
+    return this.ensureSpecializedFunctionWithContext(fn, callbackBindings)
+  }
+
+  private ensureSpecializedFunctionWithContext(
+    fn: FnDecl,
+    callbackBindings: Map<string, string>,
+    stdlibCallSite?: StdlibCallSiteContext
+  ): string {
     const parts = [...callbackBindings.entries()]
       .sort(([left], [right]) => left.localeCompare(right))
       .map(([param, target]) => `${param}_${target.replace(/[^a-zA-Z0-9_]/g, '_')}`)
+    const callSiteHash = stdlibCallSite ? this.shortHash(this.serializeCallSite(stdlibCallSite)) : null
+    if (callSiteHash) {
+      parts.push(`callsite_${callSiteHash}`)
+    }
     const key = `${fn.name}::${parts.join('::')}`
     const cached = this.specializedFunctions.get(key)
     if (cached) {
@@ -1570,7 +1797,7 @@ export class Lowering {
     const specializedName = `${fn.name}__${parts.join('__')}`
     this.specializedFunctions.set(key, specializedName)
     this.withSavedFunctionState(() => {
-      this.lowerFn(fn, { name: specializedName, callbackBindings })
+      this.lowerFn(fn, { name: specializedName, callbackBindings, stdlibCallSite })
     })
     return specializedName
   }
@@ -1595,10 +1822,12 @@ export class Lowering {
 
   private withSavedFunctionState<T>(callback: () => T): T {
     const savedCurrentFn = this.currentFn
+    const savedStdlibCallSite = this.currentStdlibCallSite
     const savedForeachCounter = this.foreachCounter
     const savedBuilder = this.builder
     const savedVarMap = new Map(this.varMap)
     const savedLambdaBindings = new Map(this.lambdaBindings)
+    const savedIntervalBindings = new Map(this.intervalBindings)
     const savedCallbackBindings = new Map(this.currentCallbackBindings)
     const savedContext = this.currentContext
     const savedBlockPosVars = new Map(this.blockPosVars)
@@ -1609,10 +1838,12 @@ export class Lowering {
       return callback()
     } finally {
       this.currentFn = savedCurrentFn
+      this.currentStdlibCallSite = savedStdlibCallSite
       this.foreachCounter = savedForeachCounter
       this.builder = savedBuilder
       this.varMap = savedVarMap
       this.lambdaBindings = savedLambdaBindings
+      this.intervalBindings = savedIntervalBindings
       this.currentCallbackBindings = savedCallbackBindings
       this.currentContext = savedContext
       this.blockPosVars = savedBlockPosVars
@@ -1628,6 +1859,18 @@ export class Lowering {
       return { kind: 'const', value: 0 }
     }
 
+    if (name === 'setTimeout') {
+      return this.lowerSetTimeout(args)
+    }
+
+    if (name === 'setInterval') {
+      return this.lowerSetInterval(args)
+    }
+
+    if (name === 'clearInterval') {
+      return this.lowerClearInterval(args, callSpan)
+    }
+
     // Special case: random - legacy scoreboard RNG for pre-1.20.3 compatibility
     if (name === 'random') {
       const dst = this.builder.freshTemp()
@@ -1658,7 +1901,7 @@ export class Lowering {
     if (name === 'scoreboard_get' || name === 'score') {
       const dst = this.builder.freshTemp()
       const player = this.exprToTargetString(args[0])
-      const objective = this.exprToString(args[1])
+      const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan)
       this.builder.emitRaw(`execute store result score ${dst} rs run scoreboard players get ${player} ${objective}`)
       return { kind: 'var', name: dst }
     }
@@ -1666,7 +1909,7 @@ export class Lowering {
     // Special case: scoreboard_set — write to vanilla MC scoreboard
     if (name === 'scoreboard_set') {
       const player = this.exprToTargetString(args[0])
-      const objective = this.exprToString(args[1])
+      const objective = this.resolveScoreboardObjective(args[0], args[1], callSpan)
       const value = this.lowerExpr(args[2])
       if (value.kind === 'const') {
         this.builder.emitRaw(`scoreboard players set ${player} ${objective} ${value.value}`)
@@ -1680,7 +1923,7 @@ export class Lowering {
 
     if (name === 'scoreboard_display') {
       const slot = this.exprToString(args[0])
-      const objective = this.exprToString(args[1])
+      const objective = this.resolveScoreboardObjective(undefined, args[1], callSpan)
       this.builder.emitRaw(`scoreboard objectives setdisplay ${slot} ${objective}`)
       return { kind: 'const', value: 0 }
     }
@@ -1692,7 +1935,7 @@ export class Lowering {
     }
 
     if (name === 'scoreboard_add_objective') {
-      const objective = this.exprToString(args[0])
+      const objective = this.resolveScoreboardObjective(undefined, args[0], callSpan)
       const criteria = this.exprToString(args[1])
       const displayName = args[2] ? ` ${this.exprToQuotedString(args[2])}` : ''
       this.builder.emitRaw(`scoreboard objectives add ${objective} ${criteria}${displayName}`)
@@ -1700,7 +1943,7 @@ export class Lowering {
     }
 
     if (name === 'scoreboard_remove_objective') {
-      const objective = this.exprToString(args[0])
+      const objective = this.resolveScoreboardObjective(undefined, args[0], callSpan)
       this.builder.emitRaw(`scoreboard objectives remove ${objective}`)
       return { kind: 'const', value: 0 }
     }
@@ -1902,6 +2145,119 @@ export class Lowering {
     return { kind: 'const', value: 0 }
   }
 
+  private lowerSetTimeout(args: Expr[]): Operand {
+    const delay = this.exprToLiteral(args[0])
+    const callback = args[1]
+    if (!callback || callback.kind !== 'lambda') {
+      throw new DiagnosticError(
+        'LoweringError',
+        'setTimeout requires a lambda callback',
+        getSpan(callback) ?? { line: 1, col: 1 }
+      )
+    }
+
+    const fnName = `__timeout_${this.timeoutCounter++}`
+    this.lowerNamedLambdaFunction(fnName, callback)
+    this.builder.emitRaw(`schedule function ${this.namespace}:${fnName} ${delay}t`)
+    return { kind: 'const', value: 0 }
+  }
+
+  private lowerSetInterval(args: Expr[]): Operand {
+    const delay = this.exprToLiteral(args[0])
+    const callback = args[1]
+    if (!callback || callback.kind !== 'lambda') {
+      throw new DiagnosticError(
+        'LoweringError',
+        'setInterval requires a lambda callback',
+        getSpan(callback) ?? { line: 1, col: 1 }
+      )
+    }
+
+    const id = this.intervalCounter++
+    const bodyName = `__interval_body_${id}`
+    const fnName = `__interval_${id}`
+
+    this.lowerNamedLambdaFunction(bodyName, callback)
+    this.lowerIntervalWrapperFunction(fnName, bodyName, delay)
+    this.intervalFunctions.set(id, fnName)
+    this.builder.emitRaw(`schedule function ${this.namespace}:${fnName} ${delay}t`)
+
+    return { kind: 'const', value: id }
+  }
+
+  private lowerClearInterval(args: Expr[], callSpan?: Span): Operand {
+    const fnName = this.resolveIntervalFunctionName(args[0])
+    if (!fnName) {
+      throw new DiagnosticError(
+        'LoweringError',
+        'clearInterval requires an interval ID returned from setInterval',
+        callSpan ?? getSpan(args[0]) ?? { line: 1, col: 1 }
+      )
+    }
+
+    this.builder.emitRaw(`schedule clear ${this.namespace}:${fnName}`)
+    return { kind: 'const', value: 0 }
+  }
+
+  private lowerNamedLambdaFunction(name: string, expr: Extract<Expr, { kind: 'lambda' }>): void {
+    const lambdaFn: FnDecl = {
+      name,
+      params: expr.params.map(param => ({
+        name: param.name,
+        type: param.type ?? { kind: 'named', name: 'int' },
+      })),
+      returnType: expr.returnType ?? this.inferLambdaReturnType(expr),
+      decorators: [],
+      body: Array.isArray(expr.body) ? expr.body : [{ kind: 'return', value: expr.body }],
+    }
+
+    this.withSavedFunctionState(() => {
+      this.lowerFn(lambdaFn)
+    })
+  }
+
+  private lowerIntervalWrapperFunction(name: string, bodyName: string, delay: string): void {
+    const intervalFn: FnDecl = {
+      name,
+      params: [],
+      returnType: { kind: 'named', name: 'void' },
+      decorators: [],
+      body: [
+        { kind: 'raw', cmd: `function ${this.namespace}:${bodyName}` },
+        { kind: 'raw', cmd: `schedule function ${this.namespace}:${name} ${delay}t` },
+      ],
+    }
+
+    this.withSavedFunctionState(() => {
+      this.lowerFn(intervalFn)
+    })
+  }
+
+  private resolveIntervalFunctionName(expr: Expr | undefined): string | null {
+    if (!expr) {
+      return null
+    }
+
+    if (expr.kind === 'ident') {
+      const boundInterval = this.intervalBindings.get(expr.name)
+      if (boundInterval) {
+        return boundInterval
+      }
+
+      const constValue = this.constValues.get(expr.name)
+      if (constValue?.kind === 'int_lit') {
+        return this.intervalFunctions.get(constValue.value) ?? null
+      }
+      return null
+    }
+
+    if (expr.kind === 'int_lit') {
+      return this.intervalFunctions.get(expr.value) ?? null
+    }
+
+    return null
+  }
+
   private lowerRichTextBuiltin(name: string, args: Expr[]): string | null {
     const messageArgIndex = this.getRichTextArgIndex(name)
     if (messageArgIndex === null) {
@@ -2078,6 +2434,32 @@ export class Lowering {
     }
   }
 
+  private exprToEntitySelector(expr: Expr): string | null {
+    if (expr.kind === 'selector') {
+      return this.selectorToString(expr.sel)
+    }
+
+    if (expr.kind === 'ident') {
+      const constValue = this.constValues.get(expr.name)
+      if (constValue) {
+        return this.exprToEntitySelector(constValue)
+      }
+      const mapped = this.varMap.get(expr.name)
+      if (mapped?.startsWith('@')) {
+        return mapped
+      }
+    }
+
+    return null
+  }
+
+  private appendTypeFilter(selector: string, mcType: string): string {
+    if (selector.endsWith(']')) {
+      return `${selector.slice(0, -1)},type=${mcType}]`
+    }
+    return `${selector}[type=${mcType}]`
+  }
+
   private exprToSnbt(expr: Expr): string {
     switch (expr.kind) {
       case 'struct_lit': {
@@ -2152,6 +2534,113 @@ export class Lowering {
     return option === 'displayName' || option === 'prefix' || option === 'suffix'
   }
 
+  private exprToScoreboardObjective(expr: Expr, span?: Span): string {
+    if (expr.kind === 'mc_name') {
+      return expr.value
+    }
+
+    const objective = this.exprToString(expr)
+    if (objective.startsWith('#') || objective.includes('.')) {
+      return objective.startsWith('#') ? objective.slice(1) : objective
+    }
+
+    return `${this.getObjectiveNamespace(span)}.${objective}`
+  }
+
+  private resolveScoreboardObjective(playerExpr: Expr | undefined, objectiveExpr: Expr, span?: Span): string {
+    const stdlibInternalObjective = this.tryGetStdlibInternalObjective(playerExpr, objectiveExpr, span)
+    if (stdlibInternalObjective) {
+      return stdlibInternalObjective
+    }
+    return this.exprToScoreboardObjective(objectiveExpr, span)
+  }
+
+  private getObjectiveNamespace(span?: Span): string {
+    const filePath = this.filePathForSpan(span)
+    if (!filePath) {
+      return this.namespace
+    }
+
+    return this.isStdlibFile(filePath) ? 'rs' : this.namespace
+  }
+
+  private tryGetStdlibInternalObjective(playerExpr: Expr | undefined, objectiveExpr: Expr, span?: Span): string | null {
+    if (!span || !this.currentStdlibCallSite || objectiveExpr.kind !== 'mc_name' || objectiveExpr.value !== 'rs') {
+      return null
+    }
+
+    const filePath = this.filePathForSpan(span)
+    if (!filePath || !this.isStdlibFile(filePath)) {
+      return null
+    }
+
+    const resourceBase = this.getStdlibInternalResourceBase(playerExpr)
+    if (!resourceBase) {
+      return null
+    }
+
+    const hash = this.shortHash(this.serializeCallSite(this.currentStdlibCallSite))
+    return `rs._${resourceBase}_${hash}`
+  }
+
+  private getStdlibInternalResourceBase(playerExpr: Expr | undefined): string | null {
+    if (!playerExpr || playerExpr.kind !== 'str_lit') {
+      return null
+    }
+
+    const match = playerExpr.value.match(/^([a-z0-9]+)_/)
+    return match?.[1] ?? null
+  }
+
+  private getStdlibCallSiteContext(fn: FnDecl, exprSpan?: Span): StdlibCallSiteContext | undefined {
+    const fnFilePath = this.filePathForSpan(getSpan(fn))
+    if (!fnFilePath || !this.isStdlibFile(fnFilePath)) {
+      return undefined
+    }
+
+    if (this.currentStdlibCallSite) {
+      return this.currentStdlibCallSite
+    }
+
+    if (!exprSpan) {
+      return undefined
+    }
+
+    return {
+      filePath: this.filePathForSpan(exprSpan),
+      line: exprSpan.line,
+      col: exprSpan.col,
+    }
+  }
+
+  private serializeCallSite(callSite: StdlibCallSiteContext): string {
+    return `${callSite.filePath ?? '<memory>'}:${callSite.line}:${callSite.col}`
+  }
+
+  private shortHash(input: string): string {
+    let hash = 2166136261
+    for (let i = 0; i < input.length; i++) {
+      hash ^= input.charCodeAt(i)
+      hash = Math.imul(hash, 16777619)
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0').slice(0, 4)
+  }
+
+  private isStdlibFile(filePath: string): boolean {
+    const normalized = path.normalize(filePath)
+    const stdlibSegment = `${path.sep}src${path.sep}stdlib${path.sep}`
+    return normalized.includes(stdlibSegment)
+  }
+
+  private filePathForSpan(span?: Span): string | undefined {
+    if (!span) {
+      return undefined
+    }
+
+    const line = span.line
+    return this.sourceRanges.find(range => line >= range.startLine && line <= range.endLine)?.filePath
+  }
+
   private lowerCoordinateBuiltin(name: string, args: Expr[]): string | null {
     const pos0 = args[0] ? this.resolveBlockPosExpr(args[0]) : null
     const pos1 = args[1] ? this.resolveBlockPosExpr(args[1]) : null
@@ -2268,7 +2757,11 @@ export class Lowering {
       }
     }
     if (expr.kind === 'call') {
-      return this.fnDecls.get(this.resolveFunctionRefByName(expr.fn) ?? expr.fn)?.returnType
+      const resolved = this.resolveFunctionRefByName(expr.fn) ?? this.resolveInstanceMethod(expr)?.loweredName ?? expr.fn
+      return this.fnDecls.get(resolved)?.returnType
+    }
+    if (expr.kind === 'static_call') {
+      return this.implMethods.get(expr.type)?.get(expr.method)?.fn.returnType
     }
     if (expr.kind === 'invoke') {
       const calleeType = this.inferExprType(expr.callee)
@@ -2297,6 +2790,25 @@ export class Lowering {
     return undefined
   }
 
+  private resolveInstanceMethod(expr: Extract<Expr, { kind: 'call' }>): { fn: FnDecl; loweredName: string } | null {
+    const receiver = expr.args[0]
+    if (!receiver) {
+      return null
+    }
+
+    const receiverType = this.inferExprType(receiver)
+    if (receiverType?.kind !== 'struct') {
+      return null
+    }
+
+    const method = this.implMethods.get(receiverType.name)?.get(expr.fn)
+    if (!method || method.fn.params[0]?.name !== 'self') {
+      return null
+    }
+
+    return method
+  }
+
   private normalizeType(type: TypeNode): TypeNode {
     if (type.kind === 'array') {
       return { kind: 'array', elem: this.normalizeType(type.elem) }