jsii-diff 1.35.0

package/lib/type-comparison.js

@@ -0,0 +1,508 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComparableEnumType = exports.ComparableStructType = exports.ComparableInterfaceType = exports.ComparableClassType = exports.ComparableReferenceType = exports.ComparableType = exports.AssemblyComparison = void 0;
+const spec_1 = require("@jsii/spec");
+const reflect = require("jsii-reflect");
+const log4js = require("log4js");
+const stability_1 = require("./stability");
+const type_analysis_1 = require("./type-analysis");
+const types_1 = require("./types");
+const util_1 = require("./util");
+const validations_1 = require("./validations");
+const LOG = log4js.getLogger('jsii-diff');
+/**
+ * Root object for comparing two assemblies
+ *
+ * Tracks mismatches and used as a lookup table to convert FQNs -> ComparableType objects
+ */
+class AssemblyComparison {
+    constructor(options) {
+        this.options = options;
+        this.types = new Map();
+        this.mismatches = new types_1.Mismatches({
+            defaultStability: options.defaultExperimental
+                ? spec_1.Stability.Experimental
+                : spec_1.Stability.Stable,
+        });
+    }
+    /**
+     * Load the types from two assemblies to compare
+     *
+     * Adds appropriate ComparableType<> instances.
+     */
+    load(original, updated) {
+        /* eslint-disable prettier/prettier */
+        for (const [origClass, updatedClass] of this.typePairs(original.classes, updated)) {
+            this.types.set(origClass.fqn, new ComparableClassType(this, origClass, updatedClass));
+        }
+        for (const [origIface, updatedIface] of this.typePairs(original.interfaces, updated)) {
+            if (origIface.datatype !== updatedIface.datatype) {
+                this.mismatches.report({
+                    ruleKey: 'iface-type',
+                    violator: origIface,
+                    message: `used to be a ${types_1.describeInterfaceType(origIface.datatype)}, is now a ${types_1.describeInterfaceType(updatedIface.datatype)}.`,
+                });
+                continue;
+            }
+            this.types.set(origIface.fqn, origIface.datatype
+                ? new ComparableStructType(this, origIface, updatedIface)
+                : new ComparableInterfaceType(this, origIface, updatedIface));
+        }
+        for (const [origEnum, updatedEnum] of this.typePairs(original.enums, updated)) {
+            this.types.set(origEnum.fqn, new ComparableEnumType(this, origEnum, updatedEnum));
+        }
+        /* eslint-enable prettier/prettier */
+    }
+    /**
+     * Perform the comparison for all loaded types
+     */
+    compare() {
+        this.comparableTypes.forEach((t) => t.markTypeRoles());
+        this.comparableTypes.forEach((t) => t.compare());
+    }
+    /**
+     * Based on a JSII TypeReference, return all reachable ComparableType<> objects.
+     */
+    typesIn(ref) {
+        const ret = new Array();
+        for (const fqn of fqnsFrom(ref)) {
+            const t = this.types.get(fqn);
+            if (t) {
+                ret.push(t);
+            }
+        }
+        return ret;
+    }
+    /**
+     * All ComparableType<>s
+     */
+    get comparableTypes() {
+        return Array.from(this.types.values());
+    }
+    /**
+     * Find the matching type in the updated assembly based on all types in the original assembly
+     */
+    *typePairs(xs, updatedAssembly) {
+        for (const origType of xs) {
+            LOG.trace(origType.fqn);
+            const updatedType = updatedAssembly.tryFindType(origType.fqn);
+            if (!updatedType) {
+                this.mismatches.report({
+                    ruleKey: 'removed',
+                    violator: origType,
+                    message: 'has been removed',
+                });
+                continue;
+            }
+            if (types_1.describeType(origType) !== types_1.describeType(updatedType)) {
+                this.mismatches.report({
+                    ruleKey: 'struct-change',
+                    violator: origType,
+                    message: `has been turned into a ${types_1.describeType(updatedType)}`,
+                });
+                continue;
+            }
+            yield [origType, updatedType]; // Trust me I know what I'm doing
+        }
+    }
+}
+exports.AssemblyComparison = AssemblyComparison;
+/**
+ * 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.
+ */
+class ComparableType {
+    constructor(assemblyComparison, oldType, newType) {
+        this.assemblyComparison = assemblyComparison;
+        this.oldType = oldType;
+        this.newType = newType;
+        this._inputTypeReasons = new Array();
+        this._outputTypeReasons = new Array();
+    }
+    /**
+     * Does this type occur in an input role?
+     */
+    get inputType() {
+        return this._inputTypeReasons.length > 0;
+    }
+    /**
+     * Does this type occur in an output role?
+     */
+    get outputType() {
+        return this._outputTypeReasons.length > 0;
+    }
+    /**
+     * 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) {
+        ComparableType.recursionBreaker.do(this, () => {
+            this._inputTypeReasons.push(reasonFragments.join(', '));
+            this.forEachRoleSharingType((type, reason) => {
+                type.markAsInputType(reason, ...reasonFragments);
+            });
+        });
+    }
+    /**
+     * 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) {
+        ComparableType.recursionBreaker.do(this, () => {
+            this._outputTypeReasons.push(reasonFragments.join(', '));
+            this.forEachRoleSharingType((type, reason) => {
+                type.markAsOutputType(reason, ...reasonFragments);
+            });
+        });
+    }
+    /**
+     * Describe why this type is an input type (if it is)
+     */
+    get inputTypeReason() {
+        return describeReasons(this._inputTypeReasons);
+    }
+    /**
+     * Describe why this type is an output type (if it is)
+     */
+    get outputTypeReason() {
+        return describeReasons(this._outputTypeReasons);
+    }
+    /**
+     * Should be overriden in subclasses to mark reachable types as input/output types
+     *
+     * Should only be implemented by subclasses that contain callables.
+     */
+    markTypeRoles() {
+        // Empty on purpose
+    }
+    /**
+     * Alias for the root object Mismaches object
+     */
+    get mismatches() {
+        return this.assemblyComparison.mismatches;
+    }
+    /**
+     * Should be overriden in subclasses to execute the callback on reachable types
+     *
+     * Should be overriden only for product types (structs).
+     */
+    forEachRoleSharingType(cb) {
+        Array.isArray(cb);
+    }
+}
+exports.ComparableType = ComparableType;
+ComparableType.recursionBreaker = new util_1.RecursionBreaker();
+/**
+ * Base class for reference types
+ *
+ * Contains shared code that applies to both class and interface types.
+ */
+class ComparableReferenceType extends ComparableType {
+    /**
+     * Compare members of the reference types
+     */
+    compare() {
+        stability_1.validateStabilities(this.oldType, this.newType, this.mismatches);
+        validations_1.validateBaseTypeAssignability(this.oldType, this.newType, this.mismatches);
+        validations_1.validateSubclassableNotRemoved(this.oldType, this.newType, this.mismatches);
+        if (this.subclassableType) {
+            validations_1.validateNoNewAbstractMembers(this.oldType, this.newType, this.mismatches);
+        }
+        this.validateMethods();
+        this.validateProperties();
+    }
+    /**
+     * Mark type accesses (input/output) of methods and properties
+     */
+    markTypeRoles() {
+        for (const method of this.oldType.ownMethods) {
+            determineTypeRolesFromMethod(this.assemblyComparison, method);
+        }
+        for (const property of this.oldType.ownProperties) {
+            determineTypeRolesFromProperty(this.assemblyComparison, property);
+        }
+    }
+    /**
+     * Validate type signatures on all methods
+     */
+    validateMethods() {
+        for (const [orig, updated] of validations_1.memberPairs(this.oldType, this.oldType.allMethods, this.newType, this.mismatches)) {
+            if (reflect.isMethod(updated)) {
+                this.validateMethod(orig, updated);
+            }
+        }
+    }
+    /**
+     * Validate type signature changes on the given method
+     */
+    validateMethod(original, updated) {
+        validations_1.validateStaticSame(original, updated, this.mismatches);
+        validations_1.validateAsyncSame(original, updated, this.mismatches);
+        if (this.subclassableType) {
+            validations_1.validateReturnTypeSame(original, updated, this.mismatches.withMotivation('type is @subclassable'));
+        }
+        else {
+            validations_1.validateReturnTypeNotWeakened(original, updated, this.mismatches);
+        }
+        this.validateCallable(original, updated);
+    }
+    /**
+     * Validate type signature changes on the given callable (method or initializer)
+     */
+    validateCallable(original, updated) {
+        stability_1.validateStabilities(original, updated, this.mismatches);
+        validations_1.validateNotMadeNonVariadic(original, updated, this.mismatches);
+        // Check that every original parameter can still be mapped to a parameter in the updated method
+        validations_1.validateExistingParams(original, updated, this.mismatches, (oldParam, newParam) => {
+            if (this.subclassableType) {
+                validations_1.validateParameterTypeSame(original, oldParam, newParam, this.mismatches.withMotivation('type is @subclassable'));
+            }
+            else {
+                validations_1.validateParameterTypeWeakened(original, oldParam, newParam, this.mismatches);
+            }
+        });
+        validations_1.validateNoNewRequiredParams(original, updated, this.mismatches);
+    }
+    /**
+     * Validate type signature changes on all properties
+     */
+    validateProperties() {
+        for (const [orig, updated] of validations_1.memberPairs(this.oldType, this.oldType.allProperties, this.newType, this.mismatches)) {
+            if (reflect.isProperty(updated)) {
+                this.validateProperty(orig, updated);
+            }
+        }
+    }
+    /**
+     * Validate type signature changes on the given property
+     */
+    validateProperty(original, updated) {
+        stability_1.validateStabilities(original, updated, this.mismatches);
+        validations_1.validateStaticSame(original, updated, this.mismatches);
+        validations_1.validateNotMadeImmutable(original, updated, this.mismatches);
+        if (this.subclassableType) {
+            // Hello C# my old friend
+            validations_1.validatePropertyTypeSame(original, updated, this.mismatches.withMotivation('type is @subclassable'));
+        }
+        else if (!original.immutable) {
+            // If the type can be read, it can't be weakened (can't change Dog to Animal, consumers might be counting on a Dog).
+            // If the type can be written, it can't be strengthened (can't change Animal to Dog, consumers might be sending a Cat).
+            // => it must remain the same
+            validations_1.validatePropertyTypeSame(original, updated, this.mismatches.withMotivation('mutable property cannot change type'));
+        }
+        else {
+            validations_1.validatePropertyTypeNotWeakened(original, updated, this.mismatches);
+        }
+    }
+    /**
+     * Whether the current reference type has been marked as subclassable
+     */
+    get subclassableType() {
+        return validations_1.subclassableType(this.oldType);
+    }
+}
+exports.ComparableReferenceType = ComparableReferenceType;
+class ComparableClassType extends ComparableReferenceType {
+    /**
+     * Perform the reference type comparison and include class-specific checks
+     */
+    compare() {
+        super.compare();
+        validations_1.validateNotMadeAbstract(this.oldType, this.newType, this.mismatches);
+        // JSII assembler has already taken care of inheritance here
+        if (this.oldType.initializer && this.newType.initializer) {
+            validations_1.validateMethodCompatible(this.oldType.initializer, this.newType.initializer, this.mismatches);
+        }
+    }
+    /**
+     * Type role marking -- include the initializer
+     */
+    markTypeRoles() {
+        if (this.oldType.initializer) {
+            determineTypeRolesFromMethod(this.assemblyComparison, this.oldType.initializer);
+        }
+        super.markTypeRoles();
+    }
+}
+exports.ComparableClassType = ComparableClassType;
+/**
+ * Interface type comparison
+ *
+ * (Actually just plain reference type comparison)
+ */
+class ComparableInterfaceType extends ComparableReferenceType {
+}
+exports.ComparableInterfaceType = ComparableInterfaceType;
+/**
+ * Struct type comparison
+ *
+ * Most notably: does no-strengthening/no-weakening checks based on whether
+ * structs appear in input/output positions.
+ */
+class ComparableStructType extends ComparableType {
+    compare() {
+        stability_1.validateStabilities(this.oldType, this.newType, this.mismatches);
+        validations_1.validateBaseTypeAssignability(this.oldType, this.newType, this.mismatches);
+        this.validateNoPropertiesRemoved();
+        if (this.inputType) {
+            // If the struct is written, it can't be strengthened (ex: can't change an optional property to required)
+            this.validateNotStrengthened(this.mismatches.withMotivation(this.inputTypeReason));
+        }
+        if (this.outputType) {
+            // If the struct is read, it can't be weakened (ex: can't change a required property to optional)
+            this.validateNotWeakened(this.mismatches.withMotivation(this.outputTypeReason));
+        }
+    }
+    /**
+     * Every type of every property should have the same in/out classification as the outer type
+     */
+    forEachRoleSharingType(cb) {
+        for (const prop of this.oldType.allProperties) {
+            for (const t of this.assemblyComparison.typesIn(prop.type)) {
+                cb(t, `type of property ${prop.name}`);
+            }
+        }
+    }
+    /**
+     * 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.
+     */
+    validateNoPropertiesRemoved() {
+        // A single run of memberPairs() with nothing else will do this check.
+        Array.from(validations_1.memberPairs(this.oldType, this.oldType.allProperties, this.newType, this.mismatches));
+    }
+    /**
+     * Check that the current type is not weakened
+     */
+    validateNotWeakened(mismatches) {
+        const ana = this.isStructuralSuperType(this.oldType, this.newType);
+        if (!ana.success) {
+            mismatches.report({
+                ruleKey: 'weakened',
+                violator: this.oldType,
+                message: ana.reasons.join(', '),
+            });
+        }
+    }
+    /**
+     * Check that the current type is not strengthened
+     */
+    validateNotStrengthened(mismatches) {
+        const ana = this.isStructuralSuperType(this.newType, this.oldType);
+        if (!ana.success) {
+            mismatches.report({
+                ruleKey: 'strengthened',
+                violator: this.oldType,
+                message: ana.reasons.join(', '),
+            });
+        }
+    }
+    isStructuralSuperType(a, b) {
+        try {
+            return type_analysis_1.isStructuralSuperType(a, b, this.newType.system);
+        }
+        catch (e) {
+            // We might get an exception if the type is supposed to come from a different
+            // assembly and the lookup fails.
+            return { success: false, reasons: [e.message] };
+        }
+    }
+}
+exports.ComparableStructType = ComparableStructType;
+/**
+ * Comparison for enums
+ */
+class ComparableEnumType extends ComparableType {
+    /**
+     * Perform comparisons on enum members
+     */
+    compare() {
+        stability_1.validateStabilities(this.oldType, this.newType, this.mismatches);
+        validations_1.validateExistingMembers(this.oldType, this.newType, this.mismatches, (oldMember, newMember) => {
+            stability_1.validateStabilities(oldMember, newMember, this.mismatches);
+        });
+    }
+}
+exports.ComparableEnumType = ComparableEnumType;
+/**
+ * Determines input/output roles of types used in this method
+ *
+ * - Argument types are treated as IN types
+ * - Return type is treated as OUT type
+ */
+function determineTypeRolesFromMethod(comparison, method) {
+    var _a;
+    if (reflect.isMethod(method)) {
+        for (const t of comparison.typesIn(method.returns.type)) {
+            t.markAsOutputType(`returned from ${types_1.apiElementIdentifier(method)}`);
+        }
+    }
+    for (const param of (_a = method.parameters) !== null && _a !== void 0 ? _a : []) {
+        for (const t of comparison.typesIn(param.type)) {
+            t.markAsInputType(`input to ${types_1.apiElementIdentifier(method)}`);
+        }
+    }
+}
+/**
+ * Determines input/output roles of types used in this property
+ *
+ * - Property type is treated as OUT type
+ * - If mutable, property type is also treated as IN type
+ *
+ * In effect, a property is treated as the following methods:
+ *
+ * - property(): T;
+ * - setProperty(: T);  <- only if mutable
+ */
+function determineTypeRolesFromProperty(comparison, property) {
+    for (const t of comparison.typesIn(property.type)) {
+        t.markAsOutputType(`type of ${types_1.apiElementIdentifier(property)}`);
+    }
+    if (!property.immutable) {
+        for (const t of comparison.typesIn(property.type)) {
+            t.markAsInputType(`type of mutable ${types_1.apiElementIdentifier(property)}`);
+        }
+    }
+}
+/**
+ * Return all the FQNs from a type reference
+ *
+ * In the simple case, a simple FQN, but the type might
+ * be a union or complex type as well.
+ */
+function fqnsFrom(ref) {
+    const ret = new Array();
+    recurse(ref);
+    return ret;
+    function recurse(type) {
+        if (type.mapOfType) {
+            recurse(type.mapOfType);
+        }
+        else if (type.arrayOfType) {
+            recurse(type.arrayOfType);
+        }
+        else if (type.unionOfTypes) {
+            type.unionOfTypes.forEach(recurse);
+        }
+        else if (type.fqn) {
+            ret.push(type.fqn);
+        }
+    }
+}
+function describeReasons(reasons) {
+    if (reasons.length === 0) {
+        return '';
+    }
+    if (reasons.length === 1) {
+        return reasons[0];
+    }
+    return `${reasons[0]} (...and ${reasons.length - 1} more...)`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-comparison.js","sourceRoot":"","sources":["type-comparison.ts"],"names":[],"mappings":"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","sourcesContent":["import { Stability } from '@jsii/spec';\nimport * as reflect from 'jsii-reflect';\nimport * as log4js from 'log4js';\n\nimport { validateStabilities } from './stability';\nimport { isStructuralSuperType, Analysis } from './type-analysis';\nimport {\n  describeInterfaceType,\n  describeType,\n  ComparisonOptions,\n  Mismatches,\n  apiElementIdentifier,\n  IReport,\n} from './types';\nimport { RecursionBreaker } from './util';\nimport {\n  validateBaseTypeAssignability,\n  validateNotMadeAbstract,\n  validateSubclassableNotRemoved,\n  validateNoNewAbstractMembers,\n  subclassableType,\n  validateMethodCompatible,\n  memberPairs,\n  validateStaticSame,\n  validateAsyncSame,\n  validateReturnTypeNotWeakened,\n  validateNotMadeNonVariadic,\n  validateReturnTypeSame,\n  validateExistingParams,\n  validateNoNewRequiredParams,\n  validateParameterTypeWeakened,\n  validateParameterTypeSame,\n  validateNotMadeImmutable,\n  validatePropertyTypeNotWeakened,\n  validatePropertyTypeSame,\n  validateExistingMembers,\n} from './validations';\n\nconst LOG = log4js.getLogger('jsii-diff');\n\n/**\n * Root object for comparing two assemblies\n *\n * Tracks mismatches and used as a lookup table to convert FQNs -> ComparableType objects\n */\nexport class AssemblyComparison {\n  public readonly mismatches: Mismatches;\n  private readonly types = new Map<string, ComparableType<any>>();\n\n  public constructor(public readonly options: ComparisonOptions) {\n    this.mismatches = new Mismatches({\n      defaultStability: options.defaultExperimental\n        ? Stability.Experimental\n        : Stability.Stable,\n    });\n  }\n\n  /**\n   * Load the types from two assemblies to compare\n   *\n   * Adds appropriate ComparableType<> instances.\n   */\n  public load(original: reflect.Assembly, updated: reflect.Assembly) {\n    /* eslint-disable prettier/prettier */\n    for (const [origClass, updatedClass] of this.typePairs(original.classes, updated)) {\n      this.types.set(origClass.fqn, new ComparableClassType(this, origClass, updatedClass));\n    }\n\n    for (const [origIface, updatedIface] of this.typePairs(original.interfaces, updated)) {\n      if (origIface.datatype !== updatedIface.datatype) {\n        this.mismatches.report({\n          ruleKey: 'iface-type',\n          violator: origIface,\n          message: `used to be a ${describeInterfaceType(\n            origIface.datatype,\n          )}, is now a ${describeInterfaceType(updatedIface.datatype)}.`,\n        });\n        continue;\n      }\n\n      this.types.set(origIface.fqn, origIface.datatype\n        ? new ComparableStructType(this, origIface, updatedIface)\n        : new ComparableInterfaceType(this, origIface, updatedIface));\n    }\n\n    for (const [origEnum, updatedEnum] of this.typePairs(original.enums, updated)) {\n      this.types.set(origEnum.fqn, new ComparableEnumType(this, origEnum, updatedEnum));\n    }\n    /* eslint-enable prettier/prettier */\n  }\n\n  /**\n   * Perform the comparison for all loaded types\n   */\n  public compare() {\n    this.comparableTypes.forEach((t) => t.markTypeRoles());\n    this.comparableTypes.forEach((t) => t.compare());\n  }\n\n  /**\n   * Based on a JSII TypeReference, return all reachable ComparableType<> objects.\n   */\n  public typesIn(ref: reflect.TypeReference): Array<ComparableType<any>> {\n    const ret = new Array<ComparableType<any>>();\n\n    for (const fqn of fqnsFrom(ref)) {\n      const t = this.types.get(fqn);\n      if (t) {\n        ret.push(t);\n      }\n    }\n    return ret;\n  }\n\n  /**\n   * All ComparableType<>s\n   */\n  private get comparableTypes() {\n    return Array.from(this.types.values());\n  }\n\n  /**\n   * Find the matching type in the updated assembly based on all types in the original assembly\n   */\n  private *typePairs<T extends reflect.Type>(\n    xs: readonly T[],\n    updatedAssembly: reflect.Assembly,\n  ): IterableIterator<[T, T]> {\n    for (const origType of xs) {\n      LOG.trace(origType.fqn);\n\n      const updatedType = updatedAssembly.tryFindType(origType.fqn);\n      if (!updatedType) {\n        this.mismatches.report({\n          ruleKey: 'removed',\n          violator: origType,\n          message: 'has been removed',\n        });\n        continue;\n      }\n\n      if (describeType(origType) !== describeType(updatedType)) {\n        this.mismatches.report({\n          ruleKey: 'struct-change',\n          violator: origType,\n          message: `has been turned into a ${describeType(updatedType)}`,\n        });\n        continue;\n      }\n\n      yield [origType, updatedType as T]; // Trust me I know what I'm doing\n    }\n  }\n}\n\n/**\n * Base class for comparable types\n *\n * Manages notions of crawling types for other reference types, and whether\n * they occur in an input/output role, and marking as such on the comparison\n * object.\n */\nexport abstract class ComparableType<T> {\n  private static readonly recursionBreaker = new RecursionBreaker();\n\n  private readonly _inputTypeReasons = new Array<string>();\n  private readonly _outputTypeReasons = new Array<string>();\n\n  public constructor(\n    protected readonly assemblyComparison: AssemblyComparison,\n    protected readonly oldType: T,\n    protected readonly newType: T,\n  ) {}\n\n  /**\n   * Does this type occur in an input role?\n   */\n  public get inputType() {\n    return this._inputTypeReasons.length > 0;\n  }\n\n  /**\n   * Does this type occur in an output role?\n   */\n  public get outputType() {\n    return this._outputTypeReasons.length > 0;\n  }\n\n  /**\n   * Mark this type as occuring in an input rule.\n   *\n   * All types reachable from this type will be marked as input types as well.\n   */\n  public markAsInputType(...reasonFragments: string[]) {\n    ComparableType.recursionBreaker.do(this, () => {\n      this._inputTypeReasons.push(reasonFragments.join(', '));\n      this.forEachRoleSharingType((type, reason) => {\n        type.markAsInputType(reason, ...reasonFragments);\n      });\n    });\n  }\n\n  /**\n   * Mark this type as occuring in an input rule.\n   *\n   * All types reachable from this type will be marked as input types as well.\n   */\n  public markAsOutputType(...reasonFragments: string[]) {\n    ComparableType.recursionBreaker.do(this, () => {\n      this._outputTypeReasons.push(reasonFragments.join(', '));\n      this.forEachRoleSharingType((type, reason) => {\n        type.markAsOutputType(reason, ...reasonFragments);\n      });\n    });\n  }\n\n  /**\n   * Describe why this type is an input type (if it is)\n   */\n  public get inputTypeReason(): string {\n    return describeReasons(this._inputTypeReasons);\n  }\n\n  /**\n   * Describe why this type is an output type (if it is)\n   */\n  public get outputTypeReason(): string {\n    return describeReasons(this._outputTypeReasons);\n  }\n\n  /**\n   * Should be overriden in subclasses to mark reachable types as input/output types\n   *\n   * Should only be implemented by subclasses that contain callables.\n   */\n  public markTypeRoles() {\n    // Empty on purpose\n  }\n\n  /**\n   * Should be overridden in subclasses to perform the comparison\n   *\n   * Input/output marking will already have been performed before this is called.\n   */\n  public abstract compare(): void;\n\n  /**\n   * Alias for the root object Mismaches object\n   */\n  protected get mismatches() {\n    return this.assemblyComparison.mismatches;\n  }\n\n  /**\n   * Should be overriden in subclasses to execute the callback on reachable types\n   *\n   * Should be overriden only for product types (structs).\n   */\n  protected forEachRoleSharingType(\n    cb: (t: ComparableType<any>, reason: string) => void,\n  ) {\n    Array.isArray(cb);\n  }\n}\n\n/**\n * Base class for reference types\n *\n * Contains shared code that applies to both class and interface types.\n */\nexport abstract class ComparableReferenceType<\n  T extends reflect.ReferenceType,\n> extends ComparableType<T> {\n  /**\n   * Compare members of the reference types\n   */\n  public compare() {\n    validateStabilities(this.oldType, this.newType, this.mismatches);\n    validateBaseTypeAssignability(this.oldType, this.newType, this.mismatches);\n\n    validateSubclassableNotRemoved(this.oldType, this.newType, this.mismatches);\n    if (this.subclassableType) {\n      validateNoNewAbstractMembers(this.oldType, this.newType, this.mismatches);\n    }\n\n    this.validateMethods();\n    this.validateProperties();\n  }\n\n  /**\n   * Mark type accesses (input/output) of methods and properties\n   */\n  public markTypeRoles() {\n    for (const method of this.oldType.ownMethods) {\n      determineTypeRolesFromMethod(this.assemblyComparison, method);\n    }\n    for (const property of this.oldType.ownProperties) {\n      determineTypeRolesFromProperty(this.assemblyComparison, property);\n    }\n  }\n\n  /**\n   * Validate type signatures on all methods\n   */\n  protected validateMethods() {\n    for (const [orig, updated] of memberPairs(\n      this.oldType,\n      this.oldType.allMethods,\n      this.newType,\n      this.mismatches,\n    )) {\n      if (reflect.isMethod(updated)) {\n        this.validateMethod(orig, updated);\n      }\n    }\n  }\n\n  /**\n   * Validate type signature changes on the given method\n   */\n  protected validateMethod(original: reflect.Method, updated: reflect.Method) {\n    validateStaticSame(original, updated, this.mismatches);\n    validateAsyncSame(original, updated, this.mismatches);\n\n    if (this.subclassableType) {\n      validateReturnTypeSame(\n        original,\n        updated,\n        this.mismatches.withMotivation('type is @subclassable'),\n      );\n    } else {\n      validateReturnTypeNotWeakened(original, updated, this.mismatches);\n    }\n\n    this.validateCallable(original, updated);\n  }\n\n  /**\n   * Validate type signature changes on the given callable (method or initializer)\n   */\n  protected validateCallable<T extends reflect.Method | reflect.Initializer>(\n    original: T,\n    updated: T,\n  ) {\n    validateStabilities(original, updated, this.mismatches);\n    validateNotMadeNonVariadic(original, updated, this.mismatches);\n\n    // Check that every original parameter can still be mapped to a parameter in the updated method\n    validateExistingParams(\n      original,\n      updated,\n      this.mismatches,\n      (oldParam, newParam) => {\n        if (this.subclassableType) {\n          validateParameterTypeSame(\n            original,\n            oldParam,\n            newParam,\n            this.mismatches.withMotivation('type is @subclassable'),\n          );\n        } else {\n          validateParameterTypeWeakened(\n            original,\n            oldParam,\n            newParam,\n            this.mismatches,\n          );\n        }\n      },\n    );\n\n    validateNoNewRequiredParams(original, updated, this.mismatches);\n  }\n\n  /**\n   * Validate type signature changes on all properties\n   */\n  protected validateProperties() {\n    for (const [orig, updated] of memberPairs(\n      this.oldType,\n      this.oldType.allProperties,\n      this.newType,\n      this.mismatches,\n    )) {\n      if (reflect.isProperty(updated)) {\n        this.validateProperty(orig, updated);\n      }\n    }\n  }\n\n  /**\n   * Validate type signature changes on the given property\n   */\n  protected validateProperty(\n    original: reflect.Property,\n    updated: reflect.Property,\n  ) {\n    validateStabilities(original, updated, this.mismatches);\n    validateStaticSame(original, updated, this.mismatches);\n    validateNotMadeImmutable(original, updated, this.mismatches);\n\n    if (this.subclassableType) {\n      // Hello C# my old friend\n      validatePropertyTypeSame(\n        original,\n        updated,\n        this.mismatches.withMotivation('type is @subclassable'),\n      );\n    } else if (!original.immutable) {\n      // If the type can be read, it can't be weakened (can't change Dog to Animal, consumers might be counting on a Dog).\n      // If the type can be written, it can't be strengthened (can't change Animal to Dog, consumers might be sending a Cat).\n      // => it must remain the same\n      validatePropertyTypeSame(\n        original,\n        updated,\n        this.mismatches.withMotivation('mutable property cannot change type'),\n      );\n    } else {\n      validatePropertyTypeNotWeakened(original, updated, this.mismatches);\n    }\n  }\n\n  /**\n   * Whether the current reference type has been marked as subclassable\n   */\n  private get subclassableType() {\n    return subclassableType(this.oldType);\n  }\n}\n\nexport class ComparableClassType extends ComparableReferenceType<reflect.ClassType> {\n  /**\n   * Perform the reference type comparison and include class-specific checks\n   */\n  public compare() {\n    super.compare();\n\n    validateNotMadeAbstract(this.oldType, this.newType, this.mismatches);\n\n    // JSII assembler has already taken care of inheritance here\n    if (this.oldType.initializer && this.newType.initializer) {\n      validateMethodCompatible(\n        this.oldType.initializer,\n        this.newType.initializer,\n        this.mismatches,\n      );\n    }\n  }\n\n  /**\n   * Type role marking -- include the initializer\n   */\n  public markTypeRoles() {\n    if (this.oldType.initializer) {\n      determineTypeRolesFromMethod(\n        this.assemblyComparison,\n        this.oldType.initializer,\n      );\n    }\n    super.markTypeRoles();\n  }\n}\n\n/**\n * Interface type comparison\n *\n * (Actually just plain reference type comparison)\n */\nexport class ComparableInterfaceType extends ComparableReferenceType<reflect.InterfaceType> {}\n\n/**\n * Struct type comparison\n *\n * Most notably: does no-strengthening/no-weakening checks based on whether\n * structs appear in input/output positions.\n */\nexport class ComparableStructType extends ComparableType<reflect.InterfaceType> {\n  public compare() {\n    validateStabilities(this.oldType, this.newType, this.mismatches);\n    validateBaseTypeAssignability(this.oldType, this.newType, this.mismatches);\n    this.validateNoPropertiesRemoved();\n\n    if (this.inputType) {\n      // If the struct is written, it can't be strengthened (ex: can't change an optional property to required)\n      this.validateNotStrengthened(\n        this.mismatches.withMotivation(this.inputTypeReason),\n      );\n    }\n\n    if (this.outputType) {\n      // If the struct is read, it can't be weakened (ex: can't change a required property to optional)\n      this.validateNotWeakened(\n        this.mismatches.withMotivation(this.outputTypeReason),\n      );\n    }\n  }\n\n  /**\n   * Every type of every property should have the same in/out classification as the outer type\n   */\n  protected forEachRoleSharingType(\n    cb: (t: ComparableType<any>, reason: string) => void,\n  ) {\n    for (const prop of this.oldType.allProperties) {\n      for (const t of this.assemblyComparison.typesIn(prop.type)) {\n        cb(t, `type of property ${prop.name}`);\n      }\n    }\n  }\n\n  /**\n   * Check that all properties are still present\n   *\n   * This is because for all non-structurally typed languages it is not allowed\n   * to specify members which aren't actually present in the type.\n   */\n  private validateNoPropertiesRemoved() {\n    // A single run of memberPairs() with nothing else will do this check.\n    Array.from(\n      memberPairs(\n        this.oldType,\n        this.oldType.allProperties,\n        this.newType,\n        this.mismatches,\n      ),\n    );\n  }\n\n  /**\n   * Check that the current type is not weakened\n   */\n  private validateNotWeakened(mismatches: IReport) {\n    const ana = this.isStructuralSuperType(this.oldType, this.newType);\n    if (!ana.success) {\n      mismatches.report({\n        ruleKey: 'weakened',\n        violator: this.oldType,\n        message: ana.reasons.join(', '),\n      });\n    }\n  }\n\n  /**\n   * Check that the current type is not strengthened\n   */\n  private validateNotStrengthened(mismatches: IReport) {\n    const ana = this.isStructuralSuperType(this.newType, this.oldType);\n    if (!ana.success) {\n      mismatches.report({\n        ruleKey: 'strengthened',\n        violator: this.oldType,\n        message: ana.reasons.join(', '),\n      });\n    }\n  }\n\n  private isStructuralSuperType(\n    a: reflect.InterfaceType,\n    b: reflect.InterfaceType,\n  ): Analysis {\n    try {\n      return isStructuralSuperType(a, b, this.newType.system);\n    } catch (e) {\n      // We might get an exception if the type is supposed to come from a different\n      // assembly and the lookup fails.\n      return { success: false, reasons: [e.message] };\n    }\n  }\n}\n\n/**\n * Comparison for enums\n */\nexport class ComparableEnumType extends ComparableType<reflect.EnumType> {\n  /**\n   * Perform comparisons on enum members\n   */\n  public compare() {\n    validateStabilities(this.oldType, this.newType, this.mismatches);\n\n    validateExistingMembers(\n      this.oldType,\n      this.newType,\n      this.mismatches,\n      (oldMember, newMember) => {\n        validateStabilities(oldMember, newMember, this.mismatches);\n      },\n    );\n  }\n}\n\n/**\n * Determines input/output roles of types used in this method\n *\n * - Argument types are treated as IN types\n * - Return type is treated as OUT type\n */\nfunction determineTypeRolesFromMethod(\n  comparison: AssemblyComparison,\n  method: reflect.Method | reflect.Initializer,\n) {\n  if (reflect.isMethod(method)) {\n    for (const t of comparison.typesIn(method.returns.type)) {\n      t.markAsOutputType(`returned from ${apiElementIdentifier(method)}`);\n    }\n  }\n\n  for (const param of method.parameters ?? []) {\n    for (const t of comparison.typesIn(param.type)) {\n      t.markAsInputType(`input to ${apiElementIdentifier(method)}`);\n    }\n  }\n}\n\n/**\n * Determines input/output roles of types used in this property\n *\n * - Property type is treated as OUT type\n * - If mutable, property type is also treated as IN type\n *\n * In effect, a property is treated as the following methods:\n *\n * - property(): T;\n * - setProperty(: T);  <- only if mutable\n */\nfunction determineTypeRolesFromProperty(\n  comparison: AssemblyComparison,\n  property: reflect.Property,\n) {\n  for (const t of comparison.typesIn(property.type)) {\n    t.markAsOutputType(`type of ${apiElementIdentifier(property)}`);\n  }\n  if (!property.immutable) {\n    for (const t of comparison.typesIn(property.type)) {\n      t.markAsInputType(`type of mutable ${apiElementIdentifier(property)}`);\n    }\n  }\n}\n\n/**\n * Return all the FQNs from a type reference\n *\n * In the simple case, a simple FQN, but the type might\n * be a union or complex type as well.\n */\nfunction fqnsFrom(ref: reflect.TypeReference) {\n  const ret = new Array<string>();\n  recurse(ref);\n  return ret;\n\n  function recurse(type: reflect.TypeReference) {\n    if (type.mapOfType) {\n      recurse(type.mapOfType);\n    } else if (type.arrayOfType) {\n      recurse(type.arrayOfType);\n    } else if (type.unionOfTypes) {\n      type.unionOfTypes.forEach(recurse);\n    } else if (type.fqn) {\n      ret.push(type.fqn);\n    }\n  }\n}\n\nfunction describeReasons(reasons: string[]) {\n  if (reasons.length === 0) {\n    return '';\n  }\n  if (reasons.length === 1) {\n    return reasons[0];\n  }\n  return `${reasons[0]} (...and ${reasons.length - 1} more...)`;\n}\n"]}

package/lib/types.d.ts

@@ -0,0 +1,46 @@
+import { Stability } from '@jsii/spec';
+import * as reflect from 'jsii-reflect';
+export interface ComparisonOptions {
+    /**
+     * Whether to treat API elements as experimental if unmarked.
+     *
+     * @default Treat as stable
+     */
+    defaultExperimental?: boolean;
+}
+export interface ComparisonContext extends ComparisonOptions {
+    /**
+     * Where to report errors
+     */
+    mismatches: Mismatches;
+}
+export interface ApiMismatch {
+    message: string;
+    violationKey: string;
+    stability: Stability;
+}
+export declare type ApiElement = reflect.Type | reflect.TypeMember | reflect.EnumMember;
+export interface ReportOptions {
+    ruleKey: string;
+    violator: ApiElement;
+    message: string;
+}
+export interface IReport {
+    report(options: ReportOptions): void;
+    withMotivation(reason: string): IReport;
+}
+export declare class Mismatches implements IReport {
+    readonly mismatches: ApiMismatch[];
+    private readonly defaultStability;
+    constructor(opts: {
+        defaultStability: Stability;
+    });
+    report(options: ReportOptions): void;
+    messages(): Generator<string, void, unknown>;
+    get count(): number;
+    filter(pred: (x: ApiMismatch) => boolean): Mismatches;
+    withMotivation(motivation: string): IReport;
+}
+export declare function apiElementIdentifier(apiElement: ApiElement): string;
+export declare function describeType(type: reflect.Type): "ENUM" | "CLASS" | "IFACE" | "TYPE";
+export declare function describeInterfaceType(dataType: boolean): "struct" | "regular interface";