jsii-pacmak 1.64.0 → 1.66.0

package/bin/jsii-pacmak.js

@@ -36,6 +36,15 @@ const version_1 = require("../lib/version");
         type: 'boolean',
         desc: 'generate code only (instead of building and packaging)',
         default: false,
+    })
+        .option('runtime-type-checking', {
+        type: 'boolean',
+        desc: [
+            'generate runtime type checking code where compile-time type checking is not possible.',
+            'Disabling this will generate less code, but will produce less helpful error messages when',
+            'developers pass invalid values to the generated bindings.',
+        ].join(' '),
+        default: true,
     })
         .option('fingerprint', {
         type: 'boolean',
@@ -154,6 +163,7 @@ const version_1 = require("../lib/version");
         recurse: argv.recurse,
         rosettaUnknownSnippets,
         rosettaTablet: argv['rosetta-tablet'],
+        runtimeTypeChecking: argv['runtime-type-checking'],
         targets: argv.targets?.map((target) => target),
         updateNpmIgnoreFiles: argv.npmignore,
         validateAssemblies: argv['validate-assemblies'],

package/lib/builder.d.ts

@@ -8,34 +8,39 @@ export interface BuildOptions {
      * Whether to fingerprint the produced artifacts.
      * @default true
      */
-    fingerprint?: boolean;
+    readonly fingerprint?: boolean;
     /**
      * Whether artifacts should be re-build even if their fingerprints look up-to-date.
      * @default false
      */
-    force?: boolean;
+    readonly force?: boolean;
     /**
      * Arguments provided by the user (how they are used is target-dependent)
      */
-    arguments: {
+    readonly arguments: {
         readonly [name: string]: any;
     };
     /**
      * Only generate code, don't build
      */
-    codeOnly?: boolean;
+    readonly codeOnly?: boolean;
     /**
      * Whether or not to clean
      */
-    clean?: boolean;
+    readonly clean?: boolean;
     /**
      * Whether to add an additional subdirectory for the target language
      */
-    languageSubdirectory?: boolean;
+    readonly languageSubdirectory?: boolean;
     /**
      * The Rosetta instance to load examples from
      */
-    rosetta: Rosetta;
+    readonly rosetta: Rosetta;
+    /**
+     * Whether to generate runtime type checking code in places where compile-time
+     * type checking is not possible.
+     */
+    readonly runtimeTypeChecking: boolean;
 }
 /**
  * Interface for classes that can build language targets

package/lib/builder.js

@@ -63,13 +63,14 @@ class IndependentPackageBuilder {
     }
     makeTarget(module, options) {
         return new this.targetConstructor({
-            targetName: this.targetName,
-            packageDir: module.moduleDirectory,
+            arguments: options.arguments,
             assembly: module.assembly,
             fingerprint: options.fingerprint,
             force: options.force,
-            arguments: options.arguments,
+            packageDir: module.moduleDirectory,
             rosetta: options.rosetta,
+            runtimeTypeChecking: options.runtimeTypeChecking,
+            targetName: this.targetName,
         });
     }
     finalOutputDir(module, options) {

package/lib/generator.d.ts

@@ -20,6 +20,11 @@ export interface GeneratorOptions {
      * If this property is set, the generator will add "Base" to abstract class names
      */
     addBasePostfixToAbstractClassNames?: boolean;
+    /**
+     * If this property is set, the generator will add runtime type checking code in places
+     * where compile-time type checking is not possible.
+     */
+    runtimeTypeChecking: boolean;
 }
 export interface IGenerator {
     /**
@@ -72,7 +77,8 @@ export declare abstract class Generator implements IGenerator {
     private _assembly?;
     protected _reflectAssembly?: reflect.Assembly;
     private fingerprint?;
-    constructor(options?: GeneratorOptions);
+    constructor(options: GeneratorOptions);
+    protected get runtimeTypeChecking(): boolean;
     protected get assembly(): spec.Assembly;
     get reflectAssembly(): reflect.Assembly;
     get metadata(): {

package/lib/generator.js

@@ -13,11 +13,14 @@ const version_1 = require("./version");
  * Given a jsii module, it will invoke "events" to emit various elements.
  */
 class Generator {
-    constructor(options = {}) {
+    constructor(options) {
         this.options = options;
         this.excludeTypes = new Array();
         this.code = new codemaker_1.CodeMaker();
     }
+    get runtimeTypeChecking() {
+        return this.options.runtimeTypeChecking;
+    }
     get assembly() {
         if (!this._assembly) {
             throw new Error('No assembly has been loaded! The #load() method must be called first!');

package/lib/index.d.ts

@@ -6,7 +6,7 @@ export { configure as configureLogging } from './logging';
 /**
  * Generates code in the desired targets.
  */
-export declare function pacmak({ argv, clean, codeOnly, fingerprint, force, forceSubdirectory, forceTarget, inputDirectories, outputDirectory, parallel, recurse, rosettaTablet, targets, timers, rosettaUnknownSnippets, updateNpmIgnoreFiles, validateAssemblies, }: PacmakOptions): Promise<void>;
+export declare function pacmak({ argv, clean, codeOnly, fingerprint, force, forceSubdirectory, forceTarget, inputDirectories, outputDirectory, parallel, recurse, rosettaTablet, rosettaUnknownSnippets, runtimeTypeChecking, targets, timers, updateNpmIgnoreFiles, validateAssemblies, }: PacmakOptions): Promise<void>;
 /**
  * Options provided to the `pacmak` function.
  */
@@ -93,6 +93,12 @@ export interface PacmakOptions {
      * @default undefined
      */
     readonly rosettaTablet?: string;
+    /**
+     * Whether to inject runtime type checks in places where compile-time type checking is not performed.
+     *
+     * @default true
+     */
+    readonly runtimeTypeChecking?: boolean;
     /**
      * The list of targets for which code should be generated. Unless `forceTarget` is `true`, a given target will only
      * be generated for assemblies that have configured it.

package/lib/index.js

@@ -16,7 +16,7 @@ Object.defineProperty(exports, "configureLogging", { enumerable: true, get: func
 /**
  * Generates code in the desired targets.
  */
-async function pacmak({ argv = {}, clean = true, codeOnly = false, fingerprint = true, force = false, forceSubdirectory = true, forceTarget = false, inputDirectories, outputDirectory, parallel = true, recurse = false, rosettaTablet, targets = Object.values(targets_1.TargetName), timers = new timer_1.Timers(), rosettaUnknownSnippets = undefined, updateNpmIgnoreFiles = false, validateAssemblies = false, }) {
+async function pacmak({ argv = {}, clean = true, codeOnly = false, fingerprint = true, force = false, forceSubdirectory = true, forceTarget = false, inputDirectories, outputDirectory, parallel = true, recurse = false, rosettaTablet, rosettaUnknownSnippets = undefined, runtimeTypeChecking = true, targets = Object.values(targets_1.TargetName), timers = new timer_1.Timers(), updateNpmIgnoreFiles = false, validateAssemblies = false, }) {
     const rosetta = new jsii_rosetta_1.Rosetta({
         unknownSnippets: rosettaUnknownSnippets,
         prefixDisclaimer: true,
@@ -74,6 +74,7 @@ async function pacmak({ argv = {}, clean = true, codeOnly = false, fingerprint =
                 force,
                 perLanguageDirectory,
                 rosetta,
+                runtimeTypeChecking,
             }))
                 .then(() => logging.info(`${targetSet.targetType} finished`), (err) => {
                 logging.warn(`${targetSet.targetType} failed`);
@@ -95,20 +96,21 @@ async function pacmak({ argv = {}, clean = true, codeOnly = false, fingerprint =
 exports.pacmak = pacmak;
 //#endregion
 //#region Building
-async function buildTargetsForLanguage(targetLanguage, modules, { argv, clean, codeOnly, fingerprint, force, perLanguageDirectory, rosetta, }) {
+async function buildTargetsForLanguage(targetLanguage, modules, { argv, clean, codeOnly, fingerprint, force, perLanguageDirectory, rosetta, runtimeTypeChecking, }) {
     // ``argv.target`` is guaranteed valid by ``yargs`` through the ``choices`` directive.
     const factory = targets_1.ALL_BUILDERS[targetLanguage];
     if (!factory) {
         throw new Error(`Unsupported target: '${targetLanguage}'`);
     }
     return factory(modules, {
+        arguments: argv,
         clean: clean,
         codeOnly: codeOnly,
-        rosetta,
-        force: force,
         fingerprint: fingerprint,
-        arguments: argv,
+        force: force,
         languageSubdirectory: perLanguageDirectory,
+        rosetta,
+        runtimeTypeChecking,
     }).buildModules();
 }
 function sliceTargets(modulesSorted, requestedTargets, force) {

package/lib/target.d.ts

@@ -12,6 +12,7 @@ export declare abstract class Target {
     protected readonly targetName: string;
     protected readonly assembly: reflect.Assembly;
     protected readonly rosetta: Rosetta;
+    protected readonly runtimeTypeChecking: boolean;
     protected abstract readonly generator: IGenerator;
     constructor(options: TargetOptions);
     /**
@@ -125,6 +126,8 @@ export interface TargetOptions {
     assembly: reflect.Assembly;
     /** The Rosetta instance */
     rosetta: Rosetta;
+    /** Whether to generate runtime type-checking code */
+    runtimeTypeChecking: boolean;
     /**
      * Whether to fingerprint the produced artifacts.
      * @default true

package/lib/target.js

@@ -8,12 +8,13 @@ const dependency_graph_1 = require("./dependency-graph");
 const logging = require("./logging");
 class Target {
     constructor(options) {
-        this.packageDir = options.packageDir;
+        this.arguments = options.arguments;
         this.assembly = options.assembly;
-        this.rosetta = options.rosetta;
         this.fingerprint = options.fingerprint ?? true;
         this.force = options.force ?? false;
-        this.arguments = options.arguments;
+        this.packageDir = options.packageDir;
+        this.rosetta = options.rosetta;
+        this.runtimeTypeChecking = options.runtimeTypeChecking;
         this.targetName = options.targetName;
     }
     /**

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

@@ -7,13 +7,16 @@ import { Generator, Legalese } from '../../generator';
  */
 export declare class DotNetGenerator extends Generator {
     private readonly assembliesCurrentlyBeingCompiled;
+    private readonly nameutils;
     private readonly rosetta;
     private firstMemberWritten;
     private typeresolver;
-    private readonly nameutils;
     private dotnetRuntimeGenerator;
     private dotnetDocGenerator;
-    constructor(assembliesCurrentlyBeingCompiled: string[], rosetta: Rosetta);
+    constructor(assembliesCurrentlyBeingCompiled: string[], options: {
+        readonly rosetta: Rosetta;
+        readonly runtimeTypeChecking: boolean;
+    });
     load(packageRoot: string, assembly: reflect.Assembly): Promise<void>;
     /**
      * Runs the generator (in-memory).

package/lib/targets/dotnet/dotnetgenerator.js

@@ -6,6 +6,7 @@ const clone = require("clone");
 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");
@@ -14,22 +15,23 @@ 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
  */
 class DotNetGenerator extends generator_1.Generator {
-    constructor(assembliesCurrentlyBeingCompiled, rosetta) {
-        super();
+    constructor(assembliesCurrentlyBeingCompiled, options) {
+        super(options);
         this.assembliesCurrentlyBeingCompiled = assembliesCurrentlyBeingCompiled;
-        this.rosetta = rosetta;
+        this.nameutils = new nameutils_1.DotNetNameUtils();
         // Flags that tracks if we have already wrote the first member of the class
         this.firstMemberWritten = false;
-        this.nameutils = new nameutils_1.DotNetNameUtils();
         // Override the openBlock to get a correct C# looking code block with the curly brace after the line
         this.code.openBlock = function (text) {
             this.line(text);
             this.open('{');
         };
+        this.rosetta = options.rosetta;
     }
     async load(packageRoot, assembly) {
         await super.load(packageRoot, assembly);
@@ -271,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?>()`;
@@ -431,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();
         }
@@ -442,96 +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 } = {}) {
-        const unionParameters = parameters?.filter(({ type }) => containsUnionType(type));
-        if (unionParameters == null || unionParameters.length === 0) {
+    emitUnionParameterValdation(parameters = [], opts = { noMangle: false }) {
+        if (!this.runtimeTypeChecking) {
+            // We were configured not to emit those, so bail out now.
             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();
-            }
+        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)');
+        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_${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
@@ -852,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();
         }
@@ -874,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/dotnet.js

@@ -164,13 +164,14 @@ class DotnetBuilder {
     }
     makeTarget(module) {
         return new Dotnet({
-            targetName: this.targetName,
-            packageDir: module.moduleDirectory,
+            arguments: this.options.arguments,
             assembly: module.assembly,
             fingerprint: this.options.fingerprint,
             force: this.options.force,
-            arguments: this.options.arguments,
+            packageDir: module.moduleDirectory,
             rosetta: this.options.rosetta,
+            runtimeTypeChecking: this.options.runtimeTypeChecking,
+            targetName: this.targetName,
         }, this.modules.map((m) => m.name));
     }
 }
@@ -185,7 +186,7 @@ function projectLocation(module) {
 class Dotnet extends target_1.Target {
     constructor(options, assembliesCurrentlyBeingCompiled) {
         super(options);
-        this.generator = new dotnetgenerator_1.DotNetGenerator(assembliesCurrentlyBeingCompiled, options.rosetta);
+        this.generator = new dotnetgenerator_1.DotNetGenerator(assembliesCurrentlyBeingCompiled, options);
     }
     static toPackageInfos(assm) {
         const packageId = assm.targets.dotnet.packageId;