redscript-mc 1.1.0 → 1.2.1

package/src/codegen/mcfunction/index.ts

@@ -18,6 +18,7 @@
 
 import type { IRBlock, IRFunction, IRModule, Operand, Terminator } from '../../ir/types'
 import { optimizeCommandFunctions, type OptimizationStats, createEmptyOptimizationStats, mergeOptimizationStats } from '../../optimizer/commands'
+import { EVENT_TYPES, isEventTypeName, type EventTypeName } from '../../events/types'
 
 // ---------------------------------------------------------------------------
 // Utilities
@@ -270,6 +271,10 @@ export function generateDatapackWithStats(
   // Collect all trigger handlers
   const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName)
   const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName!))
+  const eventHandlers = module.functions.filter((fn): fn is IRFunction & { eventHandler: { eventType: EventTypeName; tag: string } } =>
+    !!fn.eventHandler && isEventTypeName(fn.eventHandler.eventType)
+  )
+  const eventTypes = new Set<EventTypeName>(eventHandlers.map(fn => fn.eventHandler.eventType))
 
   // Collect all tick functions
   const tickFunctionNames: string[] = []
@@ -302,6 +307,19 @@ export function generateDatapackWithStats(
     loadLines.push(`scoreboard players enable @a ${triggerName}`)
   }
 
+  for (const eventType of eventTypes) {
+    const detection = EVENT_TYPES[eventType].detection
+    if (eventType === 'PlayerDeath') {
+      loadLines.push('scoreboard objectives add rs.deaths deathCount')
+    } else if (eventType === 'EntityKill') {
+      loadLines.push('scoreboard objectives add rs.kills totalKillCount')
+    } else if (eventType === 'ItemUse') {
+      loadLines.push('# ItemUse detection requires a project-specific objective/tag setup')
+    } else if (detection === 'tag' || detection === 'advancement') {
+      loadLines.push(`# ${eventType} detection expects tag ${EVENT_TYPES[eventType].tag} to be set externally`)
+    }
+  }
+
   // Generate trigger dispatch functions
   for (const triggerName of triggerNames) {
     const handlers = triggerHandlers.filter(fn => fn.triggerName === triggerName)
@@ -391,8 +409,20 @@ export function generateDatapackWithStats(
     }
   }
 
+  if (eventHandlers.length > 0) {
+    tickLines.push('# Event checks')
+    for (const eventType of eventTypes) {
+      const tag = EVENT_TYPES[eventType].tag
+      const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType)
+      for (const handler of handlers) {
+        tickLines.push(`execute as @a[tag=${tag}] run function ${ns}:${handler.name}`)
+      }
+      tickLines.push(`tag @a[tag=${tag}] remove ${tag}`)
+    }
+  }
+
   // Only generate __tick if there's something to run
-  if (tickFunctionNames.length > 0 || triggerNames.size > 0) {
+  if (tickFunctionNames.length > 0 || triggerNames.size > 0 || eventHandlers.length > 0) {
     files.push({
       path: `data/${ns}/function/__tick.mcfunction`,
       content: tickLines.join('\n'),

package/src/codegen/structure/index.ts

@@ -5,9 +5,11 @@ import { nbt, TagType, writeNbt, type CompoundTag, type NbtTag } from '../../nbt
 import { createEmptyOptimizationStats, mergeOptimizationStats, type OptimizationStats } from '../../optimizer/commands'
 import { optimizeWithStats } from '../../optimizer/passes'
 import { optimizeForStructure, optimizeForStructureWithStats } from '../../optimizer/structure'
+import { eliminateDeadCode } from '../../optimizer/dce'
 import { preprocessSource } from '../../compile'
 import type { IRCommand, IRFunction, IRModule } from '../../ir/types'
 import type { DatapackFile } from '../mcfunction'
+import { EVENT_TYPES, isEventTypeName, type EventTypeName } from '../../events/types'
 
 const DATA_VERSION = 3953
 const MAX_WIDTH = 16
@@ -50,6 +52,10 @@ export interface StructureCompileResult {
   stats?: OptimizationStats
 }
 
+export interface StructureCompileOptions {
+  dce?: boolean
+}
+
 function escapeJsonString(value: string): string {
   return JSON.stringify(value).slice(1, -1)
 }
@@ -87,6 +93,10 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
   const entries: CommandEntry[] = []
   const triggerHandlers = module.functions.filter(fn => fn.isTriggerHandler && fn.triggerName)
   const triggerNames = new Set(triggerHandlers.map(fn => fn.triggerName!))
+  const eventHandlers = module.functions.filter((fn): fn is IRFunction & { eventHandler: { eventType: EventTypeName; tag: string } } =>
+    !!fn.eventHandler && isEventTypeName(fn.eventHandler.eventType)
+  )
+  const eventTypes = new Set<EventTypeName>(eventHandlers.map(fn => fn.eventHandler.eventType))
   const loadCommands = [
     `scoreboard objectives add ${OBJ} dummy`,
     ...module.globals.map(g => `scoreboard players set ${varRef(g.name)} ${OBJ} ${g.init}`),
@@ -99,6 +109,14 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
     ).map(constSetup),
   ]
 
+  for (const eventType of eventTypes) {
+    if (eventType === 'PlayerDeath') {
+      loadCommands.push('scoreboard objectives add rs.deaths deathCount')
+    } else if (eventType === 'EntityKill') {
+      loadCommands.push('scoreboard objectives add rs.kills totalKillCount')
+    }
+  }
+
   // Call @load functions from __load
   for (const fn of module.functions) {
     if (fn.isLoadInit) {
@@ -146,6 +164,20 @@ function collectCommandEntriesFromModule(module: IRModule): CommandEntry[] {
       })
     }
   }
+  if (eventHandlers.length > 0) {
+    for (const eventType of eventTypes) {
+      const tag = EVENT_TYPES[eventType].tag
+      const handlers = eventHandlers.filter(fn => fn.eventHandler?.eventType === eventType)
+      for (const handler of handlers) {
+        tickCommands.push({
+          cmd: `execute as @a[tag=${tag}] run function ${module.namespace}:${handler.name}`,
+        })
+      }
+      tickCommands.push({
+        cmd: `tag @a[tag=${tag}] remove ${tag}`,
+      })
+    }
+  }
   if (tickCommands.length > 0) {
     sections.push({
       name: '__tick',
@@ -288,10 +320,16 @@ export function generateStructure(input: IRModule | DatapackFile[]): StructureCo
   }
 }
 
-export function compileToStructure(source: string, namespace: string, filePath?: string): StructureCompileResult {
+export function compileToStructure(
+  source: string,
+  namespace: string,
+  filePath?: string,
+  options: StructureCompileOptions = {}
+): StructureCompileResult {
   const preprocessedSource = preprocessSource(source, { filePath })
   const tokens = new Lexer(preprocessedSource, filePath).tokenize()
-  const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const ast = options.dce ?? true ? eliminateDeadCode(parsedAst) : parsedAst
   const ir = new Lowering(namespace).lower(ast)
   const stats = createEmptyOptimizationStats()
   const optimizedIRFunctions = ir.functions.map(fn => {

package/src/compile.ts

@@ -11,6 +11,7 @@ import { Lexer } from './lexer'
 import { Parser } from './parser'
 import { Lowering } from './lowering'
 import { optimize } from './optimizer/passes'
+import { eliminateDeadCode } from './optimizer/dce'
 import { generateDatapackWithStats, DatapackFile } from './codegen/mcfunction'
 import { DiagnosticError, formatError, parseErrorMessage } from './diagnostics'
 import type { IRModule } from './ir/types'
@@ -24,6 +25,7 @@ export interface CompileOptions {
   namespace?: string
   filePath?: string
   optimize?: boolean
+  dce?: boolean
 }
 
 // ---------------------------------------------------------------------------
@@ -39,6 +41,17 @@ export interface CompileResult {
   error?: DiagnosticError
 }
 
+export interface SourceRange {
+  startLine: number
+  endLine: number
+  filePath: string
+}
+
+export interface PreprocessedSource {
+  source: string
+  ranges: SourceRange[]
+}
+
 const IMPORT_RE = /^\s*import\s+"([^"]+)"\s*;?\s*$/
 
 interface PreprocessOptions {
@@ -46,7 +59,19 @@ interface PreprocessOptions {
   seen?: Set<string>
 }
 
-export function preprocessSource(source: string, options: PreprocessOptions = {}): string {
+function countLines(source: string): number {
+  return source === '' ? 0 : source.split('\n').length
+}
+
+function offsetRanges(ranges: SourceRange[], lineOffset: number): SourceRange[] {
+  return ranges.map(range => ({
+    startLine: range.startLine + lineOffset,
+    endLine: range.endLine + lineOffset,
+    filePath: range.filePath,
+  }))
+}
+
+export function preprocessSourceWithMetadata(source: string, options: PreprocessOptions = {}): PreprocessedSource {
   const { filePath } = options
   const seen = options.seen ?? new Set<string>()
 
@@ -55,7 +80,7 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
   }
 
   const lines = source.split('\n')
-  const imports: string[] = []
+  const imports: PreprocessedSource[] = []
   const bodyLines: string[] = []
   let parsingHeader = true
 
@@ -90,7 +115,7 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
           )
         }
 
-        imports.push(preprocessSource(importedSource, { filePath: importPath, seen }))
+        imports.push(preprocessSourceWithMetadata(importedSource, { filePath: importPath, seen }))
       }
       continue
     }
@@ -104,7 +129,31 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
     bodyLines.push(line)
   }
 
-  return [...imports, bodyLines.join('\n')].filter(Boolean).join('\n')
+  const body = bodyLines.join('\n')
+  const parts = [...imports.map(entry => entry.source), body].filter(Boolean)
+  const combined = parts.join('\n')
+
+  const ranges: SourceRange[] = []
+  let lineOffset = 0
+
+  for (const entry of imports) {
+    ranges.push(...offsetRanges(entry.ranges, lineOffset))
+    lineOffset += countLines(entry.source)
+  }
+
+  if (filePath && body) {
+    ranges.push({
+      startLine: lineOffset + 1,
+      endLine: lineOffset + countLines(body),
+      filePath: path.resolve(filePath),
+    })
+  }
+
+  return { source: combined, ranges }
+}
+
+export function preprocessSource(source: string, options: PreprocessOptions = {}): string {
+  return preprocessSourceWithMetadata(source, options).source
 }
 
 // ---------------------------------------------------------------------------
@@ -113,20 +162,23 @@ export function preprocessSource(source: string, options: PreprocessOptions = {}
 
 export function compile(source: string, options: CompileOptions = {}): CompileResult {
   const { namespace = 'redscript', filePath, optimize: shouldOptimize = true } = options
+  const shouldRunDce = options.dce ?? shouldOptimize
   let sourceLines = source.split('\n')
 
   try {
-    const preprocessedSource = preprocessSource(source, { filePath })
+    const preprocessed = preprocessSourceWithMetadata(source, { filePath })
+    const preprocessedSource = preprocessed.source
     sourceLines = preprocessedSource.split('\n')
 
     // Lexing
     const tokens = new Lexer(preprocessedSource, filePath).tokenize()
 
     // Parsing
-    const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+    const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+    const ast = shouldRunDce ? eliminateDeadCode(parsedAst) : parsedAst
 
     // Lowering
-    const ir = new Lowering(namespace).lower(ast)
+    const ir = new Lowering(namespace, preprocessed.ranges).lower(ast)
 
     // Optimization
     const optimized: IRModule = shouldOptimize

package/src/events/types.ts

@@ -0,0 +1,69 @@
+import type { TypeNode } from '../ast/types'
+
+export const EVENT_TYPES = {
+  PlayerDeath: {
+    tag: 'rs.just_died',
+    params: ['player: Player'],
+    detection: 'scoreboard',
+  },
+  PlayerJoin: {
+    tag: 'rs.just_joined',
+    params: ['player: Player'],
+    detection: 'tag',
+  },
+  BlockBreak: {
+    tag: 'rs.just_broke_block',
+    params: ['player: Player', 'block: string'],
+    detection: 'advancement',
+  },
+  EntityKill: {
+    tag: 'rs.just_killed',
+    params: ['player: Player'],
+    detection: 'scoreboard',
+  },
+  ItemUse: {
+    tag: 'rs.just_used_item',
+    params: ['player: Player'],
+    detection: 'scoreboard',
+  },
+} as const
+
+export type EventTypeName = keyof typeof EVENT_TYPES
+
+export interface EventParamSpec {
+  name: string
+  type: TypeNode
+}
+
+export function isEventTypeName(value: string): value is EventTypeName {
+  return value in EVENT_TYPES
+}
+
+export function getEventParamSpecs(eventType: EventTypeName): EventParamSpec[] {
+  return EVENT_TYPES[eventType].params.map(parseEventParam)
+}
+
+function parseEventParam(spec: string): EventParamSpec {
+  const match = spec.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z_][A-Za-z0-9_]*)$/)
+  if (!match) {
+    throw new Error(`Invalid event parameter spec: ${spec}`)
+  }
+
+  const [, name, typeName] = match
+  return {
+    name,
+    type: toTypeNode(typeName),
+  }
+}
+
+function toTypeNode(typeName: string): TypeNode {
+  if (typeName === 'Player') {
+    return { kind: 'entity', entityType: 'Player' }
+  }
+
+  if (typeName === 'string' || typeName === 'int' || typeName === 'bool' || typeName === 'float' || typeName === 'void' || typeName === 'BlockPos' || typeName === 'byte' || typeName === 'short' || typeName === 'long' || typeName === 'double') {
+    return { kind: 'named', name: typeName }
+  }
+
+  return { kind: 'struct', name: typeName }
+}

package/src/index.ts

@@ -14,12 +14,13 @@ import {
   copyPropagation,
   deadCodeEliminationWithStats,
 } from './optimizer/passes'
+import { eliminateDeadCode } from './optimizer/dce'
 import {
   countMcfunctionCommands,
   generateDatapackWithStats,
   DatapackFile,
 } from './codegen/mcfunction'
-import { preprocessSource } from './compile'
+import { preprocessSource, preprocessSourceWithMetadata } from './compile'
 import type { IRModule } from './ir/types'
 import type { Program } from './ast/types'
 import type { DiagnosticError } from './diagnostics'
@@ -30,6 +31,7 @@ export interface CompileOptions {
   optimize?: boolean
   typeCheck?: boolean
   filePath?: string
+  dce?: boolean
 }
 
 export interface CompileResult {
@@ -53,14 +55,17 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
   const namespace = options.namespace ?? 'redscript'
   const shouldOptimize = options.optimize ?? true
   const shouldTypeCheck = options.typeCheck ?? true
+  const shouldRunDce = options.dce ?? shouldOptimize
   const filePath = options.filePath
-  const preprocessedSource = preprocessSource(source, { filePath })
+  const preprocessed = preprocessSourceWithMetadata(source, { filePath })
+  const preprocessedSource = preprocessed.source
 
   // Lexing
   const tokens = new Lexer(preprocessedSource, filePath).tokenize()
 
   // Parsing
-  const ast = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const parsedAst = new Parser(tokens, preprocessedSource, filePath).parse(namespace)
+  const ast = shouldRunDce ? eliminateDeadCode(parsedAst) : parsedAst
 
   // Type checking (warn mode - collect errors but don't block)
   let typeErrors: DiagnosticError[] | undefined
@@ -70,7 +75,7 @@ export function compile(source: string, options: CompileOptions = {}): CompileRe
   }
 
   // Lowering to IR
-  const lowering = new Lowering(namespace)
+  const lowering = new Lowering(namespace, preprocessed.ranges)
   const ir = lowering.lower(ast)
 
   let optimizedIR: IRModule = ir

package/src/ir/types.ts

@@ -107,6 +107,10 @@ export interface IRFunction {
     kind: 'advancement' | 'craft' | 'death' | 'login' | 'join_team'
     value?: string
   }
+  eventHandler?: {
+    eventType: string
+    tag: string
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/lexer/index.ts

@@ -15,7 +15,7 @@ import { DiagnosticError } from '../diagnostics'
 export type TokenKind =
   // Keywords
   | 'fn' | 'let' | 'const' | 'if' | 'else' | 'while' | 'for' | 'foreach' | 'match'
-  | 'return' | 'as' | 'at' | 'in' | 'struct' | 'enum' | 'trigger' | 'namespace'
+  | 'return' | 'as' | 'at' | 'in' | 'is' | 'struct' | 'impl' | 'enum' | 'trigger' | 'namespace'
   | 'execute' | 'run' | 'unless'
   // Types
   | 'int' | 'bool' | 'float' | 'string' | 'void'
@@ -34,7 +34,10 @@ export type TokenKind =
   | 'long_lit'      // 1000L
   | 'double_lit'    // 3.14d
   | 'string_lit'    // "hello"
+  | 'f_string'      // f"hello {name}"
   | 'range_lit'     // ..5  1..  1..10
+  | 'rel_coord'     // ~  ~5  ~-3  (relative coordinate)
+  | 'local_coord'   // ^  ^5  ^-3  (local/facing coordinate)
   // Operators
   | '+' | '-' | '*' | '/' | '%'
   | '~' | '^'
@@ -75,7 +78,9 @@ const KEYWORDS: Record<string, TokenKind> = {
   as: 'as',
   at: 'at',
   in: 'in',
+  is: 'is',
   struct: 'struct',
+  impl: 'impl',
   enum: 'enum',
   trigger: 'trigger',
   namespace: 'namespace',
@@ -273,8 +278,52 @@ export class Lexer {
       return
     }
 
+    // Relative coordinate: ~ or ~5 or ~-3 or ~0.5
+    if (char === '~') {
+      let value = '~'
+      // Check for optional sign
+      if (this.peek() === '-' || this.peek() === '+') {
+        value += this.advance()
+      }
+      // Check for number
+      while (/[0-9]/.test(this.peek())) {
+        value += this.advance()
+      }
+      // Check for decimal part
+      if (this.peek() === '.' && /[0-9]/.test(this.peek(1))) {
+        value += this.advance() // .
+        while (/[0-9]/.test(this.peek())) {
+          value += this.advance()
+        }
+      }
+      this.addToken('rel_coord', value, startLine, startCol)
+      return
+    }
+
+    // Local coordinate: ^ or ^5 or ^-3 or ^0.5
+    if (char === '^') {
+      let value = '^'
+      // Check for optional sign
+      if (this.peek() === '-' || this.peek() === '+') {
+        value += this.advance()
+      }
+      // Check for number
+      while (/[0-9]/.test(this.peek())) {
+        value += this.advance()
+      }
+      // Check for decimal part
+      if (this.peek() === '.' && /[0-9]/.test(this.peek(1))) {
+        value += this.advance() // .
+        while (/[0-9]/.test(this.peek())) {
+          value += this.advance()
+        }
+      }
+      this.addToken('local_coord', value, startLine, startCol)
+      return
+    }
+
     // Single-character operators and delimiters
-    const singleChar: TokenKind[] = ['+', '-', '*', '/', '%', '~', '^', '<', '>', '!', '=',
+    const singleChar: TokenKind[] = ['+', '-', '*', '/', '%', '<', '>', '!', '=',
       '{', '}', '(', ')', '[', ']', ',', ';', ':', '.']
     if (singleChar.includes(char as TokenKind)) {
       this.addToken(char as TokenKind, char, startLine, startCol)
@@ -287,6 +336,13 @@ export class Lexer {
       return
     }
 
+    // f-string literal
+    if (char === 'f' && this.peek() === '"') {
+      this.advance()
+      this.scanFString(startLine, startCol)
+      return
+    }
+
     // String literal
     if (char === '"') {
       this.scanString(startLine, startCol)
@@ -430,6 +486,53 @@ export class Lexer {
     this.addToken('string_lit', value, startLine, startCol)
   }
 
+  private scanFString(startLine: number, startCol: number): void {
+    let value = ''
+    let interpolationDepth = 0
+    let interpolationString = false
+
+    while (!this.isAtEnd()) {
+      if (interpolationDepth === 0 && this.peek() === '"') {
+        break
+      }
+
+      if (this.peek() === '\\' && this.peek(1) === '"') {
+        this.advance()
+        value += this.advance()
+        continue
+      }
+
+      if (interpolationDepth === 0 && this.peek() === '{') {
+        value += this.advance()
+        interpolationDepth = 1
+        interpolationString = false
+        continue
+      }
+
+      const char = this.advance()
+      value += char
+
+      if (interpolationDepth === 0) continue
+
+      if (char === '"' && this.source[this.pos - 2] !== '\\') {
+        interpolationString = !interpolationString
+        continue
+      }
+
+      if (interpolationString) continue
+
+      if (char === '{') interpolationDepth++
+      if (char === '}') interpolationDepth--
+    }
+
+    if (this.isAtEnd()) {
+      this.error('Unterminated f-string', startLine, startCol)
+    }
+
+    this.advance() // closing quote
+    this.addToken('f_string', value, startLine, startCol)
+  }
+
   private scanNumber(firstChar: string, startLine: number, startCol: number): void {
     let value = firstChar