Update destructure logic: don't destructure classes (#77)

Author: hoodmane

type-generation/src/astToIR.ts

@@ -204,8 +204,6 @@ function literalTypeToIR(typeNode: LiteralTypeNode): TypeIR {
  * If the parameter of sig is an Interface, from Python we allow the interface
  * entries to be passed as keyword arguments. Return the InterfaceDeclaration if
  * the last parameter is an interface, else return undefined.
- *
- * TODO: make this work for type literals too?
  */
 function getInterfaceDeclToDestructure(
   sig: Signature,
@@ -221,17 +219,23 @@ function getInterfaceDeclToDestructure(
   if (typeLiteral) {
     return typeLiteral;
   }
-
+  // If it's a type parameter, don't try to destructure.
+  if (typeNode.getType().isTypeParameter()) {
+    return undefined;
+  }
   // Handle named interface types (TypeReference)
-  const defs = typeNode
+  const ident = typeNode
     .asKind(SyntaxKind.TypeReference)
     ?.getTypeName()
-    ?.asKind(SyntaxKind.Identifier)
-    ?.getDefinitionNodes();
-  if (!defs?.length) {
+    .asKind(SyntaxKind.Identifier);
+  if (!ident) {
     return undefined;
   }
-  return defs[0].asKind(SyntaxKind.InterfaceDeclaration);
+  const classified = classifyIdentifier(ident);
+  if (classified.kind === "interfaces") {
+    return classified.ifaces[0];
+  }
+  return undefined;
 }
 
 function getFilteredTypeParams<T extends TypeParameteredNode>(

type-generation/tests/a.test.ts

@@ -1379,6 +1379,46 @@ describe("emit", () => {
         `).trim(),
       );
     });
+    it("don't destructure class", () => {
+      // At some point we had an extra popNameContext() in sigToIRDestructure()
+      // and this test failed.
+      const res = emitFile(`
+        interface C {
+          a: string;
+        }
+        declare var C: {
+            prototype: C;
+            new(): C;
+        };
+        declare function f(c: C): void;
+      `);
+      assert.strictEqual(
+        removeTypeIgnores(res.slice(1).join("\n\n")),
+        dedent(`
+          def f(c: C, /) -> None: ...
+
+          class C(C_iface, _JsObject):
+              @classmethod
+              def new(self, /) -> C: ...
+
+          class C_iface(Protocol):
+              a: str = ...
+        `).trim(),
+      );
+    });
+    it("don't destructure type param", () => {
+      // At some point we had an extra popNameContext() in sigToIRDestructure()
+      // and this test failed.
+      const res = emitFile(`
+        declare function f<T>(a : T): void
+      `);
+      assert.strictEqual(
+        removeTypeIgnores(res.slice(1).join("\n\n")),
+        dedent(`
+          def f[T](a: T, /) -> None: ...
+        `).trim(),
+      );
+    });
   });
   describe("Type literals", () => {
     it("simple", () => {