Use "real" forward refs if possible, even with forwardReferences = false

packages/jsii-pacmak/lib/targets/python.ts

@@ -165,6 +165,10 @@ interface PythonType extends PythonBase {
     addMember(member: PythonBase): void;
 }
 
+function isPythonType(arg: PythonBase): arg is PythonType {
+    return (arg as any).fqn !== undefined;
+}
+
 interface ISortableType {
     dependsOn(resolver: TypeResolver): spec.NamedTypeReference[];
 }
@@ -229,6 +233,10 @@ abstract class BasePythonClassType implements PythonType, ISortableType {
         if (this.members.length > 0) {
             for (const member of sortMembers(this.members, resolver)) {
                 member.emit(code, resolver);
+
+                if (isPythonType(member)) {
+                    resolver.markTypeEmitted(member);
+                }
             }
         } else {
             code.line("pass");
@@ -528,13 +536,21 @@ class TypedDict extends BasePythonClassType {
             code.openBlock(`class _${this.name}(${classParams.concat(["total=False"]).join(", ")})`);
             for (const member of optionalMembers) {
                 member.emit(code, resolver);
+
+                if (isPythonType(member)) {
+                    resolver.markTypeEmitted(member);
+                }
             }
             code.closeBlock();
 
             // Now we'll emit the mandatory members.
             code.openBlock(`class ${this.name}(_${this.name})`);
             for (const member of sortMembers(mandatoryMembers, resolver)) {
                 member.emit(code, resolver);
+
+                if (isPythonType(member)) {
+                    resolver.markTypeEmitted(member);
+                }
             }
             code.closeBlock();
         } else {
@@ -551,6 +567,10 @@ class TypedDict extends BasePythonClassType {
             if (this.members.length > 0) {
                 for (const member of sortMembers(this.members, resolver)) {
                     member.emit(code, resolver);
+
+                    if (isPythonType(member)) {
+                        resolver.markTypeEmitted(member);
+                    }
                 }
             } else {
                 code.line("pass");
@@ -741,6 +761,10 @@ class Module implements PythonType {
         // Emit all of our members.
         for (const member of sortMembers(this.members, resolver)) {
             member.emit(code, resolver);
+
+            if (isPythonType(member)) {
+                resolver.markTypeEmitted(member);
+            }
         }
 
         // Whatever names we've exported, we'll write out our __all__ that lists them.
@@ -916,10 +940,12 @@ class TypeResolver {
     private readonly stdTypesRe = new RegExp("^(datetime\.datetime|typing\.[A-Z][a-z]+|jsii\.Number)$");
     private readonly boundRe: RegExp;
     private readonly moduleRe = new RegExp("^((?:[^A-Z\.][^\.]+\.)*(?:[^A-Z\.][^\.]+))\.([A-Z].+)$");
+    private readonly emitted: Set<string>;
 
     constructor(types: Map<string, PythonType>, boundTo?: string) {
         this.types = types;
         this.boundTo = boundTo !== undefined ? this.toPythonFQN(boundTo) : boundTo;
+        this.emitted = new Set();
 
         if (this.boundTo !== undefined) {
             this.boundRe = new RegExp(`^(${escapeStringRegexp(this.boundTo)})\.(.+)$`);
@@ -958,6 +984,12 @@ class TypeResolver {
         return modules;
     }
 
+    public markTypeEmitted(type: PythonType) {
+        if (type.fqn) {
+            this.emitted.add(this.toPythonFQN(type.fqn));
+        }
+    }
+
     public resolve(
             typeRef: spec.TypeReference,
             opts: TypeResolverOpts = { forwardReferences: true, ignoreOptional: false }): string {
@@ -1002,7 +1034,7 @@ class TypeResolver {
                 // We have special logic here for checking if our thing is actually *in*
                 // our module, behond what we've already done, because our other logic will
                 // work for submodules, but this can't.
-                if (!forwardReferences && this.isInModule(innerType)) {
+                if (!forwardReferences && this.isInModule(innerType) && !this.emitted.has(innerType)) {
                     pythonType = pythonType.replace(re, `$1"${innerType}"$2`);
                 }