jsii-pacmak 1.121.0 → 1.122.0

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);
@@ -542,7 +552,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);
         }
@@ -636,53 +646,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) {
@@ -1320,9 +1314,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 +1335,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 +1345,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 +1363,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();
@@ -2313,6 +2289,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 +2840,58 @@ 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);
+}
 //# sourceMappingURL=java.js.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.122.0 (build d5d44e9)";
 //# 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-22T15:21:44Z 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.122.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.122.0 (build d5d44e9)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-pacmak",
-  "version": "1.121.0",
+  "version": "1.122.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.122.0",
+    "@jsii/spec": "1.122.0",
     "clone": "^2.1.2",
-    "codemaker": "^1.121.0",
+    "codemaker": "^1.122.0",
     "commonmark": "^0.31.2",
     "escape-string-regexp": "^4.0.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.121.0",
+    "jsii-reflect": "^1.122.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.122.0",
+    "@jsii/go-runtime": "^1.122.0",
+    "@jsii/java-runtime": "^1.122.0",
+    "@scope/jsii-calc-lib": "^1.122.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.122.0",
     "jsii-calc": "^3.20.120",
     "jsii-rosetta": "~5.9.10",
     "pyright": "^1.1.403"