skir 0.0.1

package/dist/compatibility_checker.test.js

@@ -0,0 +1,528 @@
+import { expect } from "buckwheat";
+import { describe, it } from "mocha";
+import { checkBackwardCompatibility, } from "./compatibility_checker.js";
+import { ModuleSet } from "./module_set.js";
+describe("compatibility checker", () => {
+    it("compatible changes", () => {
+        expect(doCheckBackwardCompatibility({
+            before: `
+          struct Point {
+            x: int32;
+            y: int32;
+          }
+
+          struct Triangle(789) {
+            a: Point;
+            b: Point;
+            removed;
+            c: Point;
+            other_points: [Point];
+          }
+
+          enum Status {
+            OK;
+            error: string;
+          }
+
+          struct Rec(790) {
+            self: Rec;
+            struct Foo {
+              value: int32;
+              rec: Rec;
+            }
+            foo: Foo;
+            foos: [Foo];
+          }
+
+          method Capitalize(string): string = 101;
+        `,
+            after: `
+          struct PointPoint {
+            xx: int64;
+            yy: float32;
+          }
+
+          struct Triangle(789) {
+            a: PointPoint;
+            b: PointPoint;
+            removed;
+            c: PointPoint;
+            other_points: [PointPoint];
+            removed;
+            new_field: string;
+          }
+
+          struct Foo(791) {}
+
+          enum Status {
+            OK;
+            error: string;
+            new_variant: int32;
+            NEW_CONSTANT;
+            removed;
+          }
+
+          struct RecRec(790) {
+            self: RecRec;
+            struct Foo {
+              value: int32;
+              rec: RecRec;
+              removed;
+            }
+            foo: Foo;
+            foos: [Foo];
+            new_field: bool;
+          }
+
+          method Capitalize(string): string = 101;
+          method Lowercase(string): string = 102;`,
+        })).toMatch([]);
+    });
+    it("missing slots", () => {
+        expect(doCheckBackwardCompatibility({
+            before: `
+          struct A(101) {
+            foo: string;
+            removed;
+            bar: string;
+            removed;
+          }
+        `,
+            after: `
+          struct B(101) {
+            foo: string;
+            removed;
+          }
+        `,
+        })).toMatch([
+            {
+                kind: "missing-slots",
+                record: {
+                    before: {
+                        record: {
+                            name: {
+                                text: "A",
+                            },
+                        },
+                    },
+                    after: {
+                        record: {
+                            name: {
+                                text: "B",
+                            },
+                        },
+                    },
+                },
+                recordExpression: {
+                    before: {
+                        kind: "record",
+                        recordName: {
+                            text: "A",
+                        },
+                    },
+                    after: {
+                        kind: "record",
+                        recordName: {
+                            text: "B",
+                        },
+                    },
+                },
+                missingRangeStart: 2,
+                missingRangeEnd: 4,
+            },
+        ]);
+    });
+    it("missing record", () => {
+        expect(doCheckBackwardCompatibility({
+            before: `
+          struct A(101) {
+            foo: string;
+          }
+        `,
+            after: `
+          struct A {
+          }
+        `,
+        })).toMatch([
+            {
+                kind: "missing-record",
+                record: {
+                    record: {
+                        name: {
+                            text: "A",
+                        },
+                    },
+                },
+                recordNumber: 101,
+            },
+        ]);
+    });
+    it("missing method", () => {
+        expect(doCheckBackwardCompatibility({
+            before: `
+          method Capitalize(string): string = 101;
+        `,
+            after: `
+          method Capitalize(string): string;
+        `,
+        })).toMatch([
+            {
+                kind: "missing-method",
+                method: {
+                    name: {
+                        text: "Capitalize",
+                    },
+                    number: 101,
+                },
+            },
+        ]);
+    });
+    it("removed number reintroduced", () => {
+        expect(doCheckBackwardCompatibility({
+            before: `
+          struct A(101) {
+            foo: string;
+            removed;
+            bar: string;
+            removed;
+          }
+        `,
+            after: `
+          struct B(101) {
+            foo: string;
+            removed;
+            bar: string;
+            zoo: int32;
+          }
+        `,
+        })).toMatch([
+            {
+                kind: "removed-number-reintroduced",
+                record: {
+                    before: {
+                        record: {
+                            name: {
+                                text: "A",
+                            },
+                        },
+                    },
+                    after: {
+                        record: {
+                            name: {
+                                text: "B",
+                            },
+                        },
+                    },
+                },
+                recordExpression: {
+                    before: {
+                        kind: "record",
+                        recordName: {
+                            text: "A",
+                        },
+                    },
+                    after: {
+                        kind: "record",
+                        recordName: {
+                            text: "B",
+                        },
+                    },
+                },
+                removedNumber: 3,
+            },
+        ]);
+    });
+    it("record kind change", () => {
+        expect(doCheckBackwardCompatibility({
+            before: `
+          struct Bar {}
+
+          struct Foo {
+            bar: [Bar];
+          }
+
+          struct A(101) {
+            foo: Foo?;
+          }
+        `,
+            after: `
+          enum BarBar {}
+
+          struct Foo {
+            barbar: [BarBar];
+            bar: BarBar;
+          }
+
+          struct A(101) {
+            foo: Foo?;
+          }
+        `,
+        })).toMatch([
+            {
+                kind: "record-kind-change",
+                record: {
+                    before: {
+                        record: {
+                            name: {
+                                text: "Bar",
+                            },
+                        },
+                    },
+                    after: {
+                        record: {
+                            name: {
+                                text: "BarBar",
+                            },
+                        },
+                    },
+                },
+                recordExpression: {
+                    before: {
+                        kind: "item",
+                        arrayExpression: {
+                            kind: "property",
+                            structExpression: {
+                                kind: "optional-value",
+                                optionalExpression: {
+                                    kind: "property",
+                                    structExpression: {
+                                        kind: "record",
+                                        recordName: {
+                                            text: "A",
+                                        },
+                                    },
+                                    fieldName: {
+                                        text: "foo",
+                                    },
+                                },
+                            },
+                            fieldName: {
+                                text: "bar",
+                            },
+                        },
+                    },
+                    after: {
+                        kind: "item",
+                        arrayExpression: {
+                            kind: "property",
+                            structExpression: {
+                                kind: "optional-value",
+                                optionalExpression: {
+                                    kind: "property",
+                                    structExpression: {
+                                        kind: "record",
+                                        recordName: {
+                                            text: "A",
+                                        },
+                                    },
+                                    fieldName: {
+                                        text: "foo",
+                                    },
+                                },
+                            },
+                            fieldName: {
+                                text: "barbar",
+                            },
+                        },
+                    },
+                },
+                recordType: {
+                    before: "struct",
+                    after: "enum",
+                },
+            },
+        ]);
+    });
+    it("enum variant kind change", () => {
+        expect(doCheckBackwardCompatibility({
+            before: `
+          enum E(100) {
+            a: string;
+          }
+        `,
+            after: `
+          enum EE(100) {
+            A;
+          }
+        `,
+        })).toMatch([
+            {
+                kind: "enum-variant-kind-change",
+                enumEpression: {
+                    before: {
+                        kind: "record",
+                        recordName: {
+                            text: "E",
+                        },
+                    },
+                    after: {
+                        kind: "record",
+                        recordName: {
+                            text: "EE",
+                        },
+                    },
+                },
+                variantName: {
+                    before: {
+                        text: "a",
+                    },
+                    after: {
+                        text: "A",
+                    },
+                },
+            },
+        ]);
+    });
+    it("primitive type compatibility", () => {
+        // Compatible primitive type changes
+        expect(doCheckBackwardCompatibility({
+            before: `
+          struct A(101) {
+            bool_field: bool;
+            int32_field: int32;
+            int64_field: int64;
+            uint64_field: uint64;
+            float32_field: float32;
+            float64_field: float64;
+          }
+        `,
+            after: `
+          struct A(101) {
+            bool_field: int64;
+            int32_field: float64;
+            int64_field: float32;
+            uint64_field: float64;
+            float32_field: float64;
+            float64_field: float32;
+          }
+        `,
+        })).toMatch([]);
+        // Incompatible primitive type changes
+        expect(doCheckBackwardCompatibility({
+            before: `
+          struct B(102) {
+            str: string;
+            num: int32;
+          }
+        `,
+            after: `
+          struct B(102) {
+            str: bytes;
+            num: string;
+          }
+        `,
+        })).toMatch([
+            {
+                kind: "illegal-type-change",
+                expression: {
+                    before: {
+                        kind: "property",
+                        structExpression: {
+                            kind: "record",
+                            recordName: {
+                                text: "B",
+                            },
+                        },
+                        fieldName: {
+                            text: "str",
+                        },
+                    },
+                    after: {
+                        kind: "property",
+                        structExpression: {
+                            kind: "record",
+                            recordName: {
+                                text: "B",
+                            },
+                        },
+                        fieldName: {
+                            text: "str",
+                        },
+                    },
+                },
+            },
+            {
+                kind: "illegal-type-change",
+                expression: {
+                    before: {
+                        kind: "property",
+                        structExpression: {
+                            kind: "record",
+                            recordName: {
+                                text: "B",
+                            },
+                        },
+                        fieldName: {
+                            text: "num",
+                        },
+                    },
+                    after: {
+                        kind: "property",
+                        structExpression: {
+                            kind: "record",
+                            recordName: {
+                                text: "B",
+                            },
+                        },
+                        fieldName: {
+                            text: "num",
+                        },
+                    },
+                },
+            },
+        ]);
+    });
+    it("incompatible method request/response types", () => {
+        expect(doCheckBackwardCompatibility({
+            before: `
+          method Get(string): string = 101;
+        `,
+            after: `
+          method Get(bool): bool = 101; 
+        `,
+        })).toMatch([
+            {
+                kind: "illegal-type-change",
+                expression: {
+                    before: {
+                        kind: "request-type",
+                    },
+                    after: {
+                        kind: "request-type",
+                    },
+                },
+                type: {
+                    before: {
+                        kind: "primitive",
+                        primitive: "string",
+                    },
+                    after: {
+                        kind: "primitive",
+                        primitive: "bool",
+                    },
+                },
+            },
+        ]);
+    });
+});
+function doCheckBackwardCompatibility(sourceCode) {
+    const moduleSet = {
+        before: parseModuleSet(sourceCode.before),
+        after: parseModuleSet(sourceCode.after),
+    };
+    return checkBackwardCompatibility(moduleSet);
+}
+function parseModuleSet(sourceCode) {
+    const modulePath = "path/to/module";
+    const modulePathToSourceCode = new Map();
+    modulePathToSourceCode.set(modulePath, sourceCode);
+    const moduleSet = ModuleSet.fromMap(modulePathToSourceCode);
+    const { errors } = moduleSet.parseAndResolve(modulePath);
+    if (errors.length > 0) {
+        const firstError = errors[0];
+        const message = firstError.message ?? `expected: ${firstError.expected}`;
+        throw new Error("Error while parsing module set: " + message);
+    }
+    return moduleSet;
+}
+//# sourceMappingURL=compatibility_checker.test.js.map

package/dist/compatibility_checker.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility_checker.test.js","sourceRoot":"","sources":["../src/compatibility_checker.test.ts"],"names":[],"mappings":"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"}

package/dist/compiler.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=compiler.d.ts.map

package/dist/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":""}