jsii-pacmak 1.62.0 → 1.63.2

package/jest.config.mjs

@@ -2,4 +2,5 @@ import { overriddenConfig } from '../../jest.config.mjs';
 
 export default overriddenConfig({
   coveragePathIgnorePatterns: ['/node_modules/', '<rootDir>/test'],
+  watchPathIgnorePatterns: ['.*\\.tsx?$'],
 });

package/lib/targets/go/types/go-type-reference.js

@@ -103,9 +103,12 @@ class GoTypeRef {
                 ret.push(...this.typeMap.value.dependencies);
                 break;
             case 'union':
-                for (const t of this.typeMap.value) {
-                    ret.push(...t.dependencies);
-                }
+                // Unions ultimately result in `interface{}` being rendered, so no import is needed. We
+                // hence ignore them entirely here for now. In the future, we may want to inject specific
+                // runtime type checks around use of unions, which may result in imports being useful.
+                // for (const t of this.typeMap.value) {
+                //   ret.push(...t.dependencies);
+                // }
                 break;
             case 'void':
             case 'primitive':

package/lib/targets/python/type-name.d.ts

@@ -1,4 +1,4 @@
-import { Assembly, OptionalValue, TypeReference } from '@jsii/spec';
+import { Assembly, OptionalValue, TypeReference, Type } from '@jsii/spec';
 export interface TypeName {
     pythonType(context: NamingContext): string;
     requiredImports(context: NamingContext): PythonImports;
@@ -17,6 +17,8 @@ export interface PythonImports {
 export interface NamingContext {
     /** The assembly in which the PythonType is expressed. */
     readonly assembly: Assembly;
+    /** A resolver to obtain complete information about a type. */
+    readonly typeResolver: (fqn: string) => Type;
     /** The submodule of the assembly in which the PythonType is expressed (could be the module root) */
     readonly submodule: string;
     /**
@@ -68,4 +70,14 @@ export declare function toPythonFqn(fqn: string, rootAssm: Assembly): {
     packageName: string;
     pythonFqn: string;
 };
+/**
+ * Computes the nesting-qualified name of a type.
+ *
+ * @param fqn      the fully qualified jsii name of the type.
+ * @param rootAssm the root assembly for the project.
+ *
+ * @returns the nesting-qualified python type name (the name of the class,
+ *          qualified with all nesting parent classes).
+ */
+export declare function toPythonFullName(fqn: string, rootAssm: Assembly): string;
 //# sourceMappingURL=type-name.d.ts.map

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

@@ -12,7 +12,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _Dict_element, _List_element, _Optional_wrapped, _Primitive_pythonType, _Union_options, _UserType_fqn;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toPythonFqn = exports.mergePythonImports = exports.toPackageName = exports.toTypeName = void 0;
+exports.toPythonFullName = exports.toPythonFqn = exports.mergePythonImports = exports.toPackageName = exports.toTypeName = void 0;
 const spec_1 = require("@jsii/spec");
 const codemaker_1 = require("codemaker");
 const crypto_1 = require("crypto");
@@ -193,11 +193,18 @@ class UserType {
         }
         return { [requiredImport.sourcePackage]: new Set([requiredImport.item]) };
     }
-    resolve({ assembly, emittedTypes, submodule, surroundingTypeFqns, typeAnnotation = true, }) {
+    resolve({ assembly, emittedTypes, submodule, surroundingTypeFqns, typeAnnotation = true, parameterType, typeResolver, }) {
         const { assemblyName, packageName, pythonFqn } = toPythonFqn(__classPrivateFieldGet(this, _UserType_fqn, "f"), assembly);
+        // If this is a type annotation for a parameter, allow dicts to be passed where structs are expected.
+        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) => pyType;
         if (assemblyName !== assembly.name) {
             return {
-                pythonType: pythonFqn,
+                // If it's a struct, then we allow passing as a dict, too...
+                pythonType: wrapType(pythonFqn),
                 requiredImport: {
                     sourcePackage: packageName,
                     item: '',
@@ -219,7 +226,7 @@ class UserType {
                 (!emittedTypes.has(__classPrivateFieldGet(this, _UserType_fqn, "f")) || nestingParent != null)) {
                 // Possibly a forward reference, outputting the stringifierd python FQN
                 return {
-                    pythonType: JSON.stringify(pythonFqn.substring(submodulePythonName.length + 1)),
+                    pythonType: wrapType(JSON.stringify(pythonFqn.substring(submodulePythonName.length + 1))),
                 };
             }
             if (!typeAnnotation && nestingParent) {
@@ -230,7 +237,7 @@ class UserType {
             }
             // We'll just make a module-qualified reference at this point.
             return {
-                pythonType: pythonFqn.substring(submodulePythonName.length + 1),
+                pythonType: wrapType(pythonFqn.substring(submodulePythonName.length + 1)),
             };
         }
         const [toImport, ...nested] = pythonFqn
@@ -262,6 +269,20 @@ function toPythonFqn(fqn, rootAssm) {
     return { assemblyName, packageName, pythonFqn: fqnParts.join('.') };
 }
 exports.toPythonFqn = toPythonFqn;
+/**
+ * Computes the nesting-qualified name of a type.
+ *
+ * @param fqn      the fully qualified jsii name of the type.
+ * @param rootAssm the root assembly for the project.
+ *
+ * @returns the nesting-qualified python type name (the name of the class,
+ *          qualified with all nesting parent classes).
+ */
+function toPythonFullName(fqn, rootAssm) {
+    const { packageName, pythonFqn } = toPythonFqn(fqn, rootAssm);
+    return pythonFqn.slice(packageName.length + 1);
+}
+exports.toPythonFullName = toPythonFullName;
 /**
  * Computes the python relative import path from `fromModule` to `toModule`.
  *

package/lib/targets/python.js

@@ -442,6 +442,10 @@ class BaseMethod {
             arguments: documentableArgs,
             documentableItem: `method-${this.pythonName}`,
         });
+        if ((this.shouldEmitBody || forceEmitBody) &&
+            (!renderAbstract || !this.abstract)) {
+            emitParameterTypeChecks(code, pythonParams.slice(1), `${(0, type_name_1.toPythonFullName)(this.parent.fqn, context.assembly)}.${this.pythonName}`);
+        }
         this.emitBody(code, context, renderAbstract, forceEmitBody, liftedPropNames, pythonParams[0], returnType);
         code.closeBlock();
     }
@@ -573,6 +577,7 @@ class BaseProperty {
         this.generator.emitDocString(code, this.apiLocation, this.docs, {
             documentableItem: `prop-${this.pythonName}`,
         });
+        // NOTE: No parameters to validate here, this is a getter...
         if ((this.shouldEmitBody || forceEmitBody) &&
             (!renderAbstract || !this.abstract)) {
             code.line(`return typing.cast(${pythonType}, jsii.${this.jsiiGetMethod}(${this.implicitParameter}, "${this.jsName}"))`);
@@ -590,6 +595,11 @@ class BaseProperty {
             openSignature(code, 'def', this.pythonName, [this.implicitParameter, `value: ${pythonType}`], false, 'None');
             if ((this.shouldEmitBody || forceEmitBody) &&
                 (!renderAbstract || !this.abstract)) {
+                emitParameterTypeChecks(code, [`value: ${pythonType}`], 
+                // In order to get a property accessor, we must resort to getting the
+                // attribute on the type, instead of the value (where the getter would
+                // be implicitly invoked for us...)
+                `getattr(${(0, type_name_1.toPythonFullName)(this.parent.fqn, context.assembly)}, ${JSON.stringify(this.pythonName)}).fset`);
                 code.line(`jsii.${this.jsiiSetMethod}(${this.implicitParameter}, "${this.jsName}", value)`);
             }
             else {
@@ -724,7 +734,7 @@ class Struct extends BasePythonClassType {
             : [implicitParameter];
         openSignature(code, 'def', '__init__', constructorArguments, false, 'None');
         this.emitConstructorDocstring(code);
-        // Re-type struct arguments that were passed as "dict"
+        // 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.toTypeName)(member.type.type).pythonType({
@@ -735,6 +745,7 @@ class Struct extends BasePythonClassType {
             code.line(`${member.pythonName} = ${typeName}(**${member.pythonName})`);
             code.closeBlock();
         }
+        emitParameterTypeChecks(code, kwargs, `${(0, type_name_1.toPythonFullName)(this.spec.fqn, context.assembly)}.__init__`);
         // Required properties, those will always be put into the dict
         assignDictionary(code, `${implicitParameter}._values: typing.Dict[str, typing.Any]`, members
             .filter((m) => !m.optional)
@@ -763,6 +774,7 @@ class Struct extends BasePythonClassType {
         code.line('@builtins.property');
         openSignature(code, 'def', member.pythonName, ['self'], true, pythonType);
         member.emitDocString(code);
+        // NOTE: No parameter to validate here, this is a getter.
         code.line(`result = self._values.get(${JSON.stringify(member.pythonName)})`);
         if (!member.optional) {
             // Add an assertion to maye MyPY happy!
@@ -1099,6 +1111,8 @@ class PythonModule {
         code.line('import jsii');
         code.line('import publication');
         code.line('import typing_extensions');
+        code.line();
+        code.line('from typeguard import check_type');
         // Determine if we need to write out the kernel load line.
         if (this.loadAssembly) {
             this.emitDependencyImports(code);
@@ -1376,6 +1390,7 @@ class Package {
             install_requires: [
                 `jsii${(0, version_utils_1.toPythonVersionRange)(`^${jsiiVersionSimple}`)}`,
                 'publication>=0.0.3',
+                'typeguard~=2.13.3',
             ]
                 .concat(dependencies)
                 .sort(),
@@ -1709,6 +1724,7 @@ class PythonGenerator extends generator_1.Generator {
             emittedTypes: new Set(),
             resolver,
             submodule: assm.name,
+            typeResolver: (fqn) => resolver.dereference(fqn),
         });
     }
     /**
@@ -1762,7 +1778,8 @@ class PythonGenerator extends generator_1.Generator {
     }
     onStaticMethod(cls, method) {
         const { parameters = [] } = method;
-        this.getPythonType(cls.fqn).addMember(new StaticMethod(this, toPythonMethodName(method.name), method.name, parameters, method.returns, method.docs, true, // Always static
+        const klass = this.getPythonType(cls.fqn);
+        klass.addMember(new StaticMethod(this, toPythonMethodName(method.name), method.name, parameters, method.returns, method.docs, true, // Always static
         {
             abstract: method.abstract,
             liftedProp: this.getliftedProp(method),
@@ -1770,7 +1787,8 @@ class PythonGenerator extends generator_1.Generator {
         }));
     }
     onStaticProperty(cls, prop) {
-        this.getPythonType(cls.fqn).addMember(new StaticProperty(this, toPythonPropertyName(prop.name, prop.const), prop.name, prop, prop.docs, {
+        const klass = this.getPythonType(cls.fqn);
+        klass.addMember(new StaticProperty(this, toPythonPropertyName(prop.name, prop.const), prop.name, prop, prop.docs, {
             abstract: prop.abstract,
             immutable: prop.immutable,
             isStatic: prop.static,
@@ -1779,15 +1797,16 @@ class PythonGenerator extends generator_1.Generator {
     }
     onMethod(cls, method) {
         const { parameters = [] } = method;
+        const klass = this.getPythonType(cls.fqn);
         if (method.async) {
-            this.getPythonType(cls.fqn).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, {
                 abstract: method.abstract,
                 liftedProp: this.getliftedProp(method),
                 parent: cls,
             }));
         }
         else {
-            this.getPythonType(cls.fqn).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, {
                 abstract: method.abstract,
                 liftedProp: this.getliftedProp(method),
                 parent: cls,
@@ -1795,7 +1814,8 @@ class PythonGenerator extends generator_1.Generator {
         }
     }
     onProperty(cls, prop) {
-        this.getPythonType(cls.fqn).addMember(new Property(this, toPythonPropertyName(prop.name, prop.const, prop.protected), prop.name, prop, prop.docs, {
+        const klass = this.getPythonType(cls.fqn);
+        klass.addMember(new Property(this, toPythonPropertyName(prop.name, prop.const, prop.protected), prop.name, prop, prop.docs, {
             abstract: prop.abstract,
             immutable: prop.immutable,
             isStatic: prop.static,
@@ -1820,17 +1840,19 @@ class PythonGenerator extends generator_1.Generator {
     }
     onInterfaceMethod(ifc, method) {
         const { parameters = [] } = method;
-        this.getPythonType(ifc.fqn).addMember(new InterfaceMethod(this, toPythonMethodName(method.name, method.protected), method.name, parameters, method.returns, method.docs, !!method.static, { liftedProp: this.getliftedProp(method), parent: ifc }));
+        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 }));
     }
     onInterfaceProperty(ifc, prop) {
         let ifaceProperty;
+        const klass = this.getPythonType(ifc.fqn);
         if (ifc.datatype) {
             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 });
         }
-        this.getPythonType(ifc.fqn).addMember(ifaceProperty);
+        klass.addMember(ifaceProperty);
     }
     onBeginEnum(enm) {
         this.addPythonType(new Enum(this, (0, util_2.toPythonIdentifier)(enm.name), enm, enm.fqn, {}, enm.docs));
@@ -1988,6 +2010,50 @@ function openSignature(code, keyword, name, params, trailingComma = false, retur
     code.unindent(false);
     code.openBlock(`)${suffix}`);
 }
+/**
+ * Emits runtime type checking code for parameters.
+ *
+ * @param code        the CodeMaker to use for emitting code.
+ * @param params      the parameter signatures to be type-checked.
+ * @param typedEntity the type-annotated entity.
+ */
+function emitParameterTypeChecks(code, params, typedEntity) {
+    const paramInfo = params.map((param) => {
+        const [name] = param.split(/\s*[:=]\s*/, 1);
+        if (name === '*') {
+            return { kwargsMark: true };
+        }
+        else if (name.startsWith('*')) {
+            return { name: name.slice(1), is_rest: true };
+        }
+        return { name };
+    });
+    const typesVar = slugifyAsNeeded('type_hints', paramInfo
+        .filter((param) => param.name != null)
+        .map((param) => param.name.split(/\s*:\s*/)[0]));
+    let openedBlock = false;
+    for (const { is_rest, kwargsMark, name } of paramInfo) {
+        if (kwargsMark) {
+            // This is the keyword-args separator, we won't check keyword arguments here because the kwargs will be rolled
+            // up into a struct instance, and that struct's constructor will be checking again...
+            break;
+        }
+        if (!openedBlock) {
+            code.openBlock('if __debug__');
+            code.line(`${typesVar} = typing.get_type_hints(${typedEntity})`);
+            openedBlock = true;
+        }
+        let expectedType = `${typesVar}[${JSON.stringify(name)}]`;
+        if (is_rest) {
+            // This is a vararg, so the value will appear as a tuple.
+            expectedType = `typing.Tuple[${expectedType}, ...]`;
+        }
+        code.line(`check_type(argname=${JSON.stringify(`argument ${name}`)}, value=${name}, expected_type=${expectedType})`);
+    }
+    if (openedBlock) {
+        code.closeBlock();
+    }
+}
 function assignCallResult(code, variable, funct, params) {
     const prefix = `${variable} = ${funct}(`;
     const suffix = ')';

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.62.0";
+export declare const VERSION = "1.63.2";
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-export declare const VERSION_DESC = "1.62.0 (build 293ac17)";
+export declare const VERSION_DESC = "1.63.2 (build a8a8833)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,9 +1,9 @@
 "use strict";
-// Generated at 2022-07-12T18:04:59Z by generate.sh
+// Generated at 2022-07-29T15:35:51Z 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.62.0';
+exports.VERSION = '1.63.2';
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.62.0 (build 293ac17)';
+exports.VERSION_DESC = '1.63.2 (build a8a8833)';
 //# sourceMappingURL=version.js.map

package/package.json

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