redscript-mc 2.5.0 → 2.6.2

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "1.2.42",
+  "version": "1.3.35",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "1.2.42",
+      "version": "1.3.35",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../",
@@ -24,7 +24,7 @@
     },
     "../..": {
       "name": "redscript-mc",
-      "version": "2.4.1",
+      "version": "2.6.0",
       "license": "MIT",
       "dependencies": {
         "vscode-languageserver": "^9.0.1",

package/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "redscript-vscode",
   "displayName": "RedScript for Minecraft",
   "description": "Syntax highlighting, error diagnostics, and language support for RedScript — a compiler targeting Minecraft Java Edition",
-  "version": "1.2.42",
+  "version": "1.3.35",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",

package/editors/vscode/snippets/redscript.json

@@ -9,58 +9,146 @@
     "description": "Define a function"
   },
   "Tick Function": {
-    "prefix": "fntick",
+    "prefix": ["fntick", "tick"],
     "body": [
       "@tick",
-      "fn ${1:name}(${2:params})${3: -> ${4:void}} {",
+      "fn ${1:name}() {",
       "    $0",
       "}"
     ],
-    "description": "Define an @tick function"
+    "description": "Define an @tick function (runs every game tick)"
   },
-  "Load Function": {
-    "prefix": "fnload",
+  "Tick Function with Rate": {
+    "prefix": "tickrate",
     "body": [
-      "@on_load",
-      "fn ${1:name}(${2:params})${3: -> ${4:void}} {",
+      "@tick(rate=${1:20})",
+      "fn ${2:name}() {",
       "    $0",
       "}"
     ],
-    "description": "Define an @on_load function"
+    "description": "Define an @tick(rate=N) function (runs every N ticks)"
   },
-  "If Statement": {
-    "prefix": "if",
+  "Event Handler": {
+    "prefix": "on",
     "body": [
-      "if (${1:condition}) {",
+      "@on(${1:PlayerDeath})",
+      "fn ${2:handle_${1/(.*)/${1:/downcase}/}}(${3:player}: ${4:Player}) {",
       "    $0",
       "}"
     ],
-    "description": "Insert an if statement"
+    "description": "Define an @on(EventType) event handler"
   },
-  "If Else Statement": {
-    "prefix": "ife",
+  "Load Function": {
+    "prefix": ["fnload", "load"],
     "body": [
-      "if (${1:condition}) {",
-      "    ${2}",
-      "} else {",
+      "@load",
+      "fn ${1:on_load}() {",
       "    $0",
       "}"
     ],
-    "description": "Insert an if-else statement"
+    "description": "Define an @load function (runs on datapack load/reload)"
+  },
+  "Schedule Function": {
+    "prefix": "schedule",
+    "body": [
+      "@schedule(ticks=${1:20})",
+      "fn ${2:name}()${3: -> void} {",
+      "    $0",
+      "}"
+    ],
+    "description": "Define an @schedule(ticks=N) delayed function (20 ticks = 1 second)"
+  },
+  "Coroutine Function": {
+    "prefix": "coroutine",
+    "body": [
+      "@coroutine(batch=${1:50}${2:, onDone=${3:on_done}})",
+      "fn ${4:name}()${5: -> void} {",
+      "    let ${6:i}: int = 0;",
+      "    while (${6:i} < ${7:1000}) {",
+      "        $0",
+      "        ${6:i} = ${6:i} + 1;",
+      "    }",
+      "}"
+    ],
+    "description": "Define an @coroutine function (spreads iterations across multiple ticks)"
+  },
+  "Struct Definition": {
+    "prefix": "struct",
+    "body": [
+      "struct ${1:Name} {",
+      "    ${2:field}: ${3:Type}$0",
+      "}"
+    ],
+    "description": "Define a struct"
+  },
+  "Impl Block": {
+    "prefix": "impl",
+    "body": [
+      "impl ${1:StructName} {",
+      "    fn ${2:method}(self${3:, ${4:param}: ${5:Type}})${6: -> ${7:ReturnType}} {",
+      "        $0",
+      "    }",
+      "}"
+    ],
+    "description": "Define an impl block for a struct"
+  },
+  "Import Statement": {
+    "prefix": "import",
+    "body": [
+      "import \"${1:path/to/module.mcrs}\""
+    ],
+    "description": "Import another RedScript module"
   },
-  "Match Expression": {
+  "Match Expression (Option)": {
     "prefix": "match",
     "body": [
       "match (${1:value}) {",
-      "    ${2:pattern} => {",
+      "    Some(${2:inner}) => {",
+      "        ${3}",
+      "    }",
+      "    None => {",
+      "        $0",
+      "    }",
+      "}"
+    ],
+    "description": "match expression for Option (Some/None)"
+  },
+  "Match Expression (Integer)": {
+    "prefix": "matchint",
+    "body": [
+      "match (${1:value}) {",
+      "    ${2:0} => {",
       "        ${3}",
       "    }",
+      "    ${4:1} => {",
+      "        ${5}",
+      "    }",
       "    _ => {",
       "        $0",
       "    }",
       "}"
     ],
-    "description": "Insert a match expression"
+    "description": "match expression for integer values with wildcard"
+  },
+  "If Statement": {
+    "prefix": "if",
+    "body": [
+      "if (${1:condition}) {",
+      "    $0",
+      "}"
+    ],
+    "description": "Insert an if statement"
+  },
+  "If Else Statement": {
+    "prefix": "ife",
+    "body": [
+      "if (${1:condition}) {",
+      "    ${2}",
+      "} else {",
+      "    $0",
+      "}"
+    ],
+    "description": "Insert an if-else statement"
   },
   "Foreach Selector": {
     "prefix": "foreach",
@@ -95,15 +183,6 @@
     ],
     "description": "Declare a constant"
   },
-  "Struct Definition": {
-    "prefix": "struct",
-    "body": [
-      "struct ${1:Name} {",
-      "    ${2:field}: ${3:Type}",
-      "}"
-    ],
-    "description": "Define a struct"
-  },
   "Enum Definition": {
     "prefix": "enum",
     "body": [

package/editors/vscode/src/extension.ts

@@ -34,16 +34,21 @@ let lspClient: LanguageClient | undefined
  * or null if not available.
  */
 function resolveLspServerPath(): string | null {
-  // When the extension bundles redscript, the LSP server is at
-  // node_modules/redscript/dist/src/lsp/main.js relative to the extension dir.
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const fs = require('fs')
   try {
-    // __dirname is the extension's out/ directory when bundled by esbuild.
+    // 1. Bundled LSP server (primary): out/lsp-server.js packed inside the vsix.
+    //    __dirname is the extension's out/ directory when bundled by esbuild.
+    const bundled = path.join(__dirname, 'lsp-server.js')
+    fs.accessSync(bundled)
+    return bundled
+  } catch { /* fall through */ }
+  try {
+    // 2. Dev/symlink: node_modules/redscript/dist/src/lsp/main.js
     const candidate = path.join(__dirname, '..', 'node_modules', 'redscript', 'dist', 'src', 'lsp', 'main.js')
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    require('fs').accessSync(candidate)
+    fs.accessSync(candidate)
     return candidate
   } catch {
-    // Not found via local node_modules; try the global bin
     return null
   }
 }
@@ -78,16 +83,13 @@ export function activate(context: vscode.ExtensionContext): void {
     context.subscriptions.push({ dispose: () => lspClient?.stop() })
   } else {
     // -----------------------------------------------------------------------
-    // Fallback: bundled compiler diagnostics (no redscript-lsp available)
+    // Fallback: bundled compiler diagnostics + legacy hover/completion
+    // Only used when LSP server is not available.
     // -----------------------------------------------------------------------
     activateFallbackDiagnostics(context)
+    registerHoverProvider(context)
+    registerCompletionProvider(context)
   }
-
-  // -------------------------------------------------------------------------
-  // Providers that always run regardless of LSP availability
-  // -------------------------------------------------------------------------
-  registerHoverProvider(context)
-  registerCompletionProvider(context)
   registerCodeActions(context)
   registerSymbolProviders(context)
 

package/examples/readme-demo.mcrs

@@ -40,19 +40,19 @@ fn _draw(px: float, py: float) {
 
         let i0: int = t;
         let s0: int = sin_fixed((i0 * 9 + phase) % 360);
-        _draw(i0 * 50 - 975, s0 / 4);
+        _draw((i0 * 50 - 975) as float, (s0 / 4) as float);
 
         let i1: int = (t + 1) % 40;
         let s1: int = sin_fixed((i1 * 9 + phase) % 360);
-        _draw(i1 * 50 - 975, s1 / 4);
+        _draw((i1 * 50 - 975) as float, (s1 / 4) as float);
 
         let i2: int = (t + 2) % 40;
         let s2: int = sin_fixed((i2 * 9 + phase) % 360);
-        _draw(i2 * 50 - 975, s2 / 4);
+        _draw((i2 * 50 - 975) as float, (s2 / 4) as float);
 
         let i3: int = (t + 3) % 40;
         let s3: int = sin_fixed((i3 * 9 + phase) % 360);
-        _draw(i3 * 50 - 975, s3 / 4);
+        _draw((i3 * 50 - 975) as float, (s3 / 4) as float);
     }
 }
 

package/jest.config.js

@@ -9,7 +9,10 @@ module.exports = {
       preset: 'ts-jest',
       testEnvironment: 'node',
       roots: ['<rootDir>/src'],
-      testMatch: ['**/__tests__/mc-integration.test.ts'],
+      testMatch: [
+        '**/__tests__/mc-integration.test.ts',
+        '**/__tests__/mc-integration/**/*.test.ts',
+      ],
       testEnvironmentOptions: {},
       retryTimes: 2,
     },
@@ -18,7 +21,7 @@ module.exports = {
       preset: 'ts-jest',
       testEnvironment: 'node',
       roots: ['<rootDir>/src'],
-      testPathIgnorePatterns: ['mc-integration'],
+      testPathIgnorePatterns: ['mc-integration.test.ts', 'mc-integration/'],
     },
   ],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "redscript-mc",
-  "version": "2.5.0",
+  "version": "2.6.2",
   "description": "A high-level programming language that compiles to Minecraft datapacks",
   "main": "dist/src/index.js",
   "bin": {

package/scripts/postbuild.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 const fs = require('fs')
 const path = require('path')
+const { execSync } = require('child_process')
 
 const shims = [
   ['dist/cli.js', './src/cli'],
@@ -13,3 +14,22 @@ for (const [outPath, target] of shims) {
   fs.writeFileSync(outPath, `// shim — delegates to dist/src/\nmodule.exports = require('${target}');\n`)
 }
 console.log('postbuild: shims written')
+
+// Auto-package VSCode extension after every build
+const vscodeDir = path.join(__dirname, '..', 'editors', 'vscode')
+if (fs.existsSync(vscodeDir)) {
+  try {
+    console.log('postbuild: packaging VSCode extension...')
+    execSync('npm run package', { cwd: vscodeDir, stdio: 'pipe' })
+    // Find the newly created vsix
+    const vsixFiles = fs.readdirSync(vscodeDir)
+      .filter(f => f.endsWith('.vsix'))
+      .map(f => ({ name: f, mtime: fs.statSync(path.join(vscodeDir, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime)
+    if (vsixFiles.length > 0) {
+      console.log(`postbuild: vsix ready → editors/vscode/${vsixFiles[0].name}`)
+    }
+  } catch (e) {
+    console.warn('postbuild: vsix packaging failed (non-fatal):', e.message)
+  }
+}

package/src/__tests__/array-dynamic.test.ts

@@ -145,3 +145,45 @@ describe('Dynamic array index: multiple arrays, separate helpers', () => {
     expect(contents).toContain('b[$(arr_idx)]')
   })
 })
+
+describe('Array literal with mixed int/non-const elements initializes correctly', () => {
+  test('non-zero int_lit at index 0 is not zeroed out when array has dynamic elements', () => {
+    const src = `
+      fn test(): void {
+        let a: int[] = [10000, 0, -10000, 0];
+      }
+    `
+    const { files } = compile(src, { namespace: 'test' })
+    const body = getFunctionBody(files, 'test')
+    // The NBT init array should start with 10000, not 0
+    expect(body).toContain('set value [10000,')
+    // The dynamic element (-10000 = unary neg) should be patched
+    expect(body).toContain('a[2]')
+  })
+})
+
+describe('interprocedural const prop substitutes nbt_read_dynamic indexSrc', () => {
+  test('dft_magnitude with constant k reads re[k] and im[k] correctly', () => {
+    const { MCRuntime } = require('../runtime')
+    const MATH = require('fs').readFileSync('./src/stdlib/math.mcrs', 'utf8')
+    const FFT = require('fs').readFileSync('./src/stdlib/fft.mcrs', 'utf8')
+    const src = `
+      fn test_mag(): int {
+        let re: int[] = [0, 20000, 0, 0];
+        let im: int[] = [0, 0, 0, 0];
+        return dft_magnitude(re, im, 1);
+      }
+    `
+    const r = compile(src, { namespace: 'test', librarySources: [MATH, FFT] })
+    const rt = new MCRuntime('test')
+    for (const f of r.files) {
+      if (!f.path.endsWith('.mcfunction')) continue
+      const m = f.path.match(/data\/([^/]+)\/function\/(.+)\.mcfunction/)
+      if (!m) continue
+      rt.loadFunction(m[1] + ':' + m[2], f.content.split('\n'))
+    }
+    rt.execFunction('test:load')
+    rt.execFunction('test:test_mag')
+    expect(rt.getScore('$ret', '__test')).toBe(20000)
+  })
+})

package/src/__tests__/builtins.test.ts

@@ -0,0 +1,66 @@
+import {
+  BUILTIN_METADATA,
+  builtinToDeclaration,
+  generateDts,
+} from '../builtins/metadata'
+
+describe('builtin metadata', () => {
+  it('keeps metadata entries structurally consistent', () => {
+    const entries = Object.entries(BUILTIN_METADATA)
+
+    expect(entries.length).toBeGreaterThan(40)
+
+    for (const [name, def] of entries) {
+      expect(def.name).toBe(name)
+      expect(def.doc).toBeTruthy()
+      expect(def.docZh).toBeTruthy()
+      expect(def.category).toBeTruthy()
+      expect(def.examples.length).toBeGreaterThan(0)
+
+      for (const param of def.params) {
+        expect(param.name).toBeTruthy()
+        expect(param.type).toBeTruthy()
+        expect(param.doc).toBeTruthy()
+        expect(param.docZh).toBeTruthy()
+        if (!param.required && param.default !== undefined) {
+          expect(param.default).not.toBe('')
+        }
+      }
+    }
+  })
+
+  it('supports direct builtin lookup for command docs', () => {
+    const say = BUILTIN_METADATA.say
+    const kill = BUILTIN_METADATA.kill
+    const particle = BUILTIN_METADATA.particle
+
+    expect(say.compilesTo).toBe('say <message>')
+    expect(say.category).toBe('chat')
+    expect(kill.params[0]).toMatchObject({
+      name: 'target',
+      required: false,
+      default: '@s',
+    })
+    expect(particle.examples.some(example => example.includes('particle('))).toBe(true)
+    expect(BUILTIN_METADATA.nonexistent).toBeUndefined()
+  })
+
+  it('renders declarations with optional defaults and runtime-safe type remapping', () => {
+    const decl = builtinToDeclaration(BUILTIN_METADATA.effect)
+
+    expect(decl).toContain('/// Applies a status effect to an entity.')
+    expect(decl).toContain('/// @param duration Duration in seconds (optional)')
+    expect(decl).not.toContain('/// @returns')
+    expect(decl).toContain('declare fn effect(target: selector, effect: string, duration: int = 30, amplifier: int = 0): void;')
+  })
+
+  it('generates grouped builtins declarations output', () => {
+    const dts = generateDts()
+
+    expect(dts).toContain('// builtins.d.mcrs')
+    expect(dts).toContain('// Chat & Display')
+    expect(dts).toContain('// Player')
+    expect(dts).toContain('declare fn say(message: string): void;')
+    expect(dts).toContain('declare fn clearInterval(id: int): void;')
+  })
+})

package/src/__tests__/compile-all.test.ts

@@ -26,8 +26,9 @@ if (!fs.existsSync(CLI)) {
 const SKIP_GLOBS = [
   'node_modules',
   '.git',
-  'builtins.d.mcrs',   // declaration-only file, not valid source
-  'editors/',          // copy of builtins.d.mcrs
+  'builtins.d.mcrs',          // declaration-only file, not valid source
+  'editors/',                  // copy of builtins.d.mcrs
+  'heap-sort-mc-test.mcrs',   // requires librarySources injection (heap.mcrs, sort.mcrs)
 ]
 
 function shouldSkip(filePath: string): boolean {

package/src/__tests__/diagnostics.test.ts

@@ -152,14 +152,10 @@ describe('compile function', () => {
     }
   })
 
-  it('throws DiagnosticError for missing semicolon', () => {
-    try {
-      compile('fn main() { let x = 42 }', { namespace: 'test' })
-      fail('Expected compile to throw')
-    } catch (e) {
-      expect((e as DiagnosticError).kind).toBe('ParseError')
-      expect((e as DiagnosticError).message).toContain("Expected ';'")
-    }
+  it('semicolons are optional: parses without semicolon', () => {
+    // Semicolons are now optional — this should parse and compile successfully
+    const result = compile('fn main() { let x = 42 }', { namespace: 'test' })
+    expect(result.success).toBe(true)
   })
 
   it('includes file path in error', () => {
@@ -169,7 +165,8 @@ describe('compile function', () => {
 
   it('formats error nicely', () => {
     try {
-      compile('fn main() {\n  let x = 42\n}', { namespace: 'test' })
+      // Missing closing paren — genuine parse error
+      compile('fn main() { let x = (42 }', { namespace: 'test' })
       fail('Expected compile to throw')
     } catch (e) {
       expect(e).toBeInstanceOf(DiagnosticError)
@@ -205,7 +202,8 @@ describe('Lexer DiagnosticError', () => {
 describe('Parser DiagnosticError', () => {
   it('includes line and column info', () => {
     try {
-      compile('fn main() { return }', { namespace: 'test' })
+      // Missing closing brace — genuine parse error with location info
+      compile('fn main() { let x = (42', { namespace: 'test' })
       fail('Expected compile to throw')
     } catch (e) {
       expect((e as DiagnosticError).location.line).toBeGreaterThan(0)