jsii-pacmak 1.114.1 → 1.115.0

package/lib/targets/java.js

@@ -19,6 +19,9 @@ const version_1 = require("../version");
 const _utils_1 = require("./_utils");
 const version_utils_1 = require("./version-utils");
 const rosetta_assembly_1 = require("../rosetta-assembly");
+const type_utils_1 = require("../type-utils");
+const type_visitor_1 = require("../type-visitor");
+const type_literals_1 = require("./type-literals");
 const index_1 = require("./index");
 // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-require-imports
 const spdxLicenseList = require('spdx-license-list');
@@ -306,7 +309,7 @@ class Java extends target_1.Target {
             mvnArguments.push(`--${arg.slice(4)}`);
             mvnArguments.push(this.arguments[arg].toString());
         }
-        await (0, util_1.shell)('mvn', [
+        await (0, util_1.subprocess)('mvn', [
             // If we don't run in verbose mode, turn on quiet mode
             ...(this.arguments.verbose ? [] : ['--quiet']),
             '--batch-mode',
@@ -395,7 +398,9 @@ class JavaGenerator extends generator_1.Generator {
         this.openFileIfNeeded(cls);
         this.addJavaDocs(cls, { api: 'type', fqn: cls.fqn });
         const classBase = this.getClassBase(cls);
-        const extendsExpression = classBase ? ` extends ${classBase}` : '';
+        const extendsExpression = classBase
+            ? ` extends ${displayStatic(classBase)}`
+            : '';
         let implementsExpr = '';
         if (cls.interfaces?.length ?? 0 > 0) {
             implementsExpr = ` implements ${cls
@@ -434,9 +439,14 @@ class JavaGenerator extends generator_1.Generator {
         const initializerAccessLevel = cls.abstract
             ? 'protected'
             : this.renderAccessLevel(method);
-        this.code.openBlock(`${initializerAccessLevel} ${cls.name}(${this.renderMethodParameters(method)})`);
+        const types = this.convertTypes(method.parameters);
+        if (types.some((t) => t.type === 'param')) {
+            throw new Error('Cannot have generic type arguments to a constructor');
+        }
+        // NOTE: even though a constructor is technically final and we COULD render covariant types, historically we didn't and I'm not changing it.
+        this.code.openBlock(`${initializerAccessLevel} ${cls.name}(${this.renderParameters(method.parameters, types, 'final-but-not-cov')})`);
         this.code.line('super(software.amazon.jsii.JsiiObject.InitializationMode.JSII);');
-        this.emitUnionParameterValdation(method.parameters);
+        this.emitUnionParameterValidation(method.parameters);
         this.code.line(`software.amazon.jsii.JsiiEngine.getInstance().createNewObject(this${this.renderMethodCallArguments(method)});`);
         this.code.closeBlock();
     }
@@ -551,22 +561,33 @@ class JavaGenerator extends generator_1.Generator {
     onInterfaceMethod(ifc, method) {
         this.code.line();
         const returnType = method.returns
-            ? this.toDecoratedJavaType(method.returns)
-            : 'void';
+            ? forceSingleType(this.toDecoratedJavaTypes(method.returns))
+            : mkStatic('void');
         const methodName = JavaGenerator.safeJavaMethodName(method.name);
         this.addJavaDocs(method, {
             api: 'member',
             fqn: ifc.fqn,
             memberName: methodName,
+        }, {
+            returnsUnion: method.returns?.type,
         });
         this.emitStabilityAnnotations(method);
-        this.code.line(`${returnType} ${methodName}(${this.renderMethodParameters(method)});`);
+        const types = this.convertTypes(method.parameters);
+        this.code.line(`${typeVarDeclarations(types)}${displayStatic(returnType)} ${methodName}(${this.renderParameters(method.parameters, types, 'overridable')});`);
     }
     onInterfaceMethodOverload(ifc, overload, _originalMethod) {
         this.onInterfaceMethod(ifc, overload);
     }
     onInterfaceProperty(ifc, prop) {
-        const getterType = this.toDecoratedJavaType(prop);
+        let apparentGetterType = prop;
+        // We can only ever return one type, so take the first one
+        if (spec.isIntersectionTypeReference(prop.type)) {
+            apparentGetterType = {
+                optional: prop.optional,
+                type: prop.type.intersection.types[0],
+            };
+        }
+        const getterType = forceSingleType(this.toDecoratedJavaTypes(apparentGetterType));
         const propName = (0, naming_util_1.jsiiToPascalCase)(JavaGenerator.safeJavaPropertyName(prop.name));
         // for unions we only generate overloads for setters, not getters.
         this.code.line();
@@ -574,18 +595,20 @@ class JavaGenerator extends generator_1.Generator {
             api: 'member',
             fqn: ifc.fqn,
             memberName: prop.name,
+        }, {
+            returnsUnion: prop.type,
         });
         this.emitStabilityAnnotations(prop);
         if (prop.optional) {
             if (prop.overrides) {
                 this.code.line('@Override');
             }
-            this.code.openBlock(`default ${getterType} get${propName}()`);
+            this.code.openBlock(`default ${displayStatic(getterType)} get${propName}()`);
             this.code.line('return null;');
             this.code.closeBlock();
         }
         else {
-            this.code.line(`${getterType} get${propName}();`);
+            this.code.line(`${displayStatic(getterType)} get${propName}();`);
         }
         if (!prop.immutable) {
             const setterTypes = this.toDecoratedJavaTypes(prop);
@@ -595,18 +618,19 @@ class JavaGenerator extends generator_1.Generator {
                     api: 'member',
                     fqn: ifc.fqn,
                     memberName: prop.name,
+                    // Setter doesn't need a union type hint because we're generating overloads
                 });
                 if (prop.optional) {
                     if (prop.overrides) {
                         this.code.line('@Override');
                     }
                     this.code.line('@software.amazon.jsii.Optional');
-                    this.code.openBlock(`default void set${propName}(final ${type} value)`);
-                    this.code.line(`throw new UnsupportedOperationException("'void " + getClass().getCanonicalName() + "#set${propName}(${type})' is not implemented!");`);
+                    this.code.openBlock(`default void set${propName}(final ${displayStatic(type)} value)`);
+                    this.code.line(`throw new UnsupportedOperationException("'void " + getClass().getCanonicalName() + "#set${propName}(${displayStatic(type)})' is not implemented!");`);
                     this.code.closeBlock();
                 }
                 else {
-                    this.code.line(`void set${propName}(final ${type} value);`);
+                    this.code.line(`void set${propName}(final ${displayStatic(type)} value);`);
                 }
             }
         }
@@ -938,13 +962,13 @@ class JavaGenerator extends generator_1.Generator {
         if (consts.length === 0) {
             return;
         }
-        const javaClass = this.toJavaType(cls);
+        const javaClass = forceSingleType(this.toJavaTypes(cls));
         this.code.line();
         this.code.openBlock('static');
         for (const prop of consts) {
             const constName = this.renderConstName(prop);
-            const propType = this.toNativeType(prop.type, { forMarshalling: true });
-            const statement = `software.amazon.jsii.JsiiObject.jsiiStaticGet(${javaClass}.class, "${prop.name}", ${propType})`;
+            const propType = this.toNativeType(forceSingleType(this.toJavaTypes(prop.type)));
+            const statement = `software.amazon.jsii.JsiiObject.jsiiStaticGet(${displayStatic(javaClass)}.class, "${prop.name}", ${propType})`;
             this.code.line(`${constName} = ${this.wrapCollection(statement, prop.type, prop.optional)};`);
         }
         this.code.closeBlock();
@@ -953,7 +977,7 @@ class JavaGenerator extends generator_1.Generator {
         return this.code.toSnakeCase(prop.name).toLocaleUpperCase(); // java consts are SNAKE_UPPER_CASE
     }
     emitConstProperty(parentType, prop) {
-        const propType = this.toJavaType(prop.type);
+        const propType = forceSingleType(this.toJavaTypes(prop.type));
         const propName = this.renderConstName(prop);
         const access = this.renderAccessLevel(prop);
         this.code.line();
@@ -961,15 +985,15 @@ class JavaGenerator extends generator_1.Generator {
             api: 'member',
             fqn: parentType.fqn,
             memberName: prop.name,
+        }, {
+            returnsUnion: prop.type,
         });
         this.emitStabilityAnnotations(prop);
-        this.code.line(`${access} final static ${propType} ${propName};`);
+        this.code.line(`${access} final static ${displayStatic(propType)} ${propName};`);
     }
     emitProperty(cls, prop, definingType, { defaultImpl = false, final = false, includeGetter = true, overrides = !!prop.overrides, } = {}) {
-        const getterType = this.toDecoratedJavaType(prop);
-        const setterTypes = this.toDecoratedJavaTypes(prop, {
-            covariant: prop.static,
-        });
+        const setterTypes = this.toDecoratedJavaTypes(prop);
+        const getterType = forceSingleType(setterTypes);
         const propName = (0, naming_util_1.jsiiToPascalCase)(JavaGenerator.safeJavaPropertyName(prop.name));
         const modifiers = [defaultImpl ? 'default' : this.renderAccessLevel(prop)];
         if (prop.static)
@@ -978,7 +1002,7 @@ class JavaGenerator extends generator_1.Generator {
             modifiers.push('abstract');
         if (final && !prop.abstract && !defaultImpl)
             modifiers.push('final');
-        const javaClass = this.toJavaType(cls);
+        const javaClass = forceSingleType(this.toJavaTypes(cls));
         // for unions we only generate overloads for setters, not getters.
         if (includeGetter) {
             this.code.line();
@@ -986,12 +1010,14 @@ class JavaGenerator extends generator_1.Generator {
                 api: 'member',
                 fqn: definingType.fqn,
                 memberName: prop.name,
+            }, {
+                returnsUnion: prop.type,
             });
             if (overrides && !prop.static) {
                 this.code.line('@Override');
             }
             this.emitStabilityAnnotations(prop);
-            const signature = `${modifiers.join(' ')} ${getterType} get${propName}()`;
+            const signature = `${modifiers.join(' ')} ${displayStatic(getterType)} get${propName}()`;
             if (prop.abstract && !defaultImpl) {
                 this.code.line(`${signature};`);
             }
@@ -999,14 +1025,12 @@ class JavaGenerator extends generator_1.Generator {
                 this.code.openBlock(signature);
                 let statement;
                 if (prop.static) {
-                    statement = `software.amazon.jsii.JsiiObject.jsiiStaticGet(${this.toJavaType(cls)}.class, `;
+                    statement = `software.amazon.jsii.JsiiObject.jsiiStaticGet(${displayStatic(forceSingleType(this.toJavaTypes(cls)))}.class, `;
                 }
                 else {
                     statement = 'software.amazon.jsii.Kernel.get(this, ';
                 }
-                statement += `"${prop.name}", ${this.toNativeType(prop.type, {
-                    forMarshalling: true,
-                })})`;
+                statement += `"${prop.name}", ${this.toNativeType(forceSingleType(this.toJavaTypes(prop.type)))})`;
                 this.code.line(`return ${this.wrapCollection(statement, prop.type, prop.optional)};`);
                 this.code.closeBlock();
             }
@@ -1018,12 +1042,14 @@ class JavaGenerator extends generator_1.Generator {
                     api: 'member',
                     fqn: cls.fqn,
                     memberName: prop.name,
+                    // No union type hint for setters
                 });
                 if (overrides && !prop.static) {
                     this.code.line('@Override');
                 }
                 this.emitStabilityAnnotations(prop);
-                const signature = `${modifiers.join(' ')} void set${propName}(final ${type} value)`;
+                // We could have emitted a covariant argument type here, but we didn't historically and I'm not changing that now.
+                const signature = `${modifiers.join(' ')} void set${propName}(final ${displayStatic(type)} value)`;
                 if (prop.abstract && !defaultImpl) {
                     this.code.line(`${signature};`);
                 }
@@ -1036,19 +1062,20 @@ class JavaGenerator extends generator_1.Generator {
                     // This allows the compiler to do this type checking for us,
                     // so we should not emit these checks for primitive-only unions.
                     // Also, Java does not allow us to perform these checks if the types
-                    // have no overlap (eg if a String instanceof Number).
-                    if (type.includes('java.lang.Object') &&
+                    // have no overlap (eg if we emit code for `String instanceof Number`,
+                    // which will always return `false`, the compiler would reject the code).
+                    if (displayStatic(type).includes('java.lang.Object') &&
                         (!spec.isPrimitiveTypeReference(prop.type) ||
                             prop.type.primitive === spec.PrimitiveType.Any)) {
-                        this.emitUnionParameterValdation([
+                        this.emitUnionParameterValidation([
                             {
                                 name: 'value',
-                                type: this.filterType(prop.type, { covariant: prop.static, optional: prop.optional }, type),
+                                type: this.filterType(prop, type),
                             },
                         ]);
                     }
                     if (prop.static) {
-                        statement += `software.amazon.jsii.JsiiObject.jsiiStaticSet(${javaClass}.class, `;
+                        statement += `software.amazon.jsii.JsiiObject.jsiiStaticSet(${displayStatic(javaClass)}.class, `;
                     }
                     else {
                         statement += 'software.amazon.jsii.Kernel.set(this, ';
@@ -1074,20 +1101,19 @@ class JavaGenerator extends generator_1.Generator {
      *
      * @returns a type reference that matches the provided javaType.
      */
-    filterType(ref, { covariant, optional }, javaType) {
-        if (!spec.isUnionTypeReference(ref)) {
+    filterType(prop, javaType) {
+        if (!spec.isUnionTypeReference(prop.type)) {
             // No filterning needed -- this isn't a type union!
-            return ref;
+            return prop.type;
         }
-        const types = ref.union.types.filter((t) => this.toDecoratedJavaType({ optional, type: t }, { covariant }) ===
-            javaType);
-        assert(types.length > 0, `No type found in ${spec.describeTypeReference(ref)} has Java type ${javaType}`);
+        const types = prop.type.union.types.filter((t) => typesEqual(forceSingleType(annotateOptional(prop, this.toJavaTypes(t))), javaType));
+        assert(types.length > 0, `No type found in ${spec.describeTypeReference(prop.type)} has Java type ${displayStatic(javaType)}`);
         return { union: { types } };
     }
     emitMethod(cls, method, { defaultImpl = false, final = false, overrides = !!method.overrides, } = {}) {
         const returnType = method.returns
-            ? this.toDecoratedJavaType(method.returns)
-            : 'void';
+            ? forceSingleType(this.toDecoratedJavaTypes(method.returns))
+            : mkStatic('void');
         const modifiers = [
             defaultImpl ? 'default' : this.renderAccessLevel(method),
         ];
@@ -1099,12 +1125,15 @@ class JavaGenerator extends generator_1.Generator {
             modifiers.push('final');
         const async = !!method.async;
         const methodName = JavaGenerator.safeJavaMethodName(method.name);
-        const signature = `${returnType} ${methodName}(${this.renderMethodParameters(method)})`;
+        const types = this.convertTypes(method.parameters);
+        const signature = `${typeVarDeclarations(types)}${displayStatic(returnType)} ${methodName}(${this.renderParameters(method.parameters, types, method.static ? 'final' : 'overridable')})`;
         this.code.line();
         this.addJavaDocs(method, {
             api: 'member',
             fqn: cls.fqn,
             memberName: method.name,
+        }, {
+            returnsUnion: method.returns?.type,
         });
         this.emitStabilityAnnotations(method);
         if (overrides && !method.static) {
@@ -1115,7 +1144,7 @@ class JavaGenerator extends generator_1.Generator {
         }
         else {
             this.code.openBlock(`${modifiers.join(' ')} ${signature}`);
-            this.emitUnionParameterValdation(method.parameters);
+            this.emitUnionParameterValidation(method.parameters);
             this.code.line(this.renderMethodCall(cls, method, async));
             this.code.closeBlock();
         }
@@ -1125,21 +1154,21 @@ class JavaGenerator extends generator_1.Generator {
      *
      * @param parameters the list of parameters received by the function.
      */
-    emitUnionParameterValdation(parameters) {
+    emitUnionParameterValidation(parameters) {
         if (!this.runtimeTypeChecking) {
             // We were configured not to emit those, so bail out now.
             return;
         }
-        const unionParameters = parameters?.filter(({ type }) => containsUnionType(type));
+        const unionParameters = parameters?.filter(({ type }) => (0, type_utils_1.containsUnionType)(type));
         if (unionParameters == null || unionParameters.length === 0) {
             return;
         }
         this.code.openBlock('if (software.amazon.jsii.Configuration.getRuntimeTypeChecking())');
         for (const param of unionParameters) {
             if (param.variadic) {
-                const javaType = this.toJavaType(param.type);
+                const javaType = this.toSingleJavaType(param.type);
                 const asListName = `__${param.name}__asList`;
-                this.code.line(`final java.util.List<${javaType}> ${asListName} = java.util.Arrays.asList(${param.name});`);
+                this.code.line(`final java.util.List<${displayStatic(javaType)}> ${asListName} = java.util.Arrays.asList(${param.name});`);
                 validate.call(this, asListName, `.append("${param.name}")`, {
                     collection: {
                         kind: spec.CollectionKind.Array,
@@ -1175,8 +1204,8 @@ class JavaGenerator extends generator_1.Generator {
             const idxName = `__idx_${suffix}`;
             const valName = `__val_${suffix}`;
             this.code.openBlock(`for (int ${idxName} = 0; ${idxName} < ${value}.size(); ${idxName}++)`);
-            const eltType = this.toJavaType(elementType);
-            this.code.line(`final ${eltType} ${valName} = ${value}.get(${idxName});`);
+            const eltType = this.toSingleJavaType(elementType);
+            this.code.line(`final ${displayStatic(eltType)} ${valName} = ${value}.get(${idxName});`);
             validate.call(this, valName, isRawArray
                 ? `${descr}.append("[").append(${idxName}).append("]")`
                 : `${descr}.append(".get(").append(${idxName}).append(")")`, elementType, parameterName);
@@ -1201,9 +1230,9 @@ class JavaGenerator extends generator_1.Generator {
                 .slice(0, 6);
             const varName = `__item_${suffix}`;
             const valName = `__val_${suffix}`;
-            const javaElemType = this.toJavaType(elementType);
-            this.code.openBlock(`for (final java.util.Map.Entry<String, ${javaElemType}> ${varName}: ${value}.entrySet())`);
-            this.code.line(`final ${javaElemType} ${valName} = ${varName}.getValue();`);
+            const javaElemType = this.toSingleJavaType(elementType);
+            this.code.openBlock(`for (final java.util.Map.Entry<String, ${displayStatic(javaElemType)}> ${varName}: ${value}.entrySet())`);
+            this.code.line(`final ${displayStatic(javaElemType)} ${valName} = ${varName}.getValue();`);
             validate.call(this, valName, `${descr}.append(".get(\\"").append((${varName}.getKey())).append("\\")")`, elementType, parameterName);
             this.code.closeBlock();
         }
@@ -1224,9 +1253,9 @@ class JavaGenerator extends generator_1.Generator {
                 else {
                     checked.add(javaRawType);
                 }
-                const javaType = this.toJavaType(typeRef);
-                if (javaRawType !== javaType) {
-                    nestedCollectionUnionTypes.set(javaType, typeRef);
+                const javaType = this.toSingleJavaType(typeRef);
+                if (javaRawType !== displayStatic(javaType)) {
+                    nestedCollectionUnionTypes.set(displayStatic(javaType), typeRef);
                 }
                 const test = `${value} instanceof ${javaRawType}`;
                 if (typeRefs.length > 1) {
@@ -1245,7 +1274,7 @@ class JavaGenerator extends generator_1.Generator {
                 this.code.openBlock(')');
                 const placeholders = typeRefs
                     .map((typeRef) => {
-                    return `${this.toJavaType(typeRef)}`;
+                    return `${displayStatic(this.toSingleJavaType(typeRef))}`;
                 })
                     .join(', ');
                 this.code.indent(`throw new IllegalArgumentException(`);
@@ -1403,6 +1432,8 @@ class JavaGenerator extends generator_1.Generator {
     toJavaProp(property, definingType, inherited) {
         const safeName = JavaGenerator.safeJavaPropertyName(property.name);
         const propName = (0, naming_util_1.jsiiToPascalCase)(safeName);
+        const noIntersectionJavaTypes = this.toJavaTypes(removeIntersections(property.type));
+        const singleJavaType = forceSingleType(noIntersectionJavaTypes);
         return {
             docs: property.docs,
             spec: property,
@@ -1411,13 +1442,10 @@ class JavaGenerator extends generator_1.Generator {
             jsiiName: property.name,
             nullable: !!property.optional,
             fieldName: this.code.toCamelCase(safeName),
-            fieldJavaType: this.toJavaType(property.type),
-            paramJavaType: this.toJavaType(property.type, { covariant: true }),
-            fieldNativeType: this.toNativeType(property.type),
-            fieldJavaClass: `${this.toJavaType(property.type, {
-                forMarshalling: true,
-            })}.class`,
-            javaTypes: this.toJavaTypes(property.type, { covariant: true }),
+            renderedFieldType: displayStatic(singleJavaType),
+            renderedParamType: displayType(singleJavaType, 'covariant'),
+            renderedNativeFieldType: this.toNativeType(singleJavaType),
+            javaTypes: this.toJavaTypes(property.type),
             immutable: property.immutable ?? false,
             inherited,
         };
@@ -1450,22 +1478,22 @@ class JavaGenerator extends generator_1.Generator {
         }
         const structType = this.reflectAssembly.findType(firstStruct.type.fqn);
         const structParamName = this.code.toCamelCase(JavaGenerator.safeJavaPropertyName(firstStruct.name));
-        const structBuilder = `${this.toJavaType(firstStruct.type)}.${BUILDER_CLASS_NAME}`;
+        const structBuilder = `${displayStatic(this.toSingleJavaType(firstStruct.type))}.${BUILDER_CLASS_NAME}`;
         const positionalParams = cls.initializer.parameters
             .filter((p) => p !== firstStruct)
             .map((param) => ({
             param,
             fieldName: this.code.toCamelCase(JavaGenerator.safeJavaPropertyName(param.name)),
-            javaType: this.toJavaType(param.type),
+            javaType: this.toSingleJavaType(param.type),
         }));
-        const builtType = this.toJavaType(cls);
+        const builtType = this.toSingleJavaType(cls);
         this.code.line();
         this.code.line('/**');
         // eslint-disable-next-line prettier/prettier
-        this.code.line(` * ${(0, _utils_1.stabilityPrefixFor)(cls.initializer)}A fluent builder for {@link ${builtType}}.`);
+        this.code.line(` * ${(0, _utils_1.stabilityPrefixFor)(cls.initializer)}A fluent builder for {@link ${displayStatic(builtType)}}.`);
         this.code.line(' */');
         this.emitStabilityAnnotations(cls.initializer);
-        this.code.openBlock(`public static final class ${BUILDER_CLASS_NAME} implements software.amazon.jsii.Builder<${builtType}>`);
+        this.code.openBlock(`public static final class ${BUILDER_CLASS_NAME} implements software.amazon.jsii.Builder<${displayStatic(builtType)}>`);
         // Static factory method(s)
         for (const params of computeOverrides(positionalParams)) {
             const dummyMethod = {
@@ -1483,7 +1511,7 @@ class JavaGenerator extends generator_1.Generator {
             });
             this.emitStabilityAnnotations(cls.initializer);
             this.code.openBlock(`public static ${BUILDER_CLASS_NAME} create(${params
-                .map((param) => `final ${param.javaType}${param.param.variadic ? '...' : ''} ${param.fieldName}`)
+                .map((param) => `final ${displayStatic(param.javaType)}${param.param.variadic ? '...' : ''} ${param.fieldName}`)
                 .join(', ')})`);
             this.code.line(`return new ${BUILDER_CLASS_NAME}(${positionalParams
                 .map((param, idx) => (idx < params.length ? param.fieldName : 'null'))
@@ -1493,13 +1521,13 @@ class JavaGenerator extends generator_1.Generator {
         // Private properties
         this.code.line();
         for (const param of positionalParams) {
-            this.code.line(`private final ${param.javaType}${param.param.variadic ? '[]' : ''} ${param.fieldName};`);
+            this.code.line(`private final ${displayStatic(param.javaType)}${param.param.variadic ? '[]' : ''} ${param.fieldName};`);
         }
         this.code.line(`private ${firstStruct.optional ? '' : 'final '}${structBuilder} ${structParamName};`);
         // Private constructor
         this.code.line();
         this.code.openBlock(`private ${BUILDER_CLASS_NAME}(${positionalParams
-            .map((param) => `final ${param.javaType}${param.param.variadic ? '...' : ''} ${param.fieldName}`)
+            .map((param) => `final ${displayStatic(param.javaType)}${param.param.variadic ? '...' : ''} ${param.fieldName}`)
             .join(', ')})`);
         for (const param of positionalParams) {
             this.code.line(`this.${param.fieldName} = ${param.fieldName};`);
@@ -1527,16 +1555,14 @@ class JavaGenerator extends generator_1.Generator {
                     },
                 ],
             };
-            for (const javaType of this.toJavaTypes(prop.type.spec, {
-                covariant: true,
-            })) {
+            for (const javaType of this.toJavaTypes(prop.type.spec)) {
                 this.addJavaDocs(setter, {
                     api: 'member',
                     fqn: prop.definingType.fqn, // Could be inherited
                     memberName: prop.name,
                 });
                 this.emitStabilityAnnotations(prop.spec);
-                this.code.openBlock(`public ${BUILDER_CLASS_NAME} ${fieldName}(final ${javaType} ${fieldName})`);
+                this.code.openBlock(`public ${BUILDER_CLASS_NAME} ${fieldName}(final ${displayType(javaType, 'covariant')} ${fieldName})`);
                 this.code.line(`this.${structParamName}${firstStruct.optional ? '()' : ''}.${fieldName}(${fieldName});`);
                 this.code.line('return this;');
                 this.code.closeBlock();
@@ -1545,11 +1571,11 @@ class JavaGenerator extends generator_1.Generator {
         // Final build method
         this.code.line();
         this.code.line('/**');
-        this.code.line(` * @return a newly built instance of {@link ${builtType}}.`);
+        this.code.line(` * @return a newly built instance of {@link ${displayStatic(builtType)}}.`);
         this.code.line(' */');
         this.emitStabilityAnnotations(cls.initializer);
         this.code.line('@Override');
-        this.code.openBlock(`public ${builtType} build()`);
+        this.code.openBlock(`public ${displayStatic(builtType)} build()`);
         const params = cls.initializer.parameters.map((param) => {
             if (param === firstStruct) {
                 return firstStruct.optional
@@ -1558,7 +1584,7 @@ class JavaGenerator extends generator_1.Generator {
             }
             return `this.${positionalParams.find((p) => param === p.param).fieldName}`;
         });
-        this.code.indent(`return new ${builtType}(`);
+        this.code.indent(`return new ${displayStatic(builtType)}(`);
         params.forEach((param, idx) => this.code.line(`${param}${idx < params.length - 1 ? ',' : ''}`));
         this.code.unindent(');');
         this.code.closeBlock();
@@ -1580,7 +1606,7 @@ class JavaGenerator extends generator_1.Generator {
             this.code.line('/**');
             this.code.line(` * Sets the value of {@link ${parentType.name}#${getterFor(prop.fieldName)}}`);
             const summary = prop.docs?.summary ?? 'the value to be set';
-            this.code.line(` * ${paramJavadoc(prop.fieldName, prop.nullable, summary)}`);
+            this.code.line(` * ${this.paramJavadoc(prop.fieldName, prop.nullable, summary)}`);
             if (prop.docs?.remarks != null) {
                 const indent = ' '.repeat(7 + prop.fieldName.length);
                 const remarks = myMarkDownToJavaDoc(this.convertSamplesInMarkdown(prop.docs.remarks, {
@@ -1598,17 +1624,18 @@ class JavaGenerator extends generator_1.Generator {
             }
             this.code.line(' */');
             this.emitStabilityAnnotations(prop.spec);
+            const renderedType = displayType(type, 'covariant');
             // We add an explicit cast if both types are generic but they are not identical (one is covariant, the other isn't)
-            const explicitCast = type.includes('<') &&
-                prop.fieldJavaType.includes('<') &&
-                type !== prop.fieldJavaType
-                ? `(${prop.fieldJavaType})`
+            const explicitCast = renderedType.includes('<') &&
+                prop.renderedFieldType.includes('<') &&
+                renderedType !== prop.renderedFieldType
+                ? `(${prop.renderedFieldType})`
                 : '';
             if (explicitCast !== '') {
                 // We'll be doing a safe, but unchecked cast, so suppress that warning
                 this.code.line('@SuppressWarnings("unchecked")');
             }
-            this.code.openBlock(`public ${builderName} ${prop.fieldName}(${type} ${prop.fieldName})`);
+            this.code.openBlock(`public ${typeVarDeclarations([type])}${builderName} ${prop.fieldName}(${renderedType} ${prop.fieldName})`);
             this.code.line(`this.${prop.fieldName} = ${explicitCast}${prop.fieldName};`);
             this.code.line('return this;');
             this.code.closeBlock();
@@ -1635,7 +1662,7 @@ class JavaGenerator extends generator_1.Generator {
         this.code.line(' */');
         this.emitStabilityAnnotations(classSpec);
         this.code.openBlock(`public static final class ${BUILDER_CLASS_NAME} implements software.amazon.jsii.Builder<${classSpec.name}>`);
-        props.forEach((prop) => this.code.line(`${prop.fieldJavaType} ${prop.fieldName};`));
+        props.forEach((prop) => this.code.line(`${prop.renderedFieldType} ${prop.fieldName};`));
         props.forEach((prop) => this.emitBuilderSetter(prop, BUILDER_CLASS_NAME, classSpec));
         // Start build()
         this.code.line();
@@ -1680,7 +1707,7 @@ class JavaGenerator extends generator_1.Generator {
         this.code.line(ANN_INTERNAL);
         this.code.openBlock(`final class ${INTERFACE_PROXY_CLASS_NAME} extends software.amazon.jsii.JsiiObject implements ${ifc.name}`);
         // Immutable properties
-        props.forEach((prop) => this.code.line(`private final ${prop.fieldJavaType} ${prop.fieldName};`));
+        props.forEach((prop) => this.code.line(`private final ${prop.renderedFieldType} ${prop.fieldName};`));
         // Start JSII reference constructor
         this.code.line();
         this.code.line('/**');
@@ -1689,7 +1716,7 @@ class JavaGenerator extends generator_1.Generator {
         this.code.line(' */');
         this.code.openBlock(`protected ${INTERFACE_PROXY_CLASS_NAME}(final software.amazon.jsii.JsiiObjectRef objRef)`);
         this.code.line('super(objRef);');
-        props.forEach((prop) => this.code.line(`this.${prop.fieldName} = software.amazon.jsii.Kernel.get(this, "${prop.jsiiName}", ${prop.fieldNativeType});`));
+        props.forEach((prop) => this.code.line(`this.${prop.fieldName} = software.amazon.jsii.Kernel.get(this, "${prop.jsiiName}", ${prop.renderedNativeFieldType});`));
         this.code.closeBlock();
         // End JSII reference constructor
         // Start builder constructor
@@ -1697,14 +1724,14 @@ class JavaGenerator extends generator_1.Generator {
         this.code.line('/**');
         this.code.line(' * Constructor that initializes the object based on literal property values passed by the {@link Builder}.');
         this.code.line(' */');
-        if (props.some((prop) => prop.fieldJavaType !== prop.paramJavaType)) {
+        if (props.some((prop) => prop.renderedFieldType !== prop.renderedParamType)) {
             this.code.line('@SuppressWarnings("unchecked")');
         }
         this.code.openBlock(`protected ${INTERFACE_PROXY_CLASS_NAME}(final ${BUILDER_CLASS_NAME} builder)`);
         this.code.line('super(software.amazon.jsii.JsiiObject.InitializationMode.JSII);');
         props.forEach((prop) => {
-            const explicitCast = prop.fieldJavaType !== prop.paramJavaType
-                ? `(${prop.fieldJavaType})`
+            const explicitCast = prop.renderedFieldType !== prop.renderedParamType
+                ? `(${prop.renderedFieldType})`
                 : '';
             this.code.line(`this.${prop.fieldName} = ${explicitCast}${_validateIfNonOptional(`builder.${prop.fieldName}`, prop)};`);
         });
@@ -1714,7 +1741,7 @@ class JavaGenerator extends generator_1.Generator {
         props.forEach((prop) => {
             this.code.line();
             this.code.line('@Override');
-            this.code.openBlock(`public final ${prop.fieldJavaType} get${prop.propName}()`);
+            this.code.openBlock(`public final ${prop.renderedFieldType} get${prop.propName}()`);
             this.code.line(`return this.${prop.fieldName};`);
             this.code.closeBlock();
         });
@@ -1855,8 +1882,11 @@ class JavaGenerator extends generator_1.Generator {
         return { filePath, name };
     }
     // eslint-disable-next-line complexity
-    addJavaDocs(doc, apiLoc, defaultText) {
-        if (!defaultText &&
+    addJavaDocs(doc, apiLoc, unionHint) {
+        const returnsUnion = unionHint?.returnsUnion && (0, type_utils_1.containsUnionType)(unionHint.returnsUnion)
+            ? this.renderTypeReference(unionHint.returnsUnion)
+            : undefined;
+        if (!returnsUnion &&
             Object.keys(doc.docs ?? {}).length === 0 &&
             !(doc.parameters ?? []).some((p) => Object.keys(p.docs ?? {}).length !== 0)) {
             return;
@@ -1866,12 +1896,12 @@ class JavaGenerator extends generator_1.Generator {
         if (docs.summary) {
             paras.push(stripNewLines(myMarkDownToJavaDoc((0, _utils_1.renderSummary)(docs))));
         }
-        else if (defaultText) {
-            paras.push(myMarkDownToJavaDoc(defaultText));
-        }
         if (docs.remarks) {
             paras.push(myMarkDownToJavaDoc(this.convertSamplesInMarkdown(docs.remarks, apiLoc)).trimRight());
         }
+        if (returnsUnion) {
+            paras.push(`Returns union: ${returnsUnion}`);
+        }
         if (docs.default) {
             paras.push(`Default: ${docs.default}`); // NOTE: there is no annotation in JavaDoc for this
         }
@@ -1907,7 +1937,7 @@ class JavaGenerator extends generator_1.Generator {
             if (method.parameters) {
                 for (const param of method.parameters) {
                     const summary = param.docs?.summary;
-                    tagLines.push(paramJavadoc(param.name, param.optional, summary));
+                    tagLines.push(this.paramJavadoc(param.name, param.optional, summary, param.type));
                 }
             }
         }
@@ -1927,134 +1957,150 @@ class JavaGenerator extends generator_1.Generator {
         }
         this.code.line(' */');
     }
+    paramJavadoc(name, optional, summary, unionTypeHint) {
+        const parts = ['@param', name];
+        if (summary) {
+            parts.push(stripNewLines(myMarkDownToJavaDoc(endWithPeriod(summary))));
+        }
+        if (unionTypeHint && (0, type_utils_1.containsUnionType)(unionTypeHint)) {
+            parts.push(`Takes union: ${this.renderTypeReference(unionTypeHint)}.`);
+        }
+        if (!optional) {
+            parts.push('This parameter is required.');
+        }
+        return parts.join(' ');
+    }
     getClassBase(cls) {
         if (!cls.base) {
-            return 'software.amazon.jsii.JsiiObject';
+            return mkStatic('software.amazon.jsii.JsiiObject');
         }
-        return this.toJavaType({ fqn: cls.base });
+        return this.toJavaTypes({ fqn: cls.base })[0];
     }
-    toDecoratedJavaType(optionalValue, { covariant = false } = {}) {
-        const result = this.toDecoratedJavaTypes(optionalValue, { covariant });
-        if (result.length > 1) {
-            return `${optionalValue.optional ? ANN_NULLABLE : ANN_NOT_NULL} java.lang.Object`;
-        }
-        return result[0];
+    /**
+     * Convert an OptionalValue, adding the `NotNull` or `Nullable` declarations as appropriate
+     */
+    toDecoratedJavaTypes(optionalValue) {
+        return annotateOptional(optionalValue, this.toJavaTypes(optionalValue.type));
     }
-    toDecoratedJavaTypes(optionalValue, { covariant = false } = {}) {
-        return this.toJavaTypes(optionalValue.type, { covariant }).map((nakedType) => `${optionalValue.optional ? ANN_NULLABLE : ANN_NOT_NULL} ${nakedType}`);
+    /**
+     * Renders a type without generic arguments
+     *
+     * Necessary because of type erasure; the compiler
+     * will not let you check `foo instanceof Map<String, Foo>`,
+     * and you must instead check `foo instanceof Map`.
+     */
+    toJavaTypeNoGenerics(type) {
+        return forceSingleType(this.toJavaTypes(type)).typeSymbol;
     }
-    // Strips <*> from the type name.
-    // necessary, because of type erasure; the compiler
-    // will not let you check `foo instanceof Map<String, Foo>`,
-    // and you must instead check `foo instanceof Map`.
-    toJavaTypeNoGenerics(type, opts) {
-        const typeStr = this.toJavaType(type, opts);
-        const leftAngleBracketIdx = typeStr.indexOf('<');
-        const rightAngleBracketIdx = typeStr.indexOf('>');
-        if ((leftAngleBracketIdx < 0 && rightAngleBracketIdx >= 0) ||
-            (leftAngleBracketIdx >= 0 && rightAngleBracketIdx < 0)) {
-            throw new Error(`Invalid generic type: found ${typeStr}`);
+    /**
+     * Return the jsii object that represents this native type
+     */
+    toNativeType(type) {
+        if (type.type === 'static' && type.typeSymbol === 'java.util.List') {
+            const nativeElementType = this.toNativeType(type.typeArguments[0]);
+            return `software.amazon.jsii.NativeType.listOf(${nativeElementType})`;
         }
-        return leftAngleBracketIdx > 0 && rightAngleBracketIdx > 0
-            ? typeStr.slice(0, leftAngleBracketIdx)
-            : typeStr;
-    }
-    toJavaType(type, opts) {
-        const types = this.toJavaTypes(type, opts);
-        if (types.length > 1) {
-            return 'java.lang.Object';
+        if (type.type === 'static' && type.typeSymbol === 'java.util.Map') {
+            const nativeElementType = this.toNativeType(type.typeArguments[1]);
+            return `software.amazon.jsii.NativeType.mapOf(${nativeElementType})`;
         }
-        return types[0];
+        return `software.amazon.jsii.NativeType.forClass(${marshallingType(type)})`;
     }
-    toNativeType(type, { forMarshalling = false, covariant = false } = {}) {
-        if (spec.isCollectionTypeReference(type)) {
-            const nativeElementType = this.toNativeType(type.collection.elementtype, {
-                forMarshalling,
-                covariant,
-            });
-            switch (type.collection.kind) {
-                case spec.CollectionKind.Array:
-                    return `software.amazon.jsii.NativeType.listOf(${nativeElementType})`;
-                case spec.CollectionKind.Map:
-                    return `software.amazon.jsii.NativeType.mapOf(${nativeElementType})`;
-                default:
-                    throw new Error(`Unsupported collection kind: ${type.collection.kind}`);
-            }
-        }
-        return `software.amazon.jsii.NativeType.forClass(${this.toJavaType(type, {
-            forMarshalling,
-            covariant,
-        })}.class)`;
+    /**
+     * Convert a jsii type to a single Java type, collapsing to object if necessary
+     */
+    toSingleJavaType(typeref, { typeSymGen = undefined } = {}) {
+        return forceSingleType(this.toJavaTypes(typeref, { typeSymGen }));
     }
-    toJavaTypes(typeref, { forMarshalling = false, covariant = false } = {}) {
+    /**
+     * Convert a jsii type to a union of Java types
+     */
+    toJavaTypes(typeref, { typeSymGen = undefined } = {}) {
+        typeSymGen = typeSymGen ?? newTypeSymGen();
         if (spec.isPrimitiveTypeReference(typeref)) {
             return [this.toJavaPrimitive(typeref.primitive)];
         }
         else if (spec.isCollectionTypeReference(typeref)) {
-            return [this.toJavaCollection(typeref, { forMarshalling, covariant })];
+            return [
+                this.toJavaCollection(typeref, {
+                    typeSymGen,
+                }),
+            ];
         }
         else if (spec.isNamedTypeReference(typeref)) {
-            return [this.toNativeFqn(typeref.fqn)];
+            const literal = (0, type_literals_1.literalTypeReference)(typeref);
+            return literal
+                ? [mkStatic(literal)]
+                : [mkStatic(this.toNativeFqn(typeref.fqn))];
         }
         else if (spec.isUnionTypeReference(typeref)) {
-            const types = new Array();
-            for (const subtype of typeref.union.types) {
-                for (const t of this.toJavaTypes(subtype, {
-                    forMarshalling,
-                    covariant,
-                })) {
-                    types.push(t);
-                }
-            }
-            return types;
-        }
-        throw new Error(`Invalid type reference: ${JSON.stringify(typeref)}`);
-    }
-    toJavaCollection(ref, { forMarshalling, covariant, }) {
-        const elementJavaType = this.toJavaType(ref.collection.elementtype, {
-            covariant,
+            return typeref.union.types.flatMap((subtype) => this.toJavaTypes(subtype, { typeSymGen }));
+        }
+        else if (spec.isIntersectionTypeReference(typeref)) {
+            const typeVariable = typeSymGen();
+            return [
+                mkParam(typeVariable, `${typeVariable} extends ${typeref.intersection.types
+                    // Take the first type of any given union (an intersect-of-union
+                    // would have been rejected by jsii-compiler anyway)
+                    .map((t) => displayStatic(this.toJavaTypes(t)[0]))
+                    .join(' & ')}`),
+            ];
+        }
+        throw new Error(`Unrenderable type reference: ${JSON.stringify(typeref)}`);
+    }
+    toJavaCollection(ref, { typeSymGen }) {
+        const elementJavaType = this.toSingleJavaType(ref.collection.elementtype, {
+            typeSymGen,
         });
-        const typeConstraint = covariant
-            ? makeCovariant(elementJavaType)
-            : elementJavaType;
         switch (ref.collection.kind) {
             case spec.CollectionKind.Array:
-                return forMarshalling
-                    ? 'java.util.List'
-                    : `java.util.List<${typeConstraint}>`;
+                return mkStatic('java.util.List', [elementJavaType]);
             case spec.CollectionKind.Map:
-                return forMarshalling
-                    ? 'java.util.Map'
-                    : `java.util.Map<java.lang.String, ${typeConstraint}>`;
+                return mkStatic('java.util.Map', [
+                    mkStatic('java.lang.String'),
+                    elementJavaType,
+                ]);
             default:
                 throw new Error(`Unsupported collection kind: ${ref.collection.kind}`);
         }
-        function makeCovariant(javaType) {
-            // Don't emit a covariant expression for String (it's `final` in Java)
-            if (javaType === 'java.lang.String') {
-                return javaType;
-            }
-            return `? extends ${javaType}`;
-        }
     }
     toJavaPrimitive(primitive) {
         switch (primitive) {
             case spec.PrimitiveType.Boolean:
-                return 'java.lang.Boolean';
+                return mkStatic('java.lang.Boolean');
             case spec.PrimitiveType.Date:
-                return 'java.time.Instant';
+                return mkStatic('java.time.Instant');
             case spec.PrimitiveType.Json:
-                return 'com.fasterxml.jackson.databind.node.ObjectNode';
+                return mkStatic('com.fasterxml.jackson.databind.node.ObjectNode');
             case spec.PrimitiveType.Number:
-                return 'java.lang.Number';
+                return mkStatic('java.lang.Number');
             case spec.PrimitiveType.String:
-                return 'java.lang.String';
+                return mkStatic('java.lang.String');
             case spec.PrimitiveType.Any:
-                return 'java.lang.Object';
+                return mkStatic('java.lang.Object');
             default:
                 throw new Error(`Unknown primitive type: ${primitive}`);
         }
     }
+    /**
+     * Render a type reference to something human readable for use in JavaDocs
+     */
+    renderTypeReference(x) {
+        return (0, type_visitor_1.visitTypeReference)(x, {
+            primitive: (x) => `{@link ${this.toJavaPrimitive(x.primitive).typeSymbol}}`,
+            named: (x) => `{@link ${this.toNativeFqn(x.fqn)}}`,
+            collection: (x) => {
+                switch (x.collection.kind) {
+                    case spec.CollectionKind.Array:
+                        return `List<${this.renderTypeReference(x.collection.elementtype)}>`;
+                    case spec.CollectionKind.Map:
+                        return `Map<String, ${this.renderTypeReference(x.collection.elementtype)}>`;
+                }
+            },
+            union: (x) => `either ${x.union.types.map((x) => this.renderTypeReference(x)).join(' or ')}`,
+            intersection: (x) => `${x.intersection.types.map((x) => this.renderTypeReference(x)).join(' + ')}`,
+        });
+    }
     renderMethodCallArguments(method) {
         if (!method.parameters || method.parameters.length === 0) {
             return '';
@@ -2082,17 +2128,16 @@ class JavaGenerator extends generator_1.Generator {
     renderMethodCall(cls, method, async) {
         let statement = '';
         if (method.static) {
-            const javaClass = this.toJavaType(cls);
-            statement += `software.amazon.jsii.JsiiObject.jsiiStaticCall(${javaClass}.class, `;
+            const javaClass = this.toSingleJavaType(cls);
+            statement += `software.amazon.jsii.JsiiObject.jsiiStaticCall(${displayStatic(javaClass)}.class, `;
         }
         else {
             statement += `software.amazon.jsii.Kernel.${async ? 'asyncCall' : 'call'}(this, `;
         }
         statement += `"${method.name}"`;
         if (method.returns) {
-            statement += `, ${this.toNativeType(method.returns.type, {
-                forMarshalling: true,
-            })}`;
+            const returnsType = forceSingleType(this.toJavaTypes(method.returns.type));
+            statement += `, ${this.toNativeType(returnsType)}`;
         }
         else {
             statement += ', software.amazon.jsii.NativeType.VOID';
@@ -2128,20 +2173,28 @@ class JavaGenerator extends generator_1.Generator {
             }
             // In the case of "optional", the value needs ot be explicitly cast to allow for cases where the raw type was returned.
             return optional
-                ? `java.util.Optional.ofNullable((${this.toJavaType(type)})(${statement})).map(java.util.Collections::${wrapper}).orElse(null)`
+                ? `java.util.Optional.ofNullable((${displayStatic(this.toSingleJavaType(type))})(${statement})).map(java.util.Collections::${wrapper}).orElse(null)`
                 : `java.util.Collections.${wrapper}(${statement})`;
         }
         return statement;
     }
-    renderMethodParameters(method) {
+    convertTypes(parameters) {
+        return (parameters ?? []).map((p) => {
+            return forceSingleType(this.toDecoratedJavaTypes(p));
+        });
+    }
+    renderParameters(parameters, types, overridable) {
+        parameters = parameters ?? [];
+        if (parameters.length !== types.length) {
+            throw new Error(`Arrays not same length: ${parameters.length} !== ${types.length}`);
+        }
+        // We can render covariant parameters only for methods that aren't overridable... so only for static methods currently.
+        // (There are some more places where we could do this, like properties and constructors, but historically we didn't
+        // and I don't want to mess with this too much because the risk/reward isn't there.)
+        const cov = overridable === 'final' ? 'covariant' : undefined;
         const params = [];
-        if (method.parameters) {
-            for (const p of method.parameters) {
-                // We can render covariant parameters only for methods that aren't overridable... so only for static methods currently.
-                params.push(`final ${this.toDecoratedJavaType(p, {
-                    covariant: method.static,
-                })}${p.variadic ? '...' : ''} ${JavaGenerator.safeJavaPropertyName(p.name)}`);
-            }
+        for (const [p, type] of (0, util_1.zip)(parameters, types)) {
+            params.push(`final ${displayType(type, cov)}${p.variadic ? '...' : ''} ${JavaGenerator.safeJavaPropertyName(p.name)}`);
         }
         return params.join(', ');
     }
@@ -2451,16 +2504,6 @@ function isNullable(optionalValue) {
         (spec.isPrimitiveTypeReference(optionalValue.type) &&
             optionalValue.type.primitive === spec.PrimitiveType.Any));
 }
-function paramJavadoc(name, optional, summary) {
-    const parts = ['@param', name];
-    if (summary) {
-        parts.push(stripNewLines(myMarkDownToJavaDoc(endWithPeriod(summary))));
-    }
-    if (!optional) {
-        parts.push('This parameter is required.');
-    }
-    return parts.join(' ');
-}
 function endWithPeriod(s) {
     s = s.trimRight();
     if (!s.endsWith('.')) {
@@ -2602,11 +2645,6 @@ function splitNamespace(ns) {
 function escape(s) {
     return s.replace(/["\\<>&]/g, (c) => `&#${c.charCodeAt(0)};`);
 }
-function containsUnionType(typeRef) {
-    return (spec.isUnionTypeReference(typeRef) ||
-        (spec.isCollectionTypeReference(typeRef) &&
-            containsUnionType(typeRef.collection.elementtype)));
-}
 function myMarkDownToJavaDoc(source) {
     if (source.includes('{@link') || source.includes('{@code')) {
         // Slightly dirty hack: if we are seeing this, it means the docstring was provided literally
@@ -2625,4 +2663,155 @@ function stripNewLines(x) {
 function escapeEndingComment(x) {
     return x.replace(/\*\//g, '*\\/');
 }
+function newTypeSymGen() {
+    let cnt = 1;
+    return () => {
+        return `T${cnt++}`;
+    };
+}
+function mkStatic(typeSymbol, typeArguments = []) {
+    return { typeSymbol, annotation: '', type: 'static', typeArguments };
+}
+function mkParam(typeVariable, typeVarDeclaration) {
+    return {
+        type: 'param',
+        annotation: '',
+        typeSymbol: typeVariable,
+        typeVariable,
+        typeVarDeclaration,
+    };
+}
+function displayStatic(x, options) {
+    if (x.type !== 'static') {
+        throw new Error(`Expected static type here, got ${JSON.stringify(x)}`);
+    }
+    return displayType(x, options);
+}
+function displayType(x, options) {
+    switch (x.type) {
+        case 'param':
+            return `${x.annotation}${x.typeSymbol}`;
+        case 'static':
+            return [
+                `${x.annotation}${x.typeSymbol}`,
+                (x.typeArguments ?? []).length > 0
+                    ? `<${x
+                        .typeArguments.map((t, i) => {
+                        const subT = displayType(t, options);
+                        // For Map<K, V> we only want to make V covariant.
+                        // Since that's and List<T> are the only types we have generics
+                        // for anyway, we hack it here (as opposed to storing a field on
+                        // the type object itself). This is simpler and Good Enough For Now(tm).
+                        const isLastParameter = i === (x.typeArguments ?? []).length - 1;
+                        // Don't emit a covariant expression for String (it's `final` in Java)
+                        const isString = subT === 'java.lang.String';
+                        return options === 'covariant' && isLastParameter && !isString
+                            ? `? extends ${subT}`
+                            : subT;
+                    })
+                        .join(', ')}>`
+                    : '',
+            ].join('');
+    }
+}
+function typeVarDeclarations(types) {
+    const ret = [];
+    for (const t of types) {
+        recurse(t);
+    }
+    return ret.length > 0 ? `<${ret.join(', ')}> ` : '';
+    function recurse(t) {
+        switch (t.type) {
+            case 'param':
+                ret.push(t.typeVarDeclaration);
+                break;
+            case 'static':
+                for (const arg of t.typeArguments ?? []) {
+                    recurse(arg);
+                }
+                break;
+        }
+    }
+}
+function typesEqual(a, b, opts) {
+    if (a.type !== b.type) {
+        return false;
+    }
+    if (a.typeSymbol !== b.typeSymbol) {
+        return false;
+    }
+    if (a.type === 'static' && b.type === 'static' && opts === 'deep') {
+        if (a.typeArguments?.length !== b.typeArguments?.length) {
+            return false;
+        }
+        if (a.typeArguments) {
+            for (let i = 0; i < a.typeArguments.length; i++) {
+                if (!typesEqual(a.typeArguments[i], b.typeArguments[i])) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+// endregion
+/**
+ * Return a reference for the marshalling class object
+ *
+ * Basically returns `Type.class`, disregarding any generic
+ * type arguments.
+ */
+function marshallingType(x) {
+    switch (x.type) {
+        case 'static':
+            return `${x.typeSymbol}.class`;
+        case 'param':
+            throw new Error(`Cannot marshall a type parameter: ${JSON.stringify(x)}`);
+    }
+}
+/**
+ * Return the one type from a union, or collapse to Object if there's more than one type in the union
+ */
+function forceSingleType(types) {
+    if (types.length > 1) {
+        return {
+            ...mkStatic('java.lang.Object'),
+            // Copy the annotation
+            annotation: types[0].annotation,
+        };
+    }
+    return types[0];
+}
+function annotateOptional(optionalValue, types) {
+    return types.map((t) => ({
+        ...t,
+        annotation: `${optionalValue.optional ? ANN_NULLABLE : ANN_NOT_NULL} `,
+    }));
+}
+/**
+ * Resolve any type intersections to the first type
+ */
+function removeIntersections(x) {
+    if (spec.isIntersectionTypeReference(x)) {
+        return x.intersection.types[0];
+    }
+    if (spec.isUnionTypeReference(x)) {
+        return {
+            ...x,
+            union: {
+                types: x.union.types.map(removeIntersections),
+            },
+        };
+    }
+    if (spec.isCollectionTypeReference(x)) {
+        return {
+            ...x,
+            collection: {
+                kind: x.collection.kind,
+                elementtype: removeIntersections(x.collection.elementtype),
+            },
+        };
+    }
+    return x;
+}
 //# sourceMappingURL=java.js.map