jsii-pacmak 1.117.0 → 1.118.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/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.118.0 (build 02eec31)";
 //# 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-10-29T09:48:29Z 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.118.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.118.0 (build 02eec31)';
 //# sourceMappingURL=version.js.map

package/package.json

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