jsii-diff 1.35.0

package/lib/validations.js

@@ -0,0 +1,487 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExistingMembers = exports.memberPairs = exports.validateNotMadeImmutable = exports.subclassableType = exports.validateMethodCompatible = exports.validateNoNewRequiredParams = exports.validateExistingParams = exports.validateParameterTypeSame = exports.validateParameterTypeWeakened = exports.validatePropertyTypeSame = exports.validatePropertyTypeNotWeakened = exports.validateReturnTypeSame = exports.validateReturnTypeNotWeakened = exports.validateNoNewAbstractMembers = exports.validateNotMadeNonVariadic = exports.validateAsyncSame = exports.validateStaticSame = exports.validateSubclassableNotRemoved = exports.validateNotMadeAbstract = exports.validateBaseTypeAssignability = void 0;
+const reflect = require("jsii-reflect");
+const log4js = require("log4js");
+const stability_1 = require("./stability");
+const type_analysis_1 = require("./type-analysis");
+const LOG = log4js.getLogger('jsii-diff');
+/**
+ * The updated type is still nominally assignable to all original base types
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * BASE instance = new CLASS();
+ * ```
+ *
+ * Where CLASS ≤: BASE.
+ */
+function validateBaseTypeAssignability(original, updated, mismatches) {
+    const ana = assignableToAllBaseTypes(original, updated);
+    if (!ana.success) {
+        mismatches.report({
+            ruleKey: 'base-types',
+            message: `not assignable to all base types anymore: ${ana.reasons.join(', ')}`,
+            violator: original,
+        });
+    }
+}
+exports.validateBaseTypeAssignability = validateBaseTypeAssignability;
+/**
+ * The updated type has not been newly made abstract
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * new CLASS();
+ * ```
+ */
+function validateNotMadeAbstract(original, updated, mismatches) {
+    if (updated.abstract && !original.abstract) {
+        mismatches.report({
+            ruleKey: 'made-abstract',
+            message: 'has gone from non-abstract to abstract',
+            violator: original,
+        });
+    }
+}
+exports.validateNotMadeAbstract = validateNotMadeAbstract;
+/**
+ * The updated type has not had its @subclassable attribute removed
+ *
+ * This would lift a restriction we can't afford.
+ */
+function validateSubclassableNotRemoved(original, updated, mismatches) {
+    if (original.docs.subclassable && !updated.docs.subclassable) {
+        mismatches.report({
+            ruleKey: 'remove-subclassable',
+            message: 'has gone from @subclassable to non-@subclassable',
+            violator: original,
+        });
+    }
+}
+exports.validateSubclassableNotRemoved = validateSubclassableNotRemoved;
+/**
+ * Check that the `static`-ness of a member hasn't changed
+ */
+function validateStaticSame(original, updated, mismatches) {
+    if (original.static !== updated.static) {
+        mismatches.report({
+            ruleKey: 'changed-static',
+            violator: original,
+            message: `used to be ${original.static ? 'static' : 'not static'}, is now ${updated.static ? 'static' : 'not static'}`,
+        });
+    }
+}
+exports.validateStaticSame = validateStaticSame;
+/**
+ * Check that the `async`-ness of a method hasn't changed
+ */
+function validateAsyncSame(original, updated, mismatches) {
+    if (original.async !== updated.async) {
+        const origQual = original.async ? 'asynchronous' : 'synchronous';
+        const updQual = updated.async ? 'asynchronous' : 'synchronous';
+        mismatches.report({
+            ruleKey: 'changed-async',
+            violator: original,
+            message: `was ${origQual}, is now ${updQual}`,
+        });
+    }
+}
+exports.validateAsyncSame = validateAsyncSame;
+/**
+ * Once variadic, can never be made non-variadic anymore (because I could always have been passing N+1 arguments)
+ */
+function validateNotMadeNonVariadic(original, updated, mismatches) {
+    if (original.variadic && !updated.variadic) {
+        mismatches.report({
+            ruleKey: 'changed-variadic',
+            violator: original,
+            message: 'used to be variadic, not variadic anymore.',
+        });
+    }
+}
+exports.validateNotMadeNonVariadic = validateNotMadeNonVariadic;
+/**
+ * Check that no new abstract members were added to a subclassable type
+ *
+ * You cannot have added abstract members to the class/interface, as they are
+ * an added burden on potential implementors.
+ */
+function validateNoNewAbstractMembers(original, updated, mismatches) {
+    const absMemberNames = new Set(updated.allMembers.filter((m) => m.abstract).map((m) => m.name));
+    const originalMemberNames = new Set(original.allMembers.map((m) => m.name));
+    for (const name of absMemberNames) {
+        if (!originalMemberNames.has(name)) {
+            mismatches.report({
+                ruleKey: 'new-abstract-member',
+                message: `adds requirement for subclasses to implement '${name}'.`,
+                violator: updated.getMembers(true)[name],
+            });
+        }
+    }
+}
+exports.validateNoNewAbstractMembers = validateNoNewAbstractMembers;
+/**
+ * Validate that a method return type is the same or strengthened
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * T value = object.method();
+ * ```
+ *
+ * Where RETURN_TYPE(method) ≤: T.
+ */
+function validateReturnTypeNotWeakened(original, updated, mismatches) {
+    const retAna = isCompatibleReturnType(original.returns, updated.returns);
+    if (!retAna.success) {
+        mismatches.report({
+            ruleKey: 'change-return-type',
+            violator: original,
+            message: `returns ${describeOptionalValueMatchingFailure(original.returns, updated.returns, retAna)}`,
+        });
+    }
+}
+exports.validateReturnTypeNotWeakened = validateReturnTypeNotWeakened;
+/**
+ * Validate that a method return type is the exact same
+ *
+ * Necessary for subclassable types in C#.
+ */
+function validateReturnTypeSame(original, updated, mismatches) {
+    const origDescr = reflect.OptionalValue.describe(original.returns);
+    const updaDescr = reflect.OptionalValue.describe(updated.returns);
+    if (origDescr !== updaDescr) {
+        mismatches.report({
+            ruleKey: 'change-return-type',
+            violator: original,
+            message: `returns ${updaDescr} (formerly ${origDescr})`,
+        });
+    }
+}
+exports.validateReturnTypeSame = validateReturnTypeSame;
+/**
+ * Validate that a property type is the same or strengthened
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * T value = object.prop;
+ * ```
+ *
+ * Where RETURN_TYPE(prop) ≤: T.
+ */
+function validatePropertyTypeNotWeakened(original, updated, mismatches) {
+    const ana = isCompatibleReturnType(original, updated);
+    if (!ana.success) {
+        mismatches.report({
+            ruleKey: 'changed-type',
+            violator: original,
+            message: `type ${describeOptionalValueMatchingFailure(original, updated, ana)}`,
+        });
+    }
+}
+exports.validatePropertyTypeNotWeakened = validatePropertyTypeNotWeakened;
+/**
+ * Validate that a property type is the exact same
+ *
+ * Necessary for subclassable types in C#.
+ */
+function validatePropertyTypeSame(original, updated, mismatches) {
+    const oldDesc = reflect.OptionalValue.describe(original);
+    const newDesc = reflect.OptionalValue.describe(updated);
+    if (oldDesc !== newDesc) {
+        mismatches.report({
+            ruleKey: 'changed-type',
+            violator: original,
+            message: `changed to ${newDesc} (formerly ${oldDesc})`,
+        });
+    }
+}
+exports.validatePropertyTypeSame = validatePropertyTypeSame;
+/**
+ * Validate that a method return type is the same or weakened
+ *
+ * Make sure the following remains compilable if U is changed:
+ *
+ * ```
+ * function method(arg: U) { ... }
+ *
+ * object.method(<T>value);
+ * ```
+ *
+ * Where T ≤: U.
+ */
+function validateParameterTypeWeakened(method, original, updated, mismatches) {
+    const argAna = isCompatibleArgumentType(original.type, updated.type);
+    if (!argAna.success) {
+        mismatches.report({
+            ruleKey: 'incompatible-argument',
+            violator: method,
+            message: `argument ${original.name}, takes ${describeOptionalValueMatchingFailure(original, updated, argAna)}`,
+        });
+        return;
+    }
+}
+exports.validateParameterTypeWeakened = validateParameterTypeWeakened;
+/**
+ * Validate that a method parameter type is the exact same
+ *
+ * Necessary for subclassable types in C#.
+ */
+function validateParameterTypeSame(method, original, updated, mismatches) {
+    if (original.type.toString() !== updated.type.toString()) {
+        mismatches.report({
+            ruleKey: 'incompatible-argument',
+            violator: method,
+            message: `argument ${original.name}, takes ${updated.type.toString()} (formerly ${original.type.toString()}): type is @subclassable`,
+        });
+    }
+}
+exports.validateParameterTypeSame = validateParameterTypeSame;
+function describeOptionalValueMatchingFailure(origType, updatedType, analysis) {
+    const origDescr = reflect.OptionalValue.describe(origType);
+    const updaDescr = reflect.OptionalValue.describe(updatedType);
+    if (origDescr !== updaDescr) {
+        return `${updaDescr} (formerly ${origDescr}): ${analysis.reasons.join(', ')}`;
+    }
+    return `${updaDescr}: ${analysis.reasons.join(', ')}`;
+}
+/**
+ * Validate that each param in the old callable is still available in the new callable, and apply custom validation to the pairs
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * object.method(a1, a2, ..., aN);
+ * ```
+ *
+ * (All types still assignable)
+ */
+function validateExistingParams(original, updated, mismatches, validateParam) {
+    original.parameters.forEach((param, i) => {
+        const updatedParam = findParam(updated.parameters, i);
+        if (updatedParam === undefined) {
+            mismatches.report({
+                ruleKey: 'removed-argument',
+                violator: original,
+                message: `argument ${param.name}, not accepted anymore.`,
+            });
+            return;
+        }
+        validateParam(param, updatedParam);
+    });
+}
+exports.validateExistingParams = validateExistingParams;
+/**
+ * Validate that no new required params got added to the end of the method
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * object.method(a1, a2, ..., aN);
+ * ```
+ *
+ * (Not too few arguments)
+ */
+function validateNoNewRequiredParams(original, updated, mismatches) {
+    updated.parameters.forEach((param, i) => {
+        if (param.optional) {
+            return;
+        }
+        const origParam = findParam(original.parameters, i);
+        if (!origParam || origParam.optional) {
+            mismatches.report({
+                ruleKey: 'new-argument',
+                violator: original,
+                message: `argument ${param.name}, newly required argument.`,
+            });
+        }
+    });
+}
+exports.validateNoNewRequiredParams = validateNoNewRequiredParams;
+function validateMethodCompatible(original, updated, mismatches) {
+    stability_1.validateStabilities(original, updated, mismatches);
+    // Type guards on original are duplicated on updated to help tsc... They are required to be the same type by the declaration.
+    if (reflect.isMethod(original) && reflect.isMethod(updated)) {
+        validateStaticSame(original, updated, mismatches);
+        validateAsyncSame(original, updated, mismatches);
+        validateReturnTypeNotWeakened(original, updated, mismatches);
+    }
+    validateNotMadeNonVariadic(original, updated, mismatches);
+    // Check that every original parameter can still be mapped to a parameter in the updated method
+    validateExistingParams(original, updated, mismatches, (oldParam, newParam) => {
+        validateParameterTypeWeakened(original, oldParam, newParam, mismatches);
+    });
+    validateNoNewRequiredParams(original, updated, mismatches);
+}
+exports.validateMethodCompatible = validateMethodCompatible;
+/**
+ * Check if a class/interface has been marked as @subclassable
+ */
+function subclassableType(x) {
+    return x.docs.subclassable;
+}
+exports.subclassableType = subclassableType;
+/**
+ * Find the indicated parameter with the given index
+ *
+ * May return the last parameter if it's variadic
+ */
+function findParam(parameters, i) {
+    if (i < parameters.length) {
+        return parameters[i];
+    }
+    const lastParam = parameters.length > 0 ? parameters[parameters.length - 1] : undefined;
+    if (lastParam && lastParam.variadic) {
+        return lastParam;
+    }
+    return undefined;
+}
+/**
+ * Validate that a previously mutable property is not made immutable
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * object.prop = value;
+ * ```
+ */
+function validateNotMadeImmutable(original, updated, mismatches) {
+    if (updated.immutable && !original.immutable) {
+        mismatches.report({
+            ruleKey: 'removed-mutability',
+            violator: original,
+            message: 'used to be mutable, is now immutable',
+        });
+    }
+}
+exports.validateNotMadeImmutable = validateNotMadeImmutable;
+function* memberPairs(origClass, xs, updatedClass, mismatches) {
+    for (const origMember of xs) {
+        LOG.trace(`${origClass.fqn}#${origMember.name}`);
+        const updatedMember = updatedClass.allMembers.find((m) => m.name === origMember.name);
+        if (!updatedMember) {
+            mismatches.report({
+                ruleKey: 'removed',
+                violator: origMember,
+                message: 'has been removed',
+            });
+            continue;
+        }
+        if (origMember.kind !== updatedMember.kind) {
+            mismatches.report({
+                ruleKey: 'changed-kind',
+                violator: origMember,
+                message: `changed from ${origMember.kind} to ${updatedMember.kind}`,
+            });
+        }
+        if (!origMember.protected && updatedMember.protected) {
+            mismatches.report({
+                ruleKey: 'hidden',
+                violator: origMember,
+                message: "changed from 'public' to 'protected'",
+            });
+        }
+        yield [origMember, updatedMember];
+    }
+}
+exports.memberPairs = memberPairs;
+/**
+ * Whether we are strengthening the postcondition (output type of a method or property)
+ *
+ * Strengthening output values is allowed!
+ */
+function isCompatibleReturnType(original, updated) {
+    if (original.type.void) {
+        return { success: true };
+    } // If we didn't use to return anything, returning something now is fine
+    if (updated.type.void) {
+        return { success: false, reasons: ["now returning 'void'"] };
+    } // If we used to return something, we can't stop doing that
+    if (!original.optional && updated.optional) {
+        return { success: false, reasons: ['output type is now optional'] };
+    }
+    return type_analysis_1.isSuperType(original.type, updated.type, updated.system);
+}
+/**
+ * Whether we are weakening the pre (input type of a method)
+ *
+ * Weakening preconditions is allowed!
+ */
+function isCompatibleArgumentType(original, updated) {
+    // Input can never be void, so no need to check
+    return type_analysis_1.isSuperType(updated, original, updated.system);
+}
+/**
+ * Verify assignability to supertypes
+ *
+ * For every base type B of type T, someone could have written:
+ *
+ * ```
+ * const variable: B = new T();
+ * ```
+ *
+ * This code needs to be valid in the updated assembly, so for each
+ * B an updated type B' needs to exist in the new assembly which is
+ * still a supertype of T'.
+ */
+function assignableToAllBaseTypes(original, updated) {
+    for (const B of baseTypes(original)) {
+        const result = type_analysis_1.isNominalSuperType(B.reference, updated.reference, updated.system);
+        if (!result.success) {
+            return result;
+        }
+    }
+    return { success: true };
+}
+/**
+ * Return all base types of the given reference type
+ */
+function baseTypes(type) {
+    const ret = new Array();
+    const todo = [type];
+    const seen = new Set();
+    while (todo.length > 0) {
+        const next = todo.pop();
+        if (seen.has(next.fqn)) {
+            continue;
+        }
+        ret.push(next);
+        seen.add(next.fqn);
+        todo.push(...next.interfaces);
+        if (next.isClassType() && next.base) {
+            todo.push(next.base);
+        }
+    }
+    return ret;
+}
+/**
+ * Validate that each enum member in the old enum enum, and apply custom validation to the enums
+ *
+ * Make sure the following remains compilable:
+ *
+ * ```
+ * T x = ENUM.member;
+ * ```
+ *
+ * (For every member of enum)
+ */
+function validateExistingMembers(original, updated, mismatches, validateMember) {
+    for (const origMember of original.members) {
+        const updatedMember = updated.members.find((m) => m.name === origMember.name);
+        if (!updatedMember) {
+            mismatches.report({
+                ruleKey: 'removed',
+                violator: origMember,
+                message: `member ${origMember.name} has been removed`,
+            });
+            continue;
+        }
+        validateMember(origMember, updatedMember);
+    }
+}
+exports.validateExistingMembers = validateExistingMembers;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validations.js","sourceRoot":"","sources":["validations.ts"],"names":[],"mappings":"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","sourcesContent":["import * as reflect from 'jsii-reflect';\nimport * as log4js from 'log4js';\n\nimport { validateStabilities } from './stability';\nimport {\n  Analysis,\n  FailedAnalysis,\n  isSuperType,\n  isNominalSuperType,\n} from './type-analysis';\nimport { IReport } from './types';\n\nconst LOG = log4js.getLogger('jsii-diff');\n\n/**\n * The updated type is still nominally assignable to all original base types\n *\n * Make sure the following remains compilable:\n *\n * ```\n * BASE instance = new CLASS();\n * ```\n *\n * Where CLASS ≤: BASE.\n */\nexport function validateBaseTypeAssignability<T extends reflect.ReferenceType>(\n  original: T,\n  updated: T,\n  mismatches: IReport,\n) {\n  const ana = assignableToAllBaseTypes(original, updated);\n  if (!ana.success) {\n    mismatches.report({\n      ruleKey: 'base-types',\n      message: `not assignable to all base types anymore: ${ana.reasons.join(\n        ', ',\n      )}`,\n      violator: original,\n    });\n  }\n}\n\n/**\n * The updated type has not been newly made abstract\n *\n * Make sure the following remains compilable:\n *\n * ```\n * new CLASS();\n * ```\n */\nexport function validateNotMadeAbstract(\n  original: reflect.ClassType,\n  updated: reflect.ClassType,\n  mismatches: IReport,\n) {\n  if (updated.abstract && !original.abstract) {\n    mismatches.report({\n      ruleKey: 'made-abstract',\n      message: 'has gone from non-abstract to abstract',\n      violator: original,\n    });\n  }\n}\n\n/**\n * The updated type has not had its @subclassable attribute removed\n *\n * This would lift a restriction we can't afford.\n */\nexport function validateSubclassableNotRemoved<T extends reflect.ReferenceType>(\n  original: T,\n  updated: T,\n  mismatches: IReport,\n) {\n  if (original.docs.subclassable && !updated.docs.subclassable) {\n    mismatches.report({\n      ruleKey: 'remove-subclassable',\n      message: 'has gone from @subclassable to non-@subclassable',\n      violator: original,\n    });\n  }\n}\n\n/**\n * Check that the `static`-ness of a member hasn't changed\n */\nexport function validateStaticSame<T extends reflect.Method | reflect.Property>(\n  original: T,\n  updated: T,\n  mismatches: IReport,\n) {\n  if (original.static !== updated.static) {\n    mismatches.report({\n      ruleKey: 'changed-static',\n      violator: original,\n      message: `used to be ${\n        original.static ? 'static' : 'not static'\n      }, is now ${updated.static ? 'static' : 'not static'}`,\n    });\n  }\n}\n\n/**\n * Check that the `async`-ness of a method hasn't changed\n */\nexport function validateAsyncSame(\n  original: reflect.Method,\n  updated: reflect.Method,\n  mismatches: IReport,\n) {\n  if (original.async !== updated.async) {\n    const origQual = original.async ? 'asynchronous' : 'synchronous';\n    const updQual = updated.async ? 'asynchronous' : 'synchronous';\n    mismatches.report({\n      ruleKey: 'changed-async',\n      violator: original,\n      message: `was ${origQual}, is now ${updQual}`,\n    });\n  }\n}\n\n/**\n * Once variadic, can never be made non-variadic anymore (because I could always have been passing N+1 arguments)\n */\nexport function validateNotMadeNonVariadic<\n  T extends reflect.Method | reflect.Initializer,\n>(original: T, updated: T, mismatches: IReport) {\n  if (original.variadic && !updated.variadic) {\n    mismatches.report({\n      ruleKey: 'changed-variadic',\n      violator: original,\n      message: 'used to be variadic, not variadic anymore.',\n    });\n  }\n}\n\n/**\n * Check that no new abstract members were added to a subclassable type\n *\n * You cannot have added abstract members to the class/interface, as they are\n * an added burden on potential implementors.\n */\nexport function validateNoNewAbstractMembers<T extends reflect.ReferenceType>(\n  original: T,\n  updated: T,\n  mismatches: IReport,\n) {\n  const absMemberNames = new Set(\n    updated.allMembers.filter((m) => m.abstract).map((m) => m.name),\n  );\n  const originalMemberNames = new Set(original.allMembers.map((m) => m.name));\n  for (const name of absMemberNames) {\n    if (!originalMemberNames.has(name)) {\n      mismatches.report({\n        ruleKey: 'new-abstract-member',\n        message: `adds requirement for subclasses to implement '${name}'.`,\n        violator: updated.getMembers(true)[name],\n      });\n    }\n  }\n}\n\n/**\n * Validate that a method return type is the same or strengthened\n *\n * Make sure the following remains compilable:\n *\n * ```\n * T value = object.method();\n * ```\n *\n * Where RETURN_TYPE(method) ≤: T.\n */\nexport function validateReturnTypeNotWeakened(\n  original: reflect.Method,\n  updated: reflect.Method,\n  mismatches: IReport,\n) {\n  const retAna = isCompatibleReturnType(original.returns, updated.returns);\n  if (!retAna.success) {\n    mismatches.report({\n      ruleKey: 'change-return-type',\n      violator: original,\n      message: `returns ${describeOptionalValueMatchingFailure(\n        original.returns,\n        updated.returns,\n        retAna,\n      )}`,\n    });\n  }\n}\n\n/**\n * Validate that a method return type is the exact same\n *\n * Necessary for subclassable types in C#.\n */\nexport function validateReturnTypeSame(\n  original: reflect.Method,\n  updated: reflect.Method,\n  mismatches: IReport,\n) {\n  const origDescr = reflect.OptionalValue.describe(original.returns);\n  const updaDescr = reflect.OptionalValue.describe(updated.returns);\n  if (origDescr !== updaDescr) {\n    mismatches.report({\n      ruleKey: 'change-return-type',\n      violator: original,\n      message: `returns ${updaDescr} (formerly ${origDescr})`,\n    });\n  }\n}\n\n/**\n * Validate that a property type is the same or strengthened\n *\n * Make sure the following remains compilable:\n *\n * ```\n * T value = object.prop;\n * ```\n *\n * Where RETURN_TYPE(prop) ≤: T.\n */\nexport function validatePropertyTypeNotWeakened(\n  original: reflect.Property,\n  updated: reflect.Property,\n  mismatches: IReport,\n) {\n  const ana = isCompatibleReturnType(original, updated);\n  if (!ana.success) {\n    mismatches.report({\n      ruleKey: 'changed-type',\n      violator: original,\n      message: `type ${describeOptionalValueMatchingFailure(\n        original,\n        updated,\n        ana,\n      )}`,\n    });\n  }\n}\n\n/**\n * Validate that a property type is the exact same\n *\n * Necessary for subclassable types in C#.\n */\nexport function validatePropertyTypeSame(\n  original: reflect.Property,\n  updated: reflect.Property,\n  mismatches: IReport,\n) {\n  const oldDesc = reflect.OptionalValue.describe(original);\n  const newDesc = reflect.OptionalValue.describe(updated);\n  if (oldDesc !== newDesc) {\n    mismatches.report({\n      ruleKey: 'changed-type',\n      violator: original,\n      message: `changed to ${newDesc} (formerly ${oldDesc})`,\n    });\n  }\n}\n\n/**\n * Validate that a method return type is the same or weakened\n *\n * Make sure the following remains compilable if U is changed:\n *\n * ```\n * function method(arg: U) { ... }\n *\n * object.method(<T>value);\n * ```\n *\n * Where T ≤: U.\n */\nexport function validateParameterTypeWeakened(\n  method: reflect.Method | reflect.Initializer,\n  original: reflect.Parameter,\n  updated: reflect.Parameter,\n  mismatches: IReport,\n) {\n  const argAna = isCompatibleArgumentType(original.type, updated.type);\n  if (!argAna.success) {\n    mismatches.report({\n      ruleKey: 'incompatible-argument',\n      violator: method,\n      message: `argument ${\n        original.name\n      }, takes ${describeOptionalValueMatchingFailure(\n        original,\n        updated,\n        argAna,\n      )}`,\n    });\n    return;\n  }\n}\n\n/**\n * Validate that a method parameter type is the exact same\n *\n * Necessary for subclassable types in C#.\n */\nexport function validateParameterTypeSame(\n  method: reflect.Method | reflect.Initializer,\n  original: reflect.Parameter,\n  updated: reflect.Parameter,\n  mismatches: IReport,\n) {\n  if (original.type.toString() !== updated.type.toString()) {\n    mismatches.report({\n      ruleKey: 'incompatible-argument',\n      violator: method,\n      message: `argument ${\n        original.name\n      }, takes ${updated.type.toString()} (formerly ${original.type.toString()}): type is @subclassable`,\n    });\n  }\n}\n\nfunction describeOptionalValueMatchingFailure(\n  origType: reflect.OptionalValue,\n  updatedType: reflect.OptionalValue,\n  analysis: FailedAnalysis,\n) {\n  const origDescr = reflect.OptionalValue.describe(origType);\n  const updaDescr = reflect.OptionalValue.describe(updatedType);\n  if (origDescr !== updaDescr) {\n    return `${updaDescr} (formerly ${origDescr}): ${analysis.reasons.join(\n      ', ',\n    )}`;\n  }\n  return `${updaDescr}: ${analysis.reasons.join(', ')}`;\n}\n\n/**\n * Validate that each param in the old callable is still available in the new callable, and apply custom validation to the pairs\n *\n * Make sure the following remains compilable:\n *\n * ```\n * object.method(a1, a2, ..., aN);\n * ```\n *\n * (All types still assignable)\n */\nexport function validateExistingParams<\n  T extends reflect.Initializer | reflect.Method,\n>(\n  original: T,\n  updated: T,\n  mismatches: IReport,\n  validateParam: (\n    oldParam: reflect.Parameter,\n    newParam: reflect.Parameter,\n  ) => void,\n) {\n  original.parameters.forEach((param, i) => {\n    const updatedParam = findParam(updated.parameters, i);\n    if (updatedParam === undefined) {\n      mismatches.report({\n        ruleKey: 'removed-argument',\n        violator: original,\n        message: `argument ${param.name}, not accepted anymore.`,\n      });\n      return;\n    }\n\n    validateParam(param, updatedParam);\n  });\n}\n\n/**\n * Validate that no new required params got added to the end of the method\n *\n * Make sure the following remains compilable:\n *\n * ```\n * object.method(a1, a2, ..., aN);\n * ```\n *\n * (Not too few arguments)\n */\nexport function validateNoNewRequiredParams<\n  T extends reflect.Initializer | reflect.Method,\n>(original: T, updated: T, mismatches: IReport) {\n  updated.parameters.forEach((param, i) => {\n    if (param.optional) {\n      return;\n    }\n\n    const origParam = findParam(original.parameters, i);\n    if (!origParam || origParam.optional) {\n      mismatches.report({\n        ruleKey: 'new-argument',\n        violator: original,\n        message: `argument ${param.name}, newly required argument.`,\n      });\n    }\n  });\n}\n\nexport function validateMethodCompatible<\n  T extends reflect.Method | reflect.Initializer,\n>(original: T, updated: T, mismatches: IReport) {\n  validateStabilities(original, updated, mismatches);\n\n  // Type guards on original are duplicated on updated to help tsc... They are required to be the same type by the declaration.\n  if (reflect.isMethod(original) && reflect.isMethod(updated)) {\n    validateStaticSame(original, updated, mismatches);\n    validateAsyncSame(original, updated, mismatches);\n    validateReturnTypeNotWeakened(original, updated, mismatches);\n  }\n\n  validateNotMadeNonVariadic(original, updated, 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    mismatches,\n    (oldParam, newParam) => {\n      validateParameterTypeWeakened(original, oldParam, newParam, mismatches);\n    },\n  );\n\n  validateNoNewRequiredParams(original, updated, mismatches);\n}\n\n/**\n * Check if a class/interface has been marked as @subclassable\n */\nexport function subclassableType(x: reflect.Documentable) {\n  return x.docs.subclassable;\n}\n\n/**\n * Find the indicated parameter with the given index\n *\n * May return the last parameter if it's variadic\n */\nfunction findParam(\n  parameters: reflect.Parameter[],\n  i: number,\n): reflect.Parameter | undefined {\n  if (i < parameters.length) {\n    return parameters[i];\n  }\n  const lastParam =\n    parameters.length > 0 ? parameters[parameters.length - 1] : undefined;\n  if (lastParam && lastParam.variadic) {\n    return lastParam;\n  }\n  return undefined;\n}\n\n/**\n * Validate that a previously mutable property is not made immutable\n *\n * Make sure the following remains compilable:\n *\n * ```\n * object.prop = value;\n * ```\n */\nexport function validateNotMadeImmutable(\n  original: reflect.Property,\n  updated: reflect.Property,\n  mismatches: IReport,\n) {\n  if (updated.immutable && !original.immutable) {\n    mismatches.report({\n      ruleKey: 'removed-mutability',\n      violator: original,\n      message: 'used to be mutable, is now immutable',\n    });\n  }\n}\n\nexport function* memberPairs<\n  T extends reflect.TypeMember,\n  U extends reflect.ReferenceType,\n>(\n  origClass: U,\n  xs: T[],\n  updatedClass: U,\n  mismatches: IReport,\n): IterableIterator<[T, reflect.TypeMember]> {\n  for (const origMember of xs) {\n    LOG.trace(`${origClass.fqn}#${origMember.name}`);\n\n    const updatedMember = updatedClass.allMembers.find(\n      (m) => m.name === origMember.name,\n    );\n    if (!updatedMember) {\n      mismatches.report({\n        ruleKey: 'removed',\n        violator: origMember,\n        message: 'has been removed',\n      });\n      continue;\n    }\n\n    if (origMember.kind !== updatedMember.kind) {\n      mismatches.report({\n        ruleKey: 'changed-kind',\n        violator: origMember,\n        message: `changed from ${origMember.kind} to ${updatedMember.kind}`,\n      });\n    }\n\n    if (!origMember.protected && updatedMember.protected) {\n      mismatches.report({\n        ruleKey: 'hidden',\n        violator: origMember,\n        message: \"changed from 'public' to 'protected'\",\n      });\n    }\n\n    yield [origMember, updatedMember];\n  }\n}\n\n/**\n * Whether we are strengthening the postcondition (output type of a method or property)\n *\n * Strengthening output values is allowed!\n */\nfunction isCompatibleReturnType(\n  original: reflect.OptionalValue,\n  updated: reflect.OptionalValue,\n): Analysis {\n  if (original.type.void) {\n    return { success: true };\n  } // If we didn't use to return anything, returning something now is fine\n  if (updated.type.void) {\n    return { success: false, reasons: [\"now returning 'void'\"] };\n  } // If we used to return something, we can't stop doing that\n  if (!original.optional && updated.optional) {\n    return { success: false, reasons: ['output type is now optional'] };\n  }\n  return isSuperType(original.type, updated.type, updated.system);\n}\n\n/**\n * Whether we are weakening the pre (input type of a method)\n *\n * Weakening preconditions is allowed!\n */\nfunction isCompatibleArgumentType(\n  original: reflect.TypeReference,\n  updated: reflect.TypeReference,\n): Analysis {\n  // Input can never be void, so no need to check\n  return isSuperType(updated, original, updated.system);\n}\n\n/**\n * Verify assignability to supertypes\n *\n * For every base type B of type T, someone could have written:\n *\n * ```\n * const variable: B = new T();\n * ```\n *\n * This code needs to be valid in the updated assembly, so for each\n * B an updated type B' needs to exist in the new assembly which is\n * still a supertype of T'.\n */\nfunction assignableToAllBaseTypes(\n  original: reflect.ReferenceType,\n  updated: reflect.ReferenceType,\n): Analysis {\n  for (const B of baseTypes(original)) {\n    const result = isNominalSuperType(\n      B.reference,\n      updated.reference,\n      updated.system,\n    );\n    if (!result.success) {\n      return result;\n    }\n  }\n  return { success: true };\n}\n\n/**\n * Return all base types of the given reference type\n */\nfunction baseTypes(type: reflect.ReferenceType) {\n  const ret = new Array<reflect.ReferenceType>();\n  const todo: reflect.ReferenceType[] = [type];\n  const seen = new Set<string>();\n\n  while (todo.length > 0) {\n    const next = todo.pop()!;\n    if (seen.has(next.fqn)) {\n      continue;\n    }\n    ret.push(next);\n    seen.add(next.fqn);\n\n    todo.push(...next.interfaces);\n    if (next.isClassType() && next.base) {\n      todo.push(next.base);\n    }\n  }\n\n  return ret;\n}\n\n/**\n * Validate that each enum member in the old enum enum, and apply custom validation to the enums\n *\n * Make sure the following remains compilable:\n *\n * ```\n * T x = ENUM.member;\n * ```\n *\n * (For every member of enum)\n */\nexport function validateExistingMembers(\n  original: reflect.EnumType,\n  updated: reflect.EnumType,\n  mismatches: IReport,\n  validateMember: (\n    oldParam: reflect.EnumMember,\n    newParam: reflect.EnumMember,\n  ) => void,\n) {\n  for (const origMember of original.members) {\n    const updatedMember = updated.members.find(\n      (m) => m.name === origMember.name,\n    );\n    if (!updatedMember) {\n      mismatches.report({\n        ruleKey: 'removed',\n        violator: origMember,\n        message: `member ${origMember.name} has been removed`,\n      });\n      continue;\n    }\n\n    validateMember(origMember, updatedMember);\n  }\n}\n"]}

package/lib/version.d.ts

@@ -0,0 +1,2 @@
+/** The qualified version number for this JSII compiler. */
+export declare const VERSION = "1.35.0 (build 6ebef96)";

package/lib/version.js

@@ -0,0 +1,7 @@
+"use strict";
+// Generated at 2021-09-28T17:08:28Z by generate.sh
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+/** The qualified version number for this JSII compiler. */
+exports.VERSION = '1.35.0 (build 6ebef96)';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLG1EQUFtRDs7O0FBRW5ELDJEQUEyRDtBQUM5QyxRQUFBLE9BQU8sR0FBRyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdlbmVyYXRlZCBhdCAyMDIxLTA5LTI4VDE3OjA4OjI4WiBieSBnZW5lcmF0ZS5zaFxuXG4vKiogVGhlIHF1YWxpZmllZCB2ZXJzaW9uIG51bWJlciBmb3IgdGhpcyBKU0lJIGNvbXBpbGVyLiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSAnMS4zNS4wIChidWlsZCA2ZWJlZjk2KSc7XG4iXX0=

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "jsii-diff",
+  "version": "1.35.0",
+  "description": "Assembly comparison for jsii",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Amazon Web Services",
+    "url": "https://aws.amazon.com"
+  },
+  "homepage": "https://github.com/aws/jsii",
+  "bugs": {
+    "url": "https://github.com/aws/jsii/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aws/jsii.git",
+    "directory": "packages/jsii-diff"
+  },
+  "engines": {
+    "node": ">= 12.7.0"
+  },
+  "main": "lib/index.js",
+  "bin": {
+    "jsii-diff": "bin/jsii-diff"
+  },
+  "scripts": {
+    "build": "bash ./generate.sh && tsc --build && npm run lint",
+    "watch": "bash ./generate.sh && tsc --build -w",
+    "lint": "eslint . --ext .js,.ts --ignore-path=.gitignore",
+    "lint:fix": "yarn lint --fix",
+    "test": "jest",
+    "test:update": "jest -u",
+    "package": "package-js"
+  },
+  "dependencies": {
+    "@jsii/check-node": "1.35.0",
+    "@jsii/spec": "^1.35.0",
+    "fs-extra": "^9.1.0",
+    "jsii-reflect": "^1.35.0",
+    "log4js": "^6.3.0",
+    "typescript": "~3.9.10",
+    "yargs": "^16.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^9.0.13",
+    "@types/jest": "^27.0.2",
+    "@types/jest-expect-message": "^1.0.3",
+    "@types/node": "^12.20.26",
+    "@types/tar-fs": "^2.0.1",
+    "eslint": "^7.32.0",
+    "jest": "^27.2.1",
+    "jest-expect-message": "^1.0.2",
+    "jsii": "^1.35.0",
+    "jsii-build-tools": "^1.35.0",
+    "prettier": "^2.4.1"
+  }
+}

package/test/classes.test.d.ts

@@ -0,0 +1 @@
+export {};