jsii-pacmak 1.65.0 → 1.67.0

package/generate.sh

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

package/lib/targets/dotnet/dotnetgenerator.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DotNetGenerator = void 0;
 const spec = require("@jsii/spec");
 const clone = require("clone");
-const crypto_1 = require("crypto");
 const fs = require("fs-extra");
 const http = require("http");
 const https = require("https");
+const reflect = require("jsii-reflect");
 const path = require("path");
 const generator_1 = require("../../generator");
 const logging_1 = require("../../logging");
@@ -15,6 +15,7 @@ const dotnetruntimegenerator_1 = require("./dotnetruntimegenerator");
 const dotnettyperesolver_1 = require("./dotnettyperesolver");
 const filegenerator_1 = require("./filegenerator");
 const nameutils_1 = require("./nameutils");
+const runtime_type_checking_1 = require("./runtime-type-checking");
 /**
  * CODE GENERATOR V2
  */
@@ -272,7 +273,8 @@ class DotNetGenerator extends generator_1.Generator {
             // 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);
+            this.emitUnionParameterValdation(this.reflectAssembly.findType(cls.fqn)
+                .initializer?.parameters);
             const args = parametersBase.length > 0
                 ? `new object?[]{${parametersBase}}`
                 : `System.Array.Empty<object?>()`;
@@ -432,7 +434,7 @@ class DotNetGenerator extends generator_1.Generator {
         }
         else {
             this.code.openBlock(`${access} ${staticKeyWord}${overrideKeyWord}${virtualKeyWord}${signature}`);
-            this.emitUnionParameterValdation(method.parameters);
+            this.emitUnionParameterValdation(this.reflectAssembly.findType(cls.fqn).allMethods.find((m) => m.name === method.name).parameters);
             this.code.line(this.dotnetRuntimeGenerator.createInvokeMethodIdentifier(method, cls));
             this.code.closeBlock();
         }
@@ -443,113 +445,18 @@ class DotNetGenerator extends generator_1.Generator {
      * @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 } = {}) {
+    emitUnionParameterValdation(parameters = [], opts = { noMangle: false }) {
         if (!this.runtimeTypeChecking) {
             // We were configured not to emit those, so bail out now.
             return;
         }
-        const unionParameters = parameters?.filter(({ type }) => containsUnionType(type));
-        if (unionParameters == null || unionParameters.length === 0) {
+        const validator = runtime_type_checking_1.ParameterValidator.forParameters(parameters, this.nameutils, opts);
+        if (validator == null) {
             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();
-            }
-        }
+        validator.emit(this.code, this.typeresolver);
         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_${(0, crypto_1.createHash)('sha256')
-                .update(descr)
-                .digest('hex')
-                .slice(0, 6)}`;
-            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_${(0, crypto_1.createHash)('sha256')
-                .update(descr)
-                .digest('hex')
-                .slice(0, 6)}`;
-            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;
-            }
-            if (typeRefs.some((ref) => spec.isNamedTypeReference(ref) &&
-                spec.isInterfaceType(this.findType(ref.fqn)))) {
-                // AnonymousObject will convert to any interface type, even if unsafely. It is the opaque
-                // type returned when a non-intrinsically typed value is passed through an any or union
-                // return point. We basically cannot type-check that at runtime in a complete way.
-                this.code.line(`&& !(${value} is Amazon.JSII.Runtime.Deputy.AnonymousObject)`);
-            }
-            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
@@ -870,15 +777,15 @@ class DotNetGenerator extends generator_1.Generator {
             }
         }
         // Emit setters
+        const reflectCls = this.reflectAssembly.findType(cls.fqn);
+        const syntheticParam = new reflect.Parameter(reflectCls.system, reflectCls, new reflect.Method(reflectCls.system, reflectCls.assembly, reflectCls, reflectCls, { name: '<synthetic>' }), {
+            name: 'value',
+            type: prop.type,
+            optional: prop.optional,
+        });
         if (backingFieldName) {
             this.code.openBlock('set');
-            this.emitUnionParameterValdation([
-                {
-                    name: 'value',
-                    type: prop.type,
-                    optional: prop.optional,
-                },
-            ], { noMangle: true });
+            this.emitUnionParameterValdation([syntheticParam], { noMangle: true });
             this.code.line(`${backingFieldName} = value;`);
             this.code.closeBlock();
         }
@@ -892,7 +799,9 @@ class DotNetGenerator extends generator_1.Generator {
                     : 'SetInstanceProperty(value);';
                 if (containsUnionType(prop.type)) {
                     this.code.openBlock('set');
-                    this.emitUnionParameterValdation([{ name: 'value', optional: prop.optional, type: prop.type }], { noMangle: true });
+                    this.emitUnionParameterValdation([syntheticParam], {
+                        noMangle: true,
+                    });
                     this.code.line(setCode);
                     this.code.closeBlock();
                 }

package/lib/targets/dotnet/dotnettyperesolver.js

@@ -203,13 +203,14 @@ class DotNetTypeResolver {
      * Translates a collection in jsii to the name of a native .NET collection
      */
     toDotNetCollectionName(ref) {
+        const [_, dollar, quote, content] = /^(?:(\$)?("))?([^"]+)"?$/.exec(this.toDotNetTypeName(ref.collection.elementtype));
+        const interpolates = dollar || !quote ? '$' : '';
+        const elementTypeName = quote ? content : `{${content}}`;
         switch (ref.collection.kind) {
             case spec.CollectionKind.Array:
-                const elementDotNetTypeName = this.toDotNetTypeName(ref.collection.elementtype);
-                return `$"{${elementDotNetTypeName}}[]"`;
+                return `${interpolates}"${elementTypeName}[]"`;
             case spec.CollectionKind.Map:
-                const elementDotNetType = this.toDotNetType(ref.collection.elementtype);
-                return `typeof(System.Collections.Generic.IDictionary<string, ${elementDotNetType}>).FullName`;
+                return `${interpolates}"System.Collections.Generic.IDictionary<string, ${elementTypeName}>"`;
             default:
                 throw new Error(`Unsupported collection kind: ${ref.collection.kind}`);
         }

package/lib/targets/dotnet/runtime-type-checking.d.ts

@@ -0,0 +1,13 @@
+import { CodeMaker } from 'codemaker';
+import { Parameter } from 'jsii-reflect';
+import { DotNetTypeResolver } from './dotnettyperesolver';
+import { DotNetNameUtils } from './nameutils';
+export declare class ParameterValidator {
+    private readonly validations;
+    static forParameters(parameters: readonly Parameter[], nameUtils: DotNetNameUtils, { noMangle }: {
+        readonly noMangle: boolean;
+    }): ParameterValidator | undefined;
+    private constructor();
+    emit(code: CodeMaker, resolver: DotNetTypeResolver): void;
+}
+//# sourceMappingURL=runtime-type-checking.d.ts.map

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterValidator = void 0;
+const spec_1 = require("@jsii/spec");
+const crypto_1 = require("crypto");
+const jsii_reflect_1 = require("jsii-reflect");
+class ParameterValidator {
+    constructor(validations) {
+        this.validations = validations;
+    }
+    static forParameters(parameters, nameUtils, { noMangle }) {
+        if (parameters.length === 0) {
+            return undefined;
+        }
+        const parameterValidations = new Map();
+        for (const param of parameters) {
+            const expr = noMangle
+                ? param.name
+                : nameUtils.convertParameterName(param.name);
+            const argName = `nameof(${expr})`;
+            const validations = new Array();
+            const validation = Validation.forTypeReference(argName, expr, `${noMangle ? '' : 'argument '}{${argName}}`, param.variadic
+                ? new jsii_reflect_1.TypeReference(param.system, {
+                    collection: {
+                        kind: spec_1.CollectionKind.Array,
+                        elementtype: param.type.spec,
+                    },
+                })
+                : param.type, param.optional);
+            if (validation) {
+                validations.push(validation);
+            }
+            if (validations.length !== 0) {
+                parameterValidations.set(param, validations);
+            }
+        }
+        if (parameterValidations.size === 0) {
+            return undefined;
+        }
+        return new ParameterValidator(parameterValidations);
+    }
+    emit(code, resolver) {
+        for (const [_parameter, validations] of this.validations) {
+            for (const validation of validations) {
+                validation.emit(code, resolver);
+            }
+        }
+    }
+}
+exports.ParameterValidator = ParameterValidator;
+class Validation {
+    static forTypeReference(argument, expression, description, ref, allowNull) {
+        if (ref.unionOfTypes) {
+            return Validation.unionCheck(argument, expression, description, ref.unionOfTypes, allowNull);
+        }
+        else if (ref.arrayOfType) {
+            return Validation.collectionCheck(argument, expression, description, 'array', ref.arrayOfType);
+        }
+        else if (ref.mapOfType) {
+            return Validation.collectionCheck(argument, expression, description, 'map', ref.mapOfType);
+        }
+        return undefined;
+    }
+    static collectionCheck(argument, expression, description, type, elementType) {
+        const elementValidator = Validation.forTypeReference(argument, `${expression}[idx]`, `${description}[@{idx}]`, elementType, false);
+        if (elementValidator == null) {
+            return undefined;
+        }
+        class CollectionCheck extends Validation {
+            emit(code, resolver) {
+                // We need to come up with a unique-enough ID here... so we use a hash.
+                const prefix = type === 'array' ? '__idx' : '__item';
+                const varName = `${prefix}_${(0, crypto_1.createHash)('sha256')
+                    .update(expression)
+                    .digest('hex')
+                    .slice(0, 6)}`;
+                if (type === 'array') {
+                    code.openBlock(`for (var ${varName} = 0 ; ${varName} < ${expression}.Length ; ${varName}++)`);
+                }
+                else {
+                    code.openBlock(`foreach (var ${varName} in ${expression})`);
+                }
+                Validation.forTypeReference(argument, type === 'array' ? `${expression}[${varName}]` : `${varName}.Value`, `${description}[${type === 'array' ? `{${varName}}` : `"{${varName}.Key}"`}]`, elementType, false).emit(code, resolver);
+                code.closeBlock();
+            }
+        }
+        return new CollectionCheck();
+    }
+    static unionCheck(argument, expression, description, types, allowNull) {
+        const hasInterface = types.some((t) => t.type?.isInterfaceType());
+        class UnionCheck extends Validation {
+            emit(code, resolver) {
+                const validTypes = new Array();
+                const castVarName = `cast_${(0, crypto_1.createHash)('sha256')
+                    .update(expression)
+                    .digest('hex')
+                    .slice(0, 6)}`;
+                code.openBlock(`switch (${expression})`);
+                for (const type of types) {
+                    validTypes.push(resolver.toDotNetTypeName(type.spec));
+                    const typeNames = [resolver.toDotNetType(type.spec)];
+                    if (typeNames[0] === 'double') {
+                        // For doubles, we accept any numeric value, really...
+                        typeNames.push('byte', 'decimal', 'float', 'int', 'long', 'sbyte', 'short', 'uint', 'ulong', 'ushort');
+                    }
+                    for (const typeName of typeNames) {
+                        code.indent(`case ${typeName} ${castVarName}:`);
+                        Validation.forTypeReference(argument, castVarName, description, type, allowNull)?.emit(code, resolver);
+                        code.line('break;');
+                        code.unindent(false);
+                    }
+                }
+                if (hasInterface) {
+                    code.indent(`case Amazon.JSII.Runtime.Deputy.AnonymousObject ${castVarName}:`);
+                    code.line('// Not enough information to type-check...');
+                    code.line('break;');
+                    code.unindent(false);
+                }
+                code.indent('case null:');
+                const acceptedTypes = validTypes
+                    .map((t) => t.startsWith('"')
+                    ? t.slice(1, t.length - 1)
+                    : t.startsWith('$"')
+                        ? t.slice(2, t.length - 1)
+                        : `{${t}}`)
+                    .join(', ');
+                if (allowNull) {
+                    code.line('break;');
+                }
+                else {
+                    const message = JSON.stringify(`Expected ${description} to be one of: ${acceptedTypes}; received null`);
+                    code.line(`throw new System.ArgumentException($${message}, ${argument});`);
+                }
+                code.unindent(false);
+                code.indent('default:');
+                const message = JSON.stringify(`Expected ${description} to be one of: ${acceptedTypes}; received {${expression}.GetType().FullName}`);
+                code.line(`throw new System.ArgumentException($${message}, ${argument});`);
+                code.unindent(false);
+                code.closeBlock();
+            }
+        }
+        return new UnionCheck();
+    }
+    constructor() { }
+}
+//# sourceMappingURL=runtime-type-checking.js.map

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

@@ -1,8 +1,11 @@
+import { Package } from './package';
 /**
  * Information about a module's dependency on "special" packages (either part of
  * the go standard library, or generated as part of the current module).
  */
 export interface SpecialDependencies {
+    /** Whether the go standard library for string formatting is needed */
+    readonly fmt: boolean;
     /** Whether the jsii runtime library for go is needed */
     readonly runtime: boolean;
     /** Whether the package's initialization hook is needed */
@@ -12,4 +15,17 @@ export interface SpecialDependencies {
     /** Whether go's standard library "time" module is needed */
     readonly time: boolean;
 }
+export declare function reduceSpecialDependencies(...specialDepsList: readonly SpecialDependencies[]): SpecialDependencies;
+export interface ImportedModule {
+    readonly alias?: string;
+    readonly module: string;
+}
+export declare function toImportedModules(specialDeps: SpecialDependencies, context: Package): readonly ImportedModule[];
+/**
+ * The name of a sub-package that includes internal type aliases it has to be
+ * "internal" so it not published.
+ */
+export declare const INTERNAL_PACKAGE_NAME = "internal";
+export declare const JSII_RT_MODULE: ImportedModule;
+export declare const GO_REFLECT: ImportedModule;
 //# sourceMappingURL=dependencies.d.ts.map

package/lib/targets/go/dependencies.js

@@ -1,3 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GO_REFLECT = exports.JSII_RT_MODULE = exports.INTERNAL_PACKAGE_NAME = exports.toImportedModules = exports.reduceSpecialDependencies = void 0;
+const assert = require("assert");
+const runtime_1 = require("./runtime");
+function reduceSpecialDependencies(...specialDepsList) {
+    const [first, ...rest] = specialDepsList;
+    if (!first) {
+        assert(rest.length === 0);
+        return {
+            fmt: false,
+            init: false,
+            internal: false,
+            runtime: false,
+            time: false,
+        };
+    }
+    return rest.reduce((acc, elt) => ({
+        fmt: acc.fmt || elt.fmt,
+        init: acc.init || elt.init,
+        internal: acc.internal || elt.internal,
+        runtime: acc.runtime || elt.runtime,
+        time: acc.time || elt.time,
+    }), first);
+}
+exports.reduceSpecialDependencies = reduceSpecialDependencies;
+function toImportedModules(specialDeps, context) {
+    const result = new Array();
+    if (specialDeps.fmt) {
+        result.push({ module: 'fmt' });
+    }
+    if (specialDeps.time) {
+        result.push({ module: 'time' });
+    }
+    if (specialDeps.runtime) {
+        result.push(exports.JSII_RT_MODULE);
+    }
+    if (specialDeps.init) {
+        result.push({
+            alias: runtime_1.JSII_INIT_ALIAS,
+            module: `${context.root.goModuleName}/${runtime_1.JSII_INIT_PACKAGE}`,
+        });
+    }
+    if (specialDeps.internal) {
+        result.push({
+            module: `${context.goModuleName}/${exports.INTERNAL_PACKAGE_NAME}`,
+        });
+    }
+    return result;
+}
+exports.toImportedModules = toImportedModules;
+/**
+ * The name of a sub-package that includes internal type aliases it has to be
+ * "internal" so it not published.
+ */
+exports.INTERNAL_PACKAGE_NAME = 'internal';
+exports.JSII_RT_MODULE = {
+    alias: runtime_1.JSII_RT_ALIAS,
+    module: runtime_1.JSII_RT_PACKAGE_NAME,
+};
+exports.GO_REFLECT = { module: 'reflect' };
 //# sourceMappingURL=dependencies.js.map

package/lib/targets/go/emit-context.d.ts

@@ -8,5 +8,7 @@ export interface EmitContext {
     readonly code: CodeMaker;
     /** A Documentation generator. Includes Rosetta stone to translate code examples. */
     readonly documenter: Documentation;
+    /** Whether runtime type checking code should be emitted */
+    readonly runtimeTypeChecking: boolean;
 }
 //# sourceMappingURL=emit-context.d.ts.map

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

@@ -48,6 +48,7 @@ export declare abstract class Package {
     private emitGoInitFunction;
     private emitImports;
     private emitTypes;
+    private emitValidators;
     private emitInternal;
 }
 export declare class RootPackage extends Package {

package/lib/targets/go/package.js

@@ -4,6 +4,7 @@ exports.InternalPackage = exports.RootPackage = exports.Package = exports.GO_VER
 const path_1 = require("path");
 const semver = require("semver");
 const version_1 = require("../../version");
+const dependencies_1 = require("./dependencies");
 const readme_file_1 = require("./readme-file");
 const runtime_1 = require("./runtime");
 const types_1 = require("./types");
@@ -11,9 +12,6 @@ const util_1 = require("./util");
 const version_file_1 = require("./version-file");
 exports.GOMOD_FILENAME = 'go.mod';
 exports.GO_VERSION = '1.16';
-// the name of a sub-package that includes internal type aliases it has to be
-// "internal" so it not published.
-const INTERNAL_PACKAGE_NAME = 'internal';
 /*
  * Package represents a single `.go` source file within a package. This can be the root package file or a submodule
  */
@@ -121,7 +119,7 @@ class Package {
             foriegnTypeName: original,
             foriegnType: typeref,
             fieldName: aliasName,
-            embed: `${INTERNAL_PACKAGE_NAME}.${aliasName}`,
+            embed: `${dependencies_1.INTERNAL_PACKAGE_NAME}.${aliasName}`,
         };
         this.embeddedTypes.set(type.fqn, embeddedType);
         return embeddedType;
@@ -136,21 +134,22 @@ class Package {
      * responsible for correctly initializing the module, including registering
      * the declared types with the jsii runtime for go.
      */
-    emitGoInitFunction({ code }) {
+    emitGoInitFunction(context) {
         // We don't emit anything if there are not types in this (sub)module. This
         // avoids registering an `init` function that does nothing, which is poor
         // form. It also saves us from "imported but unused" errors that would arise
         // as a consequence.
         if (this.types.length > 0) {
+            const { code } = context;
             const initFile = (0, path_1.join)(this.directory, `${this.packageName}.go`);
             code.openFile(initFile);
             code.line(`package ${this.packageName}`);
             code.line();
-            importGoModules(code, [GO_REFLECT, JSII_RT_MODULE]);
+            importGoModules(code, [dependencies_1.GO_REFLECT, dependencies_1.JSII_RT_MODULE]);
             code.line();
             code.openBlock('func init()');
             for (const type of this.types) {
-                type.emitRegistration(code);
+                type.emitRegistration(context);
             }
             code.closeBlock();
             code.closeFile(initFile);
@@ -158,24 +157,7 @@ class Package {
     }
     emitImports(code, type) {
         const toImport = new Array();
-        const specialDeps = type.specialDependencies;
-        if (specialDeps.time) {
-            toImport.push({ module: 'time' });
-        }
-        if (specialDeps.runtime) {
-            toImport.push(JSII_RT_MODULE);
-        }
-        if (specialDeps.init) {
-            toImport.push({
-                alias: runtime_1.JSII_INIT_ALIAS,
-                module: `${this.root.goModuleName}/${runtime_1.JSII_INIT_PACKAGE}`,
-            });
-        }
-        if (specialDeps.internal) {
-            toImport.push({
-                module: `${this.goModuleName}/${INTERNAL_PACKAGE_NAME}`,
-            });
-        }
+        toImport.push(...(0, dependencies_1.toImportedModules)(type.specialDependencies, this));
         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 (goModuleName !== this.goModuleName) {
@@ -193,6 +175,50 @@ class Package {
             this.emitImports(context.code, type);
             type.emit(context);
             context.code.closeFile(filePath);
+            this.emitValidators(context, type);
+        }
+    }
+    emitValidators({ code, runtimeTypeChecking }, type) {
+        if (!runtimeTypeChecking) {
+            return;
+        }
+        if (type.parameterValidators.length === 0 && type.structValidator == null) {
+            return;
+        }
+        emit.call(this, (0, path_1.join)(this.directory, `${this.packageName}_${type.name}__runtime_type_checks.go`), false);
+        emit.call(this, (0, path_1.join)(this.directory, `${this.packageName}_${type.name}__no_runtime_type_checking.go`), true);
+        function emit(filePath, forNoOp) {
+            code.openFile(filePath);
+            // Conditional compilation tag...
+            code.line(`//go:build ${forNoOp ? '' : '!'}no_runtime_type_checking`);
+            // For go1.16 compatibility
+            code.line(`// +build ${forNoOp ? '' : '!'}no_runtime_type_checking`);
+            code.line();
+            this.emitHeader(code);
+            if (!forNoOp) {
+                const specialDependencies = (0, dependencies_1.reduceSpecialDependencies)(...type.parameterValidators.map((v) => v.specialDependencies), ...(type.structValidator
+                    ? [type.structValidator.specialDependencies]
+                    : []));
+                importGoModules(code, [
+                    ...(0, dependencies_1.toImportedModules)(specialDependencies, this),
+                    ...Array.from(new Set([
+                        ...(type.structValidator?.dependencies ?? []),
+                        ...type.parameterValidators.flatMap((v) => v.dependencies),
+                    ].map((mod) => mod.goModuleName)))
+                        .filter((mod) => mod !== this.goModuleName)
+                        .map((mod) => ({ module: mod })),
+                ]);
+                code.line();
+            }
+            else {
+                code.line('// Building without runtime type checking enabled, so all the below just return nil');
+                code.line();
+            }
+            type.structValidator?.emitImplementation(code, this, forNoOp);
+            for (const validator of type.parameterValidators) {
+                validator.emitImplementation(code, this, forNoOp);
+            }
+            code.closeFile(filePath);
         }
     }
     emitInternal(context) {
@@ -200,9 +226,9 @@ class Package {
             return;
         }
         const code = context.code;
-        const fileName = (0, path_1.join)(this.directory, INTERNAL_PACKAGE_NAME, 'types.go');
+        const fileName = (0, path_1.join)(this.directory, dependencies_1.INTERNAL_PACKAGE_NAME, 'types.go');
         code.openFile(fileName);
-        code.line(`package ${INTERNAL_PACKAGE_NAME}`);
+        code.line(`package ${dependencies_1.INTERNAL_PACKAGE_NAME}`);
         const imports = new Set();
         for (const alias of this.embeddedTypes.values()) {
             if (!alias.foriegnType) {
@@ -321,7 +347,7 @@ class RootPackage extends Package {
         code.line(`package ${runtime_1.JSII_INIT_PACKAGE}`);
         code.line();
         const toImport = [
-            JSII_RT_MODULE,
+            dependencies_1.JSII_RT_MODULE,
             { module: 'embed', alias: '_' },
         ];
         if (dependencies.length > 0) {
@@ -391,11 +417,6 @@ function determineMajorVersionSuffix(version) {
     }
     return `/v${sv.major}`;
 }
-const JSII_RT_MODULE = {
-    alias: runtime_1.JSII_RT_ALIAS,
-    module: runtime_1.JSII_RT_PACKAGE_NAME,
-};
-const GO_REFLECT = { module: 'reflect' };
 function importGoModules(code, modules) {
     if (modules.length === 0) {
         return;

package/lib/targets/go/runtime/class-constructor.d.ts

@@ -1,9 +1,10 @@
 import { CodeMaker } from 'codemaker';
+import { EmitContext } from '../emit-context';
 import { GoClassConstructor } from '../types';
 export declare class ClassConstructor {
     readonly parent: GoClassConstructor;
     constructor(parent: GoClassConstructor);
-    emit(code: CodeMaker): void;
+    emit({ code, runtimeTypeChecking }: EmitContext): void;
     emitOverride(code: CodeMaker, instanceVar: string): void;
 }
 //# sourceMappingURL=class-constructor.d.ts.map