jsii-pacmak 1.121.0 → 1.123.0

package/lib/targets/dotnet/nameutils.js

@@ -77,6 +77,14 @@ class DotNetNameUtils {
             throw new Error(`Invalid parameter name: ${original}`);
         }
         const name = (0, codemaker_1.toCamelCase)(original);
+        if (!name) {
+            // toCamelCase will return an empty string from a string like `_(_+)`. Confirm that
+            // that is what is happening, then return the original string.
+            if (original.match(/^__+$/)) {
+                return original;
+            }
+            throw new Error(`toCamelCase returns an empty string from: ${JSON.stringify(original)}`);
+        }
         return this.escapeParameterName(name);
     }
     capitalizeWord(original) {

package/lib/targets/java.d.ts

@@ -107,16 +107,16 @@ declare class JavaGenerator extends Generator {
     protected onInterfaceMethodOverload(ifc: spec.InterfaceType, overload: spec.Method, _originalMethod: spec.Method): void;
     protected onInterfaceProperty(ifc: spec.InterfaceType, prop: spec.Property): void;
     /**
-     * Emits a local default implementation for optional properties inherited from
-     * multiple distinct parent types. This remvoes the default method dispatch
-     * ambiguity that would otherwise exist.
+     * Emits a local default implementation for properties inherited from multiple
+     * distinct parent types. This removes the default method dispatch ambiguity
+     * that would otherwise exist.
      *
      * @param ifc            the interface to be processed.
   
      *
      * @see https://github.com/aws/jsii/issues/2256
      */
-    private emitMultiplyInheritedOptionalProperties;
+    private emitMultiplyInheritedProperties;
     private emitAssemblyPackageInfo;
     private emitSubmodulePackageInfo;
     private emitMavenPom;
@@ -215,6 +215,34 @@ declare class JavaGenerator extends Generator {
     private renderAccessLevel;
     private makeModuleClass;
     private emitModuleFile;
+    /**
+     * Given a method, return the methods that we should generate implementations for on the $Default interface
+     *
+     * This can be 0..N:
+     *
+     * - 0: if the method can be inherited from a parent $Default implementation
+     * - 1: if the method cannot be inherited from a parent $Default implementation
+     * - N: ah-ha, wait! There can be overloads! And because of a historical bug,
+     *   we didn't use to generate overloads onto $Default interfaces. So it's possible
+     *   that we don't generate the "main" implementation, but we do generate its overloads.
+     *
+     * Technically speaking we only have to account for the bug if the type is from a different
+     * assembly (because we know all types from the current assembly will be generated ✨ bugless ✨,
+     * but just to keep it simple we'll always do the same thing).
+     *
+     * We can only get rid of this bug once the oldest dependency package a Java
+     * package can be used with definitely has overloaded $Default impls. So that will be a while.
+     */
+    private makeDefaultImpls;
+    /**
+     * Given a method, return the methods that we should generate implementations for on the $Proxy class
+     *
+     * See `makeDefaultImpls` for the main rationale behind this. The $Proxy class inherits from $Default
+     * so technically this could have usually been empty, but we need to account for the possibility that
+     * we implement a $Default interface from another assembly that has been generated with a buggy version
+     * of pacmak.
+     */
+    private makeProxyImpls;
     private emitJsiiInitializers;
     /**
      * Computes the java FQN for a JSII FQN:

package/lib/targets/java.js

@@ -7,6 +7,7 @@ const clone = require("clone");
 const case_utils_1 = require("codemaker/lib/case-utils");
 const crypto_1 = require("crypto");
 const fs = require("fs-extra");
+const reflect = require("jsii-reflect");
 const jsii_rosetta_1 = require("jsii-rosetta");
 const path = require("path");
 const xmlbuilder = require("xmlbuilder");
@@ -29,6 +30,14 @@ const BUILDER_CLASS_NAME = 'Builder';
 const ANN_NOT_NULL = '@org.jetbrains.annotations.NotNull';
 const ANN_NULLABLE = '@org.jetbrains.annotations.Nullable';
 const ANN_INTERNAL = '@software.amazon.jsii.Internal';
+/**
+ * Because of a historical bug, $Default interfaces we inherit from might not
+ * have all method overloads generated correctly.
+ *
+ * So when inheriting these, we might need to generate the overloads in
+ * subinterfaces/subclasses.
+ */
+const GENERATE_POTENTIALLY_MISING_DEFAULT_OVERLOADS = true;
 /**
  * Build Java packages all together, by generating an aggregate POM
  *
@@ -58,6 +67,7 @@ class JavaBuilder {
         try {
             const tempSourceDir = await this.generateAggregateSourceDir(this.modules, this.options);
             scratchDirs.push(tempSourceDir);
+            await resolveMavenVersions(tempSourceDir.directory);
             // Need any old module object to make a target to be able to invoke build, though none of its settings
             // will be used.
             const target = this.makeTarget(this.modules[0], this.options);
@@ -345,8 +355,22 @@ class JavaGenerator extends generator_1.Generator {
             return propertyName;
         }
         if (propertyName === '_') {
-            // Slightly different pattern for this one
-            return '__';
+            // Slightly different pattern for this one. We used to generate `__` here
+            // but it's somewhat likely that people will use `_, __, ___` as multiple
+            // indifferent arguments, so we pick a different name.
+            //
+            // Ideally we would look at the alternative argument names and pick
+            // something guaranteed to be unique, but unfortunately the code isn't
+            // quite structured that way so we'll pick something unlikely to collide
+            // instead.
+            //
+            // Changing from `__` -> `_under` would be a breaking change if applied to
+            // public property names, but most likely this will be used for function
+            // parameters (unfortunately the code has been structured in such a way
+            // that property and parameter names are strongly tied together, in a way
+            // that would take more time to unwind than I care to invest right now),
+            // where it doesn't matter.
+            return '_under_';
         }
         if (JavaGenerator.RESERVED_KEYWORDS.includes(propertyName)) {
             return `${propertyName}Value`;
@@ -444,9 +468,9 @@ class JavaGenerator extends generator_1.Generator {
             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.openBlock(`${initializerAccessLevel} ${cls.name}(${this.renderParameters(method.parameters, types, 'exact-types')})`);
         this.code.line('super(software.amazon.jsii.JsiiObject.InitializationMode.JSII);');
-        this.emitUnionParameterValidation(method.parameters);
+        this.emitUnionParameterValidation(method.parameters, 'exact-types');
         this.code.line(`software.amazon.jsii.JsiiEngine.getInstance().createNewObject(this${this.renderMethodCallArguments(method)});`);
         this.code.closeBlock();
     }
@@ -542,7 +566,7 @@ class JavaGenerator extends generator_1.Generator {
         this.code.openBlock(`public${inner} interface ${ifc.name} extends ${bases}`);
     }
     onEndInterface(ifc) {
-        this.emitMultiplyInheritedOptionalProperties(ifc);
+        this.emitMultiplyInheritedProperties(ifc);
         if (ifc.datatype) {
             this.emitDataType(ifc);
         }
@@ -573,7 +597,7 @@ class JavaGenerator extends generator_1.Generator {
         });
         this.emitStabilityAnnotations(method);
         const types = this.convertTypes(method.parameters);
-        this.code.line(`${typeVarDeclarations(types)}${displayStatic(returnType)} ${methodName}(${this.renderParameters(method.parameters, types, 'overridable')});`);
+        this.code.line(`${typeVarDeclarations(types)}${displayStatic(returnType)} ${methodName}(${this.renderParameters(method.parameters, types, 'exact-types')});`);
     }
     onInterfaceMethodOverload(ifc, overload, _originalMethod) {
         this.onInterfaceMethod(ifc, overload);
@@ -636,53 +660,37 @@ class JavaGenerator extends generator_1.Generator {
         }
     }
     /**
-     * Emits a local default implementation for optional properties inherited from
-     * multiple distinct parent types. This remvoes the default method dispatch
-     * ambiguity that would otherwise exist.
+     * Emits a local default implementation for properties inherited from multiple
+     * distinct parent types. This removes the default method dispatch ambiguity
+     * that would otherwise exist.
      *
      * @param ifc            the interface to be processed.
   
      *
      * @see https://github.com/aws/jsii/issues/2256
      */
-    emitMultiplyInheritedOptionalProperties(ifc) {
+    emitMultiplyInheritedProperties(ifc) {
         if (ifc.interfaces == null || ifc.interfaces.length <= 1) {
             // Nothing to do if we don't have parent interfaces, or if we have exactly one
             return;
         }
-        const inheritedOptionalProps = ifc.interfaces
-            .map(allOptionalProps.bind(this))
-            // Calculate how many direct parents brought a given optional property
-            .reduce((histogram, entry) => {
-            for (const [name, spec] of Object.entries(entry)) {
-                histogram[name] = histogram[name] ?? { spec, count: 0 };
-                histogram[name].count += 1;
-            }
-            return histogram;
-        }, {});
-        const localProps = new Set(ifc.properties?.map((prop) => prop.name) ?? []);
-        for (const { spec, count } of Object.values(inheritedOptionalProps)) {
-            if (count < 2 || localProps.has(spec.name)) {
-                continue;
-            }
-            this.onInterfaceProperty(ifc, spec);
-        }
-        function allOptionalProps(fqn) {
-            const type = this.findType(fqn);
-            const result = {};
-            for (const prop of type.properties ?? []) {
-                // Adding artifical "overrides" here for code-gen quality's sake.
-                result[prop.name] = { ...prop, overrides: type.fqn };
-            }
-            // Include optional properties of all super interfaces in the result
-            for (const base of type.interfaces ?? []) {
-                for (const [name, prop] of Object.entries(allOptionalProps.call(this, base))) {
-                    if (!(name in result)) {
-                        result[name] = prop;
-                    }
+        const memberSources = {};
+        for (const parent of ifc.interfaces) {
+            const type = this.reflectAssembly.system.findInterface(parent);
+            for (const prop of type.allProperties) {
+                if (!(prop.name in memberSources)) {
+                    memberSources[prop.name] = {};
                 }
+                memberSources[prop.name][prop.definingType.fqn] = prop.spec;
+            }
+        }
+        for (const defininingTypes of Object.values(memberSources)) {
+            // Ignore our own type
+            delete defininingTypes[ifc.fqn];
+            const keys = Object.keys(defininingTypes);
+            if (keys.length > 1) {
+                this.onInterfaceProperty(ifc, defininingTypes[keys[0]]);
             }
-            return result;
         }
     }
     emitAssemblyPackageInfo(mod) {
@@ -1072,7 +1080,7 @@ class JavaGenerator extends generator_1.Generator {
                                 name: 'value',
                                 type: this.filterType(prop, type),
                             },
-                        ]);
+                        ], 'exact-types');
                     }
                     if (prop.static) {
                         statement += `software.amazon.jsii.JsiiObject.jsiiStaticSet(${displayStatic(javaClass)}.class, `;
@@ -1126,7 +1134,8 @@ class JavaGenerator extends generator_1.Generator {
         const async = !!method.async;
         const methodName = JavaGenerator.safeJavaMethodName(method.name);
         const types = this.convertTypes(method.parameters);
-        const signature = `${typeVarDeclarations(types)}${displayStatic(returnType)} ${methodName}(${this.renderParameters(method.parameters, types, method.static ? 'final' : 'overridable')})`;
+        const covariance = covarianceFromOverridability(overridabilityFromMethod(method));
+        const signature = `${typeVarDeclarations(types)}${displayStatic(returnType)} ${methodName}(${this.renderParameters(method.parameters, types, covariance)})`;
         this.code.line();
         this.addJavaDocs(method, {
             api: 'member',
@@ -1144,7 +1153,7 @@ class JavaGenerator extends generator_1.Generator {
         }
         else {
             this.code.openBlock(`${modifiers.join(' ')} ${signature}`);
-            this.emitUnionParameterValidation(method.parameters);
+            this.emitUnionParameterValidation(method.parameters, covariance);
             this.code.line(this.renderMethodCall(cls, method, async));
             this.code.closeBlock();
         }
@@ -1154,7 +1163,7 @@ class JavaGenerator extends generator_1.Generator {
      *
      * @param parameters the list of parameters received by the function.
      */
-    emitUnionParameterValidation(parameters) {
+    emitUnionParameterValidation(parameters, covariance) {
         if (!this.runtimeTypeChecking) {
             // We were configured not to emit those, so bail out now.
             return;
@@ -1168,7 +1177,7 @@ class JavaGenerator extends generator_1.Generator {
             if (param.variadic) {
                 const javaType = this.toSingleJavaType(param.type);
                 const asListName = `__${param.name}__asList`;
-                this.code.line(`final java.util.List<${displayStatic(javaType)}> ${asListName} = java.util.Arrays.asList(${param.name});`);
+                this.code.line(`final java.util.List<${displayStatic(javaType, covariance)}> ${asListName} = java.util.Arrays.asList(${param.name});`);
                 validate.call(this, asListName, `.append("${param.name}")`, {
                     collection: {
                         kind: spec.CollectionKind.Array,
@@ -1177,7 +1186,7 @@ class JavaGenerator extends generator_1.Generator {
                 }, param.name, true);
             }
             else {
-                validate.call(this, param.name, `.append("${param.name}")`, param.type, param.name);
+                validate.call(this, param.name, `.append("${param.name}")`, param.type, param.name, false);
             }
         }
         this.code.closeBlock();
@@ -1196,7 +1205,7 @@ class JavaGenerator extends generator_1.Generator {
                 }
             }
         }
-        function validateArray(value, descr, elementType, parameterName, isRawArray = false) {
+        function validateArray(value, descr, elementType, parameterName, isRawArray) {
             const suffix = (0, crypto_1.createHash)('sha256')
                 .update(descr)
                 .digest('hex')
@@ -1208,7 +1217,7 @@ class JavaGenerator extends generator_1.Generator {
             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);
+                : `${descr}.append(".get(").append(${idxName}).append(")")`, elementType, parameterName, false);
             this.code.closeBlock();
         }
         function validateMap(value, descr, elementType, parameterName) {
@@ -1231,8 +1240,12 @@ class JavaGenerator extends generator_1.Generator {
             const varName = `__item_${suffix}`;
             const valName = `__val_${suffix}`;
             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();`);
+            const entryType = mkStatic('java.util.Map.Entry', [
+                mkStatic('java.lang.String'),
+                javaElemType,
+            ]);
+            this.code.openBlock(`for (final ${displayStatic(entryType, covariance)} ${varName}: ${value}.entrySet())`);
+            this.code.line(`final ${displayStatic(javaElemType, covariance)} ${valName} = ${varName}.getValue();`);
             validate.call(this, valName, `${descr}.append(".get(\\"").append((${varName}.getKey())).append("\\")")`, elementType, parameterName);
             this.code.closeBlock();
         }
@@ -1320,9 +1333,11 @@ class JavaGenerator extends generator_1.Generator {
         this.code.line('/**');
         this.code.line(' * A proxy class which represents a concrete javascript instance of this type.');
         this.code.line(' */');
+        // Get the list of $Default interfaces
         const baseInterfaces = this.defaultInterfacesFor(type, {
             includeThisType: true,
         });
+        // Add ourselves if we don't have a $Default interface
         if (type.isInterfaceType() && !hasDefaultInterfaces(type.assembly)) {
             // Extend this interface directly since this module does not have the Jsii$Default
             baseInterfaces.push(this.toNativeFqn(type.fqn));
@@ -1339,10 +1354,7 @@ class JavaGenerator extends generator_1.Generator {
         this.code.line('super(objRef);');
         this.code.closeBlock();
         // emit all properties
-        for (const reflectProp of type.allProperties.filter((prop) => prop.abstract &&
-            (prop.parentType.fqn === type.fqn ||
-                prop.parentType.isClassType() ||
-                !hasDefaultInterfaces(prop.assembly)))) {
+        for (const reflectProp of type.allProperties.filter(needsProxyImpl)) {
             const prop = clone(reflectProp.spec);
             prop.abstract = false;
             // Emitting "final" since this is a proxy and nothing will/should override this
@@ -1352,21 +1364,11 @@ class JavaGenerator extends generator_1.Generator {
             });
         }
         // emit all the methods
-        for (const reflectMethod of type.allMethods.filter((method) => method.abstract &&
-            (method.parentType.fqn === type.fqn ||
-                method.parentType.isClassType() ||
-                !hasDefaultInterfaces(method.assembly)))) {
-            const method = clone(reflectMethod.spec);
-            method.abstract = false;
+        for (const reflectMethod of type.allMethods.flatMap(this.makeProxyImpls.bind(this))) {
+            const method = clone(reflectMethod);
             // Emitting "final" since this is a proxy and nothing will/should override this
+            method.abstract = false;
             this.emitMethod(type.spec, method, { final: true, overrides: true });
-            for (const overloadedMethod of this.createOverloadsForOptionals(method)) {
-                overloadedMethod.abstract = false;
-                this.emitMethod(type.spec, overloadedMethod, {
-                    final: true,
-                    overrides: true,
-                });
-            }
         }
         this.code.closeBlock();
     }
@@ -1380,23 +1382,16 @@ class JavaGenerator extends generator_1.Generator {
         this.code.openBlock(`interface ${INTERFACE_DEFAULT_CLASS_NAME} extends ${baseInterfaces
             .sort()
             .join(', ')}`);
-        for (const property of type.allProperties.filter((prop) => prop.abstract &&
-            // Only checking the getter - java.lang.Object has no setters.
-            !isJavaLangObjectMethodName(`get${(0, naming_util_1.jsiiToPascalCase)(prop.name)}`) &&
-            (prop.parentType.fqn === type.fqn ||
-                !hasDefaultInterfaces(prop.assembly)))) {
+        for (const property of type.allProperties.filter(needsDefaultImpl)) {
             this.emitProperty(type.spec, property.spec, property.definingType.spec, {
                 defaultImpl: true,
                 overrides: type.isInterfaceType(),
             });
         }
-        for (const method of type.allMethods.filter((method) => method.abstract &&
-            !isJavaLangObjectMethodName(method.name) &&
-            (method.parentType.fqn === type.fqn ||
-                !hasDefaultInterfaces(method.assembly)))) {
-            this.emitMethod(type.spec, method.spec, {
+        for (const method of type.allMethods.flatMap(this.makeDefaultImpls.bind(this))) {
+            this.emitMethod(type.spec, method, {
                 defaultImpl: true,
-                overrides: type.isInterfaceType(),
+                overrides: true,
             });
         }
         this.code.closeBlock();
@@ -2185,15 +2180,11 @@ class JavaGenerator extends generator_1.Generator {
             return forceSingleType(this.toDecoratedJavaTypes(p));
         });
     }
-    renderParameters(parameters, types, overridable) {
+    renderParameters(parameters, types, cov) {
         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 = [];
         for (const [p, type] of (0, util_1.zip)(parameters, types)) {
             params.push(`final ${displayType(type, cov)}${p.variadic ? '...' : ''} ${JavaGenerator.safeJavaPropertyName(p.name)}`);
@@ -2313,6 +2304,54 @@ class JavaGenerator extends generator_1.Generator {
         this.code.closeFile(moduleFile);
         return moduleClass;
     }
+    /**
+     * Given a method, return the methods that we should generate implementations for on the $Default interface
+     *
+     * This can be 0..N:
+     *
+     * - 0: if the method can be inherited from a parent $Default implementation
+     * - 1: if the method cannot be inherited from a parent $Default implementation
+     * - N: ah-ha, wait! There can be overloads! And because of a historical bug,
+     *   we didn't use to generate overloads onto $Default interfaces. So it's possible
+     *   that we don't generate the "main" implementation, but we do generate its overloads.
+     *
+     * Technically speaking we only have to account for the bug if the type is from a different
+     * assembly (because we know all types from the current assembly will be generated ✨ bugless ✨,
+     * but just to keep it simple we'll always do the same thing).
+     *
+     * We can only get rid of this bug once the oldest dependency package a Java
+     * package can be used with definitely has overloaded $Default impls. So that will be a while.
+     */
+    makeDefaultImpls(m) {
+        const ret = [];
+        if (needsDefaultImpl(m)) {
+            ret.push(m.spec);
+        }
+        // Account for a past bug
+        if (needsDefaultImpl(m) || GENERATE_POTENTIALLY_MISING_DEFAULT_OVERLOADS) {
+            ret.push(...this.createOverloadsForOptionals(m.spec));
+        }
+        return ret;
+    }
+    /**
+     * Given a method, return the methods that we should generate implementations for on the $Proxy class
+     *
+     * See `makeDefaultImpls` for the main rationale behind this. The $Proxy class inherits from $Default
+     * so technically this could have usually been empty, but we need to account for the possibility that
+     * we implement a $Default interface from another assembly that has been generated with a buggy version
+     * of pacmak.
+     */
+    makeProxyImpls(m) {
+        const ret = [];
+        if (needsProxyImpl(m)) {
+            ret.push(m.spec);
+        }
+        // Account for a past bug
+        if (needsProxyImpl(m) || GENERATE_POTENTIALLY_MISING_DEFAULT_OVERLOADS) {
+            ret.push(...this.createOverloadsForOptionals(m.spec));
+        }
+        return ret;
+    }
     emitJsiiInitializers(cls) {
         this.code.line();
         this.code.openBlock(`protected ${cls.name}(final software.amazon.jsii.JsiiObjectRef objRef)`);
@@ -2816,4 +2855,70 @@ function removeIntersections(x) {
     }
     return x;
 }
+/**
+ * Run the maven 'versions:resolve-ranges' plugin
+ *
+ * Initially, we generate version ranges into the pom file based on the NPM
+ * version ranges.
+ *
+ * At build time, given a dependency version range, Maven will download metadata
+ * for all possible versions before every (uncached) build. This takes a long
+ * time, before finally resolving to the latest version anyway.
+ *
+ * Instead, we use the Maven 'versions' plugin to resolve our wide ranges to
+ * point versions. We want the "latest matching" version anyway, and if we don't
+ * the resolution now (which downloads the .poms of all possible versions) it
+ * will happen during every single build.
+ */
+async function resolveMavenVersions(directory) {
+    const versionsPluginVersion = '2.20.1';
+    await (0, util_1.subprocess)('mvn', [
+        `org.codehaus.mojo:versions-maven-plugin:${versionsPluginVersion}:resolve-ranges`,
+    ], {
+        cwd: directory,
+        retry: { maxAttempts: 1 },
+    });
+}
+/**
+ * Whether the given property or method needs to be implemented on a $Proxy class
+ *
+ * Proxies extend the class they're for (if for a class), and the $Default interfaces
+ * of all the base interfaces, so implementations need to be present for everything
+ * that is not abstract and can be inherited from a $Default interface.
+ */
+function needsProxyImpl(x) {
+    // Interface members are always marked 'abstract', but we only need to
+    // implement them if they come from a class (because interface members
+    // will have a $Default impl that calls out to jsii already).
+    const isAbstractClassMember = x.definingType.isClassType() && x.abstract;
+    return (isAbstractClassMember || !hasDefaultInterfaces(x.definingType.assembly));
+}
+/**
+ * Whether the given property or method needs to be implemented on a $Default interface
+ *
+ * $Default interfaces extend the interface they're for, and the $Default interfaces
+ * of all the base interfaces, so implementations need to be present for everything
+ * that is defined on the current interface or cannot be inherited from a $Default interface.
+ */
+function needsDefaultImpl(x) {
+    const isBuiltinMethod = x instanceof reflect.Property
+        ? // Only checking the getter - java.lang.Object has no setters.
+            isJavaLangObjectMethodName(`get${(0, naming_util_1.jsiiToPascalCase)(x.name)}`)
+        : isJavaLangObjectMethodName(x.name);
+    return ((!hasDefaultInterfaces(x.definingType.assembly) ||
+        x.definingType.fqn === x.parentType.fqn) &&
+        !isBuiltinMethod);
+}
+/**
+ * Return the appropriate covariance rendering for the overridability of a given method
+ */
+function covarianceFromOverridability(overridable) {
+    // 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.)
+    return overridable === 'final' ? 'covariant' : 'exact-types';
+}
+function overridabilityFromMethod(method) {
+    return method.static ? 'final' : 'overridable';
+}
 //# sourceMappingURL=java.js.map

package/lib/util.d.ts

@@ -131,6 +131,6 @@ export declare function setExtend<A>(xs: Set<A>, els: Iterable<A>): void;
 export declare function filterAsync<A>(xs: A[], pred: (x: A) => Promise<boolean>): Promise<A[]>;
 export declare function wait(ms: number): Promise<void>;
 export declare function flatten<A>(xs: readonly A[][]): A[];
-export declare function zip<A, B>(xs: A[], ys: B[]): Array<[A, B]>;
+export declare function zip<A, B>(xs: readonly A[], ys: readonly B[]): Array<[A, B]>;
 export declare function setAdd<T>(setA: Set<T>, setB: Iterable<T>): void;
 //# sourceMappingURL=util.d.ts.map

package/lib/version.d.ts

@@ -1,5 +1,5 @@
 /** The short version number for this jsii-pacmak release (e.g: `X.Y.Z`) */
 export declare const VERSION: string;
 /** The qualified version number for this jsii-pacmak release (e.g: `X.Y.Z (build #######)`) */
-export declare const VERSION_DESC = "1.121.0 (build d7af9b9)";
+export declare const VERSION_DESC = "1.123.0 (build 432bf02)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,10 +1,10 @@
 "use strict";
-// Generated at 2025-12-09T17:15:28Z by generate.sh
+// Generated at 2025-12-29T21:07:34Z by generate.sh
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION_DESC = exports.VERSION = void 0;
 /** The short version number for this jsii-pacmak release (e.g: `X.Y.Z`) */
 // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-exports.VERSION = '1.121.0';
+exports.VERSION = '1.123.0';
 /** The qualified version number for this jsii-pacmak release (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.121.0 (build d7af9b9)';
+exports.VERSION_DESC = '1.123.0 (build 432bf02)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-pacmak",
-  "version": "1.121.0",
+  "version": "1.123.0",
   "description": "A code generation framework for jsii backend languages",
   "license": "Apache-2.0",
   "author": {
@@ -37,24 +37,24 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/check-node": "1.121.0",
-    "@jsii/spec": "1.121.0",
+    "@jsii/check-node": "1.123.0",
+    "@jsii/spec": "1.123.0",
     "clone": "^2.1.2",
-    "codemaker": "^1.121.0",
+    "codemaker": "^1.123.0",
     "commonmark": "^0.31.2",
     "escape-string-regexp": "^4.0.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.121.0",
+    "jsii-reflect": "^1.123.0",
     "semver": "^7.7.2",
     "spdx-license-list": "^6.10.0",
     "xmlbuilder": "^15.1.1",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@jsii/dotnet-runtime": "^1.121.0",
-    "@jsii/go-runtime": "^1.121.0",
-    "@jsii/java-runtime": "^1.121.0",
-    "@scope/jsii-calc-lib": "^1.121.0",
+    "@jsii/dotnet-runtime": "^1.123.0",
+    "@jsii/go-runtime": "^1.123.0",
+    "@jsii/java-runtime": "^1.123.0",
+    "@scope/jsii-calc-lib": "^1.123.0",
     "@types/clone": "^2.1.4",
     "@types/commonmark": "^0.27.10",
     "@types/diff": "^5.2.3",
@@ -63,7 +63,7 @@
     "@types/yargs": "^17.0.33",
     "diff": "^5.2.0",
     "jsii": "^5.9.10",
-    "jsii-build-tools": "^1.121.0",
+    "jsii-build-tools": "^1.123.0",
     "jsii-calc": "^3.20.120",
     "jsii-rosetta": "~5.9.10",
     "pyright": "^1.1.403"