jsii-diff 1.35.0

package/lib/diagnostics.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyDiagnostics = exports.hasErrors = exports.formatDiagnostic = exports.DiagLevel = void 0;
+const spec_1 = require("@jsii/spec");
+var DiagLevel;
+(function (DiagLevel) {
+    DiagLevel[DiagLevel["Error"] = 0] = "Error";
+    DiagLevel[DiagLevel["Warning"] = 1] = "Warning";
+    DiagLevel[DiagLevel["Skipped"] = 2] = "Skipped";
+})(DiagLevel = exports.DiagLevel || (exports.DiagLevel = {}));
+const LEVEL_PREFIX = {
+    [DiagLevel.Error]: 'err ',
+    [DiagLevel.Warning]: 'warn',
+    [DiagLevel.Skipped]: 'skip',
+};
+function formatDiagnostic(diag, includeSuppressionKey = false) {
+    return [
+        LEVEL_PREFIX[diag.level],
+        '-',
+        diag.message,
+        ...(includeSuppressionKey ? [`[${diag.suppressionKey}]`] : []),
+    ].join(' ');
+}
+exports.formatDiagnostic = formatDiagnostic;
+function hasErrors(diags) {
+    return diags.some((diag) => diag.level === DiagLevel.Error);
+}
+exports.hasErrors = hasErrors;
+/**
+ * Classify API mismatches into a set of warnings and errors
+ */
+function classifyDiagnostics(mismatches, experimentalErrors, skipFilter) {
+    const ret = mismatches.mismatches.map((mis) => ({
+        level: level(mis),
+        message: mis.message,
+        suppressionKey: mis.violationKey,
+    }));
+    ret.sort((a, b) => a.level - b.level);
+    return ret;
+    function level(mis) {
+        if (skipFilter.has(mis.violationKey)) {
+            return DiagLevel.Skipped;
+        }
+        if (mis.stability === spec_1.Stability.Stable ||
+            (mis.stability === spec_1.Stability.Experimental && experimentalErrors)) {
+            return DiagLevel.Error;
+        }
+        return DiagLevel.Warning;
+    }
+}
+exports.classifyDiagnostics = classifyDiagnostics;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+import * as reflect from 'jsii-reflect';
+import { ComparisonOptions, Mismatches } from './types';
+/**
+ * Compare two assemblies
+ *
+ * We currently only check for compatibility (a full diff is
+ * harder :). The only thing we have to do is check for every API
+ * item whether it's still available and has the same shape (or
+ * bigger) in the new API.
+ */
+export declare function compareAssemblies(original: reflect.Assembly, updated: reflect.Assembly, options?: ComparisonOptions): Mismatches;

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareAssemblies = void 0;
+const type_comparison_1 = require("./type-comparison");
+/**
+ * Compare two assemblies
+ *
+ * We currently only check for compatibility (a full diff is
+ * harder :). The only thing we have to do is check for every API
+ * item whether it's still available and has the same shape (or
+ * bigger) in the new API.
+ */
+function compareAssemblies(original, updated, options = {}) {
+    const comparison = new type_comparison_1.AssemblyComparison(options);
+    comparison.load(original, updated);
+    comparison.compare();
+    return comparison.mismatches;
+}
+exports.compareAssemblies = compareAssemblies;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFQSx1REFBdUQ7QUFHdkQ7Ozs7Ozs7R0FPRztBQUNILFNBQWdCLGlCQUFpQixDQUMvQixRQUEwQixFQUMxQixPQUF5QixFQUN6QixVQUE2QixFQUFFO0lBRS9CLE1BQU0sVUFBVSxHQUFHLElBQUksb0NBQWtCLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDbkQsVUFBVSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDbkMsVUFBVSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBRXJCLE9BQU8sVUFBVSxDQUFDLFVBQVUsQ0FBQztBQUMvQixDQUFDO0FBVkQsOENBVUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyByZWZsZWN0IGZyb20gJ2pzaWktcmVmbGVjdCc7XG5cbmltcG9ydCB7IEFzc2VtYmx5Q29tcGFyaXNvbiB9IGZyb20gJy4vdHlwZS1jb21wYXJpc29uJztcbmltcG9ydCB7IENvbXBhcmlzb25PcHRpb25zLCBNaXNtYXRjaGVzIH0gZnJvbSAnLi90eXBlcyc7XG5cbi8qKlxuICogQ29tcGFyZSB0d28gYXNzZW1ibGllc1xuICpcbiAqIFdlIGN1cnJlbnRseSBvbmx5IGNoZWNrIGZvciBjb21wYXRpYmlsaXR5IChhIGZ1bGwgZGlmZiBpc1xuICogaGFyZGVyIDopLiBUaGUgb25seSB0aGluZyB3ZSBoYXZlIHRvIGRvIGlzIGNoZWNrIGZvciBldmVyeSBBUElcbiAqIGl0ZW0gd2hldGhlciBpdCdzIHN0aWxsIGF2YWlsYWJsZSBhbmQgaGFzIHRoZSBzYW1lIHNoYXBlIChvclxuICogYmlnZ2VyKSBpbiB0aGUgbmV3IEFQSS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGNvbXBhcmVBc3NlbWJsaWVzKFxuICBvcmlnaW5hbDogcmVmbGVjdC5Bc3NlbWJseSxcbiAgdXBkYXRlZDogcmVmbGVjdC5Bc3NlbWJseSxcbiAgb3B0aW9uczogQ29tcGFyaXNvbk9wdGlvbnMgPSB7fSxcbik6IE1pc21hdGNoZXMge1xuICBjb25zdCBjb21wYXJpc29uID0gbmV3IEFzc2VtYmx5Q29tcGFyaXNvbihvcHRpb25zKTtcbiAgY29tcGFyaXNvbi5sb2FkKG9yaWdpbmFsLCB1cGRhdGVkKTtcbiAgY29tcGFyaXNvbi5jb21wYXJlKCk7XG5cbiAgcmV0dXJuIGNvbXBhcmlzb24ubWlzbWF0Y2hlcztcbn1cbiJdfQ==

package/lib/stability.d.ts

@@ -0,0 +1,3 @@
+import * as reflect from 'jsii-reflect';
+import { ApiElement, IReport } from './types';
+export declare function validateStabilities(original: reflect.Documentable & ApiElement, updated: reflect.Documentable, mismatches: IReport): void;

package/lib/stability.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStabilities = void 0;
+const spec = require("@jsii/spec");
+function validateStabilities(original, updated, mismatches) {
+    // Nothing to do in these cases
+    if (original.docs.stability === undefined ||
+        original.docs.stability === updated.docs.stability) {
+        return;
+    }
+    // Not allowed to disavow stability
+    if (updated.docs.stability === undefined) {
+        mismatches.report({
+            ruleKey: 'removed-stability',
+            message: `stability was '${original.docs.stability}', has been removed`,
+            violator: original,
+        });
+        return;
+    }
+    const allowed = allowedTransitions(original.docs.stability);
+    if (!allowed.includes(updated.docs.stability)) {
+        mismatches.report({
+            ruleKey: 'changed-stability',
+            message: `stability not allowed to go from '${original.docs.stability}' to '${updated.docs.stability}'`,
+            violator: original,
+        });
+    }
+}
+exports.validateStabilities = validateStabilities;
+function allowedTransitions(start) {
+    switch (start) {
+        // Experimental can go to stable, external, or be deprecated
+        case spec.Stability.Experimental:
+            return [
+                spec.Stability.Stable,
+                spec.Stability.Deprecated,
+                spec.Stability.External,
+            ];
+        // Stable can be deprecated, or switched to external
+        case spec.Stability.Stable:
+            return [spec.Stability.Deprecated, spec.Stability.External];
+        // Deprecated can be reinstated
+        case spec.Stability.Deprecated:
+            return [spec.Stability.Stable, spec.Stability.External];
+        // external can be stableified, or deprecated
+        case spec.Stability.External:
+            return [spec.Stability.Stable, spec.Stability.Deprecated];
+        default:
+            throw new Error(`Unrecognized stability: ${start}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/type-analysis.d.ts

@@ -0,0 +1,39 @@
+import * as reflect from 'jsii-reflect';
+/**
+ * Check whether A is a supertype of B
+ *
+ * Put differently: whether any value of type B would be assignable to a
+ * variable of type A.
+ *
+ * We always check the relationship in the NEW (latest, updated) typesystem.
+ */
+export declare function isSuperType(a: reflect.TypeReference, b: reflect.TypeReference, updatedSystem: reflect.TypeSystem): Analysis;
+/**
+ * Find types A and B in the updated type system, and check whether they have a supertype relationship in the type system
+ */
+export declare function isNominalSuperType(a: reflect.TypeReference, b: reflect.TypeReference, updatedSystem: reflect.TypeSystem): Analysis;
+/**
+ * Is struct A a structural supertype of struct B?
+ *
+ * Trying to answer the question, is this assignment legal for all values
+ * of `expr in B`.
+ *
+ * ```ts
+ * const var: A = expr as B;
+ * ```
+ *
+ * A is a structural supertype of B if all required members of A are also
+ * required in B, and of a compatible type.
+ *
+ * Nullable members of A must either not exist in B, or be of a compatible
+ * type.
+ */
+export declare function isStructuralSuperType(a: reflect.InterfaceType, b: reflect.InterfaceType, updatedSystem: reflect.TypeSystem): Analysis;
+export declare type Analysis = {
+    success: true;
+} | FailedAnalysis;
+export declare type FailedAnalysis = {
+    success: false;
+    reasons: string[];
+};
+export declare function prependReason(analysis: Analysis, message: string): Analysis;

package/lib/type-analysis.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prependReason = exports.isStructuralSuperType = exports.isNominalSuperType = exports.isSuperType = void 0;
+const util_1 = require("./util");
+/**
+ * Check whether A is a supertype of B
+ *
+ * Put differently: whether any value of type B would be assignable to a
+ * variable of type A.
+ *
+ * We always check the relationship in the NEW (latest, updated) typesystem.
+ */
+function isSuperType(a, b, updatedSystem) {
+    if (a.void || b.void) {
+        throw new Error('isSuperType() does not handle voids');
+    }
+    if (a.isAny) {
+        return { success: true };
+    }
+    if (a.primitive !== undefined) {
+        if (a.primitive === b.primitive) {
+            return { success: true };
+        }
+        return failure(`${b.toString()} is not assignable to ${a.toString()}`);
+    }
+    if (a.arrayOfType !== undefined) {
+        // Arrays are covariant
+        if (b.arrayOfType === undefined) {
+            return failure(`${b.toString()} is not an array type`);
+        }
+        return prependReason(isSuperType(a.arrayOfType, b.arrayOfType, updatedSystem), `${b.toString()} is not assignable to ${a.toString()}`);
+    }
+    if (a.mapOfType !== undefined) {
+        // Maps are covariant (are they?)
+        if (b.mapOfType === undefined) {
+            return failure(`${b.toString()} is not a map type`);
+        }
+        return prependReason(isSuperType(a.mapOfType, b.mapOfType, updatedSystem), `${b.toString()} is not assignable to ${a.toString()}`);
+    }
+    // Every element of B can be assigned to A
+    if (b.unionOfTypes !== undefined) {
+        const analyses = b.unionOfTypes.map((bbb) => isSuperType(a, bbb, updatedSystem));
+        if (analyses.every((x) => x.success)) {
+            return { success: true };
+        }
+        return failure(`some of ${b.toString()} are not assignable to ${a.toString()}`, ...util_1.flatMap(analyses, (x) => (x.success ? [] : x.reasons)));
+    }
+    // There should be an element of A which can accept all of B
+    if (a.unionOfTypes !== undefined) {
+        const analyses = a.unionOfTypes.map((aaa) => isSuperType(aaa, b, updatedSystem));
+        if (analyses.some((x) => x.success)) {
+            return { success: true };
+        }
+        return failure(`none of ${b.toString()} are assignable to ${a.toString()}`, ...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.
+        // That is, if in the updated typesystem someone were to use the type name
+        // from the old assembly, do they have a typing relationship that's accepted
+        // by a nominal type system. (That check also rules out enums)
+        const nominalCheck = isNominalSuperType(a, b, updatedSystem);
+        if (nominalCheck.success === false) {
+            return nominalCheck;
+        }
+        // At this point, the only thing left to do is recurse into the structs.
+        // We used to do that here, but we don't anymore; structs check themselves
+        // for structural weakening/strengthening.
+        return { success: true };
+    }
+    catch (e) {
+        return failure(e.message);
+    }
+}
+exports.isSuperType = isSuperType;
+/**
+ * Find types A and B in the updated type system, and check whether they have a supertype relationship in the type system
+ */
+function isNominalSuperType(a, b, updatedSystem) {
+    if (a.fqn === undefined) {
+        throw new Error(`I was expecting a named type, got '${a.toString()}'`);
+    }
+    // Named type vs a non-named type
+    if (b.fqn === undefined) {
+        return failure(`${b.toString()} is not assignable to ${a.toString()}`);
+    }
+    // Short-circuit of the types are the same name, saves us some lookup
+    if (a.fqn === b.fqn) {
+        return { success: true };
+    }
+    // We now need to do subtype analysis on the
+    // Find A in B's typesystem, and see if B is a subtype of A'
+    const B = updatedSystem.tryFindFqn(b.fqn);
+    const A = updatedSystem.tryFindFqn(a.fqn);
+    if (!B) {
+        return failure(`could not find type ${b.toString()}`);
+    }
+    if (!A) {
+        return failure(`could not find type ${a.toString()}`);
+    }
+    // If they're enums, they should have been exactly the same (tested above)
+    // enums are never subtypes of any other type.
+    if (A.isEnumType()) {
+        return failure(`${a.toString()} is an enum different from ${b.toString()}`);
+    }
+    if (B.isEnumType()) {
+        return failure(`${b.toString()} is an enum different from ${a.toString()}`);
+    }
+    if (B.extends(A)) {
+        return { success: true };
+    }
+    return failure(`${b.toString()} does not extend ${a.toString()}`);
+}
+exports.isNominalSuperType = isNominalSuperType;
+/**
+ * Is struct A a structural supertype of struct B?
+ *
+ * Trying to answer the question, is this assignment legal for all values
+ * of `expr in B`.
+ *
+ * ```ts
+ * const var: A = expr as B;
+ * ```
+ *
+ * A is a structural supertype of B if all required members of A are also
+ * required in B, and of a compatible type.
+ *
+ * Nullable members of A must either not exist in B, or be of a compatible
+ * type.
+ */
+function isStructuralSuperType(a, b, updatedSystem) {
+    // We know all members can only be properties, so that makes it easier.
+    const bProps = b.getProperties(true);
+    // Use timing words in error message to make it more understandable
+    const formerly = b.system === updatedSystem ? 'formerly' : 'newly';
+    const is = b.system === updatedSystem ? 'is' : 'used to be';
+    const removed = b.system === updatedSystem ? 'removed' : 'added';
+    for (const [name, aProp] of Object.entries(a.getProperties(true))) {
+        const bProp = bProps[name];
+        if (aProp.optional) {
+            // Optional field, only requirement is that IF it exists, the type must match.
+            if (!bProp) {
+                continue;
+            }
+        }
+        else {
+            if (!bProp) {
+                return failure(`${formerly} required property '${name}' ${removed}`);
+            }
+            if (bProp.optional) {
+                return failure(`${formerly} required property '${name}' ${is} optional`);
+            }
+        }
+        const ana = isSuperType(aProp.type, bProp.type, updatedSystem);
+        if (!ana.success) {
+            return failure(`property ${name}`, ...ana.reasons);
+        }
+    }
+    return { success: true };
+}
+exports.isStructuralSuperType = isStructuralSuperType;
+function failure(...reasons) {
+    return { success: false, reasons };
+}
+function prependReason(analysis, message) {
+    if (analysis.success) {
+        return analysis;
+    }
+    return failure(message, ...analysis.reasons);
+}
+exports.prependReason = prependReason;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-analysis.js","sourceRoot":"","sources":["type-analysis.ts"],"names":[],"mappings":";;;AAGA,iCAAiC;AAEjC;;;;;;;GAOG;AACH,SAAgB,WAAW,CACzB,CAAwB,EACxB,CAAwB,EACxB,aAAiC;IAEjC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,EAAE;QACpB,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;KACxD;IACD,IAAI,CAAC,CAAC,KAAK,EAAE;QACX,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;KAC1B;IAED,IAAI,CAAC,CAAC,SAAS,KAAK,SAAS,EAAE;QAC7B,IAAI,CAAC,CAAC,SAAS,KAAK,CAAC,CAAC,SAAS,EAAE;YAC/B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;SAC1B;QACD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,yBAAyB,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;KACxE;IAED,IAAI,CAAC,CAAC,WAAW,KAAK,SAAS,EAAE;QAC/B,uBAAuB;QACvB,IAAI,CAAC,CAAC,WAAW,KAAK,SAAS,EAAE;YAC/B,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,uBAAuB,CAAC,CAAC;SACxD;QACD,OAAO,aAAa,CAClB,WAAW,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,WAAW,EAAE,aAAa,CAAC,EACxD,GAAG,CAAC,CAAC,QAAQ,EAAE,yBAAyB,CAAC,CAAC,QAAQ,EAAE,EAAE,CACvD,CAAC;KACH;IAED,IAAI,CAAC,CAAC,SAAS,KAAK,SAAS,EAAE;QAC7B,iCAAiC;QACjC,IAAI,CAAC,CAAC,SAAS,KAAK,SAAS,EAAE;YAC7B,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,oBAAoB,CAAC,CAAC;SACrD;QACD,OAAO,aAAa,CAClB,WAAW,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,aAAa,CAAC,EACpD,GAAG,CAAC,CAAC,QAAQ,EAAE,yBAAyB,CAAC,CAAC,QAAQ,EAAE,EAAE,CACvD,CAAC;KACH;IAED,0CAA0C;IAC1C,IAAI,CAAC,CAAC,YAAY,KAAK,SAAS,EAAE;QAChC,MAAM,QAAQ,GAAG,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAC1C,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa,CAAC,CACnC,CAAC;QACF,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE;YACpC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;SAC1B;QACD,OAAO,OAAO,CACZ,WAAW,CAAC,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAAC,QAAQ,EAAE,EAAE,EAC/D,GAAG,cAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAC1D,CAAC;KACH;IACD,4DAA4D;IAC5D,IAAI,CAAC,CAAC,YAAY,KAAK,SAAS,EAAE;QAChC,MAAM,QAAQ,GAAG,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAC1C,WAAW,CAAC,GAAG,EAAE,CAAC,EAAE,aAAa,CAAC,CACnC,CAAC;QACF,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE;YACnC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;SAC1B;QACD,OAAO,OAAO,CACZ,WAAW,CAAC,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC,QAAQ,EAAE,EAAE,EAC3D,GAAG,cAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAC1D,CAAC;KACH;IAED,yEAAyE;IACzE,IAAI;QACF,kEAAkE;QAClE,0EAA0E;QAC1E,4EAA4E;QAC5E,8DAA8D;QAC9D,MAAM,YAAY,GAAG,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC;QAC7D,IAAI,YAAY,CAAC,OAAO,KAAK,KAAK,EAAE;YAClC,OAAO,YAAY,CAAC;SACrB;QAED,wEAAwE;QACxE,0EAA0E;QAC1E,0CAA0C;QAC1C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;KAC1B;IAAC,OAAO,CAAC,EAAE;QACV,OAAO,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;KAC3B;AACH,CAAC;AAtFD,kCAsFC;AAED;;GAEG;AACH,SAAgB,kBAAkB,CAChC,CAAwB,EACxB,CAAwB,EACxB,aAAiC;IAEjC,IAAI,CAAC,CAAC,GAAG,KAAK,SAAS,EAAE;QACvB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;KACxE;IAED,iCAAiC;IACjC,IAAI,CAAC,CAAC,GAAG,KAAK,SAAS,EAAE;QACvB,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,yBAAyB,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;KACxE;IAED,qEAAqE;IACrE,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG,EAAE;QACnB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;KAC1B;IAED,4CAA4C;IAC5C,4DAA4D;IAC5D,MAAM,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC1C,MAAM,CAAC,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAE1C,IAAI,CAAC,CAAC,EAAE;QACN,OAAO,OAAO,CAAC,uBAAuB,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;KACvD;IACD,IAAI,CAAC,CAAC,EAAE;QACN,OAAO,OAAO,CAAC,uBAAuB,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;KACvD;IAED,0EAA0E;IAC1E,8CAA8C;IAC9C,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE;QAClB,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,8BAA8B,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;KAC7E;IACD,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE;QAClB,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,8BAA8B,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;KAC7E;IAED,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;QAChB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;KAC1B;IACD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,oBAAoB,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;AACpE,CAAC;AA5CD,gDA4CC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,qBAAqB,CACnC,CAAwB,EACxB,CAAwB,EACxB,aAAiC;IAEjC,uEAAuE;IACvE,MAAM,MAAM,GAAG,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAErC,mEAAmE;IACnE,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC;IACnE,MAAM,EAAE,GAAG,CAAC,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC;IAC5D,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,KAAK,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;IAEjE,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,EAAE;QACjE,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;QAE3B,IAAI,KAAK,CAAC,QAAQ,EAAE;YAClB,8EAA8E;YAC9E,IAAI,CAAC,KAAK,EAAE;gBACV,SAAS;aACV;SACF;aAAM;YACL,IAAI,CAAC,KAAK,EAAE;gBACV,OAAO,OAAO,CAAC,GAAG,QAAQ,uBAAuB,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC;aACtE;YACD,IAAI,KAAK,CAAC,QAAQ,EAAE;gBAClB,OAAO,OAAO,CACZ,GAAG,QAAQ,uBAAuB,IAAI,KAAK,EAAE,WAAW,CACzD,CAAC;aACH;SACF;QAED,MAAM,GAAG,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QAC/D,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE;YAChB,OAAO,OAAO,CAAC,YAAY,IAAI,EAAE,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC;SACpD;KACF;IAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC3B,CAAC;AAvCD,sDAuCC;AAOD,SAAS,OAAO,CAAC,GAAG,OAAiB;IACnC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AACrC,CAAC;AAED,SAAgB,aAAa,CAAC,QAAkB,EAAE,OAAe;IAC/D,IAAI,QAAQ,CAAC,OAAO,EAAE;QACpB,OAAO,QAAQ,CAAC;KACjB;IACD,OAAO,OAAO,CAAC,OAAO,EAAE,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;AAC/C,CAAC;AALD,sCAKC","sourcesContent":["/* eslint-disable complexity */\nimport * as reflect from 'jsii-reflect';\n\nimport { flatMap } from './util';\n\n/**\n * Check whether A is a supertype of B\n *\n * Put differently: whether any value of type B would be assignable to a\n * variable of type A.\n *\n * We always check the relationship in the NEW (latest, updated) typesystem.\n */\nexport function isSuperType(\n  a: reflect.TypeReference,\n  b: reflect.TypeReference,\n  updatedSystem: reflect.TypeSystem,\n): Analysis {\n  if (a.void || b.void) {\n    throw new Error('isSuperType() does not handle voids');\n  }\n  if (a.isAny) {\n    return { success: true };\n  }\n\n  if (a.primitive !== undefined) {\n    if (a.primitive === b.primitive) {\n      return { success: true };\n    }\n    return failure(`${b.toString()} is not assignable to ${a.toString()}`);\n  }\n\n  if (a.arrayOfType !== undefined) {\n    // Arrays are covariant\n    if (b.arrayOfType === undefined) {\n      return failure(`${b.toString()} is not an array type`);\n    }\n    return prependReason(\n      isSuperType(a.arrayOfType, b.arrayOfType, updatedSystem),\n      `${b.toString()} is not assignable to ${a.toString()}`,\n    );\n  }\n\n  if (a.mapOfType !== undefined) {\n    // Maps are covariant (are they?)\n    if (b.mapOfType === undefined) {\n      return failure(`${b.toString()} is not a map type`);\n    }\n    return prependReason(\n      isSuperType(a.mapOfType, b.mapOfType, updatedSystem),\n      `${b.toString()} is not assignable to ${a.toString()}`,\n    );\n  }\n\n  // Every element of B can be assigned to A\n  if (b.unionOfTypes !== undefined) {\n    const analyses = b.unionOfTypes.map((bbb) =>\n      isSuperType(a, bbb, updatedSystem),\n    );\n    if (analyses.every((x) => x.success)) {\n      return { success: true };\n    }\n    return failure(\n      `some of ${b.toString()} are not assignable to ${a.toString()}`,\n      ...flatMap(analyses, (x) => (x.success ? [] : x.reasons)),\n    );\n  }\n  // There should be an element of A which can accept all of B\n  if (a.unionOfTypes !== undefined) {\n    const analyses = a.unionOfTypes.map((aaa) =>\n      isSuperType(aaa, b, updatedSystem),\n    );\n    if (analyses.some((x) => x.success)) {\n      return { success: true };\n    }\n    return failure(\n      `none of ${b.toString()} are assignable to ${a.toString()}`,\n      ...flatMap(analyses, (x) => (x.success ? [] : x.reasons)),\n    );\n  }\n\n  // We have two named types, recursion might happen so protect against it.\n  try {\n    // For named types, we'll always do a nominal typing relationship.\n    // That is, if in the updated typesystem someone were to use the type name\n    // from the old assembly, do they have a typing relationship that's accepted\n    // by a nominal type system. (That check also rules out enums)\n    const nominalCheck = isNominalSuperType(a, b, updatedSystem);\n    if (nominalCheck.success === false) {\n      return nominalCheck;\n    }\n\n    // At this point, the only thing left to do is recurse into the structs.\n    // We used to do that here, but we don't anymore; structs check themselves\n    // for structural weakening/strengthening.\n    return { success: true };\n  } catch (e) {\n    return failure(e.message);\n  }\n}\n\n/**\n * Find types A and B in the updated type system, and check whether they have a supertype relationship in the type system\n */\nexport function isNominalSuperType(\n  a: reflect.TypeReference,\n  b: reflect.TypeReference,\n  updatedSystem: reflect.TypeSystem,\n): Analysis {\n  if (a.fqn === undefined) {\n    throw new Error(`I was expecting a named type, got '${a.toString()}'`);\n  }\n\n  // Named type vs a non-named type\n  if (b.fqn === undefined) {\n    return failure(`${b.toString()} is not assignable to ${a.toString()}`);\n  }\n\n  // Short-circuit of the types are the same name, saves us some lookup\n  if (a.fqn === b.fqn) {\n    return { success: true };\n  }\n\n  // We now need to do subtype analysis on the\n  // Find A in B's typesystem, and see if B is a subtype of A'\n  const B = updatedSystem.tryFindFqn(b.fqn);\n  const A = updatedSystem.tryFindFqn(a.fqn);\n\n  if (!B) {\n    return failure(`could not find type ${b.toString()}`);\n  }\n  if (!A) {\n    return failure(`could not find type ${a.toString()}`);\n  }\n\n  // If they're enums, they should have been exactly the same (tested above)\n  // enums are never subtypes of any other type.\n  if (A.isEnumType()) {\n    return failure(`${a.toString()} is an enum different from ${b.toString()}`);\n  }\n  if (B.isEnumType()) {\n    return failure(`${b.toString()} is an enum different from ${a.toString()}`);\n  }\n\n  if (B.extends(A)) {\n    return { success: true };\n  }\n  return failure(`${b.toString()} does not extend ${a.toString()}`);\n}\n\n/**\n * Is struct A a structural supertype of struct B?\n *\n * Trying to answer the question, is this assignment legal for all values\n * of `expr in B`.\n *\n * ```ts\n * const var: A = expr as B;\n * ```\n *\n * A is a structural supertype of B if all required members of A are also\n * required in B, and of a compatible type.\n *\n * Nullable members of A must either not exist in B, or be of a compatible\n * type.\n */\nexport function isStructuralSuperType(\n  a: reflect.InterfaceType,\n  b: reflect.InterfaceType,\n  updatedSystem: reflect.TypeSystem,\n): Analysis {\n  // We know all members can only be properties, so that makes it easier.\n  const bProps = b.getProperties(true);\n\n  // Use timing words in error message to make it more understandable\n  const formerly = b.system === updatedSystem ? 'formerly' : 'newly';\n  const is = b.system === updatedSystem ? 'is' : 'used to be';\n  const removed = b.system === updatedSystem ? 'removed' : 'added';\n\n  for (const [name, aProp] of Object.entries(a.getProperties(true))) {\n    const bProp = bProps[name];\n\n    if (aProp.optional) {\n      // Optional field, only requirement is that IF it exists, the type must match.\n      if (!bProp) {\n        continue;\n      }\n    } else {\n      if (!bProp) {\n        return failure(`${formerly} required property '${name}' ${removed}`);\n      }\n      if (bProp.optional) {\n        return failure(\n          `${formerly} required property '${name}' ${is} optional`,\n        );\n      }\n    }\n\n    const ana = isSuperType(aProp.type, bProp.type, updatedSystem);\n    if (!ana.success) {\n      return failure(`property ${name}`, ...ana.reasons);\n    }\n  }\n\n  return { success: true };\n}\n\n// Oh tagged union types I love you so much!\nexport type Analysis = { success: true } | FailedAnalysis;\n\nexport type FailedAnalysis = { success: false; reasons: string[] };\n\nfunction failure(...reasons: string[]): FailedAnalysis {\n  return { success: false, reasons };\n}\n\nexport function prependReason(analysis: Analysis, message: string): Analysis {\n  if (analysis.success) {\n    return analysis;\n  }\n  return failure(message, ...analysis.reasons);\n}\n"]}

package/lib/type-comparison.d.ts

@@ -0,0 +1,195 @@
+import * as reflect from 'jsii-reflect';
+import { ComparisonOptions, Mismatches } from './types';
+/**
+ * Root object for comparing two assemblies
+ *
+ * Tracks mismatches and used as a lookup table to convert FQNs -> ComparableType objects
+ */
+export declare class AssemblyComparison {
+    readonly options: ComparisonOptions;
+    readonly mismatches: Mismatches;
+    private readonly types;
+    constructor(options: ComparisonOptions);
+    /**
+     * Load the types from two assemblies to compare
+     *
+     * Adds appropriate ComparableType<> instances.
+     */
+    load(original: reflect.Assembly, updated: reflect.Assembly): void;
+    /**
+     * Perform the comparison for all loaded types
+     */
+    compare(): void;
+    /**
+     * Based on a JSII TypeReference, return all reachable ComparableType<> objects.
+     */
+    typesIn(ref: reflect.TypeReference): Array<ComparableType<any>>;
+    /**
+     * All ComparableType<>s
+     */
+    private get comparableTypes();
+    /**
+     * Find the matching type in the updated assembly based on all types in the original assembly
+     */
+    private typePairs;
+}
+/**
+ * Base class for comparable types
+ *
+ * Manages notions of crawling types for other reference types, and whether
+ * they occur in an input/output role, and marking as such on the comparison
+ * object.
+ */
+export declare abstract class ComparableType<T> {
+    protected readonly assemblyComparison: AssemblyComparison;
+    protected readonly oldType: T;
+    protected readonly newType: T;
+    private static readonly recursionBreaker;
+    private readonly _inputTypeReasons;
+    private readonly _outputTypeReasons;
+    constructor(assemblyComparison: AssemblyComparison, oldType: T, newType: T);
+    /**
+     * Does this type occur in an input role?
+     */
+    get inputType(): boolean;
+    /**
+     * Does this type occur in an output role?
+     */
+    get outputType(): boolean;
+    /**
+     * Mark this type as occuring in an input rule.
+     *
+     * All types reachable from this type will be marked as input types as well.
+     */
+    markAsInputType(...reasonFragments: string[]): void;
+    /**
+     * Mark this type as occuring in an input rule.
+     *
+     * All types reachable from this type will be marked as input types as well.
+     */
+    markAsOutputType(...reasonFragments: string[]): void;
+    /**
+     * Describe why this type is an input type (if it is)
+     */
+    get inputTypeReason(): string;
+    /**
+     * Describe why this type is an output type (if it is)
+     */
+    get outputTypeReason(): string;
+    /**
+     * Should be overriden in subclasses to mark reachable types as input/output types
+     *
+     * Should only be implemented by subclasses that contain callables.
+     */
+    markTypeRoles(): void;
+    /**
+     * Should be overridden in subclasses to perform the comparison
+     *
+     * Input/output marking will already have been performed before this is called.
+     */
+    abstract compare(): void;
+    /**
+     * Alias for the root object Mismaches object
+     */
+    protected get mismatches(): Mismatches;
+    /**
+     * Should be overriden in subclasses to execute the callback on reachable types
+     *
+     * Should be overriden only for product types (structs).
+     */
+    protected forEachRoleSharingType(cb: (t: ComparableType<any>, reason: string) => void): void;
+}
+/**
+ * Base class for reference types
+ *
+ * Contains shared code that applies to both class and interface types.
+ */
+export declare abstract class ComparableReferenceType<T extends reflect.ReferenceType> extends ComparableType<T> {
+    /**
+     * Compare members of the reference types
+     */
+    compare(): void;
+    /**
+     * Mark type accesses (input/output) of methods and properties
+     */
+    markTypeRoles(): void;
+    /**
+     * Validate type signatures on all methods
+     */
+    protected validateMethods(): void;
+    /**
+     * Validate type signature changes on the given method
+     */
+    protected validateMethod(original: reflect.Method, updated: reflect.Method): void;
+    /**
+     * Validate type signature changes on the given callable (method or initializer)
+     */
+    protected validateCallable<T extends reflect.Method | reflect.Initializer>(original: T, updated: T): void;
+    /**
+     * Validate type signature changes on all properties
+     */
+    protected validateProperties(): void;
+    /**
+     * Validate type signature changes on the given property
+     */
+    protected validateProperty(original: reflect.Property, updated: reflect.Property): void;
+    /**
+     * Whether the current reference type has been marked as subclassable
+     */
+    private get subclassableType();
+}
+export declare class ComparableClassType extends ComparableReferenceType<reflect.ClassType> {
+    /**
+     * Perform the reference type comparison and include class-specific checks
+     */
+    compare(): void;
+    /**
+     * Type role marking -- include the initializer
+     */
+    markTypeRoles(): void;
+}
+/**
+ * Interface type comparison
+ *
+ * (Actually just plain reference type comparison)
+ */
+export declare class ComparableInterfaceType extends ComparableReferenceType<reflect.InterfaceType> {
+}
+/**
+ * Struct type comparison
+ *
+ * Most notably: does no-strengthening/no-weakening checks based on whether
+ * structs appear in input/output positions.
+ */
+export declare class ComparableStructType extends ComparableType<reflect.InterfaceType> {
+    compare(): void;
+    /**
+     * Every type of every property should have the same in/out classification as the outer type
+     */
+    protected forEachRoleSharingType(cb: (t: ComparableType<any>, reason: string) => void): void;
+    /**
+     * Check that all properties are still present
+     *
+     * This is because for all non-structurally typed languages it is not allowed
+     * to specify members which aren't actually present in the type.
+     */
+    private validateNoPropertiesRemoved;
+    /**
+     * Check that the current type is not weakened
+     */
+    private validateNotWeakened;
+    /**
+     * Check that the current type is not strengthened
+     */
+    private validateNotStrengthened;
+    private isStructuralSuperType;
+}
+/**
+ * Comparison for enums
+ */
+export declare class ComparableEnumType extends ComparableType<reflect.EnumType> {
+    /**
+     * Perform comparisons on enum members
+     */
+    compare(): void;
+}