jsii-pacmak 1.114.1 → 1.115.0

package/lib/npm-modules.d.ts

@@ -1,7 +1,7 @@
 import { JsiiModule } from './packaging';
 import { Toposorted } from './toposort';
 /**
- * Find all modules that need to be packagerd
+ * Find all modules that need to be packaged
  *
  * If the input list is empty, include the current directory.
  *

package/lib/npm-modules.js

@@ -10,7 +10,7 @@ const toposort_1 = require("./toposort");
 const util_1 = require("./util");
 const logging = require("../lib/logging");
 /**
- * Find all modules that need to be packagerd
+ * Find all modules that need to be packaged
  *
  * If the input list is empty, include the current directory.
  *
@@ -66,12 +66,10 @@ async function findJsiiModules(directories, recurse) {
         }
         // outdir is either by package.json/jsii.outdir (relative to package root) or via command line (relative to cwd)
         const outputDirectory = pkg.jsii.outdir && path.resolve(realPath, pkg.jsii.outdir);
-        const targets = [...Object.keys(pkg.jsii.targets), 'js']; // "js" is an implicit target.
         ret.push(new packaging_1.JsiiModule({
             name: pkg.name,
             moduleDirectory: realPath,
             defaultOutputDirectory: outputDirectory,
-            availableTargets: targets,
             dependencyNames,
         }));
     }

package/lib/packaging.d.ts

@@ -9,10 +9,6 @@ export interface JsiiModuleOptions {
      * The module directory
      */
     moduleDirectory: string;
-    /**
-     * Identifier of the targets to build
-     */
-    availableTargets: string[];
     /**
      * Output directory where to package everything
      */
@@ -26,7 +22,6 @@ export declare class JsiiModule {
     readonly name: string;
     readonly dependencyNames: string[];
     readonly moduleDirectory: string;
-    readonly availableTargets: string[];
     outputDirectory: string;
     private _tarball?;
     _assembly?: Assembly;
@@ -38,6 +33,7 @@ export declare class JsiiModule {
     get tarball(): string;
     load(system: TypeSystem, validate?: boolean): Promise<Assembly>;
     get assembly(): Assembly;
+    get availableTargets(): string[];
     cleanup(): Promise<void>;
 }
 //# sourceMappingURL=packaging.d.ts.map

package/lib/packaging.js

@@ -6,11 +6,11 @@ const path = require("path");
 const util_1 = require("./util");
 const logging = require("../lib/logging");
 exports.DEFAULT_PACK_COMMAND = 'npm pack';
+const ASSEMBLY_SUPPORTED_FEATURES = ['intersection-types'];
 class JsiiModule {
     constructor(options) {
         this.name = options.name;
         this.moduleDirectory = options.moduleDirectory;
-        this.availableTargets = options.availableTargets;
         this.outputDirectory = options.defaultOutputDirectory;
         this.dependencyNames = options.dependencyNames ?? [];
     }
@@ -19,20 +19,19 @@ class JsiiModule {
      */
     async npmPack(packCommand = exports.DEFAULT_PACK_COMMAND) {
         this._tarball = await util_1.Scratch.make(async (tmpdir) => {
-            const args = [];
             if (packCommand === exports.DEFAULT_PACK_COMMAND) {
                 // Quoting (JSON-stringifying) the module directory in order to avoid
                 // problems if there are spaces or other special characters in the path.
-                args.push(JSON.stringify(this.moduleDirectory));
+                packCommand += ` ${JSON.stringify(this.moduleDirectory)}`;
                 if (logging.level.valueOf() >= logging.LEVEL_VERBOSE) {
-                    args.push('--loglevel=verbose');
+                    packCommand += ' --loglevel=verbose';
                 }
             }
             else {
                 // Ensure module is copied to tmpdir to ensure parallel execution does not contend on generated tarballs
                 await fs.copy(this.moduleDirectory, tmpdir, { dereference: true });
             }
-            const out = await (0, util_1.shell)(packCommand, args, {
+            const out = await (0, util_1.shell)(packCommand, {
                 cwd: tmpdir,
             });
             // Take only the last line of npm pack which should contain the
@@ -57,7 +56,10 @@ class JsiiModule {
     }
     async load(system, validate = true) {
         return system
-            .loadModule(this.moduleDirectory, { validate })
+            .loadModule(this.moduleDirectory, {
+            validate,
+            supportedFeatures: ASSEMBLY_SUPPORTED_FEATURES,
+        })
             .then((assembly) => (this._assembly = assembly));
     }
     get assembly() {
@@ -66,6 +68,10 @@ class JsiiModule {
         }
         return this._assembly;
     }
+    get availableTargets() {
+        // "js" is an implicit target
+        return [...Object.keys(this.assembly.targets ?? {}), 'js'];
+    }
     async cleanup() {
         if (this._tarball) {
             await this._tarball.cleanup();

package/lib/rosetta-assembly.d.ts

@@ -11,6 +11,10 @@ import { RosettaTabletReader } from 'jsii-rosetta';
  * and then assert it in the type system.
  *
  * The check should be cheap, this gets called quite a lot.
+ *
+ * (In actual fact, Rosetta doesn't do much with the Assembly, just crawl
+ * all API documentations, so basically most new features would be supported...
+ * but we technically should do *something* here anyway).
  */
 export declare function assertSpecIsRosettaCompatible(x: spec.Assembly): asserts x is Parameters<RosettaTabletReader['addAssembly']>[0];
 //# sourceMappingURL=rosetta-assembly.d.ts.map

package/lib/rosetta-assembly.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertSpecIsRosettaCompatible = assertSpecIsRosettaCompatible;
+const ROSETTA_SUPPORTED_ASSEMBLY_FEATURES = [
+    'intersection-types',
+];
 /**
  * Assert that the given spec is safe to give to Rosetta
  *
@@ -12,12 +15,15 @@ exports.assertSpecIsRosettaCompatible = assertSpecIsRosettaCompatible;
  * and then assert it in the type system.
  *
  * The check should be cheap, this gets called quite a lot.
+ *
+ * (In actual fact, Rosetta doesn't do much with the Assembly, just crawl
+ * all API documentations, so basically most new features would be supported...
+ * but we technically should do *something* here anyway).
  */
 function assertSpecIsRosettaCompatible(x) {
-    const rosettaSupportedFeatures = [];
-    const unsupported = (x.usedFeatures ?? []).filter((f) => !rosettaSupportedFeatures.includes(f));
+    const unsupported = (x.usedFeatures ?? []).filter((f) => !ROSETTA_SUPPORTED_ASSEMBLY_FEATURES.includes(f));
     if (unsupported.length > 0) {
-        throw new Error(`This assembly uses features Rosetta doesn't support yet: ${unsupported.join(', ')}`);
+        throw new Error(`This assembly uses features that jsii-pacmak doesn't think jsii-rosetta can handle yet: ${unsupported.join(', ')}`);
     }
 }
 //# sourceMappingURL=rosetta-assembly.js.map

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

@@ -1,6 +1,7 @@
 import * as spec from '@jsii/spec';
 import { CodeMaker } from 'codemaker';
 import { RosettaTabletReader, ApiLocation } from 'jsii-rosetta';
+import { DotNetTypeResolver } from './dotnettyperesolver';
 /**
  * Generates the Jsii attributes and calls for the .NET runtime
  *
@@ -9,9 +10,10 @@ import { RosettaTabletReader, ApiLocation } from 'jsii-rosetta';
 export declare class DotNetDocGenerator {
     private readonly rosetta;
     private readonly assembly;
+    private readonly resolver;
     private readonly code;
     private readonly nameutils;
-    constructor(code: CodeMaker, rosetta: RosettaTabletReader, assembly: spec.Assembly);
+    constructor(code: CodeMaker, rosetta: RosettaTabletReader, assembly: spec.Assembly, resolver: DotNetTypeResolver);
     /**
      * Emits all documentation depending on what is available in the jsii model
      *
@@ -31,5 +33,6 @@ export declare class DotNetDocGenerator {
     private convertExample;
     private convertSamplesInMarkdown;
     private emitXmlDoc;
+    private renderTypeForDocs;
 }
 //# sourceMappingURL=dotnetdocgenerator.d.ts.map

package/lib/targets/dotnet/dotnetdocgenerator.js

@@ -7,15 +7,27 @@ const xmlbuilder = require("xmlbuilder");
 const _utils_1 = require("../_utils");
 const nameutils_1 = require("./nameutils");
 const rosetta_assembly_1 = require("../../rosetta-assembly");
+const type_utils_1 = require("../../type-utils");
+const type_visitor_1 = require("../../type-visitor");
+// Define some tokens that will be turned into literal < and > in XML comments.
+// This will be used by a function later on that needs to output literal tokens,
+// in a string where they would usually be escaped into &lt; and &gt;
+//
+// We use a random string in here so the actual token values cannot be predicted
+// in advance, so that an attacker can not use this knowledge to inject the tokens
+// literally into  doc comments, and perform an XSS attack that way.
+const L_ANGLE = `@l${Math.random()}@`;
+const R_ANGLE = `@r${Math.random()}@`;
 /**
  * Generates the Jsii attributes and calls for the .NET runtime
  *
  * Uses the same instance of CodeMaker as the rest of the code
  */
 class DotNetDocGenerator {
-    constructor(code, rosetta, assembly) {
+    constructor(code, rosetta, assembly, resolver) {
         this.rosetta = rosetta;
         this.assembly = assembly;
+        this.resolver = resolver;
         this.nameutils = new nameutils_1.DotNetNameUtils();
         this.code = code;
     }
@@ -35,34 +47,44 @@ class DotNetDocGenerator {
         this.emitXmlDoc('summary', (0, _utils_1.renderSummary)(obj.docs));
         // Handling parameters only if the obj is a method
         const objMethod = obj;
-        if (objMethod.parameters) {
+        if (objMethod && objMethod.parameters) {
             objMethod.parameters.forEach((param) => {
                 // Remove any slug `@` from the parameter name - it's not supposed to show up here.
                 const paramName = this.nameutils
                     .convertParameterName(param.name)
                     .replace(/^@/, '');
-                this.emitXmlDoc('param', param.docs?.summary ?? '', {
+                const unionHint = (0, type_utils_1.containsUnionType)(param.type)
+                    ? `Type union: ${this.renderTypeForDocs(param.type)}`
+                    : '';
+                this.emitXmlDoc('param', combineSentences(param.docs?.summary, unionHint), {
                     attributes: { name: paramName },
                 });
             });
         }
-        // At this pdocfx namespacedocd a valid instance of docs
-        if (!docs) {
-            return;
-        }
-        if (docs.returns) {
-            this.emitXmlDoc('returns', docs.returns);
+        const returnUnionHint = objMethod.returns && (0, type_utils_1.containsUnionType)(objMethod.returns.type)
+            ? `Type union: ${this.renderTypeForDocs(objMethod.returns.type)}`
+            : '';
+        if (docs?.returns || returnUnionHint) {
+            this.emitXmlDoc('returns', combineSentences(docs?.returns, returnUnionHint));
         }
+        const propUnionHint = spec.isProperty(obj) && (0, type_utils_1.containsUnionType)(obj.type)
+            ? `Type union: ${this.renderTypeForDocs(obj.type)}`
+            : '';
         // Remarks does not use emitXmlDoc() because the remarks can contain code blocks
         // which are fenced with <code> tags, which would be escaped to
         // &lt;code&gt; if we used the xml builder.
-        const remarks = this.renderRemarks(docs, apiLocation);
-        if (remarks.length > 0) {
+        const remarks = this.renderRemarks(docs ?? {}, apiLocation);
+        if (remarks.length > 0 || propUnionHint) {
             this.code.line('/// <remarks>');
             remarks.forEach((r) => this.code.line(`/// ${r}`.trimRight()));
+            if (propUnionHint) {
+                // Very likely to contain < and > from `Dictionary<...>`, but we also want the literal angle brackets
+                // from `<see cref="...">`.
+                this.code.line(`/// <para>${unescapeAngleMarkers(escapeAngleBrackets(propUnionHint))}</para>`);
+            }
             this.code.line('/// </remarks>');
         }
-        if (docs.example) {
+        if (docs?.example) {
             this.code.line('/// <example>');
             this.emitXmlDoc('code', this.convertExample(docs.example, apiLocation));
             this.code.line('/// </example>');
@@ -139,7 +161,8 @@ class DotNetDocGenerator {
         for (const [name, value] of Object.entries(attributes)) {
             xml.att(name, value);
         }
-        const xmlstring = xml.end({ allowEmpty: true, pretty: false });
+        // Unescape angle brackets that may have been injected by `renderTypeForDocs`
+        const xmlstring = unescapeAngleMarkers(xml.end({ allowEmpty: true, pretty: false }));
         const trimLeft = tag !== 'code';
         for (const line of xmlstring
             .split('\n')
@@ -147,6 +170,22 @@ class DotNetDocGenerator {
             this.code.line(`/// ${line}`);
         }
     }
+    renderTypeForDocs(x) {
+        return (0, type_visitor_1.visitTypeReference)(x, {
+            named: (ref) => `${L_ANGLE}see cref="${this.resolver.toNativeFqn(ref.fqn)}" /${R_ANGLE}`,
+            primitive: (ref) => this.resolver.toDotNetType(ref),
+            collection: (ref) => {
+                switch (ref.collection.kind) {
+                    case spec.CollectionKind.Array:
+                        return `(${this.renderTypeForDocs(ref.collection.elementtype)})[]`;
+                    case spec.CollectionKind.Map:
+                        return `Dictionary<string, ${this.renderTypeForDocs(ref.collection.elementtype)}>`;
+                }
+            },
+            union: (ref) => `either ${ref.union.types.map((x) => this.renderTypeForDocs(x)).join(' or ')}`,
+            intersection: (ref) => `${ref.intersection.types.map((x) => this.renderTypeForDocs(x)).join(' + ')}`,
+        });
+    }
 }
 exports.DotNetDocGenerator = DotNetDocGenerator;
 /**
@@ -159,4 +198,18 @@ function shouldMentionStability(s) {
     // Don't render "stable" or "external", those are both stable by implication
     return s === spec.Stability.Deprecated || s === spec.Stability.Experimental;
 }
+function combineSentences(...xs) {
+    return xs.filter((x) => x).join('. ');
+}
+function escapeAngleBrackets(x) {
+    return x.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+/**
+ * Replace the special angle markers produced by renderTypeForDocs with literal angle brackets
+ */
+function unescapeAngleMarkers(x) {
+    return x
+        .replace(new RegExp(L_ANGLE, 'g'), '<')
+        .replace(new RegExp(R_ANGLE, 'g'), '>');
+}
 //# sourceMappingURL=dotnetdocgenerator.js.map

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

@@ -72,10 +72,6 @@ export declare class DotNetGenerator extends Generator {
      * Used to figure out if the override or virtual keywords are necessary.
      */
     private isMemberDefinedOnAncestor;
-    /**
-     * Renders method parameters string
-     */
-    private renderMethodParameters;
     /**
      * Renders parameters string for methods or constructors
      */

package/lib/targets/dotnet/dotnetgenerator.js

@@ -42,7 +42,7 @@ class DotNetGenerator extends generator_1.Generator {
     generate(fingerprint) {
         this.typeresolver = new dotnettyperesolver_1.DotNetTypeResolver(this.assembly, (fqn) => this.findModule(fqn), (fqn) => this.findType(fqn), this.assembliesCurrentlyBeingCompiled);
         this.dotnetRuntimeGenerator = new dotnetruntimegenerator_1.DotNetRuntimeGenerator(this.code, this.typeresolver);
-        this.dotnetDocGenerator = new dotnetdocgenerator_1.DotNetDocGenerator(this.code, this.rosetta, this.assembly);
+        this.dotnetDocGenerator = new dotnetdocgenerator_1.DotNetDocGenerator(this.code, this.rosetta, this.assembly, this.typeresolver);
         this.emitAssemblyDocs();
         // We need to resolve the dependency tree
         this.typeresolver.resolveNamespacesDependencies();
@@ -165,7 +165,8 @@ class DotNetGenerator extends generator_1.Generator {
             ? this.typeresolver.toDotNetType(method.returns.type)
             : 'void';
         const nullable = method.returns?.optional ? '?' : '';
-        this.code.line(`${returnType}${nullable} ${this.nameutils.convertMethodName(method.name)}(${this.renderMethodParameters(method)});`);
+        const { parameters, whereClause, typeParameters } = this.typeresolver.renderGenericParameters(method.parameters);
+        this.code.line(`${returnType}${nullable} ${this.nameutils.convertMethodName(method.name)}${typeParameters}(${this.renderParametersString(parameters)})${whereClause};`);
     }
     onInterfaceMethodOverload(ifc, overload, _originalMethod) {
         this.onInterfaceMethod(ifc, overload);
@@ -187,7 +188,12 @@ class DotNetGenerator extends generator_1.Generator {
             memberName: prop.name,
         });
         this.dotnetRuntimeGenerator.emitAttributesForProperty(prop);
-        const propType = this.typeresolver.toDotNetType(prop.type);
+        // Unfortunately we can only render this as one type. We'll take the first one.
+        let apparentType = prop.type;
+        if (spec.isIntersectionTypeReference(apparentType)) {
+            apparentType = apparentType.intersection.types[0];
+        }
+        const propType = this.typeresolver.toDotNetType(apparentType);
         const propName = this.nameutils.convertPropertyName(prop.name);
         if (prop.optional) {
             this.code.line('[Amazon.JSII.Runtime.Deputy.JsiiOptional]');
@@ -253,7 +259,11 @@ class DotNetGenerator extends generator_1.Generator {
             });
             this.dotnetRuntimeGenerator.emitDeprecatedAttributeIfNecessary(initializer);
             if (initializer.parameters) {
-                parametersDefinition = this.renderParametersString(initializer.parameters);
+                const { parameters, whereClause } = this.typeresolver.renderGenericParameters(initializer.parameters);
+                if (whereClause) {
+                    throw new Error('C# does not allow generic parameters to a constructor');
+                }
+                parametersDefinition = this.renderParametersString(parameters);
                 for (const p of initializer.parameters) {
                     parametersBase += `${this.nameutils.convertParameterName(p.name)}`;
                     // If this is not the last parameter, append ,
@@ -391,7 +401,8 @@ class DotNetGenerator extends generator_1.Generator {
         const access = this.renderAccessLevel(method);
         const methodName = this.nameutils.convertMethodName(method.name);
         const isOptional = method.returns && method.returns.optional ? '?' : '';
-        const signature = `${returnType}${isOptional} ${methodName}(${this.renderMethodParameters(method)})`;
+        const { parameters, whereClause, typeParameters } = this.typeresolver.renderGenericParameters(method.parameters);
+        const signature = `${returnType}${isOptional} ${methodName}${typeParameters}(${this.renderParametersString(parameters)})${whereClause}`;
         this.dotnetDocGenerator.emitDocs(method, {
             api: 'member',
             fqn: definingType.fqn,
@@ -514,12 +525,6 @@ class DotNetGenerator extends generator_1.Generator {
         }
         return false;
     }
-    /**
-     * Renders method parameters string
-     */
-    renderMethodParameters(method) {
-        return this.renderParametersString(method.parameters);
-    }
     /**
      * Renders parameters string for methods or constructors
      */
@@ -728,10 +733,15 @@ 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);
+        // Unfortunately we can only render this as one type. We'll take the first one.
+        let apparentType = prop.type;
+        if (spec.isIntersectionTypeReference(apparentType)) {
+            apparentType = apparentType.intersection.types[0];
+        }
+        const propTypeFQN = this.typeresolver.toDotNetType(apparentType);
         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)
+        const backingFieldName = spec.isInterfaceType(cls) && datatype && containsUnionType(apparentType)
             ? // 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;
@@ -773,7 +783,7 @@ class DotNetGenerator extends generator_1.Generator {
         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,
+            type: apparentType,
             optional: prop.optional,
         });
         if (backingFieldName) {

package/lib/targets/dotnet/dotnetruntimegenerator.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DotNetRuntimeGenerator = void 0;
 const spec = require("@jsii/spec");
 const nameutils_1 = require("./nameutils");
+const type_literals_1 = require("../type-literals");
 /**
  * Generates the Jsii attributes and calls for the jsii .NET runtime
  *
@@ -143,8 +144,16 @@ class DotNetRuntimeGenerator {
         const paramTypes = new Array();
         const params = new Array();
         if (method.parameters) {
-            for (const param of method.parameters) {
-                paramTypes.push(`typeof(${this.typeresolver.toDotNetType(param.type)}${param.variadic ? '[]' : ''})`);
+            const { parameters } = this.typeresolver.renderGenericParameters(method.parameters);
+            for (const param of parameters) {
+                if ((0, type_literals_1.isLiteralTypeReference)(param.type)) {
+                    // Generic type argument -- since we don't actually need this type anyway because we don't use it
+                    // for method resolution, we can just use Object.
+                    paramTypes.push('typeof(System.Object)');
+                }
+                else {
+                    paramTypes.push(`typeof(${this.typeresolver.toDotNetType(param.type)}${param.variadic ? '[]' : ''})`);
+                }
                 params.push(this.nameutils.convertParameterName(param.name));
             }
         }

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

@@ -48,6 +48,19 @@ export declare class DotNetTypeResolver {
      * Translates a collection in jsii to the name of a native .NET collection
      */
     private toDotNetCollectionName;
+    /**
+     * Render generics for function parameters; updates parameters replacing generic types with type parameters
+     *
+     * FIXME: This is the wrong way around. It is better to have the renderer
+     * assign a unique name and return the fact that a type needs generics. That
+     * way it's trivially possible to represent "union-of-intersections", which
+     * otherwise will be hard. See the way it's done for Java.
+     */
+    renderGenericParameters(inParameters: spec.Parameter[] | undefined): {
+        parameters: spec.Parameter[];
+        typeParameters: string;
+        whereClause: string;
+    };
 }
 export {};
 //# sourceMappingURL=dotnettyperesolver.d.ts.map

package/lib/targets/dotnet/dotnettyperesolver.js

@@ -5,6 +5,7 @@ const spec = require("@jsii/spec");
 const codemaker_1 = require("codemaker");
 const filegenerator_1 = require("./filegenerator");
 const nameutils_1 = require("./nameutils");
+const type_literals_1 = require("../type-literals");
 class DotNetTypeResolver {
     constructor(assembly, findModule, findType, assembliesCurrentlyBeingCompiled) {
         this.assembliesCurrentlyBeingCompiled = assembliesCurrentlyBeingCompiled;
@@ -100,12 +101,12 @@ class DotNetTypeResolver {
             return this.toDotNetCollection(typeref);
         }
         else if (spec.isNamedTypeReference(typeref)) {
-            return this.toNativeFqn(typeref.fqn);
+            return (0, type_literals_1.literalTypeReference)(typeref) ?? this.toNativeFqn(typeref.fqn);
         }
         else if (spec.isUnionTypeReference(typeref)) {
             return 'object';
         }
-        throw new Error(`Invalid type reference: ${JSON.stringify(typeref)}`);
+        throw new Error(`Unresolvable type reference: ${JSON.stringify(typeref)}`);
     }
     /**
      * Translates any jsii type to the name of its corresponding .NET type (as a .NET string).
@@ -219,6 +220,43 @@ class DotNetTypeResolver {
                 throw new Error(`Unsupported collection kind: ${ref.collection.kind}`);
         }
     }
+    /**
+     * Render generics for function parameters; updates parameters replacing generic types with type parameters
+     *
+     * FIXME: This is the wrong way around. It is better to have the renderer
+     * assign a unique name and return the fact that a type needs generics. That
+     * way it's trivially possible to represent "union-of-intersections", which
+     * otherwise will be hard. See the way it's done for Java.
+     */
+    renderGenericParameters(inParameters) {
+        const parameters = new Array();
+        const typeParameters = new Array();
+        const genericConstraints = new Array();
+        for (const p of inParameters ?? []) {
+            if (spec.isIntersectionTypeReference(p.type)) {
+                const typeParameterName = `T${Object.keys(genericConstraints).length + 1}`;
+                parameters.push({
+                    name: p.name,
+                    docs: p.docs,
+                    optional: p.optional,
+                    variadic: p.variadic,
+                    type: (0, type_literals_1.makeLiteralTypeReference)(typeParameterName),
+                });
+                typeParameters.push(typeParameterName);
+                genericConstraints.push(`where ${typeParameterName}: ${p.type.intersection.types
+                    .map((t) => this.toDotNetType(t))
+                    .join(', ')}`);
+            }
+            else {
+                parameters.push(p);
+            }
+        }
+        return {
+            parameters,
+            typeParameters: typeParameters.length > 0 ? `<${typeParameters.join(', ')}>` : '',
+            whereClause: genericConstraints.length > 0 ? ` ${genericConstraints.join(' ')}` : '',
+        };
+    }
 }
 exports.DotNetTypeResolver = DotNetTypeResolver;
 //# sourceMappingURL=dotnettyperesolver.js.map

package/lib/targets/dotnet.d.ts

@@ -3,7 +3,7 @@ import { TargetBuilder, BuildOptions } from '../builder';
 import { JsiiModule } from '../packaging';
 import { PackageInfo, Target, TargetOptions } from '../target';
 import { DotNetGenerator } from './dotnet/dotnetgenerator';
-export declare const TARGET_FRAMEWORK = "netcoreapp3.1";
+export declare const TARGET_FRAMEWORK = "net6.0";
 /**
  * Build .NET packages all together, by generating an aggregate solution file
  */

package/lib/targets/dotnet.js

@@ -10,7 +10,7 @@ const util_1 = require("../util");
 const dotnetgenerator_1 = require("./dotnet/dotnetgenerator");
 const version_utils_1 = require("./version-utils");
 const _1 = require(".");
-exports.TARGET_FRAMEWORK = 'netcoreapp3.1';
+exports.TARGET_FRAMEWORK = 'net6.0';
 /**
  * Build .NET packages all together, by generating an aggregate solution file
  */
@@ -36,7 +36,7 @@ class DotnetBuilder {
             scratchDirs.push(tempSourceDir);
             // Build solution
             logging.debug('Building .NET');
-            await (0, util_1.shell)('dotnet', ['build', '--force', '--configuration', 'Release'], {
+            await (0, util_1.subprocess)('dotnet', ['build', '--force', '--configuration', 'Release'], {
                 cwd: tempSourceDir.directory,
                 retry: { maxAttempts: 5 },
             });
@@ -68,8 +68,10 @@ class DotnetBuilder {
                 });
             }
             // Use 'dotnet' command line tool to build a solution file from these csprojs
-            await (0, util_1.shell)('dotnet', ['new', 'sln', '-n', 'JsiiBuild'], { cwd: tmpDir });
-            await (0, util_1.shell)('dotnet', ['sln', 'add', ...csProjs], { cwd: tmpDir });
+            await (0, util_1.subprocess)('dotnet', ['new', 'sln', '-n', 'JsiiBuild'], {
+                cwd: tmpDir,
+            });
+            await (0, util_1.subprocess)('dotnet', ['sln', 'add', ...csProjs], { cwd: tmpDir });
             await this.generateNuGetConfigForLocalDeps(tmpDir);
             return ret;
         });

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

@@ -179,6 +179,7 @@ class Validation {
                 return Validation.collectionCheck(expression, description, typeMap.value);
             case 'primitive':
             case 'void':
+            case 'intersection':
                 return undefined;
         }
     }

package/lib/targets/go/types/go-type-reference.d.ts

@@ -18,6 +18,9 @@ type TypeMap = {
 } | {
     readonly type: 'union';
     readonly value: readonly GoTypeRef[];
+} | {
+    readonly type: 'intersection';
+    readonly value: readonly GoTypeRef[];
 } | {
     readonly type: 'interface';
     readonly value: GoTypeRef;

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

@@ -63,6 +63,9 @@ class GoTypeRef {
             if (!opaqueUnionType && ref.unionOfTypes) {
                 return ref.unionOfTypes.some((item) => containsDate(item, opaqueUnionType));
             }
+            if (!opaqueUnionType && ref.intersectionOfTypes) {
+                return ref.intersectionOfTypes.some((item) => containsDate(item, opaqueUnionType));
+            }
             return false;
         }
     }
@@ -111,6 +114,13 @@ class GoTypeRef {
                     }
                 }
                 break;
+            case 'intersection':
+                if (!this.options.opaqueUnionTypes) {
+                    for (const t of this.typeMap.value) {
+                        ret.push(...t.dependencies);
+                    }
+                }
+                break;
             case 'void':
             case 'primitive':
                 break;
@@ -164,6 +174,12 @@ class GoTypeRef {
                 value: ref.reference.unionOfTypes.map((typeRef) => new GoTypeRef(this.root, typeRef, this.options)),
             };
         }
+        else if (ref.reference.intersectionOfTypes) {
+            return {
+                type: 'intersection',
+                value: ref.reference.intersectionOfTypes.map((typeRef) => new GoTypeRef(this.root, typeRef, this.options)),
+            };
+        }
         else if (ref.reference.void) {
             return { type: 'void' };
         }
@@ -195,6 +211,10 @@ class GoTypeRef {
                 return `${prefix}${typeMap.value.namespace}.${baseName}`;
             }
         }
+        else if (typeMap.type === 'intersection') {
+            const components = typeMap.value.map((inner) => this.scopedTypeName(inner.typeMap, scope, false));
+            return `interface{ ${components.join(';')} }`;
+        }
         else if (typeMap.type === 'union') {
             return 'interface{}';
         }