redscript-mc 1.0.0 → 1.1.0

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.1.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 })
@@ -91,7 +91,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')

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)
   })

package/src/__tests__/e2e.test.ts

@@ -340,7 +340,7 @@ fn test() {
       expect(fn).toContain('bossbar set ns:health visible true')
       expect(fn).toContain('bossbar set ns:health players @a')
       expect(fn).toContain('bossbar remove ns:health')
-      expect(fn).toMatch(/execute store result score \$t\d+ rs run bossbar get ns:health value/)
+      expect(fn).toMatch(/execute store result score \$_\d+ rs run bossbar get ns:health value/)
     })
 
     it('compiles team builtins', () => {
@@ -651,21 +651,21 @@ fn double_score() -> int {
       const source = 'fn test() { let x: int = random(1, 10); }'
       const files = compile(source)
       const fn = getFunction(files, 'test')
-      expect(fn).toContain('scoreboard players random $t0 rs 1 10')
+      expect(fn).toContain('scoreboard players random $_0 rs 1 10')
     })
 
     it('compiles random_native()', () => {
       const source = 'fn test() { let x: int = random_native(1, 6); }'
       const files = compile(source)
       const fn = getFunction(files, 'test')
-      expect(fn).toContain('execute store result score $t0 rs run random value 1 6')
+      expect(fn).toContain('execute store result score $_0 rs run random value 1 6')
     })
 
     it('compiles random_native() with zero min', () => {
       const source = 'fn test() { let x: int = random_native(0, 100); }'
       const files = compile(source)
       const fn = getFunction(files, 'test')
-      expect(fn).toContain('execute store result score $t0 rs run random value 0 100')
+      expect(fn).toContain('execute store result score $_0 rs run random value 0 100')
     })
 
     it('compiles random_sequence()', () => {
@@ -1188,7 +1188,7 @@ fn handle_claim() {
     })
   })
 
-  describe('Real program: zombie_game.rs', () => {
+  describe('Real program: zombie_game.mcrs', () => {
     const source = `
 // A zombie survival game logic
 // Kills nearby zombies and tracks score
@@ -1719,3 +1719,132 @@ describe('NBT parameters', () => {
     expect(fn).toContain('{Unbreakable:1b}')
   })
 })
+
+// ---------------------------------------------------------------------------
+// Set Operations
+// ---------------------------------------------------------------------------
+
+describe('Set operations', () => {
+  it('creates a new set', () => {
+    const src = `fn test() { let s = set_new(); }`
+    const files = compile(src, 'settest')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data modify storage rs:sets __set_0 set value []')
+  })
+
+  it('adds to a set with uniqueness check', () => {
+    const src = `fn test() { let s = set_new(); set_add(s, "apple"); }`
+    const files = compile(src, 'setadd')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('execute unless data storage rs:sets __set_0[{value:apple}] run data modify storage rs:sets __set_0 append value {value:apple}')
+  })
+
+  it('checks set membership', () => {
+    const src = `fn test() { let s = set_new(); set_add(s, "x"); let has = set_contains(s, "x"); }`
+    const files = compile(src, 'setcontains')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('if data storage rs:sets __set_0[{value:x}]')
+  })
+
+  it('removes from a set', () => {
+    const src = `fn test() { let s = set_new(); set_add(s, "y"); set_remove(s, "y"); }`
+    const files = compile(src, 'setremove')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data remove storage rs:sets __set_0[{value:y}]')
+  })
+
+  it('clears a set', () => {
+    const src = `fn test() { let s = set_new(); set_clear(s); }`
+    const files = compile(src, 'setclear')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data modify storage rs:sets __set_0 set value []')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Method Syntax Sugar
+// ---------------------------------------------------------------------------
+
+describe('Method syntax sugar', () => {
+  it('transforms obj.method() to method(obj)', () => {
+    const src = `fn test() { let s = set_new(); s.clear(); }`
+    const files = compile(src, 'method1')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data modify storage rs:sets __set_0 set value []')
+  })
+
+  it('transforms obj.method(arg) to method(obj, arg)', () => {
+    const src = `fn test() { let s = set_new(); s.add("apple"); }`
+    const files = compile(src, 'method2')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data modify storage rs:sets __set_0 append value {value:apple}')
+  })
+
+  it('transforms obj.method(arg) with contains', () => {
+    const src = `fn test() { let s = set_new(); s.add("x"); let r = s.contains("x"); }`
+    const files = compile(src, 'method3')
+    const fn = getFunction(files, 'test')
+    expect(fn).toBeDefined()
+  })
+
+  it('works with multiple args', () => {
+    const src = `fn test() { let s = set_new(); s.add("a"); s.add("b"); s.remove("a"); }`
+    const files = compile(src, 'method4')
+    const fn = getFunction(files, 'test')
+    expect(fn).toContain('data remove storage rs:sets __set_0[{value:a}]')
+  })
+})
+
+describe('Global variables', () => {
+  it('initializes global in __load', () => {
+    const src = `let x: int = 42;\nfn test() { say("hi"); }`
+    const files = compile(src, 'globaltest')
+    const load = getFunction(files, '__load')
+    expect(load).toContain('scoreboard players set $x rs 42')
+  })
+
+  it('reads and writes global in function', () => {
+    const src = `let count: int = 0;\nfn inc() { count = count + 1; }`
+    const files = compile(src, 'globalrw')
+    const fn = getFunction(files, 'inc')
+    expect(fn).toBeDefined()
+    // Global should be initialized in __load
+    const load = getFunction(files, '__load')
+    expect(load).toContain('scoreboard players set $count rs 0')
+  })
+
+  it('const cannot be reassigned', () => {
+    const src = `const X: int = 5;\nfn bad() { X = 10; }`
+    expect(() => compile(src, 'constbad')).toThrow()
+  })
+})
+
+describe('@load decorator', () => {
+  it('calls @load function from __load.mcfunction', () => {
+    const src = `@load fn init() { say("Datapack loaded!"); }`
+    const files = compile(src, 'loadtest')
+    const load = getFunction(files, '__load')
+    expect(load).toContain('function loadtest:init')
+  })
+
+  it('calls multiple @load functions in order', () => {
+    const src = `
+      @load fn setup() { say("setup"); }
+      @load fn init() { say("init"); }
+    `
+    const files = compile(src, 'loadtest')
+    const load = getFunction(files, '__load')!
+    const setupIdx = load.indexOf('function loadtest:setup')
+    const initIdx = load.indexOf('function loadtest:init')
+    expect(setupIdx).toBeGreaterThan(-1)
+    expect(initIdx).toBeGreaterThan(-1)
+    expect(setupIdx).toBeLessThan(initIdx)
+  })
+
+  it('generates the @load function body normally', () => {
+    const src = `@load fn init() { say("hi"); }`
+    const files = compile(src, 'loadtest')
+    const fn = getFunction(files, 'init')
+    expect(fn).toContain('say hi')
+  })
+})

package/src/__tests__/lowering.test.ts

@@ -635,7 +635,7 @@ fn test() {
       expect(rawCmds).toContain('bossbar set ns:health visible true')
       expect(rawCmds).toContain('bossbar set ns:health players @a')
       expect(rawCmds).toContain('bossbar remove ns:health')
-      expect(rawCmds.some(cmd => /^execute store result score \$t\d+ rs run bossbar get ns:health value$/.test(cmd))).toBe(true)
+      expect(rawCmds.some(cmd => /^execute store result score \$_\d+ rs run bossbar get ns:health value$/.test(cmd))).toBe(true)
     })
 
     it('lowers team management builtins', () => {
@@ -665,14 +665,14 @@ fn test() {
       const ir = compile('fn test() { let x: int = random(1, 100); }')
       const fn = getFunction(ir, 'test')!
       const rawCmds = getRawCommands(fn)
-      expect(rawCmds).toContain('scoreboard players random $t0 rs 1 100')
+      expect(rawCmds).toContain('scoreboard players random $_0 rs 1 100')
     })
 
     it('lowers random_native()', () => {
       const ir = compile('fn test() { let x: int = random_native(1, 6); }')
       const fn = getFunction(ir, 'test')!
       const rawCmds = getRawCommands(fn)
-      expect(rawCmds).toContain('execute store result score $t0 rs run random value 1 6')
+      expect(rawCmds).toContain('execute store result score $_0 rs run random value 1 6')
     })
 
     it('lowers random_sequence()', () => {
@@ -959,4 +959,49 @@ fn count_down() {
       expect(bodyBlock).toBeDefined()
     })
   })
+
+  describe('Global variables', () => {
+    it('registers global in IR globals with init value', () => {
+      const ir = compile('let x: int = 42;\nfn test() { say("hi"); }')
+      expect(ir.globals).toContainEqual({ name: '$x', init: 42 })
+    })
+
+    it('reads global variable in function body', () => {
+      const ir = compile('let count: int = 0;\nfn test() { let y: int = count; }')
+      const fn = getFunction(ir, 'test')!
+      const instrs = getInstructions(fn)
+      expect(instrs.some(i =>
+        i.op === 'assign' && i.dst === '$y' && (i.src as any).kind === 'var' && (i.src as any).name === '$count'
+      )).toBe(true)
+    })
+
+    it('writes global variable in function body', () => {
+      const ir = compile('let count: int = 0;\nfn inc() { count = 5; }')
+      const fn = getFunction(ir, 'inc')!
+      const instrs = getInstructions(fn)
+      expect(instrs.some(i =>
+        i.op === 'assign' && i.dst === '$count' && (i.src as any).kind === 'const' && (i.src as any).value === 5
+      )).toBe(true)
+    })
+
+    it('compound assignment on global variable', () => {
+      const ir = compile('let count: int = 0;\nfn inc() { count += 1; }')
+      const fn = getFunction(ir, 'inc')!
+      const instrs = getInstructions(fn)
+      expect(instrs.some(i =>
+        i.op === 'binop' && (i.lhs as any).name === '$count' && i.bop === '+' && (i.rhs as any).value === 1
+      )).toBe(true)
+    })
+
+    it('const cannot be reassigned', () => {
+      const src = 'const X: int = 5;\nfn bad() { X = 10; }'
+      expect(() => compile(src)).toThrow(/Cannot assign to constant/)
+    })
+
+    it('multiple globals with different init values', () => {
+      const ir = compile('let a: int = 10;\nlet b: int = 20;\nfn test() { a = b; }')
+      expect(ir.globals).toContainEqual({ name: '$a', init: 10 })
+      expect(ir.globals).toContainEqual({ name: '$b', init: 20 })
+    })
+  })
 })