redscript-mc 1.0.0 → 1.2.0

package/editors/vscode/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "redscript-vscode",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "redscript-vscode",
-      "version": "0.2.0",
+      "version": "1.0.0",
       "license": "MIT",
       "dependencies": {
         "redscript": "file:../../"

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": "0.5.0",
+  "version": "1.0.0",
   "publisher": "bkmashiro",
   "icon": "icon.png",
   "license": "MIT",
@@ -36,7 +36,7 @@
           "redscript"
         ],
         "extensions": [
-          ".rs"
+          ".mcrs"
         ],
         "configuration": "./redscript-language-configuration.json"
       },
@@ -116,7 +116,14 @@
           }
         ]
       }
-    }
+    },
+    "iconThemes": [
+      {
+        "id": "redscript-icons",
+        "label": "RedScript Icons",
+        "path": "./icons/redscript-icons.json"
+      }
+    ]
   },
   "scripts": {
     "compile": "node build.mjs",

package/editors/vscode/src/hover.ts

@@ -766,17 +766,70 @@ function findFnDeclLine(document: vscode.TextDocument, name: string): number | n
 function findFnSignature(document: vscode.TextDocument, name: string): string | null {
   const text = document.getText()
   // Match: fn name(params) or fn name(params) -> Type
-  const re = new RegExp(`\\bfn\\s+${escapeRe(name)}\\s*\\(([^)]*)\\)(?:\\s*->\\s*([A-Za-z_][A-Za-z0-9_\\[\\]]*))?`, 'm')
+  const re = new RegExp(`\\bfn\\s+${escapeRe(name)}\\s*\\(([^)]*)\\)(?:\\s*->\\s*([A-Za-z_][A-Za-z0-9_\\[\\]]*))?\\s*\\{`, 'm')
   const match = re.exec(text)
   if (!match) return null
   const params = match[1].trim()
-  const returnType = match[2]
+  let returnType = match[2]
+  
+  // If no explicit return type, try to infer from return statements
+  if (!returnType) {
+    returnType = inferReturnType(text, match.index + match[0].length)
+  }
+  
   if (returnType) {
     return `fn ${name}(${params}) -> ${returnType}`
   }
   return `fn ${name}(${params})`
 }
 
+/**
+ * Infer return type by looking at return statements in function body
+ */
+function inferReturnType(text: string, bodyStart: number): string | null {
+  // Find the matching closing brace
+  let braceCount = 1
+  let pos = bodyStart
+  while (pos < text.length && braceCount > 0) {
+    if (text[pos] === '{') braceCount++
+    else if (text[pos] === '}') braceCount--
+    pos++
+  }
+  const body = text.slice(bodyStart, pos - 1)
+  
+  // Look for return statements
+  const returnMatch = body.match(/\breturn\s+(.+?);/)
+  if (!returnMatch) return null
+  
+  const returnExpr = returnMatch[1].trim()
+  
+  // Infer type from expression
+  if (/^\d+$/.test(returnExpr)) return 'int'
+  if (/^\d+\.\d+$/.test(returnExpr)) return 'float'
+  if (/^\d+[bB]$/.test(returnExpr)) return 'byte'
+  if (/^\d+[sS]$/.test(returnExpr)) return 'short'
+  if (/^\d+[lL]$/.test(returnExpr)) return 'long'
+  if (/^\d+(\.\d+)?[dD]$/.test(returnExpr)) return 'double'
+  if (/^".*"$/.test(returnExpr)) return 'string'
+  if (/^(true|false)$/.test(returnExpr)) return 'bool'
+  if (/^@[aeprs]/.test(returnExpr)) return 'selector'
+  if (/^\{/.test(returnExpr)) return 'struct'
+  if (/^\[/.test(returnExpr)) return 'array'
+  
+  // Check for known builtin return types
+  const callMatch = returnExpr.match(/^(\w+)\s*\(/)
+  if (callMatch) {
+    const fnName = callMatch[1]
+    // Common builtins that return int
+    if (['scoreboard_get', 'score', 'random', 'random_native', 'str_len', 'len', 'data_get', 'bossbar_get_value', 'set_contains'].includes(fnName)) {
+      return 'int'
+    }
+    if (fnName === 'set_new') return 'string'
+  }
+  
+  return null
+}
+
 function escapeRe(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }

package/editors/vscode/src/symbols.ts

@@ -77,6 +77,38 @@ function isStructLiteralField(doc: vscode.TextDocument, position: vscode.Positio
   return null
 }
 
+/**
+ * Check if cursor is on a member access field: expr.field
+ * Returns the struct type name if found, null otherwise
+ */
+function isMemberAccessField(doc: vscode.TextDocument, position: vscode.Position, word: string): string | null {
+  const line = doc.lineAt(position.line).text
+  const wordStart = position.character
+
+  // Check if word is preceded by '.'
+  const beforeWord = line.slice(0, wordStart)
+  if (!beforeWord.endsWith('.')) return null
+
+  // Find the variable before the dot
+  const varMatch = beforeWord.match(/(\w+)\s*\.$/)
+  if (!varMatch) return null
+  const varName = varMatch[1]
+
+  // Find the variable's type declaration
+  const text = doc.getText()
+  // Look for: let varName: TypeName or fn param varName: TypeName
+  const typeRe = new RegExp(`\\b(?:let|const)\\s+${varName}\\s*:\\s*(\\w+)`, 'm')
+  const typeMatch = text.match(typeRe)
+  if (typeMatch) return typeMatch[1]
+
+  // Also check function parameters: fn xxx(varName: TypeName)
+  const paramRe = new RegExp(`\\((?:[^)]*,\\s*)?${varName}\\s*:\\s*(\\w+)`, 'm')
+  const paramMatch = text.match(paramRe)
+  if (paramMatch) return paramMatch[1]
+
+  return null
+}
+
 function findAllOccurrences(doc: vscode.TextDocument, word: string): vscode.Location[] {
   const text = doc.getText()
   const re = new RegExp(`\\b${escapeRegex(word)}\\b`, 'g')
@@ -119,6 +151,16 @@ export function registerSymbolProviders(context: vscode.ExtensionContext): void
           }
         }
 
+        // Check if this is a member access: expr.field
+        const memberAccess = isMemberAccessField(doc, position, word)
+        if (memberAccess) {
+          const structFields = findStructFields(doc)
+          const field = structFields.find(f => f.structName === memberAccess && f.fieldName === word)
+          if (field) {
+            return new vscode.Location(doc.uri, field.fieldRange)
+          }
+        }
+
         const decls = findDeclarations(doc)
         const decl = decls.find(d => d.name === word)
         if (!decl) return null

package/package.json

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

package/src/__tests__/cli.test.ts

@@ -10,11 +10,11 @@ describe('CLI API', () => {
   describe('imports', () => {
     it('compiles a file with imported helpers', () => {
       const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-imports-'))
-      const libPath = path.join(tempDir, 'lib.rs')
-      const mainPath = path.join(tempDir, 'main.rs')
+      const libPath = path.join(tempDir, 'lib.mcrs')
+      const mainPath = path.join(tempDir, 'main.mcrs')
 
       fs.writeFileSync(libPath, 'fn double(x: int) -> int { return x + x; }\n')
-      fs.writeFileSync(mainPath, 'import "./lib.rs"\n\nfn main() { let value: int = double(2); }\n')
+      fs.writeFileSync(mainPath, 'import "./lib.mcrs"\n\nfn main() { let value: int = double(2); }\n')
 
       const source = fs.readFileSync(mainPath, 'utf-8')
       const result = compile(source, { namespace: 'imports', filePath: mainPath })
@@ -26,13 +26,13 @@ describe('CLI API', () => {
 
     it('deduplicates circular imports', () => {
       const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-circular-'))
-      const aPath = path.join(tempDir, 'a.rs')
-      const bPath = path.join(tempDir, 'b.rs')
-      const mainPath = path.join(tempDir, 'main.rs')
+      const aPath = path.join(tempDir, 'a.mcrs')
+      const bPath = path.join(tempDir, 'b.mcrs')
+      const mainPath = path.join(tempDir, 'main.mcrs')
 
-      fs.writeFileSync(aPath, 'import "./b.rs"\n\nfn from_a() -> int { return 1; }\n')
-      fs.writeFileSync(bPath, 'import "./a.rs"\n\nfn from_b() -> int { return from_a(); }\n')
-      fs.writeFileSync(mainPath, 'import "./a.rs"\n\nfn main() { let value: int = from_b(); }\n')
+      fs.writeFileSync(aPath, 'import "./b.mcrs"\n\nfn from_a() -> int { return 1; }\n')
+      fs.writeFileSync(bPath, 'import "./a.mcrs"\n\nfn from_b() -> int { return from_a(); }\n')
+      fs.writeFileSync(mainPath, 'import "./a.mcrs"\n\nfn main() { let value: int = from_b(); }\n')
 
       const source = fs.readFileSync(mainPath, 'utf-8')
       const result = compile(source, { namespace: 'circular', filePath: mainPath })
@@ -40,6 +40,172 @@ describe('CLI API', () => {
       expect(result.ir.functions.filter(fn => fn.name === 'from_a')).toHaveLength(1)
       expect(result.ir.functions.filter(fn => fn.name === 'from_b')).toHaveLength(1)
     })
+
+    it('uses rs-prefixed scoreboard objectives for imported stdlib files', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-'))
+      const stdlibDir = path.join(tempDir, 'src', 'stdlib')
+      const stdlibPath = path.join(stdlibDir, 'timer.mcrs')
+      const mainPath = path.join(tempDir, 'main.mcrs')
+
+      fs.mkdirSync(stdlibDir, { recursive: true })
+      fs.writeFileSync(stdlibPath, 'fn tick_timer() { scoreboard_set("#rs", "timer_ticks", 1); }\n')
+      fs.writeFileSync(mainPath, 'import "./src/stdlib/timer.mcrs"\n\nfn main() { tick_timer(); }\n')
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'mygame', filePath: mainPath })
+      const tickTimer = result.files.find(file => file.path.endsWith('/tick_timer.mcfunction'))
+
+      expect(tickTimer?.content).toContain('scoreboard players set #rs rs.timer_ticks 1')
+    })
+
+    it('adds a call-site hash for stdlib internal scoreboard objectives', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stdlib-hash-'))
+      const stdlibDir = path.join(tempDir, 'src', 'stdlib')
+      const stdlibPath = path.join(stdlibDir, 'timer.mcrs')
+      const mainPath = path.join(tempDir, 'main.mcrs')
+
+      fs.mkdirSync(stdlibDir, { recursive: true })
+      fs.writeFileSync(stdlibPath, [
+        'fn timer_start(name: string, duration: int) {',
+        '  scoreboard_set("timer_ticks", #rs, duration);',
+        '  scoreboard_set("timer_active", #rs, 1);',
+        '}',
+        '',
+      ].join('\n'))
+      fs.writeFileSync(mainPath, [
+        'import "./src/stdlib/timer.mcrs"',
+        '',
+        'fn main() {',
+        '  timer_start("x", 100);',
+        '  timer_start("x", 100);',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'mygame', filePath: mainPath })
+      const timerFns = result.files.filter(file => /timer_start__callsite_[0-9a-f]{4}\.mcfunction$/.test(file.path))
+
+      expect(timerFns).toHaveLength(2)
+
+      const objectives = timerFns
+        .flatMap(file => [...file.content.matchAll(/rs\._timer_([0-9a-f]{4})/g)].map(match => match[0]))
+
+      expect(new Set(objectives).size).toBe(2)
+    })
+
+    it('Timer::new creates timer', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-new-'))
+      const mainPath = path.join(tempDir, 'main.mcrs')
+      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
+
+      fs.writeFileSync(mainPath, [
+        `import "${timerPath}"`,
+        '',
+        'fn main() {',
+        '  let timer: Timer = Timer::new(20);',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'timernew', filePath: mainPath })
+
+      expect(result.typeErrors).toEqual([])
+      const newFn = result.files.find(file => file.path.endsWith('/Timer_new.mcfunction'))
+      expect(newFn?.content).toContain('scoreboard players set timer_ticks rs 0')
+      expect(newFn?.content).toContain('scoreboard players set timer_active rs 0')
+    })
+
+    it('Timer.start/pause/reset', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-state-'))
+      const mainPath = path.join(tempDir, 'main.mcrs')
+      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
+
+      fs.writeFileSync(mainPath, [
+        `import "${timerPath}"`,
+        '',
+        'fn main() {',
+        '  let timer: Timer = Timer::new(20);',
+        '  timer.start();',
+        '  timer.pause();',
+        '  timer.reset();',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'timerstate', filePath: mainPath })
+
+      expect(result.typeErrors).toEqual([])
+      const startFn = result.files.find(file => file.path.endsWith('/Timer_start.mcfunction'))
+      const pauseFn = result.files.find(file => file.path.endsWith('/Timer_pause.mcfunction'))
+      const resetFn = result.files.find(file => file.path.endsWith('/Timer_reset.mcfunction'))
+
+      expect(startFn?.content).toContain('scoreboard players set timer_active rs 1')
+      expect(pauseFn?.content).toContain('scoreboard players set timer_active rs 0')
+      expect(resetFn?.content).toContain('scoreboard players set timer_ticks rs 0')
+    })
+
+    it('Timer.done returns bool', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-done-'))
+      const mainPath = path.join(tempDir, 'main.mcrs')
+      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
+
+      fs.writeFileSync(mainPath, [
+        `import "${timerPath}"`,
+        '',
+        'fn main() {',
+        '  let timer: Timer = Timer::new(20);',
+        '  let finished: bool = timer.done();',
+        '  if (finished) {',
+        '    say("done");',
+        '  }',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'timerdone', filePath: mainPath })
+
+      expect(result.typeErrors).toEqual([])
+      const doneFn = result.files.find(file => file.path.endsWith('/Timer_done.mcfunction'))
+      const mainFn = result.files.find(file => file.path.endsWith('/main.mcfunction'))
+      expect(doneFn?.content).toContain('scoreboard players get timer_ticks rs')
+      expect(doneFn?.content).toContain('return run scoreboard players get')
+      expect(mainFn?.content).toContain('execute if score $finished rs matches 1..')
+    })
+
+    it('Timer.tick increments', () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-timer-tick-'))
+      const mainPath = path.join(tempDir, 'main.mcrs')
+      const timerPath = path.resolve(process.cwd(), 'src/stdlib/timer.mcrs')
+
+      fs.writeFileSync(mainPath, [
+        `import "${timerPath}"`,
+        '',
+        'fn main() {',
+        '  let timer: Timer = Timer::new(20);',
+        '  timer.start();',
+        '  timer.tick();',
+        '}',
+        '',
+      ].join('\n'))
+
+      const source = fs.readFileSync(mainPath, 'utf-8')
+      const result = compile(source, { namespace: 'timertick', filePath: mainPath })
+
+      expect(result.typeErrors).toEqual([])
+      const tickOutput = result.files
+        .filter(file => file.path.includes('/Timer_tick'))
+        .map(file => file.content)
+        .join('\n')
+
+      expect(tickOutput).toContain('scoreboard players get timer_active rs')
+      expect(tickOutput).toContain('scoreboard players get timer_ticks rs')
+      expect(tickOutput).toContain(' += $const_1 rs')
+      expect(tickOutput).toContain('execute store result score timer_ticks rs run scoreboard players get $_')
+    })
   })
 
   describe('compile()', () => {
@@ -91,7 +257,7 @@ fn build() {
   describe('--stats flag', () => {
     it('prints optimizer statistics', () => {
       const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-stats-'))
-      const inputPath = path.join(tempDir, 'input.rs')
+      const inputPath = path.join(tempDir, 'input.mcrs')
       const outputDir = path.join(tempDir, 'out')
 
       fs.writeFileSync(inputPath, 'fn build() { setblock((0, 64, 0), "minecraft:stone"); setblock((1, 64, 0), "minecraft:stone"); }')

package/src/__tests__/codegen.test.ts

@@ -11,7 +11,7 @@ describe('generateDatapack', () => {
   })
 
   it('generates __load.mcfunction with objective setup', () => {
-    const mod: IRModule = { namespace: 'mypack', functions: [], globals: ['counter'] }
+    const mod: IRModule = { namespace: 'mypack', functions: [], globals: [{ name: 'counter', init: 0 }] }
     const files = generateDatapack(mod)
     const load = files.find(f => f.path.includes('__load.mcfunction'))
     expect(load?.content).toContain('scoreboard objectives add rs dummy')
@@ -125,4 +125,31 @@ describe('generateDatapack', () => {
     expect(json.criteria.trigger.trigger).toBe('minecraft:story/mine_diamond')
     expect(json.rewards.function).toBe('mypack:on_mine_diamond')
   })
+
+  it('generates static event dispatcher in __tick', () => {
+    const mod: IRModule = {
+      namespace: 'mypack',
+      globals: [],
+      functions: [{
+        name: 'handle_death',
+        params: [],
+        locals: [],
+        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+        eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+      }, {
+        name: 'handle_death_2',
+        params: [],
+        locals: [],
+        blocks: [{ label: 'entry', instrs: [], term: { op: 'return' } }],
+        eventHandler: { eventType: 'PlayerDeath', tag: 'rs.just_died' },
+      }],
+    }
+
+    const files = generateDatapack(mod)
+    const tickFn = files.find(f => f.path.includes('__tick.mcfunction'))
+    expect(tickFn).toBeDefined()
+    expect(tickFn!.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death')
+    expect(tickFn!.content).toContain('execute as @a[tag=rs.just_died] run function mypack:handle_death_2')
+    expect(tickFn!.content).toContain('tag @a[tag=rs.just_died] remove rs.just_died')
+  })
 })

package/src/__tests__/diagnostics.test.ts

@@ -33,11 +33,11 @@ describe('DiagnosticError', () => {
       const error = new DiagnosticError(
         'TypeError',
         'Unknown function: foo',
-        { file: 'test.rs', line: 1, col: 9 },
+        { file: 'test.mcrs', line: 1, col: 9 },
         source.split('\n')
       )
 
-      expect(formatError(error, source)).toContain('Error in test.rs at line 1, col 9:')
+      expect(formatError(error, source)).toContain('Error in test.mcrs at line 1, col 9:')
     })
   })
 
@@ -66,11 +66,11 @@ describe('DiagnosticError', () => {
       const error = new DiagnosticError(
         'LexError',
         'Unexpected character',
-        { file: 'test.rs', line: 1, col: 1 },
+        { file: 'test.mcrs', line: 1, col: 1 },
         ['@@@']
       )
       const formatted = error.format()
-      expect(formatted).toContain('test.rs:')
+      expect(formatted).toContain('test.mcrs:')
       expect(formatted).toContain('[LexError]')
     })
 
@@ -153,7 +153,7 @@ describe('compile function', () => {
   })
 
   it('includes file path in error', () => {
-    const result = compile('fn main() { }', { filePath: 'test.rs' })
+    const result = compile('fn main() { }', { filePath: 'test.mcrs' })
     // This is valid, but test that filePath is passed through
     expect(result.success).toBe(true)
   })