jsii-pacmak 1.70.0 → 1.72.0

package/bin/jsii-pacmak.js

@@ -12,16 +12,25 @@ const version_1 = require("../lib/version");
         .env('JSII_PACMAK')
         .command(['$0  [PROJECTS...]', 'generate [PROJECTS...]'], 'Generates jsii bindings for the selected project(s)', (argv) => argv.positional('PROJECTS', {
         type: 'string',
+        array: true,
         desc: 'Project(s) to generate',
         normalize: true,
         default: ['.'],
     }))
         .option('targets', {
         alias: ['target', 't'],
-        type: 'array',
+        type: 'string',
+        array: true,
         desc: 'target languages for which to generate bindings',
         defaultDescription: 'all targets defined in `package.json` will be generated',
-        choices: Object.values(lib_1.TargetName),
+        coerce: (value) => (typeof value === 'string'
+            ? value.split(',')
+            : value.flatMap((item) => item.split(','))).map((choice) => {
+            if (Object.values(lib_1.TargetName).includes(choice)) {
+                return choice;
+            }
+            throw new Error(`Invalid target name: ${choice} (valid values are: ${Object.values(lib_1.TargetName).join(', ')})`);
+        }),
         required: false,
     })
         .option('outdir', {

package/lib/targets/python/requirements-dev.txt

@@ -4,6 +4,6 @@
 # package (wheel, sdist), but not declared as build-system dependencies.
 
 setuptools~=62.1.0 # build-system
-wheel~=0.37.1      # build-system
+wheel~=0.38.4      # build-system
 
-twine~=4.0.1
+twine~=4.0.2

package/lib/targets/python/type-name.js

@@ -199,20 +199,28 @@ class UserType {
         const type = typeResolver(__classPrivateFieldGet(this, _UserType_fqn, "f"));
         const isStruct = (0, spec_1.isInterfaceType)(type) && !!type.datatype;
         const wrapType = typeAnnotation && parameterType && isStruct
-            ? (pyType) => `typing.Union[${pyType}, typing.Dict[str, typing.Any]]`
+            ? (pyType) => `typing.Union[${pyType}, typing.Dict[builtins.str, typing.Any]]`
             : (pyType) => pyType;
+        // Emit aliased imports for dependencies (this avoids name collisions)
         if (assemblyName !== assembly.name) {
+            const aliasSuffix = (0, crypto_1.createHash)('sha256')
+                .update(assemblyName)
+                .update('.*')
+                .digest('hex')
+                .substring(0, 8);
+            const alias = `_${packageName.replace(/\./g, '_')}_${aliasSuffix}`;
+            const aliasedFqn = `${alias}${pythonFqn.slice(packageName.length)}`;
             return {
                 // If it's a struct, then we allow passing as a dict, too...
-                pythonType: wrapType(pythonFqn),
+                pythonType: wrapType(aliasedFqn),
                 requiredImport: {
-                    sourcePackage: packageName,
+                    sourcePackage: `${packageName} as ${alias}`,
                     item: '',
                 },
             };
         }
         const submodulePythonName = toPythonFqn(submodule, assembly).pythonFqn;
-        const typeSubmodulePythonName = toPythonFqn(findParentSubmodule(assembly.types[__classPrivateFieldGet(this, _UserType_fqn, "f")], assembly), assembly).pythonFqn;
+        const typeSubmodulePythonName = toPythonFqn(findParentSubmodule(type, assembly), assembly).pythonFqn;
         if (typeSubmodulePythonName === submodulePythonName) {
             // Identify declarations that are not yet initialized and hence cannot be
             // used as part of a type qualification. Since this is not a forward

package/lib/targets/python.d.ts

@@ -17,6 +17,14 @@ interface EmitContext extends NamingContext {
     readonly runtimeTypeChecking: boolean;
     /** Whether to runtime type check keyword arguments (i.e: struct constructors) */
     readonly runtimeTypeCheckKwargs?: boolean;
+    /** The numerical IDs used for type annotation data storing */
+    readonly typeCheckingHelper: TypeCheckingHelper;
+}
+declare class TypeCheckingHelper {
+    #private;
+    getTypeHints(fqn: string, args: readonly string[]): string;
+    /** Emits instructions that create the annotations data... */
+    flushStubs(code: CodeMaker): void;
 }
 interface PythonBase {
     readonly pythonName: string;

package/lib/targets/python.js

@@ -1,8 +1,21 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _TypeCheckingHelper_stubs, _a, _TypeCheckingStub_PREFIX, _TypeCheckingStub_arguments, _TypeCheckingStub_hash;
 Object.defineProperty(exports, "__esModule", { value: true });
 const spec = require("@jsii/spec");
 const assert = require("assert");
 const codemaker_1 = require("codemaker");
+const crypto = require("crypto");
 const escapeStringRegexp = require("escape-string-regexp");
 const fs = require("fs-extra");
 const jsii_rosetta_1 = require("jsii-rosetta");
@@ -74,6 +87,50 @@ class Python extends target_1.Target {
     }
 }
 exports.default = Python;
+class TypeCheckingHelper {
+    constructor() {
+        _TypeCheckingHelper_stubs.set(this, new Array());
+    }
+    getTypeHints(fqn, args) {
+        const stub = new TypeCheckingStub(fqn, args);
+        __classPrivateFieldGet(this, _TypeCheckingHelper_stubs, "f").push(stub);
+        return `typing.get_type_hints(${stub.name})`;
+    }
+    /** Emits instructions that create the annotations data... */
+    flushStubs(code) {
+        for (const stub of __classPrivateFieldGet(this, _TypeCheckingHelper_stubs, "f")) {
+            stub.emit(code);
+        }
+        // Reset the stubs list
+        __classPrivateFieldSet(this, _TypeCheckingHelper_stubs, [], "f");
+    }
+}
+_TypeCheckingHelper_stubs = new WeakMap();
+class TypeCheckingStub {
+    constructor(fqn, args) {
+        _TypeCheckingStub_arguments.set(this, void 0);
+        _TypeCheckingStub_hash.set(this, void 0);
+        // Removing the quoted type names -- this will be emitted at the very end of the module.
+        __classPrivateFieldSet(this, _TypeCheckingStub_arguments, args.map((arg) => arg.replace(/"/g, '')), "f");
+        __classPrivateFieldSet(this, _TypeCheckingStub_hash, crypto
+            .createHash('sha256')
+            .update(__classPrivateFieldGet(TypeCheckingStub, _a, "f", _TypeCheckingStub_PREFIX))
+            .update(fqn)
+            .digest('hex'), "f");
+    }
+    get name() {
+        return `${__classPrivateFieldGet(TypeCheckingStub, _a, "f", _TypeCheckingStub_PREFIX)}${__classPrivateFieldGet(this, _TypeCheckingStub_hash, "f")}`;
+    }
+    emit(code) {
+        code.line();
+        openSignature(code, 'def', this.name, __classPrivateFieldGet(this, _TypeCheckingStub_arguments, "f"), 'None');
+        code.line(`"""Type checking stubs"""`);
+        code.line('pass');
+        code.closeBlock();
+    }
+}
+_a = TypeCheckingStub, _TypeCheckingStub_arguments = new WeakMap(), _TypeCheckingStub_hash = new WeakMap();
+_TypeCheckingStub_PREFIX = { value: '_typecheckingstub__' };
 const pythonModuleNameToFilename = (name) => {
     return path.join(...name.split('.'));
 };
@@ -295,7 +352,7 @@ class BasePythonClassType {
     }
 }
 class BaseMethod {
-    constructor(generator, pythonName, jsName, parameters, returns, docs, isStatic, opts) {
+    constructor(generator, pythonName, jsName, parameters, returns, docs, isStatic, pythonParent, opts) {
         this.generator = generator;
         this.pythonName = pythonName;
         this.jsName = jsName;
@@ -303,6 +360,7 @@ class BaseMethod {
         this.returns = returns;
         this.docs = docs;
         this.isStatic = isStatic;
+        this.pythonParent = pythonParent;
         this.classAsFirstParameter = false;
         this.returnFromJSIIMethod = true;
         this.shouldEmitBody = true;
@@ -441,7 +499,7 @@ class BaseMethod {
         });
         if ((this.shouldEmitBody || forceEmitBody) &&
             (!renderAbstract || !this.abstract)) {
-            emitParameterTypeChecks(code, context, pythonParams.slice(1));
+            emitParameterTypeChecks(code, context, pythonParams.slice(1), `${this.pythonParent.fqn ?? this.pythonParent.pythonName}#${this.pythonName}`);
         }
         this.emitBody(code, context, renderAbstract, forceEmitBody, liftedPropNames, pythonParams[0], returnType);
         code.closeBlock();
@@ -542,12 +600,13 @@ class BaseMethod {
     }
 }
 class BaseProperty {
-    constructor(generator, pythonName, jsName, type, docs, opts) {
+    constructor(generator, pythonName, jsName, type, docs, pythonParent, opts) {
         this.generator = generator;
         this.pythonName = pythonName;
         this.jsName = jsName;
         this.type = type;
         this.docs = docs;
+        this.pythonParent = pythonParent;
         this.shouldEmitBody = true;
         const { abstract = false, immutable = false, isStatic = false } = opts;
         this.abstract = abstract;
@@ -598,7 +657,7 @@ class BaseProperty {
             openSignature(code, 'def', this.pythonName, [this.implicitParameter, `value: ${pythonType}`], 'None');
             if ((this.shouldEmitBody || forceEmitBody) &&
                 (!renderAbstract || !this.abstract)) {
-                emitParameterTypeChecks(code, context, [`value: ${pythonType}`]);
+                emitParameterTypeChecks(code, context, [`value: ${pythonType}`], `${this.pythonParent.fqn ?? this.pythonParent.pythonName}#${this.pythonName}`);
                 code.line(`jsii.${this.jsiiSetMethod}(${this.implicitParameter}, "${this.jsName}", value)`);
             }
             else {
@@ -747,10 +806,10 @@ class Struct extends BasePythonClassType {
         if (kwargs.length > 0) {
             emitParameterTypeChecks(code, 
             // Runtime type check keyword args as this is a struct __init__ function.
-            { ...context, runtimeTypeCheckKwargs: true }, ['*', ...kwargs]);
+            { ...context, runtimeTypeCheckKwargs: true }, ['*', ...kwargs], `${this.fqn ?? this.pythonName}#__init__`);
         }
         // Required properties, those will always be put into the dict
-        assignDictionary(code, `${implicitParameter}._values: typing.Dict[str, typing.Any]`, members
+        assignDictionary(code, `${implicitParameter}._values: typing.Dict[builtins.str, typing.Any]`, members
             .filter((m) => !m.optional)
             .map((member) => `${JSON.stringify(member.pythonName)}: ${member.pythonName}`));
         // Optional properties, will only be put into the dict if they're not None
@@ -1340,6 +1399,7 @@ class Package {
             const filename = path.join('src', pythonModuleNameToFilename(mod.pythonName), '__init__.py');
             code.openFile(filename);
             mod.emit(code, context);
+            context.typeCheckingHelper.flushStubs(code);
             code.closeFile(filename);
             scripts.push(...mod.emitBinScripts(code));
         }
@@ -1735,6 +1795,7 @@ class PythonGenerator extends generator_1.Generator {
             resolver,
             runtimeTypeChecking: this.runtimeTypeChecking,
             submodule: assm.name,
+            typeCheckingHelper: new TypeCheckingHelper(),
             typeResolver: (fqn) => resolver.dereference(fqn),
         });
     }
@@ -1783,7 +1844,7 @@ class PythonGenerator extends generator_1.Generator {
         if (cls.initializer !== undefined) {
             const { parameters = [] } = cls.initializer;
             klass.addMember(new Initializer(this, '__init__', undefined, parameters, undefined, cls.initializer.docs, false, // Never static
-            { liftedProp: this.getliftedProp(cls.initializer), parent: cls }));
+            klass, { liftedProp: this.getliftedProp(cls.initializer), parent: cls }));
         }
         this.addPythonType(klass);
     }
@@ -1791,7 +1852,7 @@ class PythonGenerator extends generator_1.Generator {
         const { parameters = [] } = method;
         const klass = this.getPythonType(cls.fqn);
         klass.addMember(new StaticMethod(this, toPythonMethodName(method.name), method.name, parameters, method.returns, method.docs, true, // Always static
-        {
+        klass, {
             abstract: method.abstract,
             liftedProp: this.getliftedProp(method),
             parent: cls,
@@ -1799,7 +1860,7 @@ class PythonGenerator extends generator_1.Generator {
     }
     onStaticProperty(cls, prop) {
         const klass = this.getPythonType(cls.fqn);
-        klass.addMember(new StaticProperty(this, toPythonPropertyName(prop.name, prop.const), prop.name, prop, prop.docs, {
+        klass.addMember(new StaticProperty(this, toPythonPropertyName(prop.name, prop.const), prop.name, prop, prop.docs, klass, {
             abstract: prop.abstract,
             immutable: prop.immutable,
             isStatic: prop.static,
@@ -1810,14 +1871,14 @@ class PythonGenerator extends generator_1.Generator {
         const { parameters = [] } = method;
         const klass = this.getPythonType(cls.fqn);
         if (method.async) {
-            klass.addMember(new AsyncMethod(this, toPythonMethodName(method.name, method.protected), method.name, parameters, method.returns, method.docs, !!method.static, {
+            klass.addMember(new AsyncMethod(this, toPythonMethodName(method.name, method.protected), method.name, parameters, method.returns, method.docs, !!method.static, klass, {
                 abstract: method.abstract,
                 liftedProp: this.getliftedProp(method),
                 parent: cls,
             }));
         }
         else {
-            klass.addMember(new Method(this, toPythonMethodName(method.name, method.protected), method.name, parameters, method.returns, method.docs, !!method.static, {
+            klass.addMember(new Method(this, toPythonMethodName(method.name, method.protected), method.name, parameters, method.returns, method.docs, !!method.static, klass, {
                 abstract: method.abstract,
                 liftedProp: this.getliftedProp(method),
                 parent: cls,
@@ -1826,7 +1887,7 @@ class PythonGenerator extends generator_1.Generator {
     }
     onProperty(cls, prop) {
         const klass = this.getPythonType(cls.fqn);
-        klass.addMember(new Property(this, toPythonPropertyName(prop.name, prop.const, prop.protected), prop.name, prop, prop.docs, {
+        klass.addMember(new Property(this, toPythonPropertyName(prop.name, prop.const, prop.protected), prop.name, prop, prop.docs, klass, {
             abstract: prop.abstract,
             immutable: prop.immutable,
             isStatic: prop.static,
@@ -1852,7 +1913,7 @@ class PythonGenerator extends generator_1.Generator {
     onInterfaceMethod(ifc, method) {
         const { parameters = [] } = method;
         const klass = this.getPythonType(ifc.fqn);
-        klass.addMember(new InterfaceMethod(this, toPythonMethodName(method.name, method.protected), method.name, parameters, method.returns, method.docs, !!method.static, { liftedProp: this.getliftedProp(method), parent: ifc }));
+        klass.addMember(new InterfaceMethod(this, toPythonMethodName(method.name, method.protected), method.name, parameters, method.returns, method.docs, !!method.static, klass, { liftedProp: this.getliftedProp(method), parent: ifc }));
     }
     onInterfaceProperty(ifc, prop) {
         let ifaceProperty;
@@ -1861,7 +1922,7 @@ class PythonGenerator extends generator_1.Generator {
             ifaceProperty = new StructField(this, prop, ifc);
         }
         else {
-            ifaceProperty = new InterfaceProperty(this, toPythonPropertyName(prop.name, prop.const, prop.protected), prop.name, prop, prop.docs, { immutable: prop.immutable, isStatic: prop.static, parent: ifc });
+            ifaceProperty = new InterfaceProperty(this, toPythonPropertyName(prop.name, prop.const, prop.protected), prop.name, prop, prop.docs, klass, { immutable: prop.immutable, isStatic: prop.static, parent: ifc });
         }
         klass.addMember(ifaceProperty);
     }
@@ -2017,10 +2078,11 @@ function openSignature(code, keyword, name, params, returnType, lineComment) {
  * @param code        the CodeMaker to use for emitting code.
  * @param context     the emit context used when emitting this code.
  * @param params      the parameter signatures to be type-checked.
+ * @params pythonName the name of the Python function being checked (qualified).
  */
-function emitParameterTypeChecks(code, context, params) {
+function emitParameterTypeChecks(code, context, params, fqn) {
     if (!context.runtimeTypeChecking) {
-        return;
+        return false;
     }
     const paramInfo = params.map((param) => {
         const [name] = param.split(/\s*[:=#]\s*/, 1);
@@ -2049,16 +2111,7 @@ function emitParameterTypeChecks(code, context, params) {
         }
         if (!openedBlock) {
             code.openBlock('if __debug__');
-            const stubVar = slugifyAsNeeded('stub', [...paramNames, typesVar]);
-            // Inline a stub function to be able to have the required type hints regardless of what customers do with the
-            // code. Using a reference to the `Type.function` may result in incorrect data if some function was replaced (e.g.
-            // by a decorated version with different type annotations). We also cannot construct the actual value expected by
-            // typeguard's `check_type` because Python does not expose the APIs necessary to build many of these objects in
-            // regular Python code.
-            openSignature(code, 'def', stubVar, params, 'None');
-            code.line('...');
-            code.closeBlock();
-            code.line(`${typesVar} = typing.get_type_hints(${stubVar})`);
+            code.line(`${typesVar} = ${context.typeCheckingHelper.getTypeHints(fqn, params)}`);
             openedBlock = true;
         }
         let expectedType = `${typesVar}[${JSON.stringify(name)}]`;
@@ -2073,7 +2126,10 @@ function emitParameterTypeChecks(code, context, params) {
     }
     if (openedBlock) {
         code.closeBlock();
+        return true;
     }
+    // We did not reference type annotations data if we never opened a type-checking block.
+    return false;
 }
 function assignCallResult(code, variable, funct, params) {
     const prefix = `${variable} = ${funct}(`;

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: string;
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-export declare const VERSION_DESC = "1.70.0 (build 03c2f6f)";
+export declare const VERSION_DESC = "1.72.0 (build 4b8828b)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,10 +1,10 @@
 "use strict";
-// Generated at 2022-10-19T17:19:02Z by generate.sh
+// Generated at 2022-12-05T11:41: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`) */
 // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-exports.VERSION = '1.70.0';
+exports.VERSION = '1.72.0';
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.70.0 (build 03c2f6f)';
+exports.VERSION_DESC = '1.72.0 (build 4b8828b)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-pacmak",
-  "version": "1.70.0",
+  "version": "1.72.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.70.0",
-    "@jsii/spec": "^1.70.0",
+    "@jsii/check-node": "1.72.0",
+    "@jsii/spec": "^1.72.0",
     "clone": "^2.1.2",
-    "codemaker": "^1.70.0",
+    "codemaker": "^1.72.0",
     "commonmark": "^0.30.0",
     "escape-string-regexp": "^4.0.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.70.0",
-    "jsii-rosetta": "^1.70.0",
+    "jsii-reflect": "^1.72.0",
+    "jsii-rosetta": "^1.72.0",
     "semver": "^7.3.8",
     "spdx-license-list": "^6.6.0",
     "xmlbuilder": "^15.1.1",
     "yargs": "^16.2.0"
   },
   "devDependencies": {
-    "@jsii/dotnet-runtime": "^1.70.0",
-    "@jsii/java-runtime": "^1.70.0",
-    "@jsii/go-runtime": "^1.70.0",
-    "@scope/jsii-calc-lib": "^1.70.0",
+    "@jsii/dotnet-runtime": "^1.72.0",
+    "@jsii/java-runtime": "^1.72.0",
+    "@jsii/go-runtime": "^1.72.0",
+    "@scope/jsii-calc-lib": "^1.72.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",
+    "@types/semver": "^7.3.13",
     "diff": "^5.1.0",
-    "jsii": "^1.70.0",
-    "jsii-build-tools": "^1.70.0",
+    "jsii": "^1.72.0",
+    "jsii-build-tools": "^1.72.0",
     "jsii-calc": "^3.20.120",
-    "pyright": "^1.1.276"
+    "pyright": "^1.1.282"
   },
   "keywords": [
     "jsii",