jsii-pacmak 1.120.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();
@@ -1795,7 +1771,7 @@ class JavaGenerator extends generator_1.Generator {
         }
         this.code.line();
         this.code.line('@Override');
-        this.code.openBlock('public final boolean equals(final Object o)');
+        this.code.openBlock('public final boolean equals(final java.lang.Object o)');
         this.code.line('if (this == o) return true;');
         // This was already checked by `super.equals(o)`, so we skip it here...
         this.code.line('if (o == null || getClass() != o.getClass()) return false;');
@@ -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/targets/python/type-name.d.ts

@@ -1,10 +1,21 @@
 import { Assembly, OptionalValue, TypeReference, Type } from '@jsii/spec';
 import { CodeMaker } from 'codemaker';
+/**
+ * The position of a type
+ *
+ * Types are rendered differently depending on what position they're in:
+ *
+ * - `type`: a type annotation; these are not evaluated during execution.
+ * - `value`: a value in a function body; these are evaluated when the function is called.
+ * - `decl`: a value in a class declaration; these are evaluated when a class is being
+ *   instantiated, before it's done.
+ */
+export type TypePosition = 'type' | 'value' | 'decl';
 /**
  * Actually more of a TypeNameFactory than a TypeName
  */
 export interface TypeName {
-    pythonType(context: NamingContext): string;
+    pythonType(pos: TypePosition, context: NamingContext): string;
     requiredImports(context: NamingContext): PythonImports;
 }
 export interface PythonImports {
@@ -27,12 +38,6 @@ export interface NamingContext {
     readonly submodule: string;
     /** Holds the set of intersection types used in the current module */
     readonly intersectionTypes: IntersectionTypesRegistry;
-    /**
-     * The declaration is made in the context of a type annotation (so it can be quoted)
-     *
-     * @default true
-     */
-    readonly typeAnnotation?: boolean;
     /**
      * A an array representing the stack of declarations currently being
      * initialized. All of these names can only be referred to using a forward
@@ -40,6 +45,8 @@ export interface NamingContext {
      * they can be used safely from implementations so long as those are not *run*
      * as part of the declaration).
      *
+     * Closest to the current type is at the end.
+     *
      * @default []
      */
     readonly surroundingTypeFqns?: readonly string[];
@@ -49,12 +56,6 @@ export interface NamingContext {
      * @internal
      */
     readonly ignoreOptional?: boolean;
-    /**
-     * The set of jsii type FQNs that have already been emitted so far. This is
-     * used to determine whether a given type reference is a forward declaration
-     * or not when emitting type signatures.
-     */
-    readonly emittedTypes: Set<string>;
     /**
      * Whether the type is emitted for a parameter or not. This may change the
      * exact type signature being emitted (e.g: Arrays are typing.Sequence[T] for

package/lib/targets/python/type-name.js

@@ -87,8 +87,8 @@ class Dict {
         _Dict_element.set(this, void 0);
         __classPrivateFieldSet(this, _Dict_element, element, "f");
     }
-    pythonType(context) {
-        return `typing.Mapping[builtins.str, ${__classPrivateFieldGet(this, _Dict_element, "f").pythonType(context)}]`;
+    pythonType(pos, context) {
+        return `typing.Mapping[builtins.str, ${__classPrivateFieldGet(this, _Dict_element, "f").pythonType(pos, context)}]`;
     }
     requiredImports(context) {
         return __classPrivateFieldGet(this, _Dict_element, "f").requiredImports(context);
@@ -101,9 +101,9 @@ class List {
         _List_element.set(this, void 0);
         __classPrivateFieldSet(this, _List_element, element, "f");
     }
-    pythonType(context) {
+    pythonType(pos, context) {
         const type = context.parameterType ? 'Sequence' : 'List';
-        return `typing.${type}[${__classPrivateFieldGet(this, _List_element, "f").pythonType(context)}]`;
+        return `typing.${type}[${__classPrivateFieldGet(this, _List_element, "f").pythonType(pos, context)}]`;
     }
     requiredImports(context) {
         return __classPrivateFieldGet(this, _List_element, "f").requiredImports(context);
@@ -116,8 +116,8 @@ class Optional {
         _Optional_wrapped.set(this, void 0);
         __classPrivateFieldSet(this, _Optional_wrapped, wrapped, "f");
     }
-    pythonType(context) {
-        const optionalType = __classPrivateFieldGet(this, _Optional_wrapped, "f").pythonType({
+    pythonType(pos, context) {
+        const optionalType = __classPrivateFieldGet(this, _Optional_wrapped, "f").pythonType(pos, {
             ...context,
             ignoreOptional: true,
         });
@@ -176,9 +176,9 @@ class Union {
         _Union_options.set(this, void 0);
         __classPrivateFieldSet(this, _Union_options, options, "f");
     }
-    pythonType(context) {
+    pythonType(pos, context) {
         return `typing.Union[${__classPrivateFieldGet(this, _Union_options, "f")
-            .map((o) => o.pythonType(context))
+            .map((o) => o.pythonType(pos, context))
             .join(', ')}]`;
     }
     requiredImports(context) {
@@ -192,9 +192,9 @@ class Intersection {
         _Intersection_types.set(this, void 0);
         __classPrivateFieldSet(this, _Intersection_types, types, "f");
     }
-    pythonType(context) {
+    pythonType(pos, context) {
         // We will be generating a special type to represent the intersection
-        const name = context.intersectionTypes.obtain(__classPrivateFieldGet(this, _Intersection_types, "f").map((t) => t.pythonType(context)).map(stripQuotes));
+        const name = context.intersectionTypes.obtain(__classPrivateFieldGet(this, _Intersection_types, "f").map((t) => t.pythonType(pos, context)).map(stripQuotes));
         // This will never be in scope already, so always render between quotes
         return `'${name}'`;
     }
@@ -209,24 +209,32 @@ class UserType {
         _UserType_fqn.set(this, void 0);
         __classPrivateFieldSet(this, _UserType_fqn, fqn, "f");
     }
-    pythonType(context) {
-        return this.resolve(context).pythonType;
+    pythonType(pos, context) {
+        return this.resolve(pos, context).pythonType;
     }
     requiredImports(context) {
-        const requiredImport = this.resolve(context).requiredImport;
+        const requiredImport = this.resolve('value', context).requiredImport;
         if (requiredImport == null) {
             return {};
         }
         return { [requiredImport.sourcePackage]: new Set([requiredImport.item]) };
     }
-    resolve({ assembly, emittedTypes, submodule, surroundingTypeFqns, typeAnnotation = true, parameterType, typeResolver, }) {
+    resolve(pos, { assembly, submodule, surroundingTypeFqns, parameterType, typeResolver, }) {
         const { assemblyName, packageName, pythonFqn } = toPythonFqn(__classPrivateFieldGet(this, _UserType_fqn, "f"), assembly);
-        // If this is a type annotation for a parameter, allow dicts to be passed where structs are expected.
+        // If this is a type annotation for a parameter, allow dicts to be passed
+        // where structs are expected for backwards compatibility with the very
+        // first versions of jsii (dicts need to be in jsii-casing).
         const type = typeResolver(__classPrivateFieldGet(this, _UserType_fqn, "f"));
         const isStruct = (0, spec_1.isInterfaceType)(type) && !!type.datatype;
-        const wrapType = typeAnnotation && parameterType && isStruct
-            ? (pyType) => `typing.Union[${pyType}, typing.Dict[builtins.str, typing.Any]]`
-            : (pyType) => pyType;
+        // Make a function that quotes the string based on whether we're using it as a type annotation or not.
+        // It's never wrong to quote type annotations, and it never fails and evaluates faster because it avoids
+        // object lookups at eval time.
+        const maybeQuote = (x) => (pos === 'type' ? `"${x}"` : x);
+        const wrapType = pos === 'type' && parameterType && isStruct
+            ? (pyType) => `typing.Union[${maybeQuote(pyType)}, typing.Dict[builtins.str, typing.Any]]`
+            : maybeQuote;
+        /////////////////////////////////
+        // Type from other assembly
         // Emit aliased imports for dependencies (this avoids name collisions)
         if (assemblyName !== assembly.name) {
             const aliasSuffix = (0, crypto_1.createHash)('sha256')
@@ -247,50 +255,69 @@ class UserType {
         }
         const submodulePythonName = toPythonFqn(submodule, assembly).pythonFqn;
         const typeSubmodulePythonName = toPythonFqn(findParentSubmodule(type, assembly), assembly).pythonFqn;
-        if (typeSubmodulePythonName === submodulePythonName) {
-            // Identify declarations that are not yet initialized and hence cannot be
-            // used as part of a type qualification. Since this is not a forward
-            // reference, the type was already emitted and its un-qualified name must
-            // be used instead of its locally qualified name.
+        //////////////////////////////////////////////
+        // Type from same assembly, other submodule
+        if (typeSubmodulePythonName !== submodulePythonName) {
+            const [toImport, ...nested] = pythonFqn
+                .substring(typeSubmodulePythonName.length + 1)
+                .split('.');
+            const aliasSuffix = (0, crypto_1.createHash)('sha256')
+                .update(typeSubmodulePythonName)
+                .update('.')
+                .update(toImport)
+                .digest('hex')
+                .substring(0, 8);
+            const alias = `_${toImport}_${aliasSuffix}`;
+            return {
+                pythonType: wrapType([alias, ...nested].join('.')),
+                requiredImport: {
+                    sourcePackage: relativeImportPath(submodulePythonName, typeSubmodulePythonName),
+                    item: `${toImport} as ${alias}`,
+                },
+            };
+            // Have the 'else' here to minimize the diff.
+            // eslint-disable-next-line no-else-return
+        }
+        else {
+            //////////////////////////////////////////////
+            // Type from same submodule
+            //
+            // Considerations:
+            // - We could be in the same nested class or in a different nested class here.
+            // - We could also be trying to reference types that will be below
+            //   ourselves in the source code order, which we will need to render as
+            //   type reference strings.
             const nestingParent = surroundingTypeFqns
                 ?.map((fqn) => toPythonFqn(fqn, assembly).pythonFqn)
                 ?.reverse()
                 ?.find((parent) => pythonFqn.startsWith(`${parent}.`));
-            if (typeAnnotation &&
-                (!emittedTypes.has(__classPrivateFieldGet(this, _UserType_fqn, "f")) || nestingParent != null)) {
-                // Possibly a forward reference, outputting the stringifierd python FQN
+            if (nestingParent && pos === 'decl') {
+                // In normal function bodies etc. we must use the fully-qualified name,
+                // but while executing the class declarations we must use the shorter name
+                // of the local variable we're defining.
+                //
+                // An example is most clear:
+                //
+                // ```py
+                // class A:
+                //     class B: pass
+                //     class C(B):                         # <-- note
+                //        def some_method(self, b: "A.B"): # <-- note
+                //           return A.B()                  # <-- note
+                // ```
+                //
+                // The FQN is separated by `.` and we would
+                // also use `.` to access subtypes in Python and have the same names, so we
+                // can just use a substring.
                 return {
-                    pythonType: wrapType(JSON.stringify(pythonFqn.substring(submodulePythonName.length + 1))),
+                    pythonType: wrapType(pythonFqn.slice(nestingParent.length + 1)),
                 };
             }
-            if (!typeAnnotation && nestingParent) {
-                // This is not for a type annotation, so we should be at a point in time
-                // where the surrounding symbol has been defined entirely, so we can
-                // refer to it "normally" now.
-                return { pythonType: pythonFqn.slice(packageName.length + 1) };
-            }
             // We'll just make a module-qualified reference at this point.
             return {
                 pythonType: wrapType(pythonFqn.substring(submodulePythonName.length + 1)),
             };
         }
-        const [toImport, ...nested] = pythonFqn
-            .substring(typeSubmodulePythonName.length + 1)
-            .split('.');
-        const aliasSuffix = (0, crypto_1.createHash)('sha256')
-            .update(typeSubmodulePythonName)
-            .update('.')
-            .update(toImport)
-            .digest('hex')
-            .substring(0, 8);
-        const alias = `_${toImport}_${aliasSuffix}`;
-        return {
-            pythonType: wrapType([alias, ...nested].join('.')),
-            requiredImport: {
-                sourcePackage: relativeImportPath(submodulePythonName, typeSubmodulePythonName),
-                item: `${toImport} as ${alias}`,
-            },
-        };
     }
 }
 _UserType_fqn = new WeakMap();

package/lib/targets/python.js

@@ -341,9 +341,6 @@ class BasePythonClassType {
             code.line('pass');
         }
         code.closeBlock();
-        if (this.fqn != null) {
-            context.emittedTypes.add(this.fqn);
-        }
     }
     /**
      * Sort the this.bases array for proper Python MRO.
@@ -469,7 +466,9 @@ class BaseMethod {
     }
     emit(code, context, opts) {
         const { renderAbstract = true, forceEmitBody = false } = opts ?? {};
-        const returnType = (0, type_name_1.toTypeName)(this.returns).pythonType(context);
+        const returnType = (0, type_name_1.toTypeName)(this.returns).pythonType('type', {
+            ...context,
+        });
         // We cannot (currently?) blindly use the names given to us by the JSII for
         // initializers, because our keyword lifting will allow two names to clash.
         // This can hopefully be removed once we get https://github.com/aws/jsii/issues/288
@@ -492,7 +491,7 @@ class BaseMethod {
             // This can hopefully be removed once we get https://github.com/aws/jsii/issues/288
             // resolved.
             const paramName = toPythonParameterName(param.name, liftedPropNames);
-            const paramType = typeFac.pythonType({
+            const paramType = typeFac.pythonType('type', {
                 ...context,
                 parameterType: true,
             });
@@ -525,10 +524,9 @@ class BaseMethod {
                 // Iterate over all of our props, and reflect them into our params.
                 for (const prop of liftedProperties) {
                     const paramName = toPythonParameterName(prop.prop.name);
-                    const paramType = (0, type_name_1.toTypeName)(prop.prop).pythonType({
+                    const paramType = (0, type_name_1.toTypeName)(prop.prop).pythonType('type', {
                         ...context,
                         parameterType: true,
-                        typeAnnotation: true,
                     });
                     const paramDefault = prop.prop.optional ? ' = None' : '';
                     pythonParams.push(`${paramName}: ${paramType}${paramDefault}`);
@@ -549,7 +547,7 @@ class BaseMethod {
             pythonParams.pop();
             const lastParameter = this.parameters.slice(-1)[0];
             const paramName = toPythonParameterName(lastParameter.name);
-            const paramType = (0, type_name_1.toTypeName)(lastParameter.type).pythonType(context);
+            const paramType = (0, type_name_1.toTypeName)(lastParameter.type).pythonType('type', context);
             pythonParams.push(`*${paramName}: ${paramType}`);
         }
         const decorators = new Array();
@@ -595,10 +593,7 @@ class BaseMethod {
     emitAutoProps(code, context, liftedPropNames) {
         const lastParameter = this.parameters.slice(-1)[0];
         const argName = toPythonParameterName(lastParameter.name, liftedPropNames);
-        const typeName = (0, type_name_1.toTypeName)(lastParameter.type).pythonType({
-            ...context,
-            typeAnnotation: false,
-        });
+        const typeName = (0, type_name_1.toTypeName)(lastParameter.type).pythonType('value', context);
         // We need to build up a list of properties, which are mandatory, these are the
         // ones we will specify to start with in our dictionary literal.
         const liftedProps = this.getLiftedProperties(context.resolver).map((p) => new StructField(this.generator, p.prop, p.definingType));
@@ -616,10 +611,7 @@ class BaseMethod {
                 throw new Error('Parent not known.');
             }
             if (this.isStatic) {
-                jsiiMethodParams.push((0, type_name_1.toTypeName)(this.parent).pythonType({
-                    ...context,
-                    typeAnnotation: false,
-                }));
+                jsiiMethodParams.push((0, type_name_1.toTypeName)(this.parent).pythonType('value', context));
             }
             else {
                 // Using the dynamic class of `self`.
@@ -698,7 +690,7 @@ class BaseProperty {
     }
     emit(code, context, opts) {
         const { renderAbstract = true, forceEmitBody = false } = opts ?? {};
-        const pythonType = (0, type_name_1.toTypeName)(this.type).pythonType(context);
+        const pythonType = (0, type_name_1.toTypeName)(this.type).pythonType('type', context);
         code.line(`@${this.decorator}`);
         code.line(`@jsii.member(jsii_name="${this.jsName}")`);
         if (renderAbstract && this.abstract) {
@@ -758,10 +750,7 @@ class Interface extends BasePythonClassType {
         // Then, we have to emit a Proxy class which implements our proxy interface.
         const proxyBases = this.bases.map((b) => 
         // "# type: ignore[misc]" because MyPy cannot check dynamic base classes (naturally)
-        `jsii.proxy_for(${(0, type_name_1.toTypeName)(b).pythonType({
-            ...context,
-            typeAnnotation: false,
-        })}) # type: ignore[misc]`);
+        `jsii.proxy_for(${(0, type_name_1.toTypeName)(b).pythonType('value', context)}) # type: ignore[misc]`);
         openSignature(code, 'class', this.proxyClassName, proxyBases);
         this.generator.emitDocString(code, this.apiLocation, this.docs, {
             documentableItem: `class-${this.pythonName}`,
@@ -783,12 +772,9 @@ class Interface extends BasePythonClassType {
         code.line();
         code.line('# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface');
         code.line(`typing.cast(typing.Any, ${this.pythonName}).__jsii_proxy_class__ = lambda : ${this.proxyClassName}`);
-        if (this.fqn != null) {
-            context.emittedTypes.add(this.fqn);
-        }
     }
     getClassParams(context) {
-        const params = this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType({ ...context, typeAnnotation: false }));
+        const params = this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType('decl', context));
         params.push('typing_extensions.Protocol');
         return params;
     }
@@ -842,15 +828,12 @@ class Struct extends BasePythonClassType {
         }
         this.emitMagicMethods(code);
         code.closeBlock();
-        if (this.fqn != null) {
-            context.emittedTypes.add(this.fqn);
-        }
     }
     requiredImports(context) {
         return (0, type_name_1.mergePythonImports)(super.requiredImports(context), ...this.allMembers.map((mem) => mem.requiredImports(context)));
     }
     getClassParams(context) {
-        return this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType({ ...context, typeAnnotation: false }));
+        return this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType('decl', context));
     }
     /**
      * Find all fields (inherited as well)
@@ -876,10 +859,7 @@ class Struct extends BasePythonClassType {
         // Re-type struct arguments that were passed as "dict". Do this before validating argument types...
         for (const member of members.filter((m) => m.isStruct(this.generator))) {
             // Note that "None" is NOT an instance of dict (that's convenient!)
-            const typeName = (0, type_name_1.toTypeName)(member.type.type).pythonType({
-                ...context,
-                typeAnnotation: false,
-            });
+            const typeName = (0, type_name_1.toTypeName)(member.type.type).pythonType('value', context);
             code.openBlock(`if isinstance(${member.pythonName}, dict)`);
             code.line(`${member.pythonName} = ${typeName}(**${member.pythonName})`);
             code.closeBlock();
@@ -987,7 +967,7 @@ class StructField {
      * Return the Python type annotation for this type
      */
     typeAnnotation(context) {
-        return (0, type_name_1.toTypeName)(this.type).pythonType(context);
+        return (0, type_name_1.toTypeName)(this.type).pythonType('type', context);
     }
     emitDocString(code) {
         this.generator.emitDocString(code, this.apiLocation, this.docs, {
@@ -1042,7 +1022,7 @@ class Class extends BasePythonClassType {
     emit(code, context) {
         // First we emit our implments decorator
         if (this.interfaces.length > 0) {
-            const interfaces = this.interfaces.map((b) => (0, type_name_1.toTypeName)(b).pythonType({ ...context, typeAnnotation: false }));
+            const interfaces = this.interfaces.map((b) => (0, type_name_1.toTypeName)(b).pythonType('decl', context));
             code.line(`@jsii.implements(${interfaces.join(', ')})`);
         }
         // Then we do our normal class logic for emitting our members.
@@ -1055,10 +1035,7 @@ class Class extends BasePythonClassType {
             const proxyBases = [this.pythonName];
             for (const base of this.abstractBases) {
                 // "# type: ignore[misc]" because MyPy cannot check dynamic base classes (naturally)
-                proxyBases.push(`jsii.proxy_for(${(0, type_name_1.toTypeName)(base).pythonType({
-                    ...context,
-                    typeAnnotation: false,
-                })}) # type: ignore[misc]`);
+                proxyBases.push(`jsii.proxy_for(${(0, type_name_1.toTypeName)(base).pythonType('value', context)}) # type: ignore[misc]`);
             }
             code.line();
             code.line();
@@ -1090,7 +1067,7 @@ class Class extends BasePythonClassType {
         }
     }
     getClassParams(context) {
-        const params = this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType({ ...context, typeAnnotation: false }));
+        const params = this.bases.map((b) => (0, type_name_1.toTypeName)(b).pythonType('decl', context));
         const metaclass = this.abstract ? 'JSIIAbstractClass' : 'JSIIMeta';
         params.push(`metaclass=jsii.${metaclass}`);
         params.push(`jsii_type="${this.fqn}"`);
@@ -1948,7 +1925,6 @@ class PythonGenerator extends generator_1.Generator {
         const resolver = new TypeResolver(this.types, assm, (fqn) => this.findModule(fqn), (fqn) => this.findType(fqn));
         this.package.write(this.code, {
             assembly: assm,
-            emittedTypes: new Set(),
             resolver,
             runtimeTypeChecking: this.runtimeTypeChecking,
             submodule: assm.name,

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.120.0 (build 192dc88)";
+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-11-24T11:51:54Z 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.120.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.120.0 (build 192dc88)';
+exports.VERSION_DESC = '1.122.0 (build d5d44e9)';
 //# sourceMappingURL=version.js.map

package/package.json

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