redscript-mc 3.0.1 → 3.0.2

package/dist/src/__tests__/lint/new-rules.test.js

@@ -0,0 +1,402 @@
+"use strict";
+/**
+ * Tests for the 5 new redscript lint rules:
+ *   no-dead-assignment
+ *   prefer-match-exhaustive
+ *   no-empty-catch
+ *   naming-convention
+ *   no-magic-numbers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../lint/index");
+function lint(source, opts = {}) {
+    return (0, index_1.lintString)(source, '<test>', 'test', opts);
+}
+function warnings(source, rule, opts = {}) {
+    return lint(source, opts).filter(w => w.rule === rule);
+}
+// ---------------------------------------------------------------------------
+// Rule: no-dead-assignment
+// ---------------------------------------------------------------------------
+describe('no-dead-assignment', () => {
+    it('warns when a variable is assigned then immediately overwritten without being read', () => {
+        const src = `
+fn foo(): void {
+  let x: int = 0;
+  x = 5;
+  x = 10;
+  say("done");
+}
+`;
+        const w = warnings(src, 'no-dead-assignment');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('"x"');
+        expect(w[0].message).toContain('never read');
+    });
+    it('does NOT warn when each assignment is read before the next one', () => {
+        // x is read (return x + y) after all assignments
+        // y is read (return x + y)
+        const src = `
+fn foo(): int {
+  let x: int = 5;
+  let y: int = x;
+  x = 10;
+  return x + y;
+}
+`;
+        const w = warnings(src, 'no-dead-assignment');
+        // x is not overwritten without being read between assignments here:
+        // let x=5 → pending; y reads x → pending cleared; x=10 → no prior pending; return x reads x
+        expect(w).toHaveLength(0);
+    });
+    it('warns when let init is immediately overwritten without being read', () => {
+        // The initial let value is dead because x is reassigned before any read
+        const src = `
+fn foo(): int {
+  let x: int = 0;
+  x = 42;
+  return x;
+}
+`;
+        // let x=0 is dead (overwritten by x=42 before x is read)
+        const w = warnings(src, 'no-dead-assignment');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('"x"');
+    });
+    it('warns for multiple dead assignments in the same function', () => {
+        const src = `
+fn bar(): void {
+  let a: int = 0;
+  let b: int = 0;
+  a = 1;
+  a = 2;
+  b = 3;
+  b = 4;
+  say("done");
+}
+`;
+        const w = warnings(src, 'no-dead-assignment');
+        const msgs = w.map(warn => warn.message);
+        expect(msgs.some(m => m.includes('"a"'))).toBe(true);
+        expect(msgs.some(m => m.includes('"b"'))).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Rule: prefer-match-exhaustive
+// ---------------------------------------------------------------------------
+describe('prefer-match-exhaustive', () => {
+    it('warns when Option match is missing the None arm', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  match x {
+    Some(v) => { say("got value"); }
+  }
+}
+`;
+        const w = warnings(src, 'prefer-match-exhaustive');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w.some(warn => warn.message.includes('None'))).toBe(true);
+    });
+    it('warns when Option match is missing the Some arm', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  match x {
+    None => { say("nothing"); }
+  }
+}
+`;
+        const w = warnings(src, 'prefer-match-exhaustive');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w.some(warn => warn.message.includes('Some'))).toBe(true);
+    });
+    it('does NOT warn when both Some and None arms are present', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  match x {
+    Some(v) => { say("got value"); }
+    None => { say("nothing"); }
+  }
+}
+`;
+        const w = warnings(src, 'prefer-match-exhaustive');
+        expect(w).toHaveLength(0);
+    });
+    it('does NOT warn when a wildcard arm is present', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  match x {
+    Some(v) => { say("got"); }
+    _ => { say("other"); }
+  }
+}
+`;
+        const w = warnings(src, 'prefer-match-exhaustive');
+        expect(w).toHaveLength(0);
+    });
+    it('does NOT warn for non-Option integer match', () => {
+        const src = `
+fn foo(x: int): void {
+  match x {
+    1 => { say("one"); }
+    2 => { say("two"); }
+    _ => { say("other"); }
+  }
+}
+`;
+        const w = warnings(src, 'prefer-match-exhaustive');
+        expect(w).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Rule: no-empty-catch
+// ---------------------------------------------------------------------------
+describe('no-empty-catch', () => {
+    it('warns when if let Some has an empty else block', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  if let Some(v) = x {
+    say("got it");
+  } else {}
+}
+`;
+        const w = warnings(src, 'no-empty-catch');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('None case is silently ignored');
+    });
+    it('does NOT warn when if let Some has no else block', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  if let Some(v) = x {
+    say("got it");
+  }
+}
+`;
+        const w = warnings(src, 'no-empty-catch');
+        expect(w).toHaveLength(0);
+    });
+    it('does NOT warn when else block has statements', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  if let Some(v) = x {
+    say("got it");
+  } else {
+    say("nothing");
+  }
+}
+`;
+        const w = warnings(src, 'no-empty-catch');
+        expect(w).toHaveLength(0);
+    });
+    it('warns when a match arm body is empty', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  match x {
+    Some(v) => { say("ok"); }
+    None => {}
+  }
+}
+`;
+        const w = warnings(src, 'no-empty-catch');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('Empty match arm');
+    });
+    it('does NOT warn when all match arm bodies have statements', () => {
+        const src = `
+fn foo(x: Option<int>): void {
+  match x {
+    Some(v) => { say("ok"); }
+    None => { say("none"); }
+  }
+}
+`;
+        const w = warnings(src, 'no-empty-catch');
+        expect(w).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Rule: naming-convention
+// ---------------------------------------------------------------------------
+describe('naming-convention', () => {
+    it('warns for snake_case variable names', () => {
+        const src = `
+fn foo(): void {
+  let my_var: int = 5;
+  say("ok");
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('"my_var"');
+        expect(w[0].message).toContain('camelCase');
+    });
+    it('warns for UPPER_CASE variable names', () => {
+        const src = `
+fn foo(): void {
+  let MAX_VAL: int = 5;
+  say("ok");
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('"MAX_VAL"');
+    });
+    it('does NOT warn for camelCase variable names', () => {
+        const src = `
+fn foo(): void {
+  let myVar: int = 5;
+  let anotherOne: int = 10;
+  say("ok");
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w).toHaveLength(0);
+    });
+    it('does NOT warn for single-letter variable names', () => {
+        const src = `
+fn foo(): int {
+  let x: int = 5;
+  return x;
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w).toHaveLength(0);
+    });
+    it('warns for snake_case loop bindings in foreach', () => {
+        const src = `
+fn foo(): void {
+  foreach (my_item in @a) {
+    say("x");
+  }
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('"my_item"');
+    });
+    it('does NOT warn for camelCase loop bindings', () => {
+        const src = `
+fn foo(): void {
+  foreach (myItem in @a) {
+    say("x");
+  }
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w).toHaveLength(0);
+    });
+    it('warns for struct with lowercase start name', () => {
+        const src = `
+struct myStruct { x: int }
+
+fn foo(): void {
+  say("ok");
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('"myStruct"');
+        expect(w[0].message).toContain('PascalCase');
+    });
+    it('does NOT warn for correctly named PascalCase struct', () => {
+        const src = `
+struct MyStruct { x: int }
+
+fn foo(): void {
+  say("ok");
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w).toHaveLength(0);
+    });
+    it('allows leading underscore in variable names', () => {
+        const src = `
+fn foo(): void {
+  let _unused: int = 5;
+  say("ok");
+}
+`;
+        const w = warnings(src, 'naming-convention');
+        expect(w).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Rule: no-magic-numbers
+// ---------------------------------------------------------------------------
+describe('no-magic-numbers', () => {
+    it('warns for literal numbers other than 0 and 1', () => {
+        const src = `
+fn foo(): void {
+  let x: int = 42;
+  say("ok");
+}
+`;
+        const w = warnings(src, 'no-magic-numbers');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('42');
+        expect(w[0].message).toContain('Magic number');
+    });
+    it('does NOT warn for 0', () => {
+        const src = `
+fn foo(): int {
+  let x: int = 0;
+  return x;
+}
+`;
+        const w = warnings(src, 'no-magic-numbers');
+        expect(w).toHaveLength(0);
+    });
+    it('does NOT warn for 1', () => {
+        const src = `
+fn foo(): int {
+  let x: int = 1;
+  return x;
+}
+`;
+        const w = warnings(src, 'no-magic-numbers');
+        expect(w).toHaveLength(0);
+    });
+    it('does NOT warn for numbers in const declarations', () => {
+        const src = `
+const MAX_SIZE: int = 100;
+
+fn foo(): void {
+  say("ok");
+}
+`;
+        const w = warnings(src, 'no-magic-numbers');
+        expect(w).toHaveLength(0);
+    });
+    it('respects custom allowedNumbers list', () => {
+        const src = `
+fn foo(): void {
+  let x: int = 42;
+  let y: int = 100;
+  say("ok");
+}
+`;
+        // With 42 allowed, only 100 should warn
+        const w = warnings(src, 'no-magic-numbers', { allowedNumbers: [0, 1, 42] });
+        expect(w).toHaveLength(1);
+        expect(w[0].message).toContain('100');
+    });
+    it('warns for magic numbers used in expressions', () => {
+        const src = `
+fn foo(x: int): bool {
+  return x > 255;
+}
+`;
+        const w = warnings(src, 'no-magic-numbers');
+        expect(w.length).toBeGreaterThan(0);
+        expect(w[0].message).toContain('255');
+    });
+    it('does NOT warn for 0 and 1 even without explicit allowedNumbers', () => {
+        const src = `
+fn foo(x: int): bool {
+  return x > 0 && x < 1;
+}
+`;
+        const w = warnings(src, 'no-magic-numbers');
+        expect(w).toHaveLength(0);
+    });
+});
+//# sourceMappingURL=new-rules.test.js.map

package/dist/src/__tests__/lsp-rename.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for src/lsp/rename.ts — LSP rename symbol support
+ *
+ * Covers: findRenameRanges, buildRenameWorkspaceEdit,
+ * local variable renaming, function renaming, field renaming,
+ * nested scopes, and edge cases.
+ */
+export {};

package/dist/src/__tests__/lsp-rename.test.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Tests for src/lsp/rename.ts — LSP rename symbol support
+ *
+ * Covers: findRenameRanges, buildRenameWorkspaceEdit,
+ * local variable renaming, function renaming, field renaming,
+ * nested scopes, and edge cases.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const lexer_1 = require("../lexer");
+const parser_1 = require("../parser");
+const rename_1 = require("../lsp/rename");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+function parse(source) {
+    const tokens = new lexer_1.Lexer(source).tokenize();
+    return new parser_1.Parser(tokens, source).parse('test');
+}
+function pos(line, character) {
+    return { line, character };
+}
+describe('findRenameRanges — local variables', () => {
+    it('finds all occurrences of a local variable', () => {
+        const src = 'fn test(): void {\n  let x: int = 1;\n  let y: int = x + 2;\n}';
+        const program = parse(src);
+        // Position on 'x' in 'let x: int = 1' (line 1, char 6)
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(1, 6));
+        expect(ranges.length).toBe(2); // declaration + usage
+    });
+    it('returns empty for position not on a symbol', () => {
+        const src = 'fn test(): void {\n  let x: int = 1;\n}';
+        const program = parse(src);
+        // Position on whitespace
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(1, 0));
+        expect(ranges).toEqual([]);
+    });
+    it('handles variable used multiple times', () => {
+        const src = 'fn test(): void {\n  let x: int = 1;\n  let a: int = x;\n  let b: int = x;\n  let c: int = x;\n}';
+        const program = parse(src);
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(1, 6));
+        expect(ranges.length).toBe(4); // 1 decl + 3 uses
+    });
+});
+describe('findRenameRanges — functions', () => {
+    it('finds function name at declaration', () => {
+        const src = 'fn greet(): void {\n}\nfn main(): void {\n  greet();\n}';
+        const program = parse(src);
+        // Position on 'greet' in fn declaration (line 0, char 3)
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(0, 3));
+        expect(ranges.length).toBe(2); // declaration + call
+    });
+    it('finds function name at call site', () => {
+        const src = 'fn greet(): void {\n}\nfn main(): void {\n  greet();\n}';
+        const program = parse(src);
+        // Position on 'greet()' call (line 3, char 2)
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(3, 2));
+        expect(ranges.length).toBe(2);
+    });
+});
+describe('findRenameRanges — struct fields', () => {
+    it('finds field in struct declaration and member access', () => {
+        const src = [
+            'struct Point {',
+            '  x: int,',
+            '  y: int,',
+            '}',
+            'fn test(): Point {',
+            '  let p: Point = Point { x: 1, y: 2 };',
+            '  let v: int = p.x;',
+            '  return Point { x: v, y: 0 };',
+            '}',
+        ].join('\n');
+        const program = parse(src);
+        // Position on 'x' in struct field declaration (line 1, char 2)
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(1, 2));
+        // Should find: field decl, struct literal 'x: 1', 'p.x', and struct literal 'x: v'
+        expect(ranges.length).toBeGreaterThanOrEqual(2);
+    });
+});
+describe('findRenameRanges — nested scopes', () => {
+    it('distinguishes variables in different scopes', () => {
+        const src = [
+            'fn test(): void {',
+            '  let x: int = 1;',
+            '  if true {',
+            '    let x: int = 2;',
+            '    let a: int = x;',
+            '  }',
+            '  let b: int = x;',
+            '}',
+        ].join('\n');
+        const program = parse(src);
+        // Position on outer x (line 1, char 6)
+        const outerRanges = (0, rename_1.findRenameRanges)(src, program, pos(1, 6));
+        // Position on inner x (line 3, char 8)
+        const innerRanges = (0, rename_1.findRenameRanges)(src, program, pos(3, 8));
+        // They should refer to different symbols with different occurrence counts
+        expect(outerRanges.length).not.toBe(0);
+        expect(innerRanges.length).not.toBe(0);
+    });
+});
+describe('findRenameRanges — parameters', () => {
+    it('finds function parameter occurrences', () => {
+        const src = 'fn add(a: int, b: int): int {\n  return a + b;\n}';
+        const program = parse(src);
+        // Position on parameter 'a' (line 0, char 7)
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(0, 7));
+        expect(ranges.length).toBe(2); // param decl + usage in return
+    });
+});
+describe('buildRenameWorkspaceEdit', () => {
+    it('returns null when position is not on a symbol', () => {
+        const src = 'fn test(): void {}';
+        const program = parse(src);
+        const doc = vscode_languageserver_textdocument_1.TextDocument.create('file:///test.mcrs', 'redscript', 1, src);
+        const edit = (0, rename_1.buildRenameWorkspaceEdit)(doc, program, pos(0, 0), 'newName');
+        // 'fn' keyword at pos(0,0) — might or might not resolve
+        // If no symbol, should return null
+        if (edit === null) {
+            expect(edit).toBeNull();
+        }
+        else {
+            expect(edit.changes).toBeDefined();
+        }
+    });
+    it('returns workspace edit with correct URI and new name', () => {
+        const src = 'fn test(): void {\n  let x: int = 1;\n  let y: int = x;\n}';
+        const program = parse(src);
+        const doc = vscode_languageserver_textdocument_1.TextDocument.create('file:///test.mcrs', 'redscript', 1, src);
+        const edit = (0, rename_1.buildRenameWorkspaceEdit)(doc, program, pos(1, 6), 'newVar');
+        expect(edit).not.toBeNull();
+        expect(edit.changes).toBeDefined();
+        const changes = edit.changes['file:///test.mcrs'];
+        expect(changes.length).toBe(2);
+        expect(changes.every(c => c.newText === 'newVar')).toBe(true);
+    });
+});
+describe('findRenameRanges — edge cases', () => {
+    it('handles single function with no body statements', () => {
+        const src = 'fn empty(): void {}';
+        const program = parse(src);
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(0, 3));
+        expect(ranges.length).toBe(1); // just the declaration
+    });
+    it('handles const declarations', () => {
+        const src = 'fn test(): void {\n  const MAX: int = 100;\n  let x: int = MAX;\n}';
+        const program = parse(src);
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(1, 8));
+        expect(ranges.length).toBe(2); // decl + use
+    });
+    it('handles assign expressions', () => {
+        const src = 'fn test(): void {\n  let x: int = 1;\n  x = 2;\n  let y: int = x;\n}';
+        const program = parse(src);
+        const ranges = (0, rename_1.findRenameRanges)(src, program, pos(1, 6));
+        expect(ranges.length).toBe(3); // decl + assign + use
+    });
+});
+//# sourceMappingURL=lsp-rename.test.js.map

package/dist/src/__tests__/mc-integration/say-fstring.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * RedScript MC Integration Tests — say() with f-string
+ *
+ * Verifies that say(f"...{var}...") correctly compiles to a MC macro function
+ * ($say template with $(var) placeholders) and that variable interpolation
+ * works correctly at runtime via `function <helper> with storage rs:macro_args`.
+ *
+ * Run: npx jest say-fstring --forceExit
+ * With server: MC_SERVER_DIR=~/mc-test-server MC_PORT=25561 npx jest say-fstring --forceExit
+ */
+export {};