redscript-mc 1.2.30 → 2.1.0

package/src/lir/verify.ts

@@ -0,0 +1,129 @@
+/**
+ * LIR Verifier — validates structural invariants of LIR modules.
+ *
+ * Checks:
+ * 1. All Slots use the module's objective
+ * 2. No undefined function references (call/call_if_* targets exist)
+ * 3. macro_line only appears in isMacro functions
+ */
+
+import type { LIRModule, LIRFunction, LIRInstr, Slot } from './types'
+
+export interface LIRVerifyError {
+  fn: string
+  message: string
+}
+
+export function verifyLIR(module: LIRModule): LIRVerifyError[] {
+  const errors: LIRVerifyError[] = []
+  const fnNames = new Set(module.functions.map(f => `${module.namespace}:${f.name}`))
+
+  for (const fn of module.functions) {
+    errors.push(...verifyFunction(fn, module, fnNames))
+  }
+
+  return errors
+}
+
+function verifyFunction(
+  fn: LIRFunction,
+  module: LIRModule,
+  fnNames: Set<string>,
+): LIRVerifyError[] {
+  const errors: LIRVerifyError[] = []
+
+  for (const instr of fn.instructions) {
+    // Check objective on all slots
+    for (const slot of getSlotsFromInstr(instr)) {
+      if (slot.obj !== module.objective) {
+        errors.push({
+          fn: fn.name,
+          message: `slot '${slot.player}' uses objective '${slot.obj}' but module objective is '${module.objective}'`,
+        })
+      }
+    }
+
+    // Check function references
+    for (const ref of getFnRefsFromInstr(instr)) {
+      // Skip empty refs (used in store_cmd_to_score with cmp pattern)
+      if (ref === '' || ref === `${module.namespace}:`) continue
+      if (!fnNames.has(ref)) {
+        errors.push({
+          fn: fn.name,
+          message: `references undefined function '${ref}'`,
+        })
+      }
+    }
+
+    // Check macro_line only in macro functions
+    if (instr.kind === 'macro_line' && !fn.isMacro) {
+      errors.push({
+        fn: fn.name,
+        message: `macro_line instruction in non-macro function`,
+      })
+    }
+  }
+
+  return errors
+}
+
+function getSlotsFromInstr(instr: LIRInstr): Slot[] {
+  switch (instr.kind) {
+    case 'score_set':
+      return [instr.dst]
+    case 'score_copy':
+    case 'score_add':
+    case 'score_sub':
+    case 'score_mul':
+    case 'score_div':
+    case 'score_mod':
+    case 'score_min':
+    case 'score_max':
+      return [instr.dst, instr.src]
+    case 'score_swap':
+      return [instr.a, instr.b]
+    case 'store_cmd_to_score':
+      return [instr.dst, ...getSlotsFromInstr(instr.cmd)]
+    case 'store_score_to_nbt':
+      return [instr.src]
+    case 'store_nbt_to_score':
+      return [instr.dst]
+    case 'call_if_matches':
+    case 'call_unless_matches':
+      return [instr.slot]
+    case 'call_if_score':
+    case 'call_unless_score':
+      return [instr.a, instr.b]
+    case 'return_value':
+      return [instr.slot]
+    case 'call':
+    case 'call_macro':
+    case 'call_context':
+    case 'nbt_set_literal':
+    case 'nbt_copy':
+    case 'macro_line':
+    case 'raw':
+      return []
+  }
+}
+
+function getFnRefsFromInstr(instr: LIRInstr): string[] {
+  switch (instr.kind) {
+    case 'call':
+      return [instr.fn]
+    case 'call_macro':
+      return [instr.fn]
+    case 'call_if_matches':
+    case 'call_unless_matches':
+      return [instr.fn]
+    case 'call_if_score':
+    case 'call_unless_score':
+      return [instr.fn]
+    case 'call_context':
+      return [instr.fn]
+    case 'store_cmd_to_score':
+      return getFnRefsFromInstr(instr.cmd)
+    default:
+      return []
+  }
+}

package/src/lsp/main.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * RedScript LSP server entry point.
+ * Communicates over stdio (standard LSP protocol).
+ *
+ * Usage: redscript-lsp  (started by your editor's LSP client)
+ */
+
+import './server'

package/src/lsp/server.ts

@@ -0,0 +1,414 @@
+/**
+ * RedScript Language Server
+ *
+ * Implements LSP (Language Server Protocol) over stdio.
+ * Features:
+ *   - Diagnostics (type errors, parse errors)
+ *   - Hover (type information)
+ *   - Go-to-definition (functions, variables)
+ *   - Completion (keywords, functions, builtins)
+ */
+
+import {
+  createConnection,
+  TextDocuments,
+  ProposedFeatures,
+  InitializeParams,
+  InitializeResult,
+  TextDocumentSyncKind,
+  Diagnostic,
+  DiagnosticSeverity,
+  Hover,
+  MarkupContent,
+  MarkupKind,
+  CompletionItem,
+  CompletionItemKind,
+  Location,
+  Position,
+  TextDocumentPositionParams,
+} from 'vscode-languageserver/node'
+import { TextDocument } from 'vscode-languageserver-textdocument'
+
+import { Lexer } from '../lexer'
+import { Parser } from '../parser'
+import { TypeChecker } from '../typechecker'
+import { DiagnosticError } from '../diagnostics'
+import type { Program, FnDecl, Span, TypeNode } from '../ast/types'
+
+// ---------------------------------------------------------------------------
+// Connection and document manager
+// ---------------------------------------------------------------------------
+
+const connection = createConnection(ProposedFeatures.all)
+const documents = new TextDocuments(TextDocument)
+
+// ---------------------------------------------------------------------------
+// Per-document parse cache
+// ---------------------------------------------------------------------------
+
+interface ParsedDoc {
+  program: Program | null
+  /** Errors collected from lex/parse/typecheck */
+  errors: DiagnosticError[]
+  source: string
+}
+
+const parsedDocs = new Map<string, ParsedDoc>()
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function typeToString(t: TypeNode): string {
+  switch (t.kind) {
+    case 'named': return t.name
+    case 'array': return `${typeToString(t.elem)}[]`
+    case 'struct': return t.name
+    case 'enum': return t.name
+    case 'entity': return t.entityType
+    case 'selector': return t.entityType ? `selector<${t.entityType}>` : 'selector'
+    case 'tuple': return `(${t.elements.map(typeToString).join(', ')})`
+    case 'function_type':
+      return `(${t.params.map(typeToString).join(', ')}) => ${typeToString(t.return)}`
+    default:
+      return 'unknown'
+  }
+}
+
+/** Parse and type-check a document, caching the result. */
+function parseDocument(uri: string, source: string): ParsedDoc {
+  const errors: DiagnosticError[] = []
+  let program: Program | null = null
+
+  try {
+    const lexer = new Lexer(source)
+    const tokens = lexer.tokenize()
+    const parser = new Parser(tokens, source, uri)
+    program = parser.parse('redscript')
+
+    // Type-check (warn mode — collects errors but doesn't throw)
+    const checker = new TypeChecker(source, uri)
+    const typeErrors = checker.check(program)
+    errors.push(...typeErrors)
+  } catch (err) {
+    if (err instanceof DiagnosticError) {
+      errors.push(err)
+    } else if (err instanceof Error) {
+      // Wrap parse errors that aren't DiagnosticError
+      errors.push(new DiagnosticError(
+        'ParseError',
+        err.message,
+        { line: 1, col: 1, file: uri },
+      ))
+    }
+  }
+
+  const doc: ParsedDoc = { program, errors, source }
+  parsedDocs.set(uri, doc)
+  return doc
+}
+
+/** Convert a DiagnosticError to an LSP Diagnostic. */
+function toDiagnostic(err: DiagnosticError): Diagnostic {
+  const line = Math.max(0, (err.location?.line ?? 1) - 1)
+  const col  = Math.max(0, (err.location?.col  ?? 1) - 1)
+  return {
+    severity: DiagnosticSeverity.Error,
+    range: {
+      start: { line, character: col },
+      end:   { line, character: col + 80 },
+    },
+    message: err.message,
+    source: 'redscript',
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Hover helpers
+// ---------------------------------------------------------------------------
+
+/** Find the word at a position in a text. */
+function wordAt(source: string, position: Position): string {
+  const lines = source.split('\n')
+  const line = lines[position.line] ?? ''
+  const ch = position.character
+  // Expand left
+  let start = ch
+  while (start > 0 && /\w/.test(line[start - 1])) start--
+  // Expand right
+  let end = ch
+  while (end < line.length && /\w/.test(line[end])) end++
+  return line.slice(start, end)
+}
+
+/** Find a function declaration by name in a parsed program. */
+function findFunction(program: Program, name: string): FnDecl | undefined {
+  // Top-level functions
+  const fn = program.declarations.find(f => f.name === name)
+  if (fn) return fn
+  // Impl methods
+  for (const impl of program.implBlocks ?? []) {
+    const m = impl.methods.find(f => f.name === name)
+    if (m) return m
+  }
+  return undefined
+}
+
+/** Format a function signature for hover. */
+function formatFnSignature(fn: FnDecl): string {
+  const params = fn.params.map(p => `${p.name}: ${typeToString(p.type)}`).join(', ')
+  const ret = typeToString(fn.returnType)
+  const typeParams = fn.typeParams?.length ? `<${fn.typeParams.join(', ')}>` : ''
+  return `fn ${fn.name}${typeParams}(${params}): ${ret}`
+}
+
+// ---------------------------------------------------------------------------
+// Go-to-definition helpers
+// ---------------------------------------------------------------------------
+
+/** Build a mapping from identifier name → definition location. */
+function buildDefinitionMap(program: Program, source: string): Map<string, Span> {
+  const map = new Map<string, Span>()
+
+  for (const fn of program.declarations) {
+    if (fn.span) map.set(fn.name, fn.span)
+  }
+  for (const impl of program.implBlocks ?? []) {
+    for (const m of impl.methods) {
+      if (m.span) map.set(`${impl.typeName}.${m.name}`, m.span)
+    }
+  }
+  for (const s of program.structs ?? []) {
+    if (s.span) map.set(s.name, s.span)
+  }
+  for (const e of program.enums ?? []) {
+    if (e.span) map.set(e.name, e.span)
+  }
+  for (const c of program.consts ?? []) {
+    if (c.span) map.set(c.name, c.span)
+  }
+  for (const g of program.globals ?? []) {
+    if (g.span) map.set(g.name, g.span)
+  }
+  return map
+}
+
+// ---------------------------------------------------------------------------
+// Completion items
+// ---------------------------------------------------------------------------
+
+const KEYWORD_COMPLETIONS: CompletionItem[] = [
+  'fn', 'let', 'if', 'else', 'while', 'for', 'foreach', 'return',
+  'break', 'continue', 'as', 'at', 'match', 'struct', 'enum', 'impl',
+  'const', 'global', 'true', 'false', 'module', 'import',
+].map(kw => ({
+  label: kw,
+  kind: CompletionItemKind.Keyword,
+}))
+
+const TYPE_COMPLETIONS: CompletionItem[] = [
+  'int', 'bool', 'float', 'string', 'void', 'BlockPos', 'byte', 'short', 'long', 'double',
+  'entity', 'Player', 'Mob', 'HostileMob', 'PassiveMob',
+  'Zombie', 'Skeleton', 'Creeper', 'Spider', 'Enderman',
+].map(t => ({
+  label: t,
+  kind: CompletionItemKind.TypeParameter,
+}))
+
+const DECORATOR_COMPLETIONS: CompletionItem[] = [
+  '@tick', '@load', '@on', '@coroutine', '@keep',
+].map(d => ({
+  label: d,
+  kind: CompletionItemKind.Event,
+}))
+
+const BUILTIN_FN_COMPLETIONS: CompletionItem[] = [
+  'say', 'tell', 'give', 'kill', 'teleport', 'summon', 'setblock',
+  'fill', 'clone', 'effect', 'enchant', 'experience', 'gamemode',
+  'gamerule', 'particle', 'playsound', 'stopsound', 'scoreboard',
+  'tag', 'title', 'subtitle', 'actionbar', 'tellraw', 'announce',
+  'setTimeout', 'setInterval', 'clearInterval',
+].map(fn => ({
+  label: fn,
+  kind: CompletionItemKind.Function,
+}))
+
+// ---------------------------------------------------------------------------
+// Server lifecycle
+// ---------------------------------------------------------------------------
+
+connection.onInitialize((_params: InitializeParams): InitializeResult => {
+  return {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+      hoverProvider: true,
+      definitionProvider: true,
+      completionProvider: {
+        triggerCharacters: ['.', '@'],
+        resolveProvider: false,
+      },
+    },
+    serverInfo: {
+      name: 'redscript-lsp',
+      version: '1.0.0',
+    },
+  }
+})
+
+connection.onInitialized(() => {
+  connection.console.log('RedScript LSP server ready')
+})
+
+// ---------------------------------------------------------------------------
+// Document sync → diagnostics
+// ---------------------------------------------------------------------------
+
+function validateAndPublish(doc: TextDocument): void {
+  const source = doc.getText()
+  const parsed = parseDocument(doc.uri, source)
+  const diagnostics: Diagnostic[] = parsed.errors.map(toDiagnostic)
+  connection.sendDiagnostics({ uri: doc.uri, diagnostics })
+}
+
+documents.onDidOpen(e => validateAndPublish(e.document))
+documents.onDidChangeContent(e => validateAndPublish(e.document))
+documents.onDidClose(e => {
+  parsedDocs.delete(e.document.uri)
+  connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] })
+})
+
+// ---------------------------------------------------------------------------
+// Hover
+// ---------------------------------------------------------------------------
+
+connection.onHover((params: TextDocumentPositionParams): Hover | null => {
+  const doc = documents.get(params.textDocument.uri)
+  if (!doc) return null
+
+  const source = doc.getText()
+  const cached = parsedDocs.get(params.textDocument.uri)
+  const program = cached?.program ?? null
+  if (!program) return null
+
+  const word = wordAt(source, params.position)
+  if (!word) return null
+
+  // Check if it's a known function
+  const fn = findFunction(program, word)
+  if (fn) {
+    const sig = formatFnSignature(fn)
+    const content: MarkupContent = {
+      kind: MarkupKind.Markdown,
+      value: `\`\`\`redscript\n${sig}\n\`\`\``,
+    }
+    return { contents: content }
+  }
+
+  // Check structs
+  const struct = program.structs?.find(s => s.name === word)
+  if (struct) {
+    const fields = struct.fields.map(f => `  ${f.name}: ${typeToString(f.type)}`).join('\n')
+    const content: MarkupContent = {
+      kind: MarkupKind.Markdown,
+      value: `\`\`\`redscript\nstruct ${struct.name} {\n${fields}\n}\n\`\`\``,
+    }
+    return { contents: content }
+  }
+
+  // Check enums
+  const enumDecl = program.enums?.find(e => e.name === word)
+  if (enumDecl) {
+    const variants = enumDecl.variants.map(v => `  ${v.name}`).join('\n')
+    const content: MarkupContent = {
+      kind: MarkupKind.Markdown,
+      value: `\`\`\`redscript\nenum ${enumDecl.name} {\n${variants}\n}\n\`\`\``,
+    }
+    return { contents: content }
+  }
+
+  // Check consts
+  const constDecl = program.consts?.find(c => c.name === word)
+  if (constDecl) {
+    const content: MarkupContent = {
+      kind: MarkupKind.Markdown,
+      value: `\`\`\`redscript\nconst ${constDecl.name}: ${typeToString(constDecl.type)}\n\`\`\``,
+    }
+    return { contents: content }
+  }
+
+  return null
+})
+
+// ---------------------------------------------------------------------------
+// Go-to-definition
+// ---------------------------------------------------------------------------
+
+connection.onDefinition((params: TextDocumentPositionParams): Location | null => {
+  const doc = documents.get(params.textDocument.uri)
+  if (!doc) return null
+
+  const source = doc.getText()
+  const cached = parsedDocs.get(params.textDocument.uri)
+  const program = cached?.program ?? null
+  if (!program) return null
+
+  const word = wordAt(source, params.position)
+  if (!word) return null
+
+  const defMap = buildDefinitionMap(program, source)
+  const span = defMap.get(word)
+  if (!span) return null
+
+  const line = Math.max(0, span.line - 1)
+  const col  = Math.max(0, span.col  - 1)
+  return {
+    uri: params.textDocument.uri,
+    range: {
+      start: { line, character: col },
+      end:   { line, character: col + word.length },
+    },
+  }
+})
+
+// ---------------------------------------------------------------------------
+// Completion
+// ---------------------------------------------------------------------------
+
+connection.onCompletion((params: TextDocumentPositionParams): CompletionItem[] => {
+  const doc = documents.get(params.textDocument.uri)
+  const items: CompletionItem[] = [
+    ...KEYWORD_COMPLETIONS,
+    ...TYPE_COMPLETIONS,
+    ...BUILTIN_FN_COMPLETIONS,
+    ...DECORATOR_COMPLETIONS,
+  ]
+
+  if (!doc) return items
+
+  // Add user-defined functions from the parsed doc
+  const cached = parsedDocs.get(params.textDocument.uri)
+  const program = cached?.program ?? null
+  if (program) {
+    for (const fn of program.declarations) {
+      items.push({ label: fn.name, kind: CompletionItemKind.Function })
+    }
+    for (const s of program.structs ?? []) {
+      items.push({ label: s.name, kind: CompletionItemKind.Struct })
+    }
+    for (const e of program.enums ?? []) {
+      items.push({ label: e.name, kind: CompletionItemKind.Enum })
+    }
+    for (const c of program.consts ?? []) {
+      items.push({ label: c.name, kind: CompletionItemKind.Constant })
+    }
+  }
+
+  return items
+})
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+
+documents.listen(connection)
+connection.listen()

package/src/mc-test/runner.ts

@@ -54,9 +54,10 @@ export async function runMCTests(
     // Compile and install datapack
     const outDir = path.join(MC_SERVER_DIR, 'world', 'datapacks', 'redscript-test')
     console.log(`Compiling ${sourceFile}...`)
-    const result = compile(fs.readFileSync(sourceFile, 'utf-8'))
-    if (!result.success || !result.files) {
-      throw result.error ?? new Error('Compilation failed')
+    const ns = path.basename(sourceFile, '.mcrs')
+    const result = compile(fs.readFileSync(sourceFile, 'utf-8'), { namespace: ns, filePath: sourceFile })
+    if (!result.files) {
+      throw new Error('Compilation failed')
     }
     // Write files
     fs.mkdirSync(outDir, { recursive: true })