jsii-pacmak 1.65.0 → 1.67.0

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/targets/python/type-name.js

@@ -217,7 +217,7 @@ class UserType {
             // Identify declarations that are not yet initialized and hence cannot be
             // used as part of a type qualification. Since this is not a forward
             // reference, the type was already emitted and its un-qualified name must
-            // be used instead of it's locally qualified name.
+            // be used instead of its locally qualified name.
             const nestingParent = surroundingTypeFqns
                 ?.map((fqn) => toPythonFqn(fqn, assembly).pythonFqn)
                 ?.reverse()
@@ -233,7 +233,7 @@ class UserType {
                 // This is not for a type annotation, so we should be at a point in time
                 // where the surrounding symbol has been defined entirely, so we can
                 // refer to it "normally" now.
-                return { pythonType: pythonFqn.substring(nestingParent.length + 1) };
+                return { pythonType: pythonFqn.slice(packageName.length + 1) };
             }
             // We'll just make a module-qualified reference at this point.
             return {
@@ -251,7 +251,7 @@ class UserType {
             .substring(0, 8);
         const alias = `_${toImport}_${aliasSuffix}`;
         return {
-            pythonType: [alias, ...nested].join('.'),
+            pythonType: wrapType([alias, ...nested].join('.')),
             requiredImport: {
                 sourcePackage: relativeImportPath(submodulePythonName, typeSubmodulePythonName),
                 item: `${toImport} as ${alias}`,

package/lib/targets/python.js

@@ -394,6 +394,7 @@ class BaseMethod {
                     const paramType = (0, type_name_1.toTypeName)(prop.prop).pythonType({
                         ...context,
                         parameterType: true,
+                        typeAnnotation: true,
                     });
                     const paramDefault = prop.prop.optional ? ' = None' : '';
                     pythonParams.push(`${paramName}: ${paramType}${paramDefault}`);
@@ -739,7 +740,10 @@ class Struct extends BasePythonClassType {
         // Re-type struct arguments that were passed as "dict". Do this before validating argument types...
         for (const member of members.filter((m) => m.isStruct(this.generator))) {
             // Note that "None" is NOT an instance of dict (that's convenient!)
-            const typeName = (0, type_name_1.toPythonFullName)(member.type.type.fqn, context.assembly);
+            const typeName = (0, type_name_1.toTypeName)(member.type.type).pythonType({
+                ...context,
+                typeAnnotation: false,
+            });
             code.openBlock(`if isinstance(${member.pythonName}, dict)`);
             code.line(`${member.pythonName} = ${typeName}(**${member.pythonName})`);
             code.closeBlock();

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.65.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.65.0 (build 7a02b7f)";
+export declare const VERSION_DESC = "1.67.0 (build 2c027f5)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,9 +1,10 @@
 "use strict";
-// Generated at 2022-08-18T14:34:45Z by generate.sh
+// Generated at 2022-09-02T16:06:26Z 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.65.0';
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+exports.VERSION = '1.67.0';
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.65.0 (build 7a02b7f)';
+exports.VERSION_DESC = '1.67.0 (build 2c027f5)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-pacmak",
-  "version": "1.65.0",
+  "version": "1.67.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.65.0",
-    "@jsii/spec": "^1.65.0",
+    "@jsii/check-node": "1.67.0",
+    "@jsii/spec": "^1.67.0",
     "clone": "^2.1.2",
-    "codemaker": "^1.65.0",
+    "codemaker": "^1.67.0",
     "commonmark": "^0.30.0",
     "escape-string-regexp": "^4.0.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.65.0",
-    "jsii-rosetta": "^1.65.0",
+    "jsii-reflect": "^1.67.0",
+    "jsii-rosetta": "^1.67.0",
     "semver": "^7.3.7",
     "spdx-license-list": "^6.6.0",
     "xmlbuilder": "^15.1.1",
     "yargs": "^16.2.0"
   },
   "devDependencies": {
-    "@jsii/dotnet-runtime": "^1.65.0",
-    "@jsii/java-runtime": "^1.65.0",
-    "@jsii/go-runtime": "^1.65.0",
-    "@scope/jsii-calc-lib": "^1.65.0",
+    "@jsii/dotnet-runtime": "^1.67.0",
+    "@jsii/java-runtime": "^1.67.0",
+    "@jsii/go-runtime": "^1.67.0",
+    "@scope/jsii-calc-lib": "^1.67.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.10",
+    "@types/semver": "^7.3.12",
     "diff": "^5.1.0",
-    "jsii": "^1.65.0",
-    "jsii-build-tools": "^1.65.0",
+    "jsii": "^1.67.0",
+    "jsii-build-tools": "^1.67.0",
     "jsii-calc": "^3.20.120",
-    "pyright": "^1.1.266"
+    "pyright": "^1.1.268"
   },
   "keywords": [
     "jsii",