jsii-pacmak 1.63.2 → 1.65.1

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).
@@ -55,6 +58,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

@@ -3,9 +3,13 @@ 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 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");
@@ -15,18 +19,18 @@ const nameutils_1 = require("./nameutils");
  * 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);
@@ -48,7 +52,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 +62,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 +265,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 +432,125 @@ 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 } = {}) {
+        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) {
+            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_${(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
      *
@@ -546,7 +683,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 +808,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 +850,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 +870,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 +1040,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