jsii-pacmak 1.63.0 → 1.64.0

package/lib/targets/dotnet/dotnetgenerator.d.ts

@@ -55,6 +55,13 @@ export declare class DotNetGenerator extends Generator {
     protected onEnumMember(enm: spec.EnumType, member: spec.EnumMember): void;
     private namespaceFor;
     private emitMethod;
+    /**
+     * Emits type checks for values passed for type union parameters.
+     *
+     * @param parameters the list of parameters received by the function.
+     * @param noMangle   use parameter names as-is (useful for setters, for example) instead of mangling them.
+     */
+    private emitUnionParameterValdation;
     /**
      * Founds out if a member (property or method) is already defined in one of the base classes
      *

package/lib/targets/dotnet/dotnetgenerator.js

@@ -4,8 +4,11 @@ exports.DotNetGenerator = void 0;
 const spec = require("@jsii/spec");
 const clone = require("clone");
 const fs = require("fs-extra");
+const http = require("http");
+const https = require("https");
 const path = require("path");
 const generator_1 = require("../../generator");
+const logging_1 = require("../../logging");
 const dotnetdocgenerator_1 = require("./dotnetdocgenerator");
 const dotnetruntimegenerator_1 = require("./dotnetruntimegenerator");
 const dotnettyperesolver_1 = require("./dotnettyperesolver");
@@ -48,7 +51,6 @@ class DotNetGenerator extends generator_1.Generator {
         const tarballFileName = path.basename(tarball);
         const filegen = new filegenerator_1.FileGenerator(this.assembly, tarballFileName, this.code);
         filegen.generateAssemblyInfoFile();
-        filegen.generateProjectFile(this.typeresolver.namespaceDependencies);
         // Calling super.save() dumps the tarball in the format name@version.jsii.tgz.
         // This is not in sync with the Old .NET generator where the name is scope-name-version.tgz.
         // Hence we are saving the files ourselves here:
@@ -59,6 +61,17 @@ class DotNetGenerator extends generator_1.Generator {
         }
         await fs.mkdirp(path.join(outdir, packageId));
         await fs.copyFile(tarball, path.join(outdir, packageId, tarballFileName));
+        // Attempt to download the package icon from the configured URL so we can use the non-deprecated PackageIcon
+        // attribute. If this fails or is opted out (via $JSII_PACMAK_DOTNET_NO_DOWNLOAD_ICON being set), then only the
+        // deprecated PackageIconUrl will be emitted.
+        const iconFile = this.assembly.targets?.dotnet?.iconUrl != null &&
+            !process.env.JSII_PACMAK_DOTNET_NO_DOWNLOAD_ICON
+            ? await tryDownloadResource(this.assembly.targets.dotnet.iconUrl, path.join(outdir, packageId)).catch((err) => {
+                (0, logging_1.debug)(`[dotnet] Unable to download package icon, will only use deprecated PackageIconUrl attribute: ${err.cause}`);
+                return Promise.resolve(undefined);
+            })
+            : undefined;
+        filegen.generateProjectFile(this.typeresolver.namespaceDependencies, iconFile);
         // Create an anchor file for the current model
         this.generateDependencyAnchorFile();
         if (license) {
@@ -251,10 +264,18 @@ class DotNetGenerator extends generator_1.Generator {
             // Create the constructors:
             // Abstract classes have protected constructors.
             const visibility = cls.abstract ? 'protected' : 'public';
+            this.code.openBlock(`${visibility} ${className}(${parametersDefinition}): base(_MakeDeputyProps(${parametersBase}))`);
+            this.code.closeBlock();
+            this.code.line();
+            // This private method is injected so we can validate arguments before deferring to the base constructor, where
+            // the instance will be created in the kernel (where it'd fail on a sub-optimal error instead)...
+            this.code.line('[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]');
+            this.code.openBlock(`private static DeputyProps _MakeDeputyProps(${parametersDefinition})`);
+            this.emitUnionParameterValdation(initializer.parameters);
             const args = parametersBase.length > 0
                 ? `new object?[]{${parametersBase}}`
                 : `System.Array.Empty<object?>()`;
-            this.code.openBlock(`${visibility} ${className}(${parametersDefinition}): base(new DeputyProps(${args}))`);
+            this.code.line(`return new DeputyProps(${args});`);
             this.code.closeBlock();
             this.code.line();
         }
@@ -410,10 +431,108 @@ class DotNetGenerator extends generator_1.Generator {
         }
         else {
             this.code.openBlock(`${access} ${staticKeyWord}${overrideKeyWord}${virtualKeyWord}${signature}`);
+            this.emitUnionParameterValdation(method.parameters);
             this.code.line(this.dotnetRuntimeGenerator.createInvokeMethodIdentifier(method, cls));
             this.code.closeBlock();
         }
     }
+    /**
+     * Emits type checks for values passed for type union parameters.
+     *
+     * @param parameters the list of parameters received by the function.
+     * @param noMangle   use parameter names as-is (useful for setters, for example) instead of mangling them.
+     */
+    emitUnionParameterValdation(parameters, { noMangle = false } = {}) {
+        const unionParameters = parameters?.filter(({ type }) => containsUnionType(type));
+        if (unionParameters == null || unionParameters.length === 0) {
+            return;
+        }
+        this.code.openBlock('if (Amazon.JSII.Runtime.Configuration.RuntimeTypeChecking)');
+        for (const param of unionParameters) {
+            const name = noMangle
+                ? param.name
+                : this.nameutils.convertParameterName(param.name);
+            if (param.optional) {
+                this.code.openBlock(`if (${name} != null)`);
+            }
+            validate.call(this, name, noMangle ? name : `argument {nameof(${name})}`, param.type, noMangle ? name : `{nameof(${name})}`);
+            if (param.optional) {
+                this.code.closeBlock();
+            }
+        }
+        this.code.closeBlock();
+        function validate(value, descr, type, parameterName) {
+            if (spec.isUnionTypeReference(type)) {
+                validateTypeUnion.call(this, value, descr, type, parameterName);
+            }
+            else {
+                const collectionType = type;
+                if (collectionType.collection.kind === spec.CollectionKind.Array) {
+                    validateArray.call(this, value, descr, collectionType.collection.elementtype, parameterName);
+                }
+                else if (collectionType.collection.kind === spec.CollectionKind.Map) {
+                    validateMap.call(this, value, descr, collectionType.collection.elementtype, parameterName);
+                }
+                else {
+                    throw new Error(`Unhandled collection kind: ${spec.describeTypeReference(type)}`);
+                }
+            }
+        }
+        function validateArray(value, descr, elementType, parameterName) {
+            const varName = `__idx_${descr.replace(/[^a-z0-9_]/gi, '_')}`;
+            this.code.openBlock(`for (int ${varName} = 0 ; ${varName} < ${value}.Length ; ${varName}++)`);
+            validate.call(this, `${value}[${varName}]`, `${descr}[{${varName}}]`, elementType, parameterName);
+            this.code.closeBlock();
+        }
+        function validateMap(value, descr, elementType, parameterName) {
+            const varName = `__item_${descr.replace(/[^a-z0-9_]/gi, '_')}`;
+            this.code.openBlock(`foreach (var ${varName} in ${value})`);
+            validate.call(this, `${varName}.Value`, `${descr}[\\"{${varName}.Key}\\"]`, elementType, parameterName);
+            this.code.closeBlock();
+        }
+        function validateTypeUnion(value, descr, type, parameterName) {
+            this.code.indent('if (');
+            let emitAnd = false;
+            const typeRefs = type.union.types;
+            for (const typeRef of typeRefs) {
+                const prefix = emitAnd ? '&& ' : '';
+                const dotNetType = this.typeresolver.toDotNetType(typeRef);
+                // In the case of double, we test for all standard numeric types of .NET (these implicitly convert).
+                const test = dotNetType === 'double'
+                    ? [
+                        'byte',
+                        'decimal',
+                        'double',
+                        'float',
+                        'int',
+                        'long',
+                        'sbyte',
+                        'short',
+                        'uint',
+                        'ulong',
+                        'ushort',
+                    ]
+                        .map((numeric) => `${value} is ${numeric}`)
+                        .join(' || ')
+                    : `${value} is ${dotNetType}`;
+                this.code.line(`${prefix}!(${test})`);
+                emitAnd = true;
+            }
+            this.code.unindent(')');
+            this.code.openBlock('');
+            const placeholders = typeRefs
+                .map((typeRef) => {
+                const typeName = this.typeresolver.toDotNetTypeName(typeRef);
+                if (typeName.startsWith('"') && typeName.endsWith('"')) {
+                    return typeName.slice(1, -1);
+                }
+                return `{${typeName}}`;
+            })
+                .join(', ');
+            this.code.line(`throw new System.ArgumentException($"Expected ${descr} to be one of: ${placeholders}; received {${value}.GetType().FullName}", $"${parameterName}");`);
+            this.code.closeBlock();
+        }
+    }
     /**
      * Founds out if a member (property or method) is already defined in one of the base classes
      *
@@ -546,7 +665,8 @@ class DotNetGenerator extends generator_1.Generator {
                     : // An abstract class could extend a concrete class... We must walk up the inheritance tree in this case...
                         this.proxyMustUseNewModifier(base)));
         }
-        return (type.interfaces?.find((fqn) => this.findType(fqn).assembly === type.assembly) != null);
+        return (type.interfaces != null &&
+            type.interfaces.some((fqn) => this.findType(fqn).assembly === type.assembly));
     }
     /**
      * Emits an Interface Datatype class
@@ -670,6 +790,17 @@ class DotNetGenerator extends generator_1.Generator {
         const access = this.renderAccessLevel(prop);
         const staticKeyWord = prop.static ? 'static ' : '';
         const propName = this.nameutils.convertPropertyName(prop.name);
+        const propTypeFQN = this.typeresolver.toDotNetType(prop.type);
+        const isOptional = prop.optional ? '?' : '';
+        // We need to use a backing field so we can perform type checking if the property type is a union, and this is a struct.
+        const backingFieldName = spec.isInterfaceType(cls) && datatype && containsUnionType(prop.type)
+            ? // We down-case the first letter, private fields are conventionally named with a _ prefix, and a camelCase name.
+                `_${propName.replace(/[A-Z]/, (c) => c.toLowerCase())}`
+            : undefined;
+        if (backingFieldName != null) {
+            this.code.line(`private ${propTypeFQN}${isOptional} ${backingFieldName};`);
+            this.code.line();
+        }
         this.dotnetDocGenerator.emitDocs(prop, {
             api: 'member',
             fqn: definingType.fqn,
@@ -701,12 +832,13 @@ class DotNetGenerator extends generator_1.Generator {
                 isVirtualKeyWord = 'virtual ';
             }
         }
-        const propTypeFQN = this.typeresolver.toDotNetType(prop.type);
-        const isOptional = prop.optional ? '?' : '';
         const statement = `${access} ${isAbstractKeyword}${isVirtualKeyWord}${staticKeyWord}${isOverrideKeyWord}${propTypeFQN}${isOptional} ${propName}`;
         this.code.openBlock(statement);
         // Emit getters
-        if (datatype || prop.const || prop.abstract) {
+        if (backingFieldName != null) {
+            this.code.line(`get => ${backingFieldName};`);
+        }
+        else if (datatype || prop.const || prop.abstract) {
             this.code.line('get;');
         }
         else {
@@ -720,16 +852,34 @@ class DotNetGenerator extends generator_1.Generator {
             }
         }
         // Emit setters
-        if (datatype || (!prop.immutable && prop.abstract)) {
+        if (backingFieldName) {
+            this.code.openBlock('set');
+            this.emitUnionParameterValdation([
+                {
+                    name: 'value',
+                    type: prop.type,
+                    optional: prop.optional,
+                },
+            ], { noMangle: true });
+            this.code.line(`${backingFieldName} = value;`);
+            this.code.closeBlock();
+        }
+        else if (datatype || (!prop.immutable && prop.abstract)) {
             this.code.line('set;');
         }
         else {
             if (!prop.immutable) {
-                if (prop.static) {
-                    this.code.line(`set => SetStaticProperty(typeof(${className}), value);`);
+                const setCode = prop.static
+                    ? `SetStaticProperty(typeof(${className}), value);`
+                    : 'SetInstanceProperty(value);';
+                if (containsUnionType(prop.type)) {
+                    this.code.openBlock('set');
+                    this.emitUnionParameterValdation([{ name: 'value', optional: prop.optional, type: prop.type }], { noMangle: true });
+                    this.code.line(setCode);
+                    this.code.closeBlock();
                 }
                 else {
-                    this.code.line('set => SetInstanceProperty(value);');
+                    this.code.line(`set => ${setCode}`);
                 }
             }
         }
@@ -872,4 +1022,100 @@ class DotNetGenerator extends generator_1.Generator {
     }
 }
 exports.DotNetGenerator = DotNetGenerator;
+async function tryDownloadResource(urlText, into) {
+    const url = new URL(urlText);
+    let request;
+    switch (url.protocol) {
+        case 'http:':
+            request = http.get;
+            break;
+        case 'https:':
+            request = https.get;
+            break;
+        default:
+            // Unhandled protocol... ignoring
+            (0, logging_1.debug)(`Unsupported URL protocol for resource download: ${url.protocol} (full URL: ${urlText})`);
+            return undefined;
+    }
+    return new Promise((ok, ko) => request(url, (res) => {
+        switch (res.statusCode) {
+            case 200:
+                let fileName = path.basename(url.pathname);
+                // Ensure there is a content-appropriate extension on the result...
+                switch (res.headers['content-type']) {
+                    case 'image/gif':
+                        if (!fileName.endsWith('.gif')) {
+                            fileName = `${fileName}.gif`;
+                        }
+                        break;
+                    case 'image/jpeg':
+                        if (!fileName.endsWith('.jpg')) {
+                            fileName = `${fileName}.jpg`;
+                        }
+                        break;
+                    case 'image/png':
+                        if (!fileName.endsWith('.png')) {
+                            fileName = `${fileName}.png`;
+                        }
+                        break;
+                    default:
+                    // Nothing to do...
+                }
+                const filePath = path.join('resources', fileName);
+                try {
+                    fs.mkdirpSync(path.join(into, 'resources'));
+                }
+                catch (err) {
+                    return ko(err);
+                }
+                try {
+                    const fd = fs.openSync(path.join(into, filePath), fs.constants.O_CREAT |
+                        fs.constants.O_TRUNC |
+                        fs.constants.O_WRONLY);
+                    res
+                        .once('error', (cause) => {
+                        try {
+                            fs.closeSync(fd);
+                        }
+                        catch {
+                            // IGNORE
+                        }
+                        ko(cause);
+                    })
+                        .on('data', (chunk) => {
+                        const buff = Buffer.from(chunk);
+                        let offset = 0;
+                        while (offset < buff.length) {
+                            try {
+                                offset += fs.writeSync(fd, buff, offset);
+                            }
+                            catch (err) {
+                                return ko(err);
+                            }
+                        }
+                    })
+                        .once('close', () => {
+                        try {
+                            fs.closeSync(fd);
+                            ok(filePath);
+                        }
+                        catch (err) {
+                            ko(err);
+                        }
+                    });
+                }
+                catch (err) {
+                    return ko(err);
+                }
+                break;
+            default:
+                ko(new Error(`GET ${urlText} -- HTTP ${res.statusCode ?? 0} (${res.statusMessage ?? 'Unknown Error'})`));
+        }
+    }).once('error', ko));
+}
+function containsUnionType(typeRef) {
+    return (spec.isUnionTypeReference(typeRef) ||
+        (spec.isCollectionTypeReference(typeRef) &&
+            containsUnionType(typeRef.collection.elementtype)));
+}
 //# sourceMappingURL=dotnetgenerator.js.map

package/lib/targets/dotnet/dotnettyperesolver.d.ts

@@ -27,15 +27,27 @@ export declare class DotNetTypeResolver {
      * Translates any jsii type to its corresponding .NET type
      */
     toDotNetType(typeref: spec.TypeReference): string;
+    /**
+     * Translates any jsii type to the name of its corresponding .NET type (as a .NET string).
+     */
+    toDotNetTypeName(typeref: spec.TypeReference): string;
     resolveNamespace(assm: spec.AssemblyConfiguration, assmName: string, ns: string): string;
     /**
      * Translates a primitive in jsii to a native .NET primitive
      */
     private toDotNetPrimitive;
+    /**
+     * Translates a primitive in jsii to the name of a native .NET primitive
+     */
+    private toDotNetPrimitiveName;
     /**
      * Translates a collection in jsii to a native .NET collection
      */
     private toDotNetCollection;
+    /**
+     * Translates a collection in jsii to the name of a native .NET collection
+     */
+    private toDotNetCollectionName;
 }
 export {};
 //# sourceMappingURL=dotnettyperesolver.d.ts.map

package/lib/targets/dotnet/dotnettyperesolver.js

@@ -107,6 +107,24 @@ class DotNetTypeResolver {
         }
         throw new Error(`Invalid type reference: ${JSON.stringify(typeref)}`);
     }
+    /**
+     * Translates any jsii type to the name of its corresponding .NET type (as a .NET string).
+     */
+    toDotNetTypeName(typeref) {
+        if (spec.isPrimitiveTypeReference(typeref)) {
+            return this.toDotNetPrimitiveName(typeref.primitive);
+        }
+        else if (spec.isCollectionTypeReference(typeref)) {
+            return this.toDotNetCollectionName(typeref);
+        }
+        else if (spec.isNamedTypeReference(typeref)) {
+            return `typeof(${this.toNativeFqn(typeref.fqn)}).FullName`;
+        }
+        else if (typeref.union) {
+            return '"object"';
+        }
+        throw new Error(`Invalid type reference: ${JSON.stringify(typeref)}`);
+    }
     resolveNamespace(assm, assmName, ns) {
         let resolved = assm.targets?.dotnet?.namespace;
         if (!resolved) {
@@ -146,6 +164,27 @@ class DotNetTypeResolver {
                 throw new Error(`Unknown primitive type: ${primitive}`);
         }
     }
+    /**
+     * Translates a primitive in jsii to the name of a native .NET primitive
+     */
+    toDotNetPrimitiveName(primitive) {
+        switch (primitive) {
+            case spec.PrimitiveType.Boolean:
+                return '"bool"';
+            case spec.PrimitiveType.Date:
+                return 'typeof(System.DateTime).FullName';
+            case spec.PrimitiveType.Json:
+                return 'typeof(Newtonsoft.Json.Linq.JObject).FullName';
+            case spec.PrimitiveType.Number:
+                return '"double"';
+            case spec.PrimitiveType.String:
+                return '"string"';
+            case spec.PrimitiveType.Any:
+                return '"object"';
+            default:
+                throw new Error(`Unknown primitive type: ${primitive}`);
+        }
+    }
     /**
      * Translates a collection in jsii to a native .NET collection
      */
@@ -160,6 +199,21 @@ class DotNetTypeResolver {
                 throw new Error(`Unsupported collection kind: ${ref.collection.kind}`);
         }
     }
+    /**
+     * Translates a collection in jsii to the name of a native .NET collection
+     */
+    toDotNetCollectionName(ref) {
+        switch (ref.collection.kind) {
+            case spec.CollectionKind.Array:
+                const elementDotNetTypeName = this.toDotNetTypeName(ref.collection.elementtype);
+                return `$"{${elementDotNetTypeName}}[]"`;
+            case spec.CollectionKind.Map:
+                const elementDotNetType = this.toDotNetType(ref.collection.elementtype);
+                return `typeof(System.Collections.Generic.IDictionary<string, ${elementDotNetType}>).FullName`;
+            default:
+                throw new Error(`Unsupported collection kind: ${ref.collection.kind}`);
+        }
+    }
 }
 exports.DotNetTypeResolver = DotNetTypeResolver;
 //# sourceMappingURL=dotnettyperesolver.js.map

package/lib/targets/dotnet/filegenerator.d.ts

@@ -15,7 +15,7 @@ export declare class FileGenerator {
     private readonly assemblyInfoNamespaces;
     private readonly nameutils;
     constructor(assm: Assembly, tarballFileName: string, code: CodeMaker);
-    generateProjectFile(dependencies: Map<string, DotNetDependency>): void;
+    generateProjectFile(dependencies: Map<string, DotNetDependency>, iconFile?: string): void;
     generateAssemblyInfoFile(): void;
     private getDescription;
     private getDecoratedVersion;

package/lib/targets/dotnet/filegenerator.js

@@ -34,7 +34,7 @@ class FileGenerator {
         this.code = code;
     }
     // Generates the .csproj file
-    generateProjectFile(dependencies) {
+    generateProjectFile(dependencies, iconFile) {
         const assembly = this.assm;
         const packageId = assembly.targets.dotnet.packageId;
         const projectFilePath = path.join(packageId, `${packageId}.csproj`);
@@ -49,6 +49,19 @@ class FileGenerator {
         const dotnetInfo = assembly.targets.dotnet;
         propertyGroup.comment('Package Identification');
         propertyGroup.ele('Description', this.getDescription());
+        if (iconFile != null) {
+            propertyGroup.ele('PackageIcon', iconFile.split(/[/\\]+/).join('\\'));
+            // We also need to actually include the icon in the package
+            const noneNode = rootNode.ele('ItemGroup').ele('None');
+            noneNode.att('Include', iconFile.split(/[/\\]+/).join('\\'));
+            noneNode.att('Pack', 'true');
+            noneNode.att('PackagePath', `\\${path
+                .dirname(iconFile)
+                .split(/[/\\]+/)
+                .join('\\')}`);
+        }
+        // We continue to include the PackageIconUrl even if we put PackageIcon for backwards compatibility, as suggested
+        // by https://docs.microsoft.com/en-us/nuget/reference/msbuild-targets#packageicon
         if (dotnetInfo.iconUrl != null) {
             propertyGroup.ele('PackageIconUrl', dotnetInfo.iconUrl);
         }

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

@@ -1,6 +1,5 @@
 import { CodeMaker } from 'codemaker';
 import { Assembly, ModuleLike as JsiiModuleLike, Submodule as JsiiSubmodule } from 'jsii-reflect';
-import { SpecialDependencies } from './dependencies';
 import { EmitContext } from './emit-context';
 import { GoClass, GoType, GoInterface, GoTypeRef } from './types';
 export declare const GOMOD_FILENAME = "go.mod";
@@ -21,7 +20,6 @@ export declare abstract class Package {
     constructor(jsiiModule: JsiiModuleLike, packageName: string, filePath: string, moduleName: string, version: string, root?: Package);
     get dependencies(): Package[];
     get goModuleName(): string;
-    get dependencyImports(): Set<string>;
     findType(fqn: string): GoType | undefined;
     emit(context: EmitContext): void;
     emitSubmodules(context: EmitContext): void;
@@ -41,7 +39,6 @@ export declare abstract class Package {
      */
     resolveEmbeddedType(type: GoClass | GoInterface): EmbeddedType;
     protected emitHeader(code: CodeMaker): void;
-    protected get specialDependencies(): SpecialDependencies;
     /**
      * Emits a `func init() { ... }` in a dedicated file (so we don't have to
      * worry about what needs to be imported and whatnot). This function is

package/lib/targets/go/package.js

@@ -28,7 +28,7 @@ class Package {
         this.version = version;
         this.embeddedTypes = new Map();
         this.directory = filePath;
-        this.file = `${this.directory}/${packageName}.go`;
+        this.file = (0, path_1.join)(this.directory, `${packageName}.go`);
         this.root = root ?? this;
         this.submodules = this.jsiiModule.submodules.map((sm) => new InternalPackage(this.root, this, sm));
         this.types = this.jsiiModule.types.map((type) => {
@@ -68,12 +68,6 @@ class Package {
         const suffix = this.filePath !== '' ? `/${this.filePath}` : ``;
         return `${prefix}${rootPackageName}${versionSuffix}${suffix}`;
     }
-    /*
-     * The module names of this module's dependencies. Used for import statements.
-     */
-    get dependencyImports() {
-        return new Set(this.dependencies.map((pkg) => pkg.goModuleName));
-    }
     /*
      * Search for a type with a `fqn` within this. Searches all Children modules as well.
      */
@@ -81,12 +75,7 @@ class Package {
         return (0, util_1.findTypeInTree)(this, fqn);
     }
     emit(context) {
-        const { code } = context;
-        code.openFile(this.file);
-        this.emitHeader(code);
-        this.emitImports(code);
         this.emitTypes(context);
-        code.closeFile(this.file);
         this.readmeFile?.emit(context);
         this.emitGoInitFunction(context);
         this.emitSubmodules(context);
@@ -141,16 +130,6 @@ class Package {
         code.line(`package ${this.packageName}`);
         code.line();
     }
-    get specialDependencies() {
-        return this.types
-            .map((t) => t.specialDependencies)
-            .reduce((acc, elt) => ({
-            runtime: acc.runtime || elt.runtime,
-            init: acc.init || elt.init,
-            internal: acc.internal || elt.internal,
-            time: acc.time || elt.time,
-        }), { runtime: false, init: false, internal: false, time: false });
-    }
     /**
      * Emits a `func init() { ... }` in a dedicated file (so we don't have to
      * worry about what needs to be imported and whatnot). This function is
@@ -163,7 +142,7 @@ class Package {
         // form. It also saves us from "imported but unused" errors that would arise
         // as a consequence.
         if (this.types.length > 0) {
-            const initFile = (0, path_1.join)((0, path_1.dirname)(this.file), `${(0, path_1.basename)(this.file, '.go')}.init.go`);
+            const initFile = (0, path_1.join)(this.directory, `${this.packageName}.go`);
             code.openFile(initFile);
             code.line(`package ${this.packageName}`);
             code.line();
@@ -177,9 +156,9 @@ class Package {
             code.closeFile(initFile);
         }
     }
-    emitImports(code) {
+    emitImports(code, type) {
         const toImport = new Array();
-        const specialDeps = this.specialDependencies;
+        const specialDeps = type.specialDependencies;
         if (specialDeps.time) {
             toImport.push({ module: 'time' });
         }
@@ -197,10 +176,10 @@ class Package {
                 module: `${this.goModuleName}/${INTERNAL_PACKAGE_NAME}`,
             });
         }
-        for (const packageName of this.dependencyImports) {
+        for (const goModuleName of new Set(type.dependencies.map(({ goModuleName }) => goModuleName))) {
             // If the module is the same as the current one being written, don't emit an import statement
-            if (packageName !== this.packageName) {
-                toImport.push({ module: packageName });
+            if (goModuleName !== this.goModuleName) {
+                toImport.push({ module: goModuleName });
             }
         }
         importGoModules(code, toImport);
@@ -208,7 +187,12 @@ class Package {
     }
     emitTypes(context) {
         for (const type of this.types) {
+            const filePath = (0, path_1.join)(this.directory, `${this.packageName}_${type.name}.go`);
+            context.code.openFile(filePath);
+            this.emitHeader(context.code);
+            this.emitImports(context.code, type);
             type.emit(context);
+            context.code.closeFile(filePath);
         }
     }
     emitInternal(context) {

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

@@ -56,9 +56,12 @@ class GoTypeRef {
             if (ref.mapOfType) {
                 return containsDate(ref.mapOfType);
             }
-            if (ref.unionOfTypes) {
-                return ref.unionOfTypes.some(containsDate);
-            }
+            // NOTE: UNION gets represented as interface{} so we don't need to import
+            // individual types here...
+            //
+            // if (ref.unionOfTypes) {
+            //   return ref.unionOfTypes.some(containsDate);
+            // }
             return false;
         }
     }

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

@@ -8,9 +8,9 @@ import { GoType } from './go-type';
 import { GoMethod, GoProperty } from './type-member';
 export declare class GoInterface extends GoType<InterfaceType> {
     readonly methods: InterfaceMethod[];
-    readonly reimplementedMethods?: readonly InterfaceMethod[];
+    readonly reimplementedMethods: readonly InterfaceMethod[];
     readonly properties: InterfaceProperty[];
-    readonly reimplementedProperties?: readonly InterfaceProperty[];
+    readonly reimplementedProperties: readonly InterfaceProperty[];
     constructor(pkg: Package, type: InterfaceType);
     emit(context: EmitContext): void;
     emitRegistration(code: CodeMaker): void;

package/lib/targets/go/types/interface.js

@@ -34,6 +34,10 @@ class GoInterface extends go_type_1.GoType {
                 .map((property) => new InterfaceProperty(this, property))
                 .sort(comparators.byName);
         }
+        else {
+            this.reimplementedMethods = [];
+            this.reimplementedProperties = [];
+        }
     }
     emit(context) {
         this.emitDocs(context);
@@ -67,7 +71,7 @@ class GoInterface extends go_type_1.GoType {
         for (const method of this.methods) {
             method.emit(context);
         }
-        for (const method of this.reimplementedMethods ?? []) {
+        for (const method of this.reimplementedMethods) {
             method.emit(context);
         }
         for (const prop of this.properties) {
@@ -76,7 +80,7 @@ class GoInterface extends go_type_1.GoType {
                 prop.emitSetterProxy(context);
             }
         }
-        for (const prop of this.reimplementedProperties ?? []) {
+        for (const prop of this.reimplementedProperties) {
             prop.emitGetterProxy(context);
             if (!prop.immutable) {
                 prop.emitSetterProxy(context);
@@ -111,7 +115,9 @@ class GoInterface extends go_type_1.GoType {
     get specialDependencies() {
         return [
             ...this.properties.map((p) => p.specialDependencies),
+            ...this.reimplementedProperties.map((p) => p.specialDependencies),
             ...this.methods.map((m) => m.specialDependencies),
+            ...this.reimplementedMethods.map((m) => m.specialDependencies),
         ].reduce((acc, elt) => ({
             runtime: acc.runtime || elt.runtime,
             init: acc.init || elt.init,
@@ -143,8 +149,11 @@ class GoInterface extends go_type_1.GoType {
         return [
             ...this.extendsDependencies,
             ...(0, util_1.getMemberDependencies)(this.methods),
-            ...(0, util_1.getParamDependencies)(this.methods),
+            ...(0, util_1.getMemberDependencies)(this.reimplementedMethods),
             ...(0, util_1.getMemberDependencies)(this.properties),
+            ...(0, util_1.getMemberDependencies)(this.reimplementedProperties),
+            ...(0, util_1.getParamDependencies)(this.methods),
+            ...(0, util_1.getParamDependencies)(this.reimplementedMethods),
         ];
     }
 }

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

@@ -5,7 +5,7 @@ export declare function findTypeInTree(module: Package, fqn: string): GoType | u
 export declare function goPackageNameForAssembly(assembly: Assembly | Submodule): string;
 export declare function flatMap<T, R>(collection: readonly T[], mapper: (value: T) => readonly R[]): readonly R[];
 export declare function getMemberDependencies(members: readonly GoTypeMember[]): Package[];
-export declare function getParamDependencies(methods: GoMethod[]): Package[];
+export declare function getParamDependencies(methods: readonly GoMethod[]): Package[];
 export declare function substituteReservedWords(name: string): string;
 /**
  * Computes a safe tarball name for the provided assembly.

package/lib/targets/go/util.js

@@ -35,21 +35,11 @@ exports.flatMap = flatMap;
  * Return module dependencies of a class or interface members
  */
 function getMemberDependencies(members) {
-    const deps = new Array();
-    for (const member of members) {
-        deps.push(...(member.reference?.dependencies ?? []));
-    }
-    return deps;
+    return members.flatMap((member) => member.reference?.dependencies ?? []);
 }
 exports.getMemberDependencies = getMemberDependencies;
 function getParamDependencies(methods) {
-    const dependencies = [];
-    for (const method of methods) {
-        for (const param of method.parameters) {
-            dependencies.push(...(param.reference?.dependencies ?? []));
-        }
-    }
-    return dependencies;
+    return methods.flatMap(({ parameters }) => parameters.flatMap((param) => param.reference?.dependencies ?? []));
 }
 exports.getParamDependencies = getParamDependencies;
 const RESERVED_WORDS = {

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

@@ -295,7 +295,7 @@ class BasePythonClassType {
     }
 }
 class BaseMethod {
-    constructor(generator, pythonName, jsName, parameters, returns, docs, isStatic, pythonParent, opts) {
+    constructor(generator, pythonName, jsName, parameters, returns, docs, isStatic, opts) {
         this.generator = generator;
         this.pythonName = pythonName;
         this.jsName = jsName;
@@ -303,7 +303,6 @@ class BaseMethod {
         this.returns = returns;
         this.docs = docs;
         this.isStatic = isStatic;
-        this.pythonParent = pythonParent;
         this.classAsFirstParameter = false;
         this.returnFromJSIIMethod = true;
         this.shouldEmitBody = true;
@@ -420,7 +419,6 @@ class BaseMethod {
         }
         const decorators = new Array();
         if (this.jsName !== undefined) {
-            // "# type: ignore[misc]" needed because mypy does not know how to check decorated declarations
             decorators.push(`@jsii.member(jsii_name="${this.jsName}")`);
         }
         if (this.decorator !== undefined) {
@@ -430,22 +428,19 @@ class BaseMethod {
             decorators.push('@abc.abstractmethod');
         }
         if (decorators.length > 0) {
-            // "# type: ignore[misc]" needed because mypy does not know how to check decorated declarations
-            for (const decorator of decorators
-                .join(' # type: ignore[misc]\n')
-                .split('\n')) {
+            for (const decorator of decorators) {
                 code.line(decorator);
             }
         }
         pythonParams.unshift(slugifyAsNeeded(this.implicitParameter, pythonParams.map((param) => param.split(':')[0].trim())));
-        openSignature(code, 'def', this.pythonName, pythonParams, false, returnType);
+        openSignature(code, 'def', this.pythonName, pythonParams, returnType);
         this.generator.emitDocString(code, this.apiLocation, this.docs, {
             arguments: documentableArgs,
             documentableItem: `method-${this.pythonName}`,
         });
         if ((this.shouldEmitBody || forceEmitBody) &&
             (!renderAbstract || !this.abstract)) {
-            emitParameterTypeChecks(code, pythonParams.slice(1), `${this.pythonParent.pythonName}.${this.pythonName}`);
+            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();
@@ -546,13 +541,12 @@ class BaseMethod {
     }
 }
 class BaseProperty {
-    constructor(generator, pythonName, jsName, type, docs, pythonParent, opts) {
+    constructor(generator, pythonName, jsName, type, docs, 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;
@@ -569,13 +563,17 @@ class BaseProperty {
     emit(code, context, opts) {
         const { renderAbstract = true, forceEmitBody = false } = opts ?? {};
         const pythonType = (0, type_name_1.toTypeName)(this.type).pythonType(context);
-        // "# type: ignore[misc]" is needed because mypy cannot check decorated things
-        code.line(`@${this.decorator} # type: ignore[misc]`);
+        code.line(`@${this.decorator}`);
         code.line(`@jsii.member(jsii_name="${this.jsName}")`);
         if (renderAbstract && this.abstract) {
             code.line('@abc.abstractmethod');
         }
-        openSignature(code, 'def', this.pythonName, [this.implicitParameter], true, pythonType);
+        openSignature(code, 'def', this.pythonName, [this.implicitParameter], pythonType, 
+        // PyRight and MyPY both special-case @property, but not custom implementations such as our @classproperty...
+        // MyPY reports on the re-declaration, but PyRight reports on the initial declaration (duh!)
+        this.isStatic && !this.immutable
+            ? 'pyright: ignore [reportGeneralTypeIssues]'
+            : undefined);
         this.generator.emitDocString(code, this.apiLocation, this.docs, {
             documentableItem: `prop-${this.pythonName}`,
         });
@@ -590,18 +588,20 @@ class BaseProperty {
         code.closeBlock();
         if (!this.immutable) {
             code.line();
+            // PyRight and MyPY both special-case @property, but not custom implementations such as our @classproperty...
+            // MyPY reports on the re-declaration, but PyRight reports on the initial declaration (duh!)
             code.line(`@${this.pythonName}.setter${this.isStatic ? ' # type: ignore[no-redef]' : ''}`);
             if (renderAbstract && this.abstract) {
                 code.line('@abc.abstractmethod');
             }
-            openSignature(code, 'def', this.pythonName, [this.implicitParameter, `value: ${pythonType}`], false, 'None');
+            openSignature(code, 'def', this.pythonName, [this.implicitParameter, `value: ${pythonType}`], '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(${this.pythonParent.pythonName}, ${JSON.stringify(this.pythonName)}).fset`);
+                `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 {
@@ -734,20 +734,17 @@ class Struct extends BasePythonClassType {
         const constructorArguments = kwargs.length > 0
             ? [implicitParameter, '*', ...kwargs]
             : [implicitParameter];
-        openSignature(code, 'def', '__init__', constructorArguments, false, 'None');
+        openSignature(code, 'def', '__init__', constructorArguments, 'None');
         this.emitConstructorDocstring(code);
         // 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({
-                ...context,
-                typeAnnotation: false,
-            });
+            const typeName = (0, type_name_1.toPythonFullName)(member.type.type.fqn, context.assembly);
             code.openBlock(`if isinstance(${member.pythonName}, dict)`);
             code.line(`${member.pythonName} = ${typeName}(**${member.pythonName})`);
             code.closeBlock();
         }
-        emitParameterTypeChecks(code, kwargs, `${this.pythonName}.__init__`);
+        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)
@@ -774,7 +771,7 @@ class Struct extends BasePythonClassType {
     emitGetter(member, code, context) {
         const pythonType = member.typeAnnotation(context);
         code.line('@builtins.property');
-        openSignature(code, 'def', member.pythonName, ['self'], true, pythonType);
+        openSignature(code, 'def', member.pythonName, ['self'], pythonType);
         member.emitDocString(code);
         // NOTE: No parameter to validate here, this is a getter.
         code.line(`result = self._values.get(${JSON.stringify(member.pythonName)})`);
@@ -1485,6 +1482,12 @@ class Package {
             .reduce((buildTools, entry) => (entry ? [...buildTools, entry] : buildTools), new Array());
         code.line(`requires = [${buildTools.map((x) => `"${x}"`).join(', ')}]`);
         code.line('build-backend = "setuptools.build_meta"');
+        code.line();
+        code.line('[tool.pyright]');
+        code.line('defineConstant = { DEBUG = true }');
+        code.line('pythonVersion = "3.7"');
+        code.line('pythonPlatform = "All"');
+        code.line('reportSelfClsParameterName = false');
         code.closeFile('pyproject.toml');
         // We also need to write out a MANIFEST.in to ensure that all of our required
         // files are included.
@@ -1726,6 +1729,7 @@ class PythonGenerator extends generator_1.Generator {
             emittedTypes: new Set(),
             resolver,
             submodule: assm.name,
+            typeResolver: (fqn) => resolver.dereference(fqn),
         });
     }
     /**
@@ -1773,7 +1777,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
-            klass, { liftedProp: this.getliftedProp(cls.initializer), parent: cls }));
+            { liftedProp: this.getliftedProp(cls.initializer), parent: cls }));
         }
         this.addPythonType(klass);
     }
@@ -1781,7 +1785,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,
@@ -1789,7 +1793,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, {
+        klass.addMember(new StaticProperty(this, toPythonPropertyName(prop.name, prop.const), prop.name, prop, prop.docs, {
             abstract: prop.abstract,
             immutable: prop.immutable,
             isStatic: prop.static,
@@ -1800,14 +1804,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, {
+            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 {
-            klass.addMember(new Method(this, toPythonMethodName(method.name, method.protected), method.name, parameters, method.returns, method.docs, !!method.static, klass, {
+            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,
@@ -1816,7 +1820,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, {
+        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,
@@ -1842,7 +1846,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, klass, { 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, { liftedProp: this.getliftedProp(method), parent: ifc }));
     }
     onInterfaceProperty(ifc, prop) {
         let ifaceProperty;
@@ -1851,7 +1855,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, klass, { immutable: prop.immutable, isStatic: prop.static, parent: ifc });
+            ifaceProperty = new InterfaceProperty(this, toPythonPropertyName(prop.name, prop.const, prop.protected), prop.name, prop, prop.docs, { immutable: prop.immutable, isStatic: prop.static, parent: ifc });
         }
         klass.addMember(ifaceProperty);
     }
@@ -1973,7 +1977,7 @@ function slugifyAsNeeded(name, inUse) {
 //
 // @see https://black.readthedocs.io/en/stable/the_black_code_style.html
 const TARGET_LINE_LENGTH = 88;
-function openSignature(code, keyword, name, params, trailingComma = false, returnType) {
+function openSignature(code, keyword, name, params, returnType, lineComment) {
     const prefix = `${keyword} ${name}`;
     const suffix = returnType ? ` -> ${returnType}` : '';
     if (params.length === 0) {
@@ -1982,8 +1986,8 @@ function openSignature(code, keyword, name, params, trailingComma = false, retur
     }
     const join = ', ';
     const { elementsSize, joinSize } = totalSizeOf(params, join);
-    const hasComments = !params.some((param) => /# .+$/.exec(param));
-    if (hasComments &&
+    const hasComments = params.some((param) => /#\s*.+$/.exec(param) != null);
+    if (!hasComments &&
         TARGET_LINE_LENGTH >
             code.currentIndentLength +
                 prefix.length +
@@ -1991,25 +1995,15 @@ function openSignature(code, keyword, name, params, trailingComma = false, retur
                 joinSize +
                 suffix.length +
                 2) {
-        code.openBlock(`${prefix}(${params.join(join)})${suffix}`);
+        code.indent(`${prefix}(${params.join(join)})${suffix}:${lineComment ? `  # ${lineComment}` : ''}`);
         return;
     }
     code.indent(`${prefix}(`);
-    if (!hasComments &&
-        TARGET_LINE_LENGTH >
-            code.currentIndentLength +
-                elementsSize +
-                joinSize +
-                (trailingComma ? 1 : 0)) {
-        code.line(`${params.join(join)}${trailingComma ? ',' : ''}`);
-    }
-    else {
-        for (const param of params) {
-            code.line(param.replace(/(\s*# .+)?$/, ',$1'));
-        }
+    for (const param of params) {
+        code.line(param.replace(/(\s*# .+)?$/, ',$1'));
     }
     code.unindent(false);
-    code.openBlock(`)${suffix}`);
+    code.indent(`)${suffix}:${lineComment ? `  # ${lineComment}` : ''}`);
 }
 /**
  * Emits runtime type checking code for parameters.
@@ -2020,7 +2014,7 @@ function openSignature(code, keyword, name, params, trailingComma = false, retur
  */
 function emitParameterTypeChecks(code, params, typedEntity) {
     const paramInfo = params.map((param) => {
-        const [name] = param.split(/\s*[:=]\s*/, 1);
+        const [name] = param.split(/\s*[:=#]\s*/, 1);
         if (name === '*') {
             return { kwargsMark: true };
         }
@@ -2045,11 +2039,14 @@ function emitParameterTypeChecks(code, params, typedEntity) {
             openedBlock = true;
         }
         let expectedType = `${typesVar}[${JSON.stringify(name)}]`;
+        let comment = '';
         if (is_rest) {
             // This is a vararg, so the value will appear as a tuple.
             expectedType = `typing.Tuple[${expectedType}, ...]`;
+            // Need to ignore reportGeneralTypeIssues because pyright incorrectly parses that as a type annotation 😒
+            comment = ' # pyright: ignore [reportGeneralTypeIssues]';
         }
-        code.line(`check_type(argname=${JSON.stringify(`argument ${name}`)}, value=${name}, expected_type=${expectedType})`);
+        code.line(`check_type(argname=${JSON.stringify(`argument ${name}`)}, value=${name}, expected_type=${expectedType})${comment}`);
     }
     if (openedBlock) {
         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.63.0";
+export declare const VERSION = "1.64.0";
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-export declare const VERSION_DESC = "1.63.0 (build 7c24e36)";
+export declare const VERSION_DESC = "1.64.0 (build 4c1eae8)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,9 +1,9 @@
 "use strict";
-// Generated at 2022-07-26T16:29:28Z by generate.sh
+// Generated at 2022-08-12T17:08:11Z 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.63.0';
+exports.VERSION = '1.64.0';
 /** The qualified version number for this JSII compiler (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.63.0 (build 7c24e36)';
+exports.VERSION_DESC = '1.64.0 (build 4c1eae8)';
 //# sourceMappingURL=version.js.map

package/package.json

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