jsii-diff 1.114.1 → 1.115.0

package/bin/jsii-diff.js

@@ -11,6 +11,7 @@ const diagnostics_1 = require("../lib/diagnostics");
 const util_1 = require("../lib/util");
 const version_1 = require("../lib/version");
 const LOG = log4js.getLogger('jsii-diff');
+const ASSEMBLY_SUPPORTED_FEATURES = ['intersection-types'];
 async function main() {
     const argv = await yargs
         .env('JSII_DIFF')
@@ -177,9 +178,15 @@ async function loadFromFilesystem(name, options) {
     const stat = await fs.stat(name);
     const ts = new reflect.TypeSystem();
     if (stat.isDirectory()) {
-        return ts.loadModule(name, options);
+        return ts.loadModule(name, {
+            ...options,
+            supportedFeatures: ASSEMBLY_SUPPORTED_FEATURES,
+        });
     }
-    return ts.loadFile(name, options);
+    return ts.loadFile(name, {
+        ...options,
+        supportedFeatures: ASSEMBLY_SUPPORTED_FEATURES,
+    });
 }
 main()
     .then((n) => {

package/lib/type-analysis.js

@@ -56,6 +56,22 @@ function isSuperType(a, b, updatedSystem) {
         }
         return failure(`none of ${b.toString()} are assignable to ${a.toString()}`, ...(0, util_1.flatMap)(analyses, (x) => (x.success ? [] : x.reasons)));
     }
+    // intersection A ⊒ B <=> all of the elements of A ⊒ B
+    if (a.intersectionOfTypes !== undefined) {
+        const analyses = a.intersectionOfTypes.map((aaa) => isSuperType(aaa, b, updatedSystem));
+        if (analyses.every((x) => x.success)) {
+            return { success: true };
+        }
+        return failure(`${b.toString()} is not assignable to all of ${a.toString()}`, ...(0, util_1.flatMap)(analyses, (x) => (x.success ? [] : x.reasons)));
+    }
+    // A ⊒ intersection B <=> A ⊒ any of the elements of B
+    if (b.intersectionOfTypes !== undefined) {
+        const analyses = b.intersectionOfTypes.map((bbb) => isSuperType(a, bbb, updatedSystem));
+        if (analyses.some((x) => x.success)) {
+            return { success: true };
+        }
+        return failure(`some of ${b.toString()} are not assignable to ${a.toString()}`, ...(0, util_1.flatMap)(analyses, (x) => (x.success ? [] : x.reasons)));
+    }
     // We have two named types, recursion might happen so protect against it.
     try {
         // For named types, we'll always do a nominal typing relationship.

package/lib/version.d.ts

@@ -1,3 +1,3 @@
 /** The qualified version number for this JSII compiler. */
-export declare const VERSION = "1.114.1 (build 8a29f60)";
+export declare const VERSION = "1.115.0 (build 9c5134e)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,7 +1,7 @@
 "use strict";
-// Generated at 2025-09-04T13:08:56Z by generate.sh
+// Generated at 2025-09-29T13:26:02Z by generate.sh
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 /** The qualified version number for this JSII compiler. */
-exports.VERSION = '1.114.1 (build 8a29f60)';
+exports.VERSION = '1.115.0 (build 9c5134e)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-diff",
-  "version": "1.114.1",
+  "version": "1.115.0",
   "description": "Assembly comparison for jsii",
   "license": "Apache-2.0",
   "author": {
@@ -33,10 +33,10 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/check-node": "1.114.1",
-    "@jsii/spec": "1.114.1",
+    "@jsii/check-node": "1.115.0",
+    "@jsii/spec": "1.115.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.114.1",
+    "jsii-reflect": "^1.115.0",
     "log4js": "^6.9.1",
     "yargs": "^17.7.2"
   },
@@ -45,7 +45,7 @@
     "@types/tar-fs": "^2.0.4",
     "@types/yargs": "^17.0.33",
     "jest-expect-message": "^1.1.3",
-    "jsii": "^5.9.1",
-    "jsii-build-tools": "^1.114.1"
+    "jsii": "^5.9.6",
+    "jsii-build-tools": "^1.115.0"
   }
 }

package/test/type-intersections.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=type-intersections.test.d.ts.map

package/test/type-intersections.test.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("./util");
+jest.setTimeout(50000);
+const PREAMBLE = `
+export interface IFoo {
+  readonly foo: string;
+}
+
+export interface IBar {
+  readonly bar: string;
+}
+
+export interface IBaz {
+  readonly baz: string;
+}
+
+export interface ICombined extends IFoo, IBar { }
+`;
+describe.each(['argument', 'prop'])('%s position', (where) => {
+    function sources(old, noo) {
+        return [old, noo].map((type) => {
+            switch (where) {
+                case 'argument':
+                    return `
+            ${PREAMBLE}
+            export class Api {
+              public static fooAndBar(x: ${type}) {
+                void(x);
+                return '';
+              }
+            }`;
+                case 'prop':
+                    return `
+          ${PREAMBLE}
+          export interface Props {
+            readonly input: ${type};
+          }
+          export class Api {
+            public static fooAndBar(props: Props) {
+              Array.isArray(props);
+              return '';
+            }
+          }`;
+            }
+        });
+    }
+    // ----------------------------------------------------------------------
+    test('types can remain unchanged', () => (0, util_1.expectNoError)(...sources('IFoo & IBar', 'IFoo & IBar')));
+    // ----------------------------------------------------------------------
+    test('can turn interface into intersection', () => (0, util_1.expectNoError)(...sources('ICombined', 'IFoo & IBar')));
+    // ----------------------------------------------------------------------
+    test('can not turn interface into intersection that requires a non-extended type', () => (0, util_1.expectError)(/testpkg.ICombined does not extend testpkg.IBaz/, ...sources('ICombined', 'IFoo & IBaz')));
+    // ----------------------------------------------------------------------
+    test('can turn part of union into intersection', () => (0, util_1.expectNoError)(...sources('string | ICombined', 'string | (IFoo & IBar)')));
+    // ----------------------------------------------------------------------
+    test('can require fewer intersection elements', () => (0, util_1.expectNoError)(...sources('IFoo & IBar & IBaz', 'IFoo & IBar')));
+    // ----------------------------------------------------------------------
+    test('can not add intersection elements', () => (0, util_1.expectError)(/some of testpkg.IBar & testpkg.IFoo are not assignable to testpkg.IBaz/, ...sources('IFoo & IBar', 'IFoo & IBar & IBaz')));
+});
+// ----------------------------------------------------------------------
+test('allow requiring a new interface in intersection if interface is extended at the same time', () => (0, util_1.expectNoError)(`
+    ${PREAMBLE}
+    export interface IChangeable extends IFoo {}
+
+    export class Api {
+      public static fooAndBar(x: IChangeable) {
+        void(x);
+        return '';
+      }
+    }`, `
+    ${PREAMBLE}
+    export interface IChangeable extends IFoo, IBar {}
+
+    export class Api {
+      public static fooAndBar(x: IFoo & IBar) {
+        void(x);
+        return '';
+      }
+    }`));
+//# sourceMappingURL=type-intersections.test.js.map

package/test/util.js

@@ -11,7 +11,7 @@ function expectNoError(original, updated) {
     for (const msg of mms.messages()) {
         console.error(`- ${msg}`);
     }
-    expect(mms.count).toBe(0);
+    expect(Array.from(mms.messages())).toEqual([]);
 }
 function expectError(error, original, updated) {
     if (error == null) {