skir 0.0.1 → 0.0.2

package/dist/module_set.test.js

@@ -26,10 +26,13 @@ describe("module set", () => {
           struct Inner(101) {}
           inner: Inner;
           zoo: other_module.Outer.Zoo;
+
+          loo_loo: struct {};
         }
 
         method GetBar(Outer.Foo): Bar;
         method GetBar2(Outer.Foo): Bar = 100;
+        method Search(enum {}): struct {};
       `);
         fakeFileReader.pathToCode.set("path/to/root/path/to/other/module", `
         struct Outer {
@@ -103,9 +106,10 @@ describe("module set", () => {
                             { name: { text: "foo2" } },
                             { name: { text: "inner" } },
                             { name: { text: "zoo" } },
+                            { name: { text: "loo_loo" } },
                         ],
-                        numSlots: 4,
-                        numSlotsInclRemovedNumbers: 4,
+                        numSlots: 5,
+                        numSlotsInclRemovedNumbers: 5,
                     },
                     GetBar: {
                         kind: "method",
@@ -132,6 +136,14 @@ describe("module set", () => {
                     GetBar2: {
                         number: 100,
                     },
+                    Search: {},
+                    SearchRequest: {
+                        name: {
+                            text: "SearchRequest",
+                            originalText: "Search",
+                        },
+                    },
+                    SearchResponse: {},
                 },
                 declarations: [
                     { name: { text: "other_module" } },
@@ -139,12 +151,18 @@ describe("module set", () => {
                     { name: { text: "Bar" } },
                     { name: { text: "GetBar" } },
                     { name: { text: "GetBar2" } },
+                    { name: { text: "Search" } },
+                    { name: { text: "SearchRequest" } },
+                    { name: { text: "SearchResponse" } },
                 ],
                 records: [
                     { record: { name: { text: "Foo" } } },
                     { record: { name: { text: "Outer" } } },
                     { record: { name: { text: "Inner" }, recordNumber: 101 } },
+                    { record: { name: { text: "LooLoo" } } },
                     { record: { name: { text: "Bar" } } },
+                    { record: { name: { text: "SearchRequest" } } },
+                    { record: { name: { text: "SearchResponse" } } },
                 ],
             },
             errors: [],
@@ -362,25 +380,6 @@ describe("module set", () => {
         const actual = moduleSet.parseAndResolve("path/to/module");
         expect(actual).toMatch({ errors: [] });
     });
-    it("field numbering constraint not satisfied", () => {
-        const fakeFileReader = new FakeFileReader();
-        fakeFileReader.pathToCode.set("path/to/root/path/to/module", `
-        struct Foo { foo: int32; }
-        struct Bar { foo: Foo = 0; }
-      `);
-        const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
-        const actual = moduleSet.parseAndResolve("path/to/module");
-        expect(actual).toMatch({
-            errors: [
-                {
-                    token: {
-                        text: "Foo",
-                    },
-                    message: "Field type references a struct with implicit numbering, but field belongs to a struct with explicit numbering",
-                },
-            ],
-        });
-    });
     describe("keyed arrays", () => {
         it("works", () => {
             const fakeFileReader = new FakeFileReader();
@@ -522,7 +521,7 @@ describe("module set", () => {
                         token: {
                             text: "|",
                         },
-                        expected: '"]"',
+                        expected: "']'",
                     },
                 ],
             });
@@ -566,7 +565,7 @@ describe("module set", () => {
                         token: {
                             text: "key",
                         },
-                        expected: '"kind"',
+                        expected: "'kind'",
                     },
                 ],
             });
@@ -693,8 +692,9 @@ describe("module set", () => {
                         {
                             token: {
                                 text: "Foo",
+                                position: 18,
                             },
-                            message: "Cannot reimport imported name 'Foo'",
+                            message: "Cannot reimport imported record",
                         },
                     ],
                 });
@@ -709,7 +709,7 @@ describe("module set", () => {
           struct Bar { foo: foo.Foo; }
         `);
                 fakeFileReader.pathToCode.set("path/to/root/path/to/module", `
-          import foo from "./bar";
+          import foo, DoesNotExist from "./bar";
           struct Zoo { foo: foo.Foo; }
         `);
                 const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
@@ -719,8 +719,15 @@ describe("module set", () => {
                         {
                             token: {
                                 text: "foo",
+                                position: 18,
                             },
-                            message: "Cannot reimport imported name 'foo'",
+                            message: "Not a record",
+                        },
+                        {
+                            token: {
+                                text: "DoesNotExist",
+                            },
+                            message: "Not found",
                         },
                     ],
                 });
@@ -746,7 +753,7 @@ describe("module set", () => {
                             token: {
                                 text: "Foo",
                             },
-                            message: "Cannot reimport imported name 'Foo'",
+                            message: "Cannot refer to imports of imported module",
                         },
                     ],
                 });
@@ -772,7 +779,7 @@ describe("module set", () => {
                             token: {
                                 text: "foo",
                             },
-                            message: "Cannot reimport imported name 'foo'",
+                            message: "Cannot refer to imports of imported module",
                         },
                     ],
                 });
@@ -1326,5 +1333,565 @@ describe("module set", () => {
             });
         });
     });
+    describe("doc comment references", () => {
+        it("resolves reference to enum field", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          /// Hello [Bar.OK]
+          struct Foo {
+            x: int32;
+          }
+
+          enum Bar { OK; }
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            const fooRecord = actual.result?.records.find((r) => r.record?.name.text === "Foo");
+            expect(fooRecord).toMatch({
+                record: {
+                    name: { text: "Foo" },
+                    doc: {
+                        pieces: [
+                            { kind: "text", text: "Hello " },
+                            {
+                                kind: "reference",
+                                nameChain: [{ text: "Bar" }, { text: "OK" }],
+                                referee: {
+                                    kind: "field",
+                                    field: { name: { text: "OK" } },
+                                    record: { name: { text: "Bar" } },
+                                },
+                            },
+                        ],
+                    },
+                },
+            });
+            expect(actual.errors).toMatch([]);
+        });
+        it("resolves reference to sibling field", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          struct Foo {
+            x: int32;
+            /// Must be different from [x]
+            y: int32;
+          }
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            expect(actual).toMatch({
+                result: {
+                    records: [
+                        {
+                            record: {
+                                fields: [
+                                    { name: { text: "x" } },
+                                    {
+                                        name: { text: "y" },
+                                        doc: {
+                                            pieces: [
+                                                { kind: "text", text: "Must be different from " },
+                                                {
+                                                    kind: "reference",
+                                                    nameChain: [{ text: "x" }],
+                                                    referee: {
+                                                        kind: "field",
+                                                        field: { name: { text: "x" } },
+                                                        record: { name: { text: "Foo" } },
+                                                    },
+                                                },
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+                errors: [],
+            });
+        });
+        it("resolves reference to record", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          /// See [Bar] for details
+          struct Foo {
+            x: int32;
+          }
+
+          struct Bar {}
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            const fooRecord = actual.result?.records.find((r) => r.record?.name.text === "Foo");
+            expect(fooRecord).toMatch({
+                record: {
+                    name: { text: "Foo" },
+                    doc: {
+                        pieces: [
+                            { kind: "text", text: "See " },
+                            {
+                                kind: "reference",
+                                nameChain: [{ text: "Bar" }],
+                                referee: { kind: "record", name: { text: "Bar" } },
+                            },
+                            { kind: "text", text: " for details" },
+                        ],
+                    },
+                },
+            });
+            expect(actual.errors).toMatch([]);
+        });
+        it("resolves reference to nested record", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          /// Uses [Outer.Inner]
+          struct Foo {
+            x: int32;
+          }
+
+          struct Outer {
+            struct Inner {}
+          }
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            const fooRecord = actual.result?.records.find((r) => r.record?.name.text === "Foo");
+            expect(fooRecord).toMatch({
+                record: {
+                    name: { text: "Foo" },
+                    doc: {
+                        pieces: [
+                            { kind: "text", text: "Uses " },
+                            {
+                                kind: "reference",
+                                nameChain: [{ text: "Outer" }, { text: "Inner" }],
+                                referee: { kind: "record", name: { text: "Inner" } },
+                            },
+                        ],
+                    },
+                },
+            });
+            expect(actual.errors).toMatch([]);
+        });
+        it("resolves absolute reference", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          struct Outer {
+            /// Reference to [.Bar]
+            struct Inner {}
+            struct Bar {}
+          }
+
+          struct Bar {}
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            const outerRecord = actual.result?.records.find((r) => r.record?.name.text === "Outer");
+            expect(outerRecord).toMatch({
+                record: {
+                    name: { text: "Outer" },
+                    nestedRecords: [
+                        {
+                            name: { text: "Inner" },
+                            doc: {
+                                pieces: [
+                                    { kind: "text", text: "Reference to " },
+                                    {
+                                        kind: "reference",
+                                        absolute: true,
+                                        nameChain: [{ text: "Bar" }],
+                                        referee: {
+                                            kind: "record",
+                                            name: { text: "Bar", colNumber: 17 },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        {
+                            name: { text: "Bar", colNumber: 19 },
+                        },
+                    ],
+                },
+            });
+            expect(actual.errors).toMatch([]);
+        });
+        it("resolves reference to method", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          /// Calls [GetData]
+          struct Foo {}
+
+          method GetData(Foo): Foo;
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            expect(actual).toMatch({
+                result: {
+                    records: [
+                        {
+                            record: {
+                                name: { text: "Foo" },
+                                doc: {
+                                    pieces: [
+                                        { kind: "text", text: "Calls " },
+                                        {
+                                            kind: "reference",
+                                            nameChain: [{ text: "GetData" }],
+                                            referee: { kind: "method", name: { text: "GetData" } },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    ],
+                },
+                errors: [],
+            });
+        });
+        it("resolves reference to constant", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          /// Default is [DEFAULT_VALUE]
+          struct Foo {
+            x: int32;
+          }
+
+          const DEFAULT_VALUE: int32 = 42;
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            expect(actual).toMatch({
+                result: {
+                    records: [
+                        {
+                            record: {
+                                name: { text: "Foo" },
+                                doc: {
+                                    pieces: [
+                                        { kind: "text", text: "Default is " },
+                                        {
+                                            kind: "reference",
+                                            nameChain: [{ text: "DEFAULT_VALUE" }],
+                                            referee: {
+                                                kind: "constant",
+                                                name: { text: "DEFAULT_VALUE" },
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    ],
+                },
+                errors: [],
+            });
+        });
+        it("resolves reference from field type scope", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          struct Foo {
+            /// Uses [OK] from the Bar enum
+            bar: Bar;
+          }
+
+          enum Bar { OK; }
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            const fooRecord = actual.result?.records.find((r) => r.record?.name.text === "Foo");
+            expect(fooRecord).toMatch({
+                record: {
+                    name: { text: "Foo" },
+                    fields: [
+                        {
+                            name: { text: "bar" },
+                            doc: {
+                                pieces: [
+                                    { kind: "text", text: "Uses " },
+                                    {
+                                        kind: "reference",
+                                        nameChain: [{ text: "OK" }],
+                                        referee: {
+                                            kind: "field",
+                                            field: { name: { text: "OK" } },
+                                            record: { name: { text: "Bar" } },
+                                        },
+                                    },
+                                    { kind: "text", text: " from the Bar enum" },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            });
+            expect(actual.errors).toMatch([]);
+        });
+        it("resolves reference from method request type scope", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          struct Request {
+            x: int32;
+          }
+
+          struct Response {}
+
+          /// Input [x] must be positive
+          method DoWork(Request): Response;
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            expect(actual).toMatch({
+                result: {
+                    methods: [
+                        {
+                            name: { text: "DoWork" },
+                            doc: {
+                                pieces: [
+                                    { kind: "text", text: "Input " },
+                                    {
+                                        kind: "reference",
+                                        nameChain: [{ text: "x" }],
+                                        referee: {
+                                            kind: "field",
+                                            field: { name: { text: "x" } },
+                                            record: { name: { text: "Request" } },
+                                        },
+                                    },
+                                    { kind: "text", text: " must be positive" },
+                                ],
+                            },
+                        },
+                    ],
+                },
+                errors: [],
+            });
+        });
+        it("resolves reference from constant type scope", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          enum Status { OK; }
+
+          /// Default status is [OK]
+          const DEFAULT_STATUS: Status = "OK";
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            expect(actual).toMatch({
+                result: {
+                    constants: [
+                        {
+                            name: { text: "DEFAULT_STATUS" },
+                            doc: {
+                                pieces: [
+                                    { kind: "text", text: "Default status is " },
+                                    {
+                                        kind: "reference",
+                                        nameChain: [{ text: "OK" }],
+                                        referee: {
+                                            kind: "field",
+                                            field: { name: { text: "OK" } },
+                                            record: { name: { text: "Status" } },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+                errors: [],
+            });
+        });
+        it("resolves multiple references in same doc comment", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          /// Compare [Foo] and [Bar]
+          struct Baz {}
+
+          struct Foo {}
+          struct Bar {}
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            const bazRecord = actual.result?.records.find((r) => r.record?.name.text === "Baz");
+            expect(bazRecord).toMatch({
+                record: {
+                    name: { text: "Baz" },
+                    doc: {
+                        pieces: [
+                            { kind: "text", text: "Compare " },
+                            {
+                                kind: "reference",
+                                nameChain: [{ text: "Foo" }],
+                                referee: { kind: "record", name: { text: "Foo" } },
+                            },
+                            { kind: "text", text: " and " },
+                            {
+                                kind: "reference",
+                                nameChain: [{ text: "Bar" }],
+                                referee: { kind: "record", name: { text: "Bar" } },
+                            },
+                        ],
+                    },
+                },
+            });
+            expect(actual.errors).toMatch([]);
+        });
+        it("resolves reference through import alias", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          import * as other from "./other";
+
+          /// Uses [other.Foo]
+          struct Bar {}
+        `);
+            fakeFileReader.pathToCode.set("path/to/root/other", `
+          struct Foo {}
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            const barRecord = actual.result?.records.find((r) => r.record?.name.text === "Bar");
+            expect(barRecord).toMatch({
+                record: {
+                    name: { text: "Bar" },
+                    doc: {
+                        pieces: [
+                            { kind: "text", text: "Uses " },
+                            {
+                                kind: "reference",
+                                nameChain: [{ text: "other" }, { text: "Foo" }],
+                                referee: { kind: "record", name: { text: "Foo" } },
+                            },
+                        ],
+                    },
+                },
+            });
+            expect(actual.errors).toMatch([{ message: "Unused import alias" }]);
+        });
+        it("resolves reference through import", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          import * as other from "./other";
+
+          /// Uses [other.Foo]
+          struct Bar {}
+        `);
+            fakeFileReader.pathToCode.set("path/to/root/other", `
+          struct Foo {}
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            const barRecord = actual.result?.records.find((r) => r.record?.name.text === "Bar");
+            expect(barRecord).toMatch({
+                record: {
+                    name: { text: "Bar" },
+                    doc: {
+                        pieces: [
+                            { kind: "text", text: "Uses " },
+                            {
+                                kind: "reference",
+                                nameChain: [{ text: "other" }, { text: "Foo" }],
+                                referee: { kind: "record", name: { text: "Foo" } },
+                            },
+                        ],
+                    },
+                },
+            });
+            expect(actual.errors).toMatch([{ message: "Unused import alias" }]);
+        });
+        it("reports error for unresolved reference", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          /// See [NonExistent]
+          struct Foo {}
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            expect(actual).toMatch({
+                result: {},
+                errors: [
+                    {
+                        token: { text: "[NonExistent]" },
+                        message: "Cannot resolve reference",
+                    },
+                ],
+            });
+        });
+        it("reports error for unresolved nested reference", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          /// See [Bar.NonExistent]
+          struct Foo {}
+
+          struct Bar {}
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            expect(actual).toMatch({
+                result: {},
+                errors: [
+                    {
+                        token: { text: "[Bar.NonExistent]" },
+                        message: "Cannot resolve reference",
+                    },
+                ],
+            });
+        });
+        it("prioritizes nested scope over module scope", () => {
+            const fakeFileReader = new FakeFileReader();
+            fakeFileReader.pathToCode.set("path/to/root/module", `
+          struct Outer {
+            struct Inner {
+              /// Reference to [Foo] (nested)
+              x: int32;
+            }
+            struct Foo {}
+          }
+
+          struct Foo {}
+        `);
+            const moduleSet = ModuleSet.create(fakeFileReader, "path/to/root");
+            const actual = moduleSet.parseAndResolve("module");
+            // Find the Outer record
+            const outerRecord = actual.result?.records.find((r) => r.record.name.text === "Outer");
+            expect(outerRecord).toMatch({
+                record: {
+                    name: { text: "Outer" },
+                    nestedRecords: [
+                        {
+                            name: { text: "Inner" },
+                            fields: [
+                                {
+                                    name: { text: "x" },
+                                    doc: {
+                                        pieces: [
+                                            { kind: "text", text: "Reference to " },
+                                            {
+                                                kind: "reference",
+                                                nameChain: [{ text: "Foo" }],
+                                                // Should resolve to Outer.Foo, not the top-level Foo
+                                                referee: {
+                                                    kind: "record",
+                                                    name: { text: "Foo" },
+                                                },
+                                            },
+                                            { kind: "text", text: " (nested)" },
+                                        ],
+                                    },
+                                },
+                            ],
+                        },
+                        {
+                            name: { text: "Foo" },
+                        },
+                    ],
+                },
+            });
+            expect(actual).toMatch({
+                errors: [],
+            });
+        });
+    });
 });
 //# sourceMappingURL=module_set.test.js.map