jsii 5.9.5-dev.4 → 5.9.5-dev.5

package/lib/assembler.d.ts

@@ -15,7 +15,6 @@ export declare class Assembler implements Emitter {
     private readonly mainFile;
     private readonly tscRootDir?;
     private readonly compressAssembly?;
-    private readonly usedFeatures;
     private readonly _typeChecker;
     private _diagnostics;
     private _deferred;
@@ -57,7 +56,7 @@ export declare class Assembler implements Emitter {
      *
      * @param fqn FQN of the current type (the type that has a dependency on baseTypes)
      * @param baseTypes Array of type references to be looked up
-     * @param referencingNode Node to report a diagnostic on if we fail to look up a type
+     * @param referencingNode Node to report a diagnostic on if we fail to look up a t ype
      * @param cb Callback to be invoked with the Types corresponding to the TypeReferences in baseTypes
      */
     private _deferUntilTypesAvailable;
@@ -165,26 +164,11 @@ export declare class Assembler implements Emitter {
     private _toParameter;
     private _typeReference;
     private _optionalValue;
-    /**
-     * Validate the restrictions on an intersection type reference
-     *
-     * - Type only consists of (behavioral) interface types
-     * - For all types referenced in the intersection, the definitions of all shared
-     *   members must match exactly.
-     */
-    private validateIntersectionType;
-    private comparePropForIntersection;
-    private compareMethodForIntersection;
     private callDeferredsInOrder;
     /**
      * Return the set of all (inherited) properties of an interface
      */
     private allProperties;
-    /**
-     * Return the set of all (inherited) methods of an interface
-     */
-    private allMethods;
-    private allInterfacesRecursively;
     private _verifyConsecutiveOptionals;
     /**
      * Updates the runtime type info with the fully-qualified name for the current class definition.
@@ -197,13 +181,6 @@ export declare class Assembler implements Emitter {
      */
     private mySubmodules;
     private findPackageInfo;
-    /**
-     * Validate types against input/output positions in functions and APIs
-     *
-     * Currently used to validate that intersection types are only used in input position,
-     * not output position
-     */
-    private validateTypesAgainstPositions;
 }
 export interface AssemblerOptions {
     /**

package/lib/assembler.js

@@ -19,13 +19,10 @@ const jsii_diagnostic_1 = require("./jsii-diagnostic");
 const literate = require("./literate");
 const bindings = require("./node-bindings");
 const reserved_words_1 = require("./reserved-words");
-const sets_1 = require("./sets");
 const deprecated_remover_1 = require("./transforms/deprecated-remover");
 const deprecation_warnings_1 = require("./transforms/deprecation-warnings");
 const runtime_info_1 = require("./transforms/runtime-info");
 const utils_1 = require("./transforms/utils");
-const type_reference_1 = require("./type-reference");
-const type_visitor_1 = require("./type-visitor");
 const utils_2 = require("./utils");
 const validator_1 = require("./validator");
 const version_1 = require("./version");
@@ -47,7 +44,6 @@ class Assembler {
         this.system = system;
         this.program = program;
         this.stdlib = stdlib;
-        this.usedFeatures = new Set();
         this._diagnostics = new Array();
         this._deferred = new Array();
         this._types = new Map();
@@ -139,7 +135,6 @@ class Assembler {
             }
         }
         this.callDeferredsInOrder();
-        this.validateTypesAgainstPositions();
         // Skip emitting if any diagnostic message is an error
         if (this._diagnostics.find((diag) => diag.category === ts.DiagnosticCategory.Error) != null) {
             LOG.debug('Skipping emit due to errors.');
@@ -183,7 +178,6 @@ class Assembler {
             jsiiVersion,
             bin: this.projectInfo.bin,
             fingerprint: '<TBD>',
-            usedFeatures: this.usedFeatures.size > 0 ? Array.from(this.usedFeatures) : undefined,
         };
         if (this.deprecatedRemover) {
             this._diagnostics.push(...this.deprecatedRemover.removeFrom(assembly));
@@ -257,7 +251,7 @@ class Assembler {
      *
      * @param fqn FQN of the current type (the type that has a dependency on baseTypes)
      * @param baseTypes Array of type references to be looked up
-     * @param referencingNode Node to report a diagnostic on if we fail to look up a type
+     * @param referencingNode Node to report a diagnostic on if we fail to look up a t ype
      * @param cb Callback to be invoked with the Types corresponding to the TypeReferences in baseTypes
      */
     _deferUntilTypesAvailable(fqn, baseTypes, referencingNode, cb) {
@@ -266,19 +260,9 @@ class Assembler {
             cb();
             return;
         }
-        const baseFqns = baseTypes.flatMap((bt) => {
-            if (typeof bt === 'string') {
-                return [bt];
-            }
-            if (spec.isNamedTypeReference(bt)) {
-                return [bt.fqn];
-            }
-            return [];
-        });
+        const baseFqns = baseTypes.map((bt) => (typeof bt === 'string' ? bt : bt.fqn));
         this._defer(fqn, baseFqns, () => {
-            const resolved = baseFqns
-                .map((x) => this._dereference(x, referencingNode, 'used-in-syntax'))
-                .filter((x) => x !== undefined);
+            const resolved = baseFqns.map((x) => this._dereference(x, referencingNode)).filter((x) => x !== undefined);
             if (resolved.length > 0) {
                 cb(...resolved);
             }
@@ -306,7 +290,7 @@ class Assembler {
      *
      * @returns the de-referenced type, if it was found, otherwise ``undefined``.
      */
-    _dereference(ref, referencingNode, usedInSyntax) {
+    _dereference(ref, referencingNode) {
         if (typeof ref !== 'string') {
             ref = ref.fqn;
         }
@@ -327,7 +311,7 @@ class Assembler {
                 }
             }
         }
-        if (!type && usedInSyntax === 'used-in-syntax') {
+        if (!type) {
             this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_9002_UNRESOLVEABLE_TYPE.create(referencingNode, // Cheating here for now, until the referencingNode can be made required
             ref));
         }
@@ -406,7 +390,7 @@ class Assembler {
             assembly: dep,
         });
         const fqn = (dep && symbolId ? symbolIdIndex(dep)[symbolId] : undefined) ?? fallbackFqn;
-        if (!fqn || !this._dereference({ fqn }, sym.valueDeclaration, 'used-in-syntax')) {
+        if (!fqn || !this._dereference({ fqn }, sym.valueDeclaration)) {
             if (!hasError) {
                 this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_3002_USE_OF_UNEXPORTED_FOREIGN_TYPE.create(typeAnnotationNode, fqn ?? tsName, typeUse, pkg).addRelatedInformationIf(typeDeclaration, 'The referenced type is declared here'));
                 hasError = true;
@@ -1019,12 +1003,9 @@ class Assembler {
                 if (signature) {
                     for (const param of signature.getParameters()) {
                         jsiiType.initializer.parameters = jsiiType.initializer.parameters ?? [];
-                        const jsiiParam = // eslint-disable-next-line no-await-in-loop
-                         this._toParameter(param, ctx.replaceStability(jsiiType.docs?.stability));
-                        if (containsIntersection(jsiiParam.type)) {
-                            this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_1010_INTERSECTION_NOT_IN_CTOR.create(param.declarations?.[0]));
-                        }
-                        jsiiType.initializer.parameters.push(jsiiParam);
+                        jsiiType.initializer.parameters.push(
+                        // eslint-disable-next-line no-await-in-loop
+                        this._toParameter(param, ctx.replaceStability(jsiiType.docs?.stability)));
                         jsiiType.initializer.variadic = jsiiType.initializer?.parameters?.some((p) => !!p.variadic) || undefined;
                         jsiiType.initializer.protected =
                             (ts.getCombinedModifierFlags(ctorDeclaration) & ts.ModifierFlags.Protected) !== 0 || undefined;
@@ -1086,7 +1067,7 @@ class Assembler {
             .filter((x) => !x.static)
             .map((x) => x.name));
         // Intersect
-        for (const member of sets_1.Sets.intersect(statics, nonStatics)) {
+        for (const member of intersect(statics, nonStatics)) {
             this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_5013_STATIC_INSTANCE_CONFLICT.create(decl, member, klass));
         }
         // Check against base classes. They will not contain duplicate member names so we can load
@@ -1452,7 +1433,7 @@ class Assembler {
                 // Liftable datatype, make sure no parameter names match any of the properties in the datatype
                 const propNames = this.allProperties(lastParamType);
                 const paramNames = new Set(parameters.slice(0, parameters.length - 1).map((x) => x.name));
-                const sharedNames = sets_1.Sets.intersection(propNames, paramNames);
+                const sharedNames = intersection(propNames, paramNames);
                 for (const badName of sharedNames) {
                     this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_5017_POSITIONAL_KEYWORD_CONFLICT.create(declaration, badName));
                 }
@@ -1587,18 +1568,7 @@ class Assembler {
             return { type: primitiveType };
         }
         if (type.isUnion() && !_isEnumLike(type)) {
-            return _setType.call(this, 'union');
-        }
-        if (type.isIntersection()) {
-            this.usedFeatures.add('intersection-types');
-            const ret = _setType.call(this, 'intersection');
-            const intersectionType = ret.type;
-            this.validateIntersectionType(intersectionType, declaration);
-            return ret;
-        }
-        if ((type.getFlags() & ts.TypeFlags.Never) !== 0) {
-            this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_1007_NEVER_TYPE.create(declaration));
-            return { type: spec.CANONICAL_ANY };
+            return _unionType.call(this);
         }
         if (!type.symbol) {
             this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_1001_TYPE_HAS_NO_SYMBOL.create(declaration));
@@ -1704,7 +1674,7 @@ class Assembler {
             // Not a primitive type!
             return undefined;
         }
-        function _setType(field) {
+        function _unionType() {
             const types = new Array();
             let optional;
             for (const subType of type.types) {
@@ -1719,112 +1689,16 @@ class Assembler {
                 }
                 types.push(resolvedType);
             }
-            const returnedType = {
-                [field]: { types },
-            };
-            return types.length === 1 ? { optional, type: types[0] } : { optional, type: returnedType };
+            return types.length === 1 ? { optional, type: types[0] } : { optional, type: { union: { types } } };
         }
     }
-    /**
-     * Validate the restrictions on an intersection type reference
-     *
-     * - Type only consists of (behavioral) interface types
-     * - For all types referenced in the intersection, the definitions of all shared
-     *   members must match exactly.
-     */
-    validateIntersectionType(intersectionType, declaration) {
-        // Validate that this intersection type only consists of interface types
-        this._deferUntilTypesAvailable('', intersectionType.intersection.types, declaration, (...elementTypes) => {
-            const requestedFqns = new Set(intersectionType.intersection.types.map(type_reference_1.typeReferenceToString));
-            const resolvedFqns = new Set(elementTypes.map((t) => t.fqn));
-            const unresolved = sets_1.Sets.diff(requestedFqns, resolvedFqns);
-            if (unresolved.size > 0) {
-                this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_1008_ONLY_INTERFACE_INTERSECTION.create(declaration, Array.from(unresolved).join(', ')));
-            }
-            const nonBehavioral = elementTypes.filter((t) => !(0, type_visitor_1.isBehavioralInterfaceType)(t));
-            if (nonBehavioral.length > 0) {
-                this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_1008_ONLY_INTERFACE_INTERSECTION.create(declaration, nonBehavioral.map((t) => t.fqn).join(', ')));
-            }
-            // Check that shared members are the same
-            const interfaces = elementTypes.filter(type_visitor_1.isBehavioralInterfaceType);
-            const allProps = sets_1.Sets.union(...interfaces.map((int) => this.allProperties(int)));
-            const allMethods = sets_1.Sets.union(...interfaces.map((int) => this.allMethods(int)));
-            for (let i = 1; i < interfaces.length; i++) {
-                let int0 = interfaces[0];
-                let int1 = interfaces[i];
-                for (const prop of allProps) {
-                    const p1 = int0.properties?.find((p) => p.name === prop);
-                    const p2 = int1.properties?.find((p) => p.name === prop);
-                    const diff = this.comparePropForIntersection(p1, p2);
-                    if (diff) {
-                        this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_1011_INTERSECTION_MEMBER_DIFFERENT.create(declaration, prop, int0.name, diff[0], int1.name, diff[1]));
-                    }
-                }
-                for (const meth of allMethods) {
-                    const m1 = int0.methods?.find((p) => p.name === meth);
-                    const m2 = int1.methods?.find((p) => p.name === meth);
-                    const diff = this.compareMethodForIntersection(m1, m2);
-                    if (diff) {
-                        this._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_1011_INTERSECTION_MEMBER_DIFFERENT.create(declaration, meth, int0.name, diff[0], int1.name, diff[1]));
-                    }
-                }
-            }
-        });
-    }
-    comparePropForIntersection(a, b) {
-        if (!a || !b) {
-            return undefined;
-        }
-        if (!(0, type_reference_1.typeReferenceEqual)(a.type, b.type)) {
-            return [(0, type_reference_1.typeReferenceToString)(a.type), (0, type_reference_1.typeReferenceToString)(b.type)];
-        }
-        return (cmpDesc(a.static, b.static, (s) => (s ? 'static' : 'instance member')) ??
-            cmpDesc(a.optional, b.optional, (o) => (o ? 'optional' : 'required')) ??
-            cmpDesc(a.abstract, b.abstract, (s) => (s ? 'abstract' : 'concrete')));
-    }
-    compareMethodForIntersection(a, b) {
-        if (!a || !b) {
-            return undefined;
-        }
-        if (a.returns && b.returns) {
-            if (!(0, type_reference_1.typeReferenceEqual)(a.returns.type, b.returns.type)) {
-                return [(0, type_reference_1.typeReferenceToString)(a.returns.type), (0, type_reference_1.typeReferenceToString)(b.returns.type)];
-            }
-            const x = cmpDesc(a.returns.optional, b.returns.optional, (o) => o ? 'return type optional' : 'return type required');
-            if (x) {
-                return x;
-            }
-        }
-        const paramsA = a.parameters ?? [];
-        const paramsB = b.parameters ?? [];
-        if (paramsA.length !== paramsB.length) {
-            return [`${paramsA.length} parameters`, `${paramsB.length} parameters`];
-        }
-        for (let i = 0; i < paramsA.length; i++) {
-            const p1 = paramsA[i];
-            const p2 = paramsB[i];
-            if (!(0, type_reference_1.typeReferenceEqual)(p1.type, p2.type)) {
-                return [(0, type_reference_1.typeReferenceToString)(p1.type), (0, type_reference_1.typeReferenceToString)(p2.type)];
-            }
-            const x = cmpDesc(p1.optional, p2.optional, (o) => (o ? `parameter ${i + 1} optional` : `parameter ${i + 1} required`)) ??
-                cmpDesc(p1.variadic, p2.variadic, (v) => v ? `parameter ${i + 1} variadic` : `parameter ${i + 1} not variadic`);
-            if (x) {
-                return x;
-            }
-        }
-        return (cmpDesc(a.abstract, b.abstract, (s) => (s ? 'abstract' : 'concrete')) ??
-            cmpDesc(a.async, b.async, (s) => (s ? 'async' : 'async')) ??
-            cmpDesc(a.protected, b.protected, (p) => (p ? 'protected' : 'public')) ??
-            cmpDesc(a.variadic, b.variadic, (v) => (v ? 'variadic' : 'non-variadic')) ??
-            cmpDesc(a.static, b.static, (s) => (s ? 'static' : 'instance member')));
-    }
     callDeferredsInOrder() {
         // Do a topological call order of all deferreds.
         while (this._deferred.length > 0) {
             // All fqns in dependency lists that don't have any pending
             // deferreds themselves can be executed now, so are removed from
             // dependency lists.
-            const pendingFqns = new Set(this._deferred.map((x) => x.fqn).filter((x) => x));
+            const pendingFqns = new Set(this._deferred.map((x) => x.fqn));
             for (const deferred of this._deferred) {
                 restrictDependenciesTo(deferred, pendingFqns);
             }
@@ -1853,33 +1727,20 @@ class Assembler {
      * Return the set of all (inherited) properties of an interface
      */
     allProperties(root) {
-        return this.allInterfacesRecursively(root, (int) => {
-            return (int.properties ?? []).map((p) => p.name);
-        });
-    }
-    /**
-     * Return the set of all (inherited) methods of an interface
-     */
-    allMethods(root) {
-        return this.allInterfacesRecursively(root, (int) => {
-            return (int.methods ?? []).map((p) => p.name);
-        });
-    }
-    allInterfacesRecursively(root, cb) {
         const ret = new Set();
         recurse.call(this, root);
         return ret;
         function recurse(int) {
-            for (const x of cb(int)) {
-                ret.add(x);
+            for (const property of int.properties ?? []) {
+                ret.add(property.name);
             }
             for (const baseRef of int.interfaces ?? []) {
-                const base = this._dereference(baseRef, undefined, 'used-in-syntax');
+                const base = this._dereference(baseRef, undefined);
                 if (!base) {
-                    throw new Error('Impossible to have unresolvable base in allInterfacesRecursively()');
+                    throw new Error('Impossible to have unresolvable base in allProperties()');
                 }
                 if (!spec.isInterfaceType(base)) {
-                    throw new Error('Impossible to have non-interface base in allInterfacesRecursively()');
+                    throw new Error('Impossible to have non-interface base in allProperties()');
                 }
                 recurse.call(this, base);
             }
@@ -1935,89 +1796,6 @@ class Assembler {
             return this.findPackageInfo(parent);
         }
     }
-    /**
-     * Validate types against input/output positions in functions and APIs
-     *
-     * Currently used to validate that intersection types are only used in input position,
-     * not output position
-     */
-    validateTypesAgainstPositions() {
-        const self = this;
-        const validatedFqns = {
-            in: new Set(),
-            out: new Set(),
-        };
-        for (const type of this._types.values()) {
-            if (spec.isClassType(type)) {
-                for (const ctorParam of type.initializer?.parameters ?? []) {
-                    validateRefFor.call(this, 'in', ctorParam.type, `a constructor parameter of ${type.name}`);
-                }
-            }
-            if (spec.isClassType(type) || (0, type_visitor_1.isBehavioralInterfaceType)(type)) {
-                for (const property of type.properties ?? []) {
-                    validateRefFor.call(this, 'out', property.type, `type of property ${type.name}.${property.name}`);
-                }
-                for (const method of type.methods ?? []) {
-                    for (const param of method.parameters ?? []) {
-                        validateRefFor.call(this, 'in', param.type, `a parameter of method ${type.name}.${method.name}()`);
-                    }
-                    if (method.returns) {
-                        validateRefFor.call(this, 'out', method.returns.type, `return type of method ${type.name}.${method.name}()`);
-                    }
-                }
-            }
-        }
-        function validateRefFor(dir, typeRef, reason) {
-            (0, type_visitor_1.visitTypeReference)(typeRef, {
-                named: (ref) => {
-                    // Named types we'll only validate once for every direction
-                    if (validatedFqns[dir].has(ref.fqn)) {
-                        return;
-                    }
-                    validatedFqns[dir].add(ref.fqn);
-                    const type = self._dereference(ref, undefined, 'just-validating');
-                    if (!type) {
-                        // Maybe this is an unexported type.
-                        return;
-                    }
-                    validateTypeFor(dir, type, reason);
-                },
-                primitive: () => { },
-                collection: (ref) => {
-                    validateRefFor(dir, ref.collection.elementtype, reason);
-                },
-                union: (ref) => {
-                    for (const t of ref.union.types) {
-                        validateRefFor(dir, t, reason);
-                    }
-                },
-                intersection: (ref) => {
-                    if (dir === 'out') {
-                        self._diagnostics.push(jsii_diagnostic_1.JsiiDiagnostic.JSII_1009_INTERSECTION_ONLY_INPUT.createDetached(reason));
-                    }
-                    for (const t of ref.intersection.types) {
-                        validateRefFor(dir, t, reason);
-                    }
-                },
-            });
-        }
-        function validateTypeFor(dir, type, reason) {
-            (0, type_visitor_1.visitType)(type, {
-                dataType: (t) => {
-                    // We only need to validate data types, because classes and interfaces
-                    // are done as part of the main loop.
-                    //
-                    // Recurse.
-                    for (const prop of t.properties ?? []) {
-                        validateRefFor(dir, prop.type, `type of property ${t.name}.${prop.name}, ${reason}`);
-                    }
-                },
-                classType: () => { },
-                interfaceType: () => { },
-                enumType: () => { },
-            });
-        }
-    }
 }
 exports.Assembler = Assembler;
 function _fingerprint(assembly) {
@@ -2151,6 +1929,18 @@ function last(xs) {
 function apply(x, fn) {
     return x !== undefined ? fn(x) : undefined;
 }
+/**
+ * Return the intersection of two sets
+ */
+function intersection(xs, ys) {
+    const ret = new Set();
+    for (const x of xs) {
+        if (ys.has(x)) {
+            ret.add(x);
+        }
+    }
+    return ret;
+}
 /**
  * Return all members names of a JSII interface type
  *
@@ -2181,10 +1971,12 @@ function isInterfaceName(name) {
 function getConstructor(type) {
     return type.symbol.members?.get(ts.InternalSymbolName.Constructor);
 }
-function cmpDesc(a, b, desc) {
-    const desc1 = desc(a);
-    const desc2 = desc(b);
-    return desc1 !== desc2 ? [desc1, desc2] : undefined;
+function* intersect(xs, ys) {
+    for (const x of xs) {
+        if (ys.has(x)) {
+            yield x;
+        }
+    }
 }
 function noEmptyDict(xs) {
     if (xs == null || Object.keys(xs).length === 0) {
@@ -2368,18 +2160,6 @@ function _findHint(decl, hint) {
     const [node] = ts.getAllJSDocTags(decl, (tag) => tag.tagName.text === hint);
     return node;
 }
-function containsIntersection(type) {
-    if (spec.isIntersectionTypeReference(type)) {
-        return true;
-    }
-    if (spec.isUnionTypeReference(type)) {
-        return type.union.types.some(containsIntersection);
-    }
-    if (spec.isCollectionTypeReference(type)) {
-        return containsIntersection(type.collection.elementtype);
-    }
-    return false;
-}
 /**
  * Resolve a Type to Symbol, taking into account single-valued enums which have a bug
  *