jsii-pacmak 1.117.0 → 1.119.0

package/lib/targets/go/types/class.d.ts

@@ -51,6 +51,7 @@ export declare class ClassMethod extends GoMethod {
     constructor(parent: GoClass, method: Method);
     emit(context: EmitContext): void;
     emitDecl({ code, documenter }: EmitContext): void;
+    private get returnTypeForDocs();
     get instanceArg(): string;
     get static(): boolean;
     get specialDependencies(): SpecialDependencies;

package/lib/targets/go/types/class.js

@@ -13,6 +13,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 var _GoClass_parameterValidators, _GoClassConstructor_validator;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticMethod = exports.ClassMethod = exports.GoClassConstructor = exports.GoClass = void 0;
+const jsii_reflect_1 = require("jsii-reflect");
 const naming_util_1 = require("../../../naming-util");
 const comparators = require("../comparators");
 const runtime_1 = require("../runtime");
@@ -306,8 +307,20 @@ class ClassMethod extends type_member_1.GoMethod {
     emitDecl({ code, documenter }) {
         const returnTypeString = this.reference?.void ? '' : ` ${this.returnType}`;
         documenter.emit(this.method.docs, this.apiLocation);
+        // Document the actual return type
+        if (this.returnTypeForDocs !== this.returnType) {
+            documenter.emit(new jsii_reflect_1.Docs(this.method.system, this.method, {
+                summary: `Returns \`${this.returnTypeForDocs}\`, use interface conversion if needed`,
+            }), this.apiLocation);
+        }
         code.line(`${this.name}(${this.paramString()})${returnTypeString}`);
     }
+    get returnTypeForDocs() {
+        if (jsii_reflect_1.Method.isMethod(this.method) && this.method.returns.type) {
+            return new go_type_reference_1.GoTypeRef(this.parent.pkg.root, this.method.returns.type).scopedReference(this.parent.pkg);
+        }
+        return this.method.toString();
+    }
     get instanceArg() {
         return this.parent.name.substring(0, 1).toLowerCase();
     }

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

@@ -115,10 +115,8 @@ class GoTypeRef {
                 }
                 break;
             case 'intersection':
-                if (!this.options.opaqueUnionTypes) {
-                    for (const t of this.typeMap.value) {
-                        ret.push(...t.dependencies);
-                    }
+                for (const t of this.typeMap.value) {
+                    ret.push(...t.dependencies);
                 }
                 break;
             case 'void':

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

@@ -19,12 +19,14 @@ export declare class GoProperty implements GoTypeMember {
     readonly setterName: string;
     readonly immutable: boolean;
     protected readonly apiLocation: ApiLocation;
+    private _propertyForSignature?;
     constructor(parent: GoType, property: Property);
     get validator(): ParameterValidator | undefined;
     get reference(): GoTypeRef;
     get specialDependencies(): SpecialDependencies;
     get static(): boolean;
     get returnType(): string;
+    private get returnTypeForDocs();
     get instanceArg(): string;
     get override(): string;
     emitStructMember({ code, documenter }: EmitContext): void;
@@ -32,15 +34,33 @@ export declare class GoProperty implements GoTypeMember {
     emitSetterDecl({ code, documenter }: EmitContext): void;
     emitGetterProxy(context: EmitContext): void;
     emitSetterProxy(context: EmitContext): void;
+    /**
+     * Returns the property we're overriding
+     *
+     * This is necessary because jsii allows classes to make the type of
+     * properties in subclasses more specific (this is known as "covariant return
+     * types"), but Go doesn't support this feature.
+     *
+     * If we render the signature of the property itself, and it has changed its
+     * return type, Go will see that as two conflicting definitions of the same
+     * accessor method.
+     *
+     * So instead, we will always render the type signature of the topmost method.
+     * That is either the same as the current method (in which case it doesn't make
+     * a difference), or it is a different signature, but then that's the one
+     * we need to render to prevent the method collission.
+     */
+    get propertyForSignature(): Property;
 }
 export declare abstract class GoMethod implements GoTypeMember {
     #private;
     readonly parent: GoClass | GoInterface;
     readonly method: Callable;
     readonly name: string;
-    readonly parameters: GoParameter[];
     protected readonly apiLocation: ApiLocation;
+    private _methodForSignature?;
     constructor(parent: GoClass | GoInterface, method: Callable);
+    get parameters(): GoParameter[];
     get validator(): ParameterValidator | undefined;
     abstract emit(context: EmitContext): void;
     abstract get specialDependencies(): SpecialDependencies;
@@ -51,6 +71,23 @@ export declare abstract class GoMethod implements GoTypeMember {
     get override(): string;
     get static(): boolean;
     paramString(): string;
+    /**
+     * Returns the first method we're overriding
+     *
+     * This is necessary because jsii allows classes to make the return type of
+     * methods in subclasses more specific (this is known as "covariant return
+     * types"), but Go doesn't support this feature.
+     *
+     * If we render the signature of the method itself, and it has changed its
+     * return type, Go will see that as two conflicting definitions of the same
+     * method.
+     *
+     * So instead, we will always render the type signature of the topmost method.
+     * That is either the same as the current method (in which case it doesn't make
+     * a difference), or it is a different signature, but then that's the one
+     * we need to render to prevent the method collision.
+     */
+    get methodForSignature(): Callable;
 }
 export declare class GoParameter {
     readonly name: string;

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

@@ -49,7 +49,7 @@ class GoProperty {
         return __classPrivateFieldGet(this, _GoProperty_validator, "f");
     }
     get reference() {
-        return new index_1.GoTypeRef(this.parent.pkg.root, this.property.type);
+        return new index_1.GoTypeRef(this.parent.pkg.root, this.propertyForSignature.type);
     }
     get specialDependencies() {
         return {
@@ -65,7 +65,10 @@ class GoProperty {
     }
     get returnType() {
         return (this.reference?.scopedReference(this.parent.pkg) ??
-            this.property.type.toString());
+            this.propertyForSignature.type.toString());
+    }
+    get returnTypeForDocs() {
+        return (new index_1.GoTypeRef(this.parent.pkg.root, this.property.type).scopedReference(this.parent.pkg) ?? this.property.type.toString());
     }
     get instanceArg() {
         return this.parent.proxyName.substring(0, 1).toLowerCase();
@@ -78,13 +81,21 @@ class GoProperty {
         const memberType = this.reference?.type?.name === this.parent.name
             ? `*${this.returnType}`
             : this.returnType;
-        const requiredOrOptional = this.property.optional ? 'optional' : 'required';
+        const requiredOrOptional = this.propertyForSignature.optional
+            ? 'optional'
+            : 'required';
         // Adds json and yaml tags for easy deserialization
         code.line(`${this.name} ${memberType} \`field:"${requiredOrOptional}" json:"${this.property.name}" yaml:"${this.property.name}"\``);
         // TODO add newline if not the last member
     }
     emitGetterDecl({ code, documenter }) {
         documenter.emit(this.property.docs, this.apiLocation);
+        // Document the actual return type
+        if (this.returnTypeForDocs !== this.returnType) {
+            documenter.emit(new jsii_reflect_1.Docs(this.property.system, this.property, {
+                summary: `Returns \`${this.returnTypeForDocs}\`, use interface conversion if needed`,
+            }), this.apiLocation);
+        }
         code.line(`${this.name}() ${this.returnType}`);
     }
     emitSetterDecl({ code, documenter }) {
@@ -129,6 +140,37 @@ class GoProperty {
             code.line();
         }
     }
+    /**
+     * Returns the property we're overriding
+     *
+     * This is necessary because jsii allows classes to make the type of
+     * properties in subclasses more specific (this is known as "covariant return
+     * types"), but Go doesn't support this feature.
+     *
+     * If we render the signature of the property itself, and it has changed its
+     * return type, Go will see that as two conflicting definitions of the same
+     * accessor method.
+     *
+     * So instead, we will always render the type signature of the topmost method.
+     * That is either the same as the current method (in which case it doesn't make
+     * a difference), or it is a different signature, but then that's the one
+     * we need to render to prevent the method collission.
+     */
+    get propertyForSignature() {
+        // Cache for speed
+        if (this._propertyForSignature) {
+            return this._propertyForSignature;
+        }
+        let ret = this.property;
+        while (true) {
+            const next = ret.overriddenProperty;
+            if (!next) {
+                this._propertyForSignature = ret;
+                return ret;
+            }
+            ret = next;
+        }
+    }
 }
 exports.GoProperty = GoProperty;
 _GoProperty_validator = new WeakMap();
@@ -138,12 +180,14 @@ class GoMethod {
         this.method = method;
         _GoMethod_validator.set(this, null);
         this.name = (0, naming_util_1.jsiiToPascalCase)(method.name);
-        this.parameters = this.method.parameters.map((param) => new GoParameter(parent, param));
         this.apiLocation =
             method.kind === jsii_reflect_1.MemberKind.Initializer
                 ? { api: 'initializer', fqn: parent.fqn }
                 : { api: 'member', fqn: parent.fqn, memberName: method.name };
     }
+    get parameters() {
+        return this.methodForSignature.parameters.map((param) => new GoParameter(this.parent, param));
+    }
     get validator() {
         if (__classPrivateFieldGet(this, _GoMethod_validator, "f") === null) {
             __classPrivateFieldSet(this, _GoMethod_validator, runtime_type_checking_1.ParameterValidator.forMethod(this), "f");
@@ -151,8 +195,9 @@ class GoMethod {
         return __classPrivateFieldGet(this, _GoMethod_validator, "f");
     }
     get reference() {
-        if (jsii_reflect_1.Method.isMethod(this.method) && this.method.returns.type) {
-            return new index_1.GoTypeRef(this.parent.pkg.root, this.method.returns.type);
+        const sig = this.methodForSignature;
+        if (jsii_reflect_1.Method.isMethod(sig) && sig.returns.type) {
+            return new index_1.GoTypeRef(this.parent.pkg.root, sig.returns.type);
         }
         return undefined;
     }
@@ -166,7 +211,8 @@ class GoMethod {
         return false;
     }
     get returnType() {
-        return (this.reference?.scopedReference(this.parent.pkg) ?? this.method.toString());
+        return (this.reference?.scopedReference(this.parent.pkg) ??
+            this.methodForSignature.toString());
     }
     get instanceArg() {
         return this.parent.name.substring(0, 1).toLowerCase();
@@ -182,6 +228,42 @@ class GoMethod {
             ? ''
             : this.parameters.map((p) => p.toString()).join(', ');
     }
+    /**
+     * Returns the first method we're overriding
+     *
+     * This is necessary because jsii allows classes to make the return type of
+     * methods in subclasses more specific (this is known as "covariant return
+     * types"), but Go doesn't support this feature.
+     *
+     * If we render the signature of the method itself, and it has changed its
+     * return type, Go will see that as two conflicting definitions of the same
+     * method.
+     *
+     * So instead, we will always render the type signature of the topmost method.
+     * That is either the same as the current method (in which case it doesn't make
+     * a difference), or it is a different signature, but then that's the one
+     * we need to render to prevent the method collision.
+     */
+    get methodForSignature() {
+        // Cache for speed
+        if (this._methodForSignature) {
+            return this._methodForSignature;
+        }
+        // Not sure why `this.method :: Callable` and not `this.method :: Method`, but
+        // let's be safe.
+        if (!(this.method instanceof jsii_reflect_1.Method)) {
+            return this.method;
+        }
+        let ret = this.method;
+        while (true) {
+            const next = ret.overriddenMethod;
+            if (!next) {
+                this._methodForSignature = ret;
+                return ret;
+            }
+            ret = next;
+        }
+    }
 }
 exports.GoMethod = GoMethod;
 _GoMethod_validator = new WeakMap();

package/lib/targets/go.js

@@ -45,8 +45,11 @@ class Golang extends target_1.Target {
             // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
             return Promise.reject(e);
         }
-        if (process.env.JSII_BUILD_GO) {
-            // This step is taken to ensure that the generated code is compilable
+        // This step is taken to ensure that the generated code is compilable
+        // Do it by default, because we didn't use to and that was masking a code generation
+        // problem.
+        const doBuild = !['false', '0', 'no'].includes(process.env.JSII_BUILD_GO ?? '1');
+        if (doBuild) {
             await go('build', ['-modfile', localGoMod.path, './...'], {
                 cwd: pkgDir,
             });

package/lib/targets/python.js

@@ -31,6 +31,7 @@ const type_name_1 = require("./python/type-name");
 const util_2 = require("./python/util");
 const version_utils_1 = require("./version-utils");
 const rosetta_assembly_1 = require("../rosetta-assembly");
+const toposort_1 = require("../toposort");
 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');
@@ -318,8 +319,9 @@ class BasePythonClassType {
     }
     emit(code, context) {
         context = nestedContext(context, this.fqn);
-        const classParams = this.getClassParams(context);
-        openSignature(code, 'class', this.pythonName, classParams);
+        this.sortBasesForMro();
+        const baseClasses = this.getClassParams(context);
+        openSignature(code, 'class', this.pythonName, baseClasses);
         this.generator.emitDocString(code, this.apiLocation, this.docs, {
             documentableItem: `class-${this.pythonName}`,
             trailingNewLine: true,
@@ -343,6 +345,80 @@ class BasePythonClassType {
             context.emittedTypes.add(this.fqn);
         }
     }
+    /**
+     * Sort the this.bases array for proper Python MRO.
+     *
+     * If we don't do this, there is a chance that a superclass and subclass (or interface)
+     * have the parents in different order, which leads to an MRO violation.
+     *
+     * See: <https://docs.python.org/3/howto/mro.html>
+     *
+     * The bottom line is: child classes higher up in the hierarchy first.
+     * As an example, in the hierarchy:
+     *
+     * ```
+     *  ┌─────┐
+     *  │  A  │
+     *  └─────┘
+     *     ▲
+     *     ├─────┐
+     *     │  ┌─────┐
+     *     │  │  C  │
+     *     │  └─────┘
+     *     │     ▲
+     *     ├─────┘
+     *  ┌─────┐
+     *  │  B  │
+     *  └─────┘
+     * ```
+     *
+     * The order should be `class B(C, A)`, and not the other way around.
+     *
+     * This is yet another instance of topological sort.
+     */
+    sortBasesForMro() {
+        if (this.bases.length <= 1) {
+            return;
+        }
+        // Record original order
+        const originalOrder = new Map();
+        for (let i = 0; i < this.bases.length; i++) {
+            originalOrder.set(this.bases[i], i);
+        }
+        // Classify into sortable and non-sortable types
+        const sortableBases = [];
+        const nonSortableBases = [];
+        for (const baseRef of this.bases) {
+            if (spec.isNamedTypeReference(baseRef)) {
+                sortableBases.push(baseRef);
+            }
+            else {
+                nonSortableBases.push(baseRef);
+            }
+        }
+        // Toposort, in reverse (highest in the tree last)
+        const typeSystem = this.generator.reflectAssembly.system;
+        const sorted = (0, toposort_1.topologicalSort)(sortableBases, (t) => t.fqn, (d) => typeBaseFqns(typeSystem.findFqn(d.fqn)));
+        sorted.reverse();
+        // Inside a trance, we keep original sort order in the source declarations.
+        for (const tranche of sorted) {
+            tranche.sort((a, b) => originalOrder.get(a) - originalOrder.get(b));
+        }
+        // Replace original bases
+        this.bases.splice(0, this.bases.length, ...sorted.flatMap((xs) => xs), ...nonSortableBases);
+        function typeBaseFqns(x) {
+            if (x.isClassType()) {
+                return [
+                    ...(x.base ? [x.base?.fqn] : []),
+                    ...x.getInterfaces().map((i) => i.fqn),
+                ];
+            }
+            if (x.isInterfaceType()) {
+                return x.getInterfaces().map((i) => i.fqn);
+            }
+            return [];
+        }
+    }
     boundResolver(resolver) {
         if (this.fqn == null) {
             return resolver;
@@ -672,6 +748,7 @@ class BaseProperty {
 }
 class Interface extends BasePythonClassType {
     emit(code, context) {
+        this.sortBasesForMro();
         context = nestedContext(context, this.fqn);
         emitList(code, '@jsii.interface(', [`jsii_type="${this.fqn}"`], ')');
         // First we do our normal class logic for emitting our members.
@@ -749,6 +826,7 @@ class Struct extends BasePythonClassType {
         this.directMembers.push(member);
     }
     emit(code, context) {
+        this.sortBasesForMro();
         context = nestedContext(context, this.fqn);
         const baseInterfaces = this.getClassParams(context);
         code.indent('@jsii.data_type(');

package/lib/toposort.d.ts

@@ -34,5 +34,5 @@ export declare function topologicalSort<T>(xs: Iterable<T>, keyFn: KeyFunc<T>, d
  * We do declare the type `Toposorted<A>` here so that if we ever change
  * the type, we can find all usage sites quickly.
  */
-export type Toposorted<A> = readonly A[][];
+export type Toposorted<A> = A[][];
 //# sourceMappingURL=toposort.d.ts.map

package/lib/util.d.ts

@@ -132,4 +132,5 @@ export declare function filterAsync<A>(xs: A[], pred: (x: A) => Promise<boolean>
 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 setAdd<T>(setA: Set<T>, setB: Iterable<T>): void;
 //# sourceMappingURL=util.d.ts.map

package/lib/util.js

@@ -14,6 +14,7 @@ exports.filterAsync = filterAsync;
 exports.wait = wait;
 exports.flatten = flatten;
 exports.zip = zip;
+exports.setAdd = setAdd;
 const child_process_1 = require("child_process");
 const fs = require("fs-extra");
 const os = require("os");
@@ -341,4 +342,9 @@ function zip(xs, ys) {
     }
     return ret;
 }
+function setAdd(setA, setB) {
+    for (const b of setB) {
+        setA.add(b);
+    }
+}
 //# sourceMappingURL=util.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.117.0 (build b8499c7)";
+export declare const VERSION_DESC = "1.119.0 (build 1634eac)";
 //# sourceMappingURL=version.d.ts.map

package/lib/version.js

@@ -1,10 +1,10 @@
 "use strict";
-// Generated at 2025-10-22T16:32:40Z by generate.sh
+// Generated at 2025-11-10T14:25:15Z 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.117.0';
+exports.VERSION = '1.119.0';
 /** The qualified version number for this jsii-pacmak release (e.g: `X.Y.Z (build #######)`) */
-exports.VERSION_DESC = '1.117.0 (build b8499c7)';
+exports.VERSION_DESC = '1.119.0 (build 1634eac)';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsii-pacmak",
-  "version": "1.117.0",
+  "version": "1.119.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.117.0",
-    "@jsii/spec": "1.117.0",
+    "@jsii/check-node": "1.119.0",
+    "@jsii/spec": "1.119.0",
     "clone": "^2.1.2",
-    "codemaker": "^1.117.0",
+    "codemaker": "^1.119.0",
     "commonmark": "^0.31.2",
     "escape-string-regexp": "^4.0.0",
     "fs-extra": "^10.1.0",
-    "jsii-reflect": "^1.117.0",
+    "jsii-reflect": "^1.119.0",
     "semver": "^7.7.2",
     "spdx-license-list": "^6.10.0",
     "xmlbuilder": "^15.1.1",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@jsii/dotnet-runtime": "^1.117.0",
-    "@jsii/go-runtime": "^1.117.0",
-    "@jsii/java-runtime": "^1.117.0",
-    "@scope/jsii-calc-lib": "^1.117.0",
+    "@jsii/dotnet-runtime": "^1.119.0",
+    "@jsii/go-runtime": "^1.119.0",
+    "@jsii/java-runtime": "^1.119.0",
+    "@scope/jsii-calc-lib": "^1.119.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.117.0",
+    "jsii-build-tools": "^1.119.0",
     "jsii-calc": "^3.20.120",
     "jsii-rosetta": "~5.9.10",
     "pyright": "^1.1.403"