jsii 5.8.22-dev.8 → 5.8.22

package/lib/type-analysis.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowedCovariantSubtype = isAllowedCovariantSubtype;
+const spec = require("@jsii/spec");
+const deepEqual = require("fast-deep-equal");
+/**
+ * Check if subType is an allowed covariant subtype to superType
+ *
+ * This is not a generic check for subtypes or covariance, but a specific implementation
+ * that checks the currently allowed conditions for class covariance.
+ * In practice, this is driven by C# limitations.
+ */
+function isAllowedCovariantSubtype(subType, superType, dereference) {
+    // one void, while other isn't => not covariant
+    if ((subType === undefined) !== (superType === undefined)) {
+        return false;
+    }
+    // Same type is always covariant
+    if (deepEqual(subType, superType)) {
+        return true;
+    }
+    // Handle array collections (covariant)
+    if (spec.isCollectionTypeReference(subType) && spec.isCollectionTypeReference(superType)) {
+        if (subType.collection.kind === 'array' && superType.collection.kind === 'array') {
+            return isAllowedCovariantSubtype(subType.collection.elementtype, superType.collection.elementtype, dereference);
+        }
+        // Maps are not allowed to be covariant in C#, so we exclude them here.
+        // This seems to be because we use C# Dictionary to implements Maps, which are using generics and generics are not allowed to be covariant
+        return false;
+    }
+    // Union types are currently not allowed, because we have not seen the need for it.
+    // Technically narrowing (removing `| Type` or subtyping) could be allowed and this works in C#.
+    if (spec.isUnionTypeReference(subType) || spec.isUnionTypeReference(superType)) {
+        return false;
+    }
+    // Intersection types are invalid, because intersections are only allowed as inputs
+    // and covariance is only allowed in outputs.
+    if (spec.isIntersectionTypeReference(subType) || spec.isIntersectionTypeReference(superType)) {
+        return false;
+    }
+    // Primitives can never be covariant to each other in C#
+    if (spec.isPrimitiveTypeReference(subType) || spec.isPrimitiveTypeReference(superType)) {
+        return false;
+    }
+    // We really only support covariance for named types (and lists of named types).
+    // To be safe, let's guard against any unknown cases.
+    if (!spec.isNamedTypeReference(subType) || !spec.isNamedTypeReference(superType)) {
+        return false;
+    }
+    const subTypeSpec = dereference(subType.fqn);
+    const superTypeSpec = dereference(superType.fqn);
+    if (!subTypeSpec || !superTypeSpec) {
+        return false;
+    }
+    // Handle class-to-class inheritance
+    if (spec.isClassType(subTypeSpec) && spec.isClassType(superTypeSpec)) {
+        return _classExtendsClass(subTypeSpec, superType.fqn);
+    }
+    // Handle interface-to-interface inheritance
+    if (spec.isInterfaceType(subTypeSpec) && spec.isInterfaceType(superTypeSpec)) {
+        return _interfaceExtendsInterface(subTypeSpec, superType.fqn);
+    }
+    // Handle class implementing interface
+    if (spec.isClassType(subTypeSpec) && spec.isInterfaceType(superTypeSpec)) {
+        return _classImplementsInterface(subTypeSpec, superType.fqn);
+    }
+    return false;
+    function _classExtendsClass(classType, targetFqn) {
+        let current = classType;
+        while (current.base) {
+            if (current.base === targetFqn) {
+                return true;
+            }
+            const baseType = dereference(current.base);
+            if (!spec.isClassType(baseType)) {
+                break;
+            }
+            current = baseType;
+        }
+        return false;
+    }
+    function _classImplementsInterface(classType, interfaceFqn) {
+        // Check direct interfaces
+        if (classType.interfaces?.includes(interfaceFqn)) {
+            return true;
+        }
+        // Check inherited interfaces
+        if (classType.interfaces) {
+            for (const iface of classType.interfaces) {
+                const ifaceType = dereference(iface);
+                if (spec.isInterfaceType(ifaceType) && _interfaceExtendsInterface(ifaceType, interfaceFqn)) {
+                    return true;
+                }
+            }
+        }
+        // Check base class interfaces
+        if (classType.base) {
+            const baseType = dereference(classType.base);
+            if (spec.isClassType(baseType)) {
+                return _classImplementsInterface(baseType, interfaceFqn);
+            }
+        }
+        return false;
+    }
+    function _interfaceExtendsInterface(interfaceType, targetFqn) {
+        if (interfaceType.fqn === targetFqn) {
+            return true;
+        }
+        if (interfaceType.interfaces) {
+            for (const iface of interfaceType.interfaces) {
+                if (iface === targetFqn) {
+                    return true;
+                }
+                const ifaceType = dereference(iface);
+                if (spec.isInterfaceType(ifaceType) && _interfaceExtendsInterface(ifaceType, targetFqn)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=type-analysis.js.map

package/lib/type-analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-analysis.js","sourceRoot":"","sources":["../src/type-analysis.ts"],"names":[],"mappings":";;AAWA,8DAqIC;AAhJD,mCAAmC;AACnC,6CAA6C;AAG7C;;;;;;GAMG;AACH,SAAgB,yBAAyB,CACvC,OAAuC,EACvC,SAAyC,EACzC,WAAyB;IAEzB,+CAA+C;IAC/C,IAAI,CAAC,OAAO,KAAK,SAAS,CAAC,KAAK,CAAC,SAAS,KAAK,SAAS,CAAC,EAAE,CAAC;QAC1D,OAAO,KAAK,CAAC;IACf,CAAC;IAED,gCAAgC;IAChC,IAAI,SAAS,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,uCAAuC;IACvC,IAAI,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,yBAAyB,CAAC,SAAS,CAAC,EAAE,CAAC;QACzF,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,KAAK,OAAO,IAAI,SAAS,CAAC,UAAU,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACjF,OAAO,yBAAyB,CAAC,OAAO,CAAC,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC,UAAU,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;QAClH,CAAC;QACD,uEAAuE;QACvE,0IAA0I;QAC1I,OAAO,KAAK,CAAC;IACf,CAAC;IAED,mFAAmF;IACnF,gGAAgG;IAChG,IAAI,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,EAAE,CAAC;QAC/E,OAAO,KAAK,CAAC;IACf,CAAC;IAED,mFAAmF;IACnF,6CAA6C;IAC7C,IAAI,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,2BAA2B,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7F,OAAO,KAAK,CAAC;IACf,CAAC;IAED,wDAAwD;IACxD,IAAI,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,EAAE,CAAC;QACvF,OAAO,KAAK,CAAC;IACf,CAAC;IAED,gFAAgF;IAChF,qDAAqD;IACrD,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,EAAE,CAAC;QACjF,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC7C,MAAM,aAAa,GAAG,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAEjD,IAAI,CAAC,WAAW,IAAI,CAAC,aAAa,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,oCAAoC;IACpC,IAAI,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,EAAE,CAAC;QACrE,OAAO,kBAAkB,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IACxD,CAAC;IAED,4CAA4C;IAC5C,IAAI,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,CAAC;QAC7E,OAAO,0BAA0B,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAChE,CAAC;IAED,sCAAsC;IACtC,IAAI,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,CAAC;QACzE,OAAO,yBAAyB,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,KAAK,CAAC;IAEb,SAAS,kBAAkB,CAAC,SAAyB,EAAE,SAAiB;QACtE,IAAI,OAAO,GAAG,SAAS,CAAC;QACxB,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC;YACpB,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC/B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAChC,MAAM;YACR,CAAC;YACD,OAAO,GAAG,QAAQ,CAAC;QACrB,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,yBAAyB,CAAC,SAAyB,EAAE,YAAoB;QAChF,0BAA0B;QAC1B,IAAI,SAAS,CAAC,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;YACjD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,6BAA6B;QAC7B,IAAI,SAAS,CAAC,UAAU,EAAE,CAAC;YACzB,KAAK,MAAM,KAAK,IAAI,SAAS,CAAC,UAAU,EAAE,CAAC;gBACzC,MAAM,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;gBACrC,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,0BAA0B,CAAC,SAAS,EAAE,YAAY,CAAC,EAAE,CAAC;oBAC3F,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QAED,8BAA8B;QAC9B,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC;YACnB,MAAM,QAAQ,GAAG,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YAC7C,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC/B,OAAO,yBAAyB,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,0BAA0B,CAAC,aAAiC,EAAE,SAAiB;QACtF,IAAI,aAAa,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,aAAa,CAAC,UAAU,EAAE,CAAC;YAC7B,KAAK,MAAM,KAAK,IAAI,aAAa,CAAC,UAAU,EAAE,CAAC;gBAC7C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;oBACxB,OAAO,IAAI,CAAC;gBACd,CAAC;gBACD,MAAM,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;gBACrC,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,IAAI,0BAA0B,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;oBACxF,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["import * as spec from '@jsii/spec';\nimport * as deepEqual from 'fast-deep-equal';\nimport { TypeResolver } from './type-reference';\n\n/**\n * Check if subType is an allowed covariant subtype to superType\n *\n * This is not a generic check for subtypes or covariance, but a specific implementation\n * that checks the currently allowed conditions for class covariance.\n * In practice, this is driven by C# limitations.\n */\nexport function isAllowedCovariantSubtype(\n  subType: spec.TypeReference | undefined,\n  superType: spec.TypeReference | undefined,\n  dereference: TypeResolver,\n): boolean {\n  // one void, while other isn't => not covariant\n  if ((subType === undefined) !== (superType === undefined)) {\n    return false;\n  }\n\n  // Same type is always covariant\n  if (deepEqual(subType, superType)) {\n    return true;\n  }\n\n  // Handle array collections (covariant)\n  if (spec.isCollectionTypeReference(subType) && spec.isCollectionTypeReference(superType)) {\n    if (subType.collection.kind === 'array' && superType.collection.kind === 'array') {\n      return isAllowedCovariantSubtype(subType.collection.elementtype, superType.collection.elementtype, dereference);\n    }\n    // Maps are not allowed to be covariant in C#, so we exclude them here.\n    // This seems to be because we use C# Dictionary to implements Maps, which are using generics and generics are not allowed to be covariant\n    return false;\n  }\n\n  // Union types are currently not allowed, because we have not seen the need for it.\n  // Technically narrowing (removing `| Type` or subtyping) could be allowed and this works in C#.\n  if (spec.isUnionTypeReference(subType) || spec.isUnionTypeReference(superType)) {\n    return false;\n  }\n\n  // Intersection types are invalid, because intersections are only allowed as inputs\n  // and covariance is only allowed in outputs.\n  if (spec.isIntersectionTypeReference(subType) || spec.isIntersectionTypeReference(superType)) {\n    return false;\n  }\n\n  // Primitives can never be covariant to each other in C#\n  if (spec.isPrimitiveTypeReference(subType) || spec.isPrimitiveTypeReference(superType)) {\n    return false;\n  }\n\n  // We really only support covariance for named types (and lists of named types).\n  // To be safe, let's guard against any unknown cases.\n  if (!spec.isNamedTypeReference(subType) || !spec.isNamedTypeReference(superType)) {\n    return false;\n  }\n\n  const subTypeSpec = dereference(subType.fqn);\n  const superTypeSpec = dereference(superType.fqn);\n\n  if (!subTypeSpec || !superTypeSpec) {\n    return false;\n  }\n\n  // Handle class-to-class inheritance\n  if (spec.isClassType(subTypeSpec) && spec.isClassType(superTypeSpec)) {\n    return _classExtendsClass(subTypeSpec, superType.fqn);\n  }\n\n  // Handle interface-to-interface inheritance\n  if (spec.isInterfaceType(subTypeSpec) && spec.isInterfaceType(superTypeSpec)) {\n    return _interfaceExtendsInterface(subTypeSpec, superType.fqn);\n  }\n\n  // Handle class implementing interface\n  if (spec.isClassType(subTypeSpec) && spec.isInterfaceType(superTypeSpec)) {\n    return _classImplementsInterface(subTypeSpec, superType.fqn);\n  }\n\n  return false;\n\n  function _classExtendsClass(classType: spec.ClassType, targetFqn: string): boolean {\n    let current = classType;\n    while (current.base) {\n      if (current.base === targetFqn) {\n        return true;\n      }\n      const baseType = dereference(current.base);\n      if (!spec.isClassType(baseType)) {\n        break;\n      }\n      current = baseType;\n    }\n    return false;\n  }\n\n  function _classImplementsInterface(classType: spec.ClassType, interfaceFqn: string): boolean {\n    // Check direct interfaces\n    if (classType.interfaces?.includes(interfaceFqn)) {\n      return true;\n    }\n\n    // Check inherited interfaces\n    if (classType.interfaces) {\n      for (const iface of classType.interfaces) {\n        const ifaceType = dereference(iface);\n        if (spec.isInterfaceType(ifaceType) && _interfaceExtendsInterface(ifaceType, interfaceFqn)) {\n          return true;\n        }\n      }\n    }\n\n    // Check base class interfaces\n    if (classType.base) {\n      const baseType = dereference(classType.base);\n      if (spec.isClassType(baseType)) {\n        return _classImplementsInterface(baseType, interfaceFqn);\n      }\n    }\n\n    return false;\n  }\n\n  function _interfaceExtendsInterface(interfaceType: spec.InterfaceType, targetFqn: string): boolean {\n    if (interfaceType.fqn === targetFqn) {\n      return true;\n    }\n\n    if (interfaceType.interfaces) {\n      for (const iface of interfaceType.interfaces) {\n        if (iface === targetFqn) {\n          return true;\n        }\n        const ifaceType = dereference(iface);\n        if (spec.isInterfaceType(ifaceType) && _interfaceExtendsInterface(ifaceType, targetFqn)) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n}\n"]}

package/lib/type-reference.d.ts

@@ -0,0 +1,20 @@
+import * as spec from '@jsii/spec';
+/**
+ * Convert a type reference to a string
+ */
+export declare function typeReferenceToString(x: spec.TypeReference): string;
+/**
+ * Return whether the given type references are equal
+ */
+export declare function typeReferenceEqual(a: spec.TypeReference, b: spec.TypeReference): boolean;
+export type TypeResolver = (typeRef: string | spec.NamedTypeReference) => spec.Type | undefined;
+/**
+ * Creates a type resolver function for a given context (assembly + dependency closure).
+ */
+export declare function createTypeResolver(assembly: spec.Assembly, dependencyClosure: readonly spec.Assembly[]): TypeResolver;
+/**
+ * Resolve a type from a name to the actual type.
+ * Uses a given assembly and dependency closure for lookup.
+ */
+export declare function resolveType(typeRef: string | spec.NamedTypeReference, assembly: spec.Assembly, dependencyClosure: readonly spec.Assembly[]): spec.Type | undefined;
+//# sourceMappingURL=type-reference.d.ts.map

package/lib/type-reference.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeReferenceToString = typeReferenceToString;
+exports.typeReferenceEqual = typeReferenceEqual;
+exports.createTypeResolver = createTypeResolver;
+exports.resolveType = resolveType;
+const spec = require("@jsii/spec");
+const type_visitor_1 = require("./type-visitor");
+/**
+ * Convert a type reference to a string
+ */
+function typeReferenceToString(x) {
+    return (0, type_visitor_1.visitTypeReference)(x, {
+        named: function (ref) {
+            return ref.fqn;
+        },
+        primitive: function (ref) {
+            return ref.primitive;
+        },
+        collection: function (ref) {
+            return `${ref.collection.kind}<${typeReferenceToString(ref.collection.elementtype)}>`;
+        },
+        union: function (ref) {
+            return ref.union.types.map(typeReferenceToString).join(' | ');
+        },
+        intersection: function (ref) {
+            return ref.intersection.types.map(typeReferenceToString).join(' & ');
+        },
+    });
+}
+/**
+ * Return whether the given type references are equal
+ */
+function typeReferenceEqual(a, b) {
+    if (spec.isNamedTypeReference(a) && spec.isNamedTypeReference(b)) {
+        return a.fqn === b.fqn;
+    }
+    if (spec.isPrimitiveTypeReference(a) && spec.isPrimitiveTypeReference(b)) {
+        return a.primitive === b.primitive;
+    }
+    if (spec.isCollectionTypeReference(a) && spec.isCollectionTypeReference(b)) {
+        return (a.collection.kind === b.collection.kind && typeReferenceEqual(a.collection.elementtype, b.collection.elementtype));
+    }
+    if (spec.isUnionTypeReference(a) && spec.isUnionTypeReference(b)) {
+        return (a.union.types.length === b.union.types.length &&
+            a.union.types.every((aType, i) => typeReferenceEqual(aType, b.union.types[i])));
+    }
+    if (spec.isIntersectionTypeReference(a) && spec.isIntersectionTypeReference(b)) {
+        return (a.intersection.types.length === b.intersection.types.length &&
+            a.intersection.types.every((aType, i) => typeReferenceEqual(aType, b.intersection.types[i])));
+    }
+    return false;
+}
+/**
+ * Creates a type resolver function for a given context (assembly + dependency closure).
+ */
+function createTypeResolver(assembly, dependencyClosure) {
+    return (typeRef) => resolveType(typeRef, assembly, dependencyClosure);
+}
+/**
+ * Resolve a type from a name to the actual type.
+ * Uses a given assembly and dependency closure for lookup.
+ */
+function resolveType(typeRef, assembly, dependencyClosure) {
+    if (typeof typeRef !== 'string') {
+        typeRef = typeRef.fqn;
+    }
+    const [assm] = typeRef.split('.');
+    if (assembly.name === assm) {
+        return assembly.types?.[typeRef];
+    }
+    const foreignAssm = dependencyClosure.find((dep) => dep.name === assm);
+    return foreignAssm?.types?.[typeRef];
+}
+//# sourceMappingURL=type-reference.js.map

package/lib/type-reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-reference.js","sourceRoot":"","sources":["../src/type-reference.ts"],"names":[],"mappings":"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","sourcesContent":["import * as spec from '@jsii/spec';\nimport { visitTypeReference } from './type-visitor';\n\n/**\n * Convert a type reference to a string\n */\nexport function typeReferenceToString(x: spec.TypeReference): string {\n  return visitTypeReference<string>(x, {\n    named: function (ref: spec.NamedTypeReference) {\n      return ref.fqn;\n    },\n    primitive: function (ref: spec.PrimitiveTypeReference) {\n      return ref.primitive;\n    },\n    collection: function (ref: spec.CollectionTypeReference) {\n      return `${ref.collection.kind}<${typeReferenceToString(ref.collection.elementtype)}>`;\n    },\n    union: function (ref: spec.UnionTypeReference) {\n      return ref.union.types.map(typeReferenceToString).join(' | ');\n    },\n    intersection: function (ref: spec.IntersectionTypeReference) {\n      return ref.intersection.types.map(typeReferenceToString).join(' & ');\n    },\n  });\n}\n\n/**\n * Return whether the given type references are equal\n */\nexport function typeReferenceEqual(a: spec.TypeReference, b: spec.TypeReference): boolean {\n  if (spec.isNamedTypeReference(a) && spec.isNamedTypeReference(b)) {\n    return a.fqn === b.fqn;\n  }\n  if (spec.isPrimitiveTypeReference(a) && spec.isPrimitiveTypeReference(b)) {\n    return a.primitive === b.primitive;\n  }\n  if (spec.isCollectionTypeReference(a) && spec.isCollectionTypeReference(b)) {\n    return (\n      a.collection.kind === b.collection.kind && typeReferenceEqual(a.collection.elementtype, b.collection.elementtype)\n    );\n  }\n  if (spec.isUnionTypeReference(a) && spec.isUnionTypeReference(b)) {\n    return (\n      a.union.types.length === b.union.types.length &&\n      a.union.types.every((aType, i) => typeReferenceEqual(aType, b.union.types[i]))\n    );\n  }\n  if (spec.isIntersectionTypeReference(a) && spec.isIntersectionTypeReference(b)) {\n    return (\n      a.intersection.types.length === b.intersection.types.length &&\n      a.intersection.types.every((aType, i) => typeReferenceEqual(aType, b.intersection.types[i]))\n    );\n  }\n  return false;\n}\n\nexport type TypeResolver = (typeRef: string | spec.NamedTypeReference) => spec.Type | undefined;\n\n/**\n * Creates a type resolver function for a given context (assembly + dependency closure).\n */\nexport function createTypeResolver(assembly: spec.Assembly, dependencyClosure: readonly spec.Assembly[]): TypeResolver {\n  return (typeRef) => resolveType(typeRef, assembly, dependencyClosure);\n}\n\n/**\n * Resolve a type from a name to the actual type.\n * Uses a given assembly and dependency closure for lookup.\n */\nexport function resolveType(\n  typeRef: string | spec.NamedTypeReference,\n  assembly: spec.Assembly,\n  dependencyClosure: readonly spec.Assembly[],\n): spec.Type | undefined {\n  if (typeof typeRef !== 'string') {\n    typeRef = typeRef.fqn;\n  }\n  const [assm] = typeRef.split('.');\n  if (assembly.name === assm) {\n    return assembly.types?.[typeRef];\n  }\n  const foreignAssm = dependencyClosure.find((dep) => dep.name === assm);\n  return foreignAssm?.types?.[typeRef];\n}\n"]}

package/lib/type-visitor.d.ts

@@ -0,0 +1,19 @@
+import * as spec from '@jsii/spec';
+export interface TypeReferenceVisitor<A = void> {
+    named(ref: spec.NamedTypeReference): A;
+    primitive(ref: spec.PrimitiveTypeReference): A;
+    collection(ref: spec.CollectionTypeReference): A;
+    union(ref: spec.UnionTypeReference): A;
+    intersection(ref: spec.IntersectionTypeReference): A;
+}
+export declare function visitTypeReference<A>(typeRef: spec.TypeReference, visitor: TypeReferenceVisitor<A>): A;
+export interface TypeVisitor<A = void> {
+    classType(t: spec.ClassType): A;
+    interfaceType(t: spec.InterfaceType): A;
+    dataType(t: spec.InterfaceType): A;
+    enumType(t: spec.EnumType): A;
+}
+export declare function visitType<A>(t: spec.Type, visitor: TypeVisitor<A>): A;
+export declare function isDataType(t: spec.Type): t is spec.InterfaceType;
+export declare function isBehavioralInterfaceType(t: spec.Type): t is spec.InterfaceType;
+//# sourceMappingURL=type-visitor.d.ts.map

package/lib/type-visitor.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitTypeReference = visitTypeReference;
+exports.visitType = visitType;
+exports.isDataType = isDataType;
+exports.isBehavioralInterfaceType = isBehavioralInterfaceType;
+const spec = require("@jsii/spec");
+function visitTypeReference(typeRef, visitor) {
+    if (spec.isNamedTypeReference(typeRef)) {
+        return visitor.named(typeRef);
+    }
+    else if (spec.isPrimitiveTypeReference(typeRef)) {
+        return visitor.primitive(typeRef);
+    }
+    else if (spec.isCollectionTypeReference(typeRef)) {
+        return visitor.collection(typeRef);
+    }
+    else if (spec.isUnionTypeReference(typeRef)) {
+        return visitor.union(typeRef);
+    }
+    else if (spec.isIntersectionTypeReference(typeRef)) {
+        return visitor.intersection(typeRef);
+    }
+    else {
+        throw new Error(`Unknown type reference: ${JSON.stringify(typeRef)}`);
+    }
+}
+function visitType(t, visitor) {
+    if (spec.isClassType(t)) {
+        return visitor.classType(t);
+    }
+    else if (spec.isInterfaceType(t) && t.datatype) {
+        return visitor.dataType(t);
+    }
+    else if (spec.isInterfaceType(t)) {
+        return visitor.interfaceType(t);
+    }
+    else if (spec.isEnumType(t)) {
+        return visitor.enumType(t);
+    }
+    else {
+        throw new Error(`Unknown type: ${JSON.stringify(t)}`);
+    }
+}
+function isDataType(t) {
+    return spec.isInterfaceType(t) && !!t.datatype;
+}
+function isBehavioralInterfaceType(t) {
+    return spec.isInterfaceType(t) && !t.datatype;
+}
+//# sourceMappingURL=type-visitor.js.map

package/lib/type-visitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-visitor.js","sourceRoot":"","sources":["../src/type-visitor.ts"],"names":[],"mappings":";;AAUA,gDAcC;AASD,8BAYC;AAED,gCAEC;AAED,8DAEC;AArDD,mCAAmC;AAUnC,SAAgB,kBAAkB,CAAI,OAA2B,EAAE,OAAgC;IACjG,IAAI,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC;QACvC,OAAO,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;SAAM,IAAI,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,EAAE,CAAC;QAClD,OAAO,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;SAAM,IAAI,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAAE,CAAC;QACnD,OAAO,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;SAAM,IAAI,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC;QAC9C,OAAO,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;SAAM,IAAI,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAAC,EAAE,CAAC;QACrD,OAAO,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,KAAK,CAAC,2BAA2B,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACxE,CAAC;AACH,CAAC;AASD,SAAgB,SAAS,CAAI,CAAY,EAAE,OAAuB;IAChE,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;QACxB,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC9B,CAAC;SAAM,IAAI,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;QACjD,OAAO,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;SAAM,IAAI,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;QACnC,OAAO,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;SAAM,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9B,OAAO,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,KAAK,CAAC,iBAAiB,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACxD,CAAC;AACH,CAAC;AAED,SAAgB,UAAU,CAAC,CAAY;IACrC,OAAO,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;AACjD,CAAC;AAED,SAAgB,yBAAyB,CAAC,CAAY;IACpD,OAAO,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;AAChD,CAAC","sourcesContent":["import * as spec from '@jsii/spec';\n\nexport interface TypeReferenceVisitor<A = void> {\n  named(ref: spec.NamedTypeReference): A;\n  primitive(ref: spec.PrimitiveTypeReference): A;\n  collection(ref: spec.CollectionTypeReference): A;\n  union(ref: spec.UnionTypeReference): A;\n  intersection(ref: spec.IntersectionTypeReference): A;\n}\n\nexport function visitTypeReference<A>(typeRef: spec.TypeReference, visitor: TypeReferenceVisitor<A>) {\n  if (spec.isNamedTypeReference(typeRef)) {\n    return visitor.named(typeRef);\n  } else if (spec.isPrimitiveTypeReference(typeRef)) {\n    return visitor.primitive(typeRef);\n  } else if (spec.isCollectionTypeReference(typeRef)) {\n    return visitor.collection(typeRef);\n  } else if (spec.isUnionTypeReference(typeRef)) {\n    return visitor.union(typeRef);\n  } else if (spec.isIntersectionTypeReference(typeRef)) {\n    return visitor.intersection(typeRef);\n  } else {\n    throw new Error(`Unknown type reference: ${JSON.stringify(typeRef)}`);\n  }\n}\n\nexport interface TypeVisitor<A = void> {\n  classType(t: spec.ClassType): A;\n  interfaceType(t: spec.InterfaceType): A;\n  dataType(t: spec.InterfaceType): A;\n  enumType(t: spec.EnumType): A;\n}\n\nexport function visitType<A>(t: spec.Type, visitor: TypeVisitor<A>) {\n  if (spec.isClassType(t)) {\n    return visitor.classType(t);\n  } else if (spec.isInterfaceType(t) && t.datatype) {\n    return visitor.dataType(t);\n  } else if (spec.isInterfaceType(t)) {\n    return visitor.interfaceType(t);\n  } else if (spec.isEnumType(t)) {\n    return visitor.enumType(t);\n  } else {\n    throw new Error(`Unknown type: ${JSON.stringify(t)}`);\n  }\n}\n\nexport function isDataType(t: spec.Type): t is spec.InterfaceType {\n  return spec.isInterfaceType(t) && !!t.datatype;\n}\n\nexport function isBehavioralInterfaceType(t: spec.Type): t is spec.InterfaceType {\n  return spec.isInterfaceType(t) && !t.datatype;\n}\n"]}

package/lib/validator.d.ts

@@ -3,13 +3,17 @@ import * as ts from 'typescript';
 import { Emitter } from './emitter';
 import { JsiiDiagnostic } from './jsii-diagnostic';
 import { ProjectInfo } from './project-info';
+export interface ValidationResult extends ts.EmitResult {
+    readonly usedFeatures?: spec.JsiiFeature[];
+}
 export declare class Validator implements Emitter {
     readonly projectInfo: ProjectInfo;
     readonly assembly: spec.Assembly;
     static VALIDATIONS: ValidationFunction[];
     constructor(projectInfo: ProjectInfo, assembly: spec.Assembly);
-    emit(): ts.EmitResult;
+    emit(): ValidationResult;
 }
 export type DiagnosticEmitter = (diag: JsiiDiagnostic) => void;
-export type ValidationFunction = (validator: Validator, assembly: spec.Assembly, diagnostic: DiagnosticEmitter) => void;
+export type FeatureTracker = (feat: spec.JsiiFeature) => void;
+export type ValidationFunction = (validator: Validator, assembly: spec.Assembly, diagnostic: DiagnosticEmitter, useFeatures: FeatureTracker) => void;
 //# sourceMappingURL=validator.d.ts.map

package/lib/validator.js

@@ -9,6 +9,8 @@ const Case = require("./case");
 const jsii_diagnostic_1 = require("./jsii-diagnostic");
 const node_bindings_1 = require("./node-bindings");
 const bindings = require("./node-bindings");
+const type_analysis_1 = require("./type-analysis");
+const type_reference_1 = require("./type-reference");
 class Validator {
     constructor(projectInfo, assembly) {
         this.projectInfo = projectInfo;
@@ -16,12 +18,14 @@ class Validator {
     }
     emit() {
         const diagnostics = new Array();
+        const usedFeatures = new Array();
         for (const validation of Validator.VALIDATIONS) {
-            validation(this, this.assembly, diagnostics.push.bind(diagnostics));
+            validation(this, this.assembly, diagnostics.push.bind(diagnostics), usedFeatures.push.bind(usedFeatures));
         }
         return {
             diagnostics: diagnostics,
             emitSkipped: diagnostics.some((diag) => diag.category === ts.DiagnosticCategory.Error),
+            usedFeatures,
         };
     }
 }
@@ -34,7 +38,7 @@ function _defaultValidations() {
         _staticConstantNamesMustUseUpperSnakeCase,
         _memberNamesMustNotLookLikeJavaGettersOrSetters,
         _allTypeReferencesAreValid,
-        _inehritanceDoesNotChangeContracts,
+        _inheritanceDoesNotChangeContracts,
         _staticMembersAndNestedTypesMustNotSharePascalCaseName,
         _abstractClassesMustImplementAllProperties,
     ];
@@ -107,7 +111,8 @@ function _defaultValidations() {
             }
         }
     }
-    function _inehritanceDoesNotChangeContracts(validator, assembly, diagnostic) {
+    function _inheritanceDoesNotChangeContracts(validator, assembly, diagnostic, useFeature) {
+        const _dereference = (0, type_reference_1.createTypeResolver)(assembly, validator.projectInfo.dependencyClosure);
         for (const type of _allTypes(assembly)) {
             if (spec.isClassType(type)) {
                 for (const method of type.methods ?? []) {
@@ -147,7 +152,7 @@ function _defaultValidations() {
             }
             if (spec.isClassType(type) && type.base) {
                 // We have a parent class, collect their concrete members, too (recursively)...
-                const base = _dereference(type.base, assembly, validator);
+                const base = _dereference(type.base);
                 assert(base != null && spec.isClassType(base));
                 for (const member of _allImplementations(base, getter)) {
                     if (known.has(member.name)) {
@@ -175,7 +180,7 @@ function _defaultValidations() {
             if (!type.base) {
                 return false;
             }
-            const baseType = _dereference(type.base, assembly, validator);
+            const baseType = _dereference(type.base);
             if (!baseType) {
                 return false;
             }
@@ -183,7 +188,9 @@ function _defaultValidations() {
             if (!overridden) {
                 return _validateMethodOverride(method, baseType);
             }
-            _assertSignaturesMatch(overridden, method, `${type.fqn}#${method.name}`, `overriding ${baseType.fqn}`);
+            _assertSignaturesMatch(overridden, method, `${type.fqn}#${method.name}`, `overriding ${baseType.fqn}`, {
+                allowReturnTypeCovariance: true,
+            });
             method.overrides = baseType.fqn;
             return true;
         }
@@ -191,7 +198,7 @@ function _defaultValidations() {
             if (!type.base) {
                 return false;
             }
-            const baseType = _dereference(type.base, assembly, validator);
+            const baseType = _dereference(type.base);
             if (!baseType) {
                 return false;
             }
@@ -199,7 +206,9 @@ function _defaultValidations() {
             if (!overridden) {
                 return _validatePropertyOverride(property, baseType);
             }
-            _assertPropertiesMatch(overridden, property, `${type.fqn}#${property.name}`, `overriding ${baseType.fqn}`);
+            _assertPropertiesMatch(overridden, property, `${type.fqn}#${property.name}`, `overriding ${baseType.fqn}`, {
+                allowCovariance: true,
+            });
             property.overrides = baseType.fqn;
             return true;
         }
@@ -207,15 +216,17 @@ function _defaultValidations() {
             if (!type.interfaces) {
                 // Abstract classes may not directly implement all members, need to check their supertypes...
                 if (spec.isClassType(type) && type.base && type.abstract) {
-                    return _validateMethodImplementation(method, _dereference(type.base, assembly, validator));
+                    return _validateMethodImplementation(method, _dereference(type.base));
                 }
                 return false;
             }
             for (const iface of type.interfaces) {
-                const ifaceType = _dereference(iface, assembly, validator);
+                const ifaceType = _dereference(iface);
                 const implemented = (ifaceType.methods ?? []).find((m) => m.name === method.name);
                 if (implemented) {
-                    _assertSignaturesMatch(implemented, method, `${type.fqn}#${method.name}`, `implementing ${ifaceType.fqn}`);
+                    _assertSignaturesMatch(implemented, method, `${type.fqn}#${method.name}`, `implementing ${ifaceType.fqn}`, {
+                        allowReturnTypeCovariance: false,
+                    });
                     // We won't replace a previous overrides declaration from a method override, as those have
                     // higher precedence than an initial implementation.
                     method.overrides = method.overrides ?? iface;
@@ -231,15 +242,15 @@ function _defaultValidations() {
             if (!type.interfaces) {
                 // Abstract classes may not directly implement all members, need to check their supertypes...
                 if (spec.isClassType(type) && type.base && type.abstract) {
-                    return _validatePropertyImplementation(property, _dereference(type.base, assembly, validator));
+                    return _validatePropertyImplementation(property, _dereference(type.base));
                 }
                 return false;
             }
             for (const iface of type.interfaces) {
-                const ifaceType = _dereference(iface, assembly, validator);
+                const ifaceType = _dereference(iface);
                 const implemented = (ifaceType.properties ?? []).find((p) => p.name === property.name);
                 if (implemented) {
-                    _assertPropertiesMatch(implemented, property, `${type.fqn}#${property.name}`, `implementing ${ifaceType.fqn}`);
+                    _assertPropertiesMatch(implemented, property, `${type.fqn}#${property.name}`, `implementing ${ifaceType.fqn}`, { allowCovariance: false });
                     // We won't replace a previous overrides declaration from a property override, as those
                     // have higher precedence than an initial implementation.
                     property.overrides = property.overrides ?? ifaceType.fqn;
@@ -251,16 +262,30 @@ function _defaultValidations() {
             }
             return false;
         }
-        function _assertSignaturesMatch(expected, actual, label, action) {
+        function _assertSignaturesMatch(expected, actual, label, action, opts) {
             if (!!expected.protected !== !!actual.protected) {
                 const expVisibility = expected.protected ? 'protected' : 'public';
                 const actVisibility = actual.protected ? 'protected' : 'public';
                 diagnostic(jsii_diagnostic_1.JsiiDiagnostic.JSII_5002_OVERRIDE_CHANGES_VISIBILITY.createDetached(label, action, actVisibility, expVisibility));
             }
+            // Types must generally be the same, but can be covariant sometimes
             if (!deepEqual(actual.returns, expected.returns)) {
-                const expType = spec.describeTypeReference(expected.returns?.type);
-                const actType = spec.describeTypeReference(actual.returns?.type);
-                diagnostic(jsii_diagnostic_1.JsiiDiagnostic.JSII_5003_OVERRIDE_CHANGES_RETURN_TYPE.createDetached(label, action, actType, expType));
+                const actualReturnType = actual.returns?.type;
+                const expectedReturnType = expected.returns?.type;
+                if (
+                // return type covariance is allowed
+                opts.allowReturnTypeCovariance &&
+                    // static members can never change
+                    !actual.static &&
+                    // this is a valid covariant return type (actual is more specific than expected)
+                    (0, type_analysis_1.isAllowedCovariantSubtype)(actualReturnType, expectedReturnType, _dereference)) {
+                    useFeature('class-covariant-overrides');
+                }
+                else {
+                    const expType = spec.describeTypeReference(expectedReturnType);
+                    const actType = spec.describeTypeReference(actualReturnType);
+                    diagnostic(jsii_diagnostic_1.JsiiDiagnostic.JSII_5003_OVERRIDE_CHANGES_RETURN_TYPE.createDetached(label, action, actType, expType));
+                }
             }
             const expectedParams = expected.parameters ?? [];
             const actualParams = actual.parameters ?? [];
@@ -283,7 +308,7 @@ function _defaultValidations() {
                 }
             }
         }
-        function _assertPropertiesMatch(expected, actual, label, action) {
+        function _assertPropertiesMatch(expected, actual, label, action, opts) {
             const actualNode = bindings.getPropertyRelatedNode(actual);
             const expectedNode = bindings.getPropertyRelatedNode(expected);
             if (!!expected.protected !== !!actual.protected) {
@@ -291,8 +316,21 @@ function _defaultValidations() {
                 const actVisibility = actual.protected ? 'protected' : 'public';
                 diagnostic(jsii_diagnostic_1.JsiiDiagnostic.JSII_5002_OVERRIDE_CHANGES_VISIBILITY.create(actualNode?.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.PublicKeyword || mod.kind === ts.SyntaxKind.ProtectedKeyword) ?? declarationName(actualNode), label, action, actVisibility, expVisibility).maybeAddRelatedInformation(expectedNode?.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.PublicKeyword || mod.kind === ts.SyntaxKind.ProtectedKeyword) ?? declarationName(expectedNode), 'The implemented declaration is here.'));
             }
-            if (!deepEqual(expected.type, actual.type)) {
-                diagnostic(jsii_diagnostic_1.JsiiDiagnostic.JSII_5004_OVERRIDE_CHANGES_PROP_TYPE.create(actualNode?.type ?? declarationName(actualNode), label, action, actual.type, expected.type).maybeAddRelatedInformation(expectedNode?.type ?? declarationName(expectedNode), 'The implemented declaration is here.'));
+            // Types must generally be the same, but can be covariant sometimes
+            if (!deepEqual(actual.type, expected.type)) {
+                if (
+                // return type covariance is allowed
+                opts.allowCovariance &&
+                    // static members can never change
+                    !actual.static &&
+                    // immutable properties may change in some case, as long as they are covariant
+                    actual.immutable &&
+                    (0, type_analysis_1.isAllowedCovariantSubtype)(actual.type, expected.type, _dereference)) {
+                    useFeature('class-covariant-overrides');
+                }
+                else {
+                    diagnostic(jsii_diagnostic_1.JsiiDiagnostic.JSII_5004_OVERRIDE_CHANGES_PROP_TYPE.create(actualNode?.type ?? declarationName(actualNode), label, action, actual.type, expected.type).maybeAddRelatedInformation(expectedNode?.type ?? declarationName(expectedNode), 'The implemented declaration is here.'));
+                }
             }
             if (expected.immutable !== actual.immutable) {
                 diagnostic(jsii_diagnostic_1.JsiiDiagnostic.JSII_5010_OVERRIDE_CHANGES_MUTABILITY.create(actualNode?.modifiers?.find((mod) => mod.kind === ts.SyntaxKind.ReadonlyKeyword) ??
@@ -316,6 +354,7 @@ function _defaultValidations() {
      * don't want to give an implementation yet.
      */
     function _abstractClassesMustImplementAllProperties(validator, assembly, diagnostic) {
+        const _dereference = (0, type_reference_1.createTypeResolver)(assembly, validator.projectInfo.dependencyClosure);
         for (const type of _allTypes(assembly)) {
             if (!spec.isClassType(type) || !type.abstract) {
                 continue;
@@ -333,7 +372,7 @@ function _defaultValidations() {
                 into.add(prop.name);
             }
             if (type.base) {
-                const base = _dereference(type.base, assembly, validator);
+                const base = _dereference(type.base);
                 if (spec.isClassType(base)) {
                     collectClassProps(base, into);
                 }
@@ -341,7 +380,7 @@ function _defaultValidations() {
             return into;
         }
         function checkInterfacePropsImplemented(interfaceFqn, cls, propNames) {
-            const intf = _dereference(interfaceFqn, assembly, validator);
+            const intf = _dereference(interfaceFqn);
             if (!spec.isInterfaceType(intf)) {
                 return;
             }
@@ -482,17 +521,6 @@ function _allTypeReferences(assm) {
         }
     }
 }
-function _dereference(typeRef, assembly, validator) {
-    if (typeof typeRef !== 'string') {
-        typeRef = typeRef.fqn;
-    }
-    const [assm] = typeRef.split('.');
-    if (assembly.name === assm) {
-        return assembly.types?.[typeRef];
-    }
-    const foreignAssm = validator.projectInfo.dependencyClosure.find((dep) => dep.name === assm);
-    return foreignAssm?.types?.[typeRef];
-}
 function _isEmpty(array) {
     return array == null || array.length === 0;
 }