jsii-pacmak 1.66.0 → 1.68.0

package/generate.sh

@@ -15,7 +15,8 @@ cat > lib/version.ts <<HERE
 // Generated at $(date -u +"%Y-%m-%dT%H:%M:%SZ") by generate.sh
 
 /** The short version number for this JSII compiler (e.g: \`X.Y.Z\`) */
-export const VERSION = '${VERSION}';
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+export const VERSION: string = '${VERSION}';
 
 /** The qualified version number for this JSII compiler (e.g: \`X.Y.Z (build #######)\`) */
 export const VERSION_DESC = '${VERSION} (build ${commit:0:7}${suffix:-})';

package/lib/targets/dotnet/runtime-type-checking.js

@@ -98,6 +98,24 @@ class Validation {
                 code.openBlock(`switch (${expression})`);
                 for (const type of types) {
                     validTypes.push(resolver.toDotNetTypeName(type.spec));
+                    /**
+                     * Filter to remove classes and interfaces from a set of type references that
+                     * are implied by another entry in the set. Practically this is meant to remove
+                     * types from a set if a parent type of it is also present in the set, keeping
+                     * only the most generic declaration.
+                     *
+                     * This is useful because the TypeScript compiler and jsii do not guarantee that
+                     * all entries in a type union are unrelated, but the C# compiler treats dead
+                     * code as an error, and will refuse to compile (error CS8120) a pattern-matching
+                     * switch case if it cannot be matched (for example, if it matches on a child of
+                     * a type that was previously matched on already).
+                     */
+                    if ((type.type?.isClassType() || type.type?.isInterfaceType()) &&
+                        types.some((other) => other !== type &&
+                            other.type != null &&
+                            type.type.extends(other.type))) {
+                        continue;
+                    }
                     const typeNames = [resolver.toDotNetType(type.spec)];
                     if (typeNames[0] === 'double') {
                         // For doubles, we accept any numeric value, really...

package/lib/targets/go/package.d.ts

@@ -55,6 +55,7 @@ export declare class RootPackage extends Package {
     readonly assembly: Assembly;
     readonly version: string;
     private readonly versionFile;
+    private readonly typeCache;
     private readonly rootPackageCache;
     constructor(assembly: Assembly, rootPackageCache?: Map<string, RootPackage>);
     emit(context: EmitContext): void;

package/lib/targets/go/package.js

@@ -263,6 +263,7 @@ class RootPackage extends Package {
         const moduleName = goConfig.moduleName ?? '';
         const version = `${assembly.version}${goConfig.versionSuffix ?? ''}`;
         super(assembly, packageName, filePath, moduleName, version);
+        this.typeCache = new Map();
         this.rootPackageCache = rootPackageCache;
         this.rootPackageCache.set(assembly.name, this);
         this.assembly = assembly;
@@ -315,12 +316,15 @@ class RootPackage extends Package {
      * This allows resolving type references from other JSII modules
      */
     findType(fqn) {
-        return this.packageDependencies.reduce((accum, current) => {
-            if (accum) {
-                return accum;
-            }
-            return current.findType(fqn);
-        }, super.findType(fqn));
+        if (!this.typeCache.has(fqn)) {
+            this.typeCache.set(fqn, this.packageDependencies.reduce((accum, current) => {
+                if (accum) {
+                    return accum;
+                }
+                return current.findType(fqn);
+            }, super.findType(fqn)));
+        }
+        return this.typeCache.get(fqn);
     }
     /*
      * Get all JSII module dependencies of the package being generated

package/lib/targets/java.d.ts

@@ -124,7 +124,25 @@ declare class JavaGenerator extends Generator {
     private renderConstName;
     private emitConstProperty;
     private emitProperty;
+    /**
+     * Filters types from a union to select only those that correspond to the
+     * specified javaType.
+     *
+     * @param ref the type to be filtered.
+     * @param javaType the java type that is expected.
+     * @param covariant whether collections should use the covariant form.
+     * @param optional whether the type at an optional location or not
+     *
+     * @returns a type reference that matches the provided javaType.
+     */
+    private filterType;
     private emitMethod;
+    /**
+     * Emits type checks for values passed for type union parameters.
+     *
+     * @param parameters the list of parameters received by the function.
+     */
+    private emitUnionParameterValdation;
     /**
      * We are now going to build a class that can be used as a proxy for untyped
      * javascript objects that implement this interface. we want java code to be
@@ -153,6 +171,7 @@ declare class JavaGenerator extends Generator {
     private getClassBase;
     private toDecoratedJavaType;
     private toDecoratedJavaTypes;
+    private toJavaTypeNoGenerics;
     private toJavaType;
     private toNativeType;
     private toJavaTypes;

package/lib/targets/java.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaBuilder = void 0;
 const spec = require("@jsii/spec");
+const assert = require("assert");
 const clone = require("clone");
 const case_utils_1 = require("codemaker/lib/case-utils");
+const crypto_1 = require("crypto");
 const fs = require("fs-extra");
 const jsii_rosetta_1 = require("jsii-rosetta");
 const path = require("path");
@@ -425,6 +427,7 @@ class JavaGenerator extends generator_1.Generator {
             : this.renderAccessLevel(method);
         this.code.openBlock(`${initializerAccessLevel} ${cls.name}(${this.renderMethodParameters(method)})`);
         this.code.line('super(software.amazon.jsii.JsiiObject.InitializationMode.JSII);');
+        this.emitUnionParameterValdation(method.parameters);
         this.code.line(`software.amazon.jsii.JsiiEngine.getInstance().createNewObject(this${this.renderMethodCallArguments(method)});`);
         this.code.closeBlock();
     }
@@ -861,7 +864,10 @@ class JavaGenerator extends generator_1.Generator {
             dependencies.push({
                 groupId: 'software.amazon.jsii',
                 artifactId: 'jsii-runtime',
-                version: (0, version_utils_1.toMavenVersionRange)(`^${version_1.VERSION}`),
+                version: version_1.VERSION === '0.0.0'
+                    ? '[0.0.0-SNAPSHOT]'
+                    : // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                        (0, version_utils_1.toMavenVersionRange)(`^${version_1.VERSION}`),
             });
             // Provides @org.jetbrains.*
             dependencies.push({
@@ -1008,6 +1014,23 @@ class JavaGenerator extends generator_1.Generator {
                 else {
                     this.code.openBlock(signature);
                     let statement = '';
+                    // Setters have one overload for each possible type in the union parameter.
+                    // If a setter can take a `String | Number`, then we render two setters;
+                    // one that takes a string, and one that takes a number.
+                    // This allows the compiler to do this type checking for us,
+                    // so we should not emit these checks for primitive-only unions.
+                    // Also, Java does not allow us to perform these checks if the types
+                    // have no overlap (eg if a String instanceof Number).
+                    if (type.includes('java.lang.Object') &&
+                        (!spec.isPrimitiveTypeReference(prop.type) ||
+                            prop.type.primitive === spec.PrimitiveType.Any)) {
+                        this.emitUnionParameterValdation([
+                            {
+                                name: 'value',
+                                type: this.filterType(prop.type, { covariant: prop.static, optional: prop.optional }, type),
+                            },
+                        ]);
+                    }
                     if (prop.static) {
                         statement += `software.amazon.jsii.JsiiObject.jsiiStaticSet(${javaClass}.class, `;
                     }
@@ -1024,6 +1047,27 @@ class JavaGenerator extends generator_1.Generator {
             }
         }
     }
+    /**
+     * Filters types from a union to select only those that correspond to the
+     * specified javaType.
+     *
+     * @param ref the type to be filtered.
+     * @param javaType the java type that is expected.
+     * @param covariant whether collections should use the covariant form.
+     * @param optional whether the type at an optional location or not
+     *
+     * @returns a type reference that matches the provided javaType.
+     */
+    filterType(ref, { covariant, optional }, javaType) {
+        if (!spec.isUnionTypeReference(ref)) {
+            // No filterning needed -- this isn't a type union!
+            return ref;
+        }
+        const types = ref.union.types.filter((t) => this.toDecoratedJavaType({ optional, type: t }, { covariant }) ===
+            javaType);
+        assert(types.length > 0, `No type found in ${spec.describeTypeReference(ref)} has Java type ${javaType}`);
+        return { union: { types } };
+    }
     emitMethod(cls, method, { defaultImpl = false, final = false, overrides = !!method.overrides, } = {}) {
         const returnType = method.returns
             ? this.toDecoratedJavaType(method.returns)
@@ -1055,10 +1099,167 @@ class JavaGenerator extends generator_1.Generator {
         }
         else {
             this.code.openBlock(`${modifiers.join(' ')} ${signature}`);
+            this.emitUnionParameterValdation(method.parameters);
             this.code.line(this.renderMethodCall(cls, method, async));
             this.code.closeBlock();
         }
     }
+    /**
+     * Emits type checks for values passed for type union parameters.
+     *
+     * @param parameters the list of parameters received by the function.
+     */
+    emitUnionParameterValdation(parameters) {
+        if (!this.runtimeTypeChecking) {
+            // We were configured not to emit those, so bail out now.
+            return;
+        }
+        const unionParameters = parameters?.filter(({ type }) => containsUnionType(type));
+        if (unionParameters == null || unionParameters.length === 0) {
+            return;
+        }
+        this.code.openBlock('if (software.amazon.jsii.Configuration.getRuntimeTypeChecking())');
+        for (const param of unionParameters) {
+            if (param.variadic) {
+                const javaType = this.toJavaType(param.type);
+                const asListName = `__${param.name}__asList`;
+                this.code.line(`final java.util.List<${javaType}> ${asListName} = java.util.Arrays.asList(${param.name});`);
+                validate.call(this, asListName, `.append("${param.name}")`, {
+                    collection: {
+                        kind: spec.CollectionKind.Array,
+                        elementtype: param.type,
+                    },
+                }, param.name, true);
+            }
+            else {
+                validate.call(this, param.name, `.append("${param.name}")`, param.type, param.name);
+            }
+        }
+        this.code.closeBlock();
+        function validate(value, descr, type, parameterName, isRawArray = false) {
+            if (spec.isUnionTypeReference(type)) {
+                validateTypeUnion.call(this, value, descr, type, parameterName);
+            }
+            else if (spec.isCollectionTypeReference(type)) {
+                switch (type.collection.kind) {
+                    case spec.CollectionKind.Array:
+                        return validateArray.call(this, value, descr, type.collection.elementtype, parameterName, isRawArray);
+                    case spec.CollectionKind.Map:
+                        return validateMap.call(this, value, descr, type.collection.elementtype, parameterName);
+                    default:
+                        throw new Error(`Unhandled collection kind: ${spec.describeTypeReference(type)}`);
+                }
+            }
+        }
+        function validateArray(value, descr, elementType, parameterName, isRawArray = false) {
+            const suffix = (0, crypto_1.createHash)('sha256')
+                .update(descr)
+                .digest('hex')
+                .slice(0, 6);
+            const idxName = `__idx_${suffix}`;
+            const valName = `__val_${suffix}`;
+            this.code.openBlock(`for (int ${idxName} = 0; ${idxName} < ${value}.size(); ${idxName}++)`);
+            const eltType = this.toJavaType(elementType);
+            this.code.line(`final ${eltType} ${valName} = ${value}.get(${idxName});`);
+            validate.call(this, valName, isRawArray
+                ? `${descr}.append("[").append(${idxName}).append("]")`
+                : `${descr}.append(".get(").append(${idxName}).append(")")`, elementType, parameterName);
+            this.code.closeBlock();
+        }
+        function validateMap(value, descr, elementType, parameterName) {
+            // we have to perform this check before the loop,
+            // because the loop will assume that the keys are Strings;
+            // this throws a ClassCastException
+            this.code.openBlock(`if (!(${value}.keySet().toArray()[0] instanceof String))`);
+            this.code.indent(`throw new IllegalArgumentException(`);
+            this.code.indent(`new java.lang.StringBuilder("Expected ")`);
+            this.code.line(`${descr}.append(".keySet()")`);
+            this.code.line(`.append(" to contain class String; received ")`);
+            this.code.line(`.append(${value}.keySet().toArray()[0].getClass()).toString());`);
+            this.code.unindent(false);
+            this.code.unindent(false);
+            this.code.closeBlock();
+            const suffix = (0, crypto_1.createHash)('sha256')
+                .update(descr)
+                .digest('hex')
+                .slice(0, 6);
+            const varName = `__item_${suffix}`;
+            const valName = `__val_${suffix}`;
+            const javaElemType = this.toJavaType(elementType);
+            this.code.openBlock(`for (final java.util.Map.Entry<String, ${javaElemType}> ${varName}: ${value}.entrySet())`);
+            this.code.line(`final ${javaElemType} ${valName} = ${varName}.getValue();`);
+            validate.call(this, valName, `${descr}.append(".get(\\"").append((${varName}.getKey())).append("\\")")`, elementType, parameterName);
+            this.code.closeBlock();
+        }
+        function validateTypeUnion(value, descr, type, parameterName) {
+            let emitAnd = false;
+            const nestedCollectionUnionTypes = new Map();
+            const typeRefs = type.union.types;
+            if (typeRefs.length > 1) {
+                this.code.indent('if (');
+            }
+            const checked = new Set();
+            for (const typeRef of typeRefs) {
+                const prefix = emitAnd ? '&&' : '';
+                const javaRawType = this.toJavaTypeNoGenerics(typeRef);
+                if (checked.has(javaRawType)) {
+                    continue;
+                }
+                else {
+                    checked.add(javaRawType);
+                }
+                const javaType = this.toJavaType(typeRef);
+                if (javaRawType !== javaType) {
+                    nestedCollectionUnionTypes.set(javaType, typeRef);
+                }
+                const test = `${value} instanceof ${javaRawType}`;
+                if (typeRefs.length > 1) {
+                    this.code.line(`${prefix} !(${test})`);
+                }
+                emitAnd = true;
+            }
+            if (typeRefs.length > 1 &&
+                typeRefs.some((t) => spec.isNamedTypeReference(t) &&
+                    spec.isInterfaceType(this.findType(t.fqn)))) {
+                // Only anonymous objects at runtime can be `JsiiObject`s.
+                this.code.line(`&& !(${value}.getClass().equals(software.amazon.jsii.JsiiObject.class))`);
+            }
+            if (typeRefs.length > 1) {
+                this.code.unindent(false);
+                this.code.openBlock(')');
+                const placeholders = typeRefs
+                    .map((typeRef) => {
+                    return `${this.toJavaType(typeRef)}`;
+                })
+                    .join(', ');
+                this.code.indent(`throw new IllegalArgumentException(`);
+                this.code.indent(`new java.lang.StringBuilder("Expected ")`);
+                this.code.line(descr);
+                this.code.line(`.append(" to be one of: ${placeholders}; received ")`);
+                this.code.line(`.append(${value}.getClass()).toString());`);
+                this.code.unindent(false);
+                this.code.unindent(false);
+                this.code.closeBlock();
+            }
+            for (const [javaType, typeRef] of nestedCollectionUnionTypes) {
+                const varName = typeRefs.length > 1
+                    ? `__cast_${(0, crypto_1.createHash)('sha256')
+                        .update(value)
+                        .digest('hex')
+                        .slice(0, 6)}`
+                    : value;
+                if (typeRefs.length > 1) {
+                    this.code.openBlock(`if (${value} instanceof ${this.toJavaTypeNoGenerics(typeRef)})`);
+                    this.code.line(`@SuppressWarnings("unchecked")`);
+                    this.code.line(`final ${javaType} ${varName} = (${javaType})${value};`);
+                }
+                validate.call(this, varName, descr, typeRef, parameterName);
+                if (typeRefs.length > 1) {
+                    this.code.closeBlock();
+                }
+            }
+        }
+    }
     /**
      * We are now going to build a class that can be used as a proxy for untyped
      * javascript objects that implement this interface. we want java code to be
@@ -1726,6 +1927,22 @@ class JavaGenerator extends generator_1.Generator {
     toDecoratedJavaTypes(optionalValue, { covariant = false } = {}) {
         return this.toJavaTypes(optionalValue.type, { covariant }).map((nakedType) => `${optionalValue.optional ? ANN_NULLABLE : ANN_NOT_NULL} ${nakedType}`);
     }
+    // Strips <*> from the type name.
+    // necessary, because of type erasure; the compiler
+    // will not let you check `foo instanceof Map<String, Foo>`,
+    // and you must instead check `foo instanceof Map`.
+    toJavaTypeNoGenerics(type, opts) {
+        const typeStr = this.toJavaType(type, opts);
+        const leftAngleBracketIdx = typeStr.indexOf('<');
+        const rightAngleBracketIdx = typeStr.indexOf('>');
+        if ((leftAngleBracketIdx < 0 && rightAngleBracketIdx >= 0) ||
+            (leftAngleBracketIdx >= 0 && rightAngleBracketIdx < 0)) {
+            throw new Error(`Invalid generic type: found ${typeStr}`);
+        }
+        return leftAngleBracketIdx > 0 && rightAngleBracketIdx > 0
+            ? typeStr.slice(0, leftAngleBracketIdx)
+            : typeStr;
+    }
     toJavaType(type, opts) {
         const types = this.toJavaTypes(type, opts);
         if (types.length > 1) {
@@ -2366,4 +2583,9 @@ function splitNamespace(ns) {
 function escape(s) {
     return s.replace(/["\\<>&]/g, (c) => `&#${c.charCodeAt(0)};`);
 }
+function containsUnionType(typeRef) {
+    return (spec.isUnionTypeReference(typeRef) ||
+        (spec.isCollectionTypeReference(typeRef) &&
+            containsUnionType(typeRef.collection.elementtype)));
+}
 //# sourceMappingURL=java.js.map

package/lib/version.d.ts

@@ -1,5 +1,5 @@
 /** The short version number for this JSII compiler (e.g: `X.Y.Z`) */
-export declare const VERSION = "1.66.0";
+export declare const VERSION: string;
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-export declare const VERSION_DESC = "1.66.0 (build 3c9512b)";
+export declare const VERSION_DESC = "1.68.0 (build b45f2f6)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,9 +1,10 @@
 "use strict";
-// Generated at 2022-08-29T23:52:00Z by generate.sh
+// Generated at 2022-09-22T19:38:42Z by generate.sh
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION_DESC = exports.VERSION = void 0;
 /** The short version number for this JSII compiler (e.g: `X.Y.Z`) */
-exports.VERSION = '1.66.0';
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+exports.VERSION = '1.68.0';
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.66.0 (build 3c9512b)';
+exports.VERSION_DESC = '1.68.0 (build b45f2f6)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-pacmak",
-  "version": "1.66.0",
+  "version": "1.68.0",
   "description": "A code generation framework for jsii backend languages",
   "license": "Apache-2.0",
   "author": {
@@ -37,35 +37,35 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/check-node": "1.66.0",
-    "@jsii/spec": "^1.66.0",
+    "@jsii/check-node": "1.68.0",
+    "@jsii/spec": "^1.68.0",
     "clone": "^2.1.2",
-    "codemaker": "^1.66.0",
+    "codemaker": "^1.68.0",
     "commonmark": "^0.30.0",
     "escape-string-regexp": "^4.0.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.66.0",
-    "jsii-rosetta": "^1.66.0",
+    "jsii-reflect": "^1.68.0",
+    "jsii-rosetta": "^1.68.0",
     "semver": "^7.3.7",
     "spdx-license-list": "^6.6.0",
     "xmlbuilder": "^15.1.1",
     "yargs": "^16.2.0"
   },
   "devDependencies": {
-    "@jsii/dotnet-runtime": "^1.66.0",
-    "@jsii/java-runtime": "^1.66.0",
-    "@jsii/go-runtime": "^1.66.0",
-    "@scope/jsii-calc-lib": "^1.66.0",
+    "@jsii/dotnet-runtime": "^1.68.0",
+    "@jsii/java-runtime": "^1.68.0",
+    "@jsii/go-runtime": "^1.68.0",
+    "@scope/jsii-calc-lib": "^1.68.0",
     "@types/clone": "^2.1.1",
     "@types/diff": "^5.0.2",
     "@types/commonmark": "^0.27.5",
     "@types/fs-extra": "^9.0.13",
     "@types/semver": "^7.3.12",
     "diff": "^5.1.0",
-    "jsii": "^1.66.0",
-    "jsii-build-tools": "^1.66.0",
+    "jsii": "^1.68.0",
+    "jsii-build-tools": "^1.68.0",
     "jsii-calc": "^3.20.120",
-    "pyright": "^1.1.267"
+    "pyright": "^1.1.272"
   },
   "keywords": [
     "jsii",