@alloy-js/python 0.4.0-dev.3 → 0.4.0-dev.6

package/dist/dev/test/dataclassdeclarations.test.js

@@ -0,0 +1,1068 @@
+import { createComponent as _$createComponent, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { Prose, namekey, refkey } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import { dataclassesModule } from "../src/builtins/python.js";
+import * as py from "../src/index.js";
+import { assertFileContents, toSourceText, toSourceTextMultiple } from "./utils.js";
+describe("DataclassDeclaration", () => {
+  it("Creates a dataclass with a class doc", () => {
+    const doc = _$createComponent(py.ClassDoc, {
+      get description() {
+        return [_$createComponent(Prose, {
+          children: "Represents a user."
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 15,
+          columnNumber: 34
+        })];
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 15,
+      columnNumber: 7
+    });
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          doc: doc
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 20,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 19,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass
+        class User:
+            """
+            Represents a user.
+            """
+
+            pass
+
+
+      `);
+  });
+  it("Creates a dataclass with fields and defaults", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "id",
+              type: "int"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 49,
+              columnNumber: 13
+            }), _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              get name() {
+                return namekey("_", {
+                  ignoreNamePolicy: true
+                });
+              },
+              get type() {
+                return dataclassesModule["."].KW_ONLY;
+              },
+              omitNone: true
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 55,
+              columnNumber: 13
+            }), _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              name: "name",
+              type: "str",
+              initializer: "Anonymous"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 61,
+              columnNumber: 13
+            })];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 48,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 47,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+        from typing import TYPE_CHECKING
+
+        if TYPE_CHECKING:
+            from dataclasses import KW_ONLY
+
+
+        @dataclass
+        class User:
+            id: int
+            _: KW_ONLY
+            name: str = "Anonymous"
+
+
+      `);
+  });
+  it("Creates a dataclass with keyword arguments", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          frozen: true,
+          slots: true,
+          kwOnly: true,
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "id",
+              type: "int"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 98,
+              columnNumber: 13
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 97,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 96,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass(frozen=True, slots=True, kw_only=True)
+        class User:
+            id: int
+
+
+      `);
+  });
+  it("Creates a dataclass with all keyword arguments", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          init: true,
+          repr: false,
+          eq: true,
+          order: false,
+          unsafeHash: true,
+          frozen: true,
+          matchArgs: false,
+          kwOnly: true,
+          slots: true,
+          weakrefSlot: false
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 128,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 127,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass(init=True, repr=False, eq=True, order=False, unsafe_hash=True, frozen=True, match_args=False, kw_only=True, slots=True, weakref_slot=False)
+        class User:
+            pass
+
+
+      `);
+  });
+  it("Throws error when weakref_slot=True without slots=True", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          weakrefSlot: true
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 165,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 164,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/weakref_slot=True requires slots=True in @dataclass decorator/);
+  });
+  it("Allows weakref_slot=True when slots=True", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          slots: true,
+          weakrefSlot: true
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 179,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 178,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass(slots=True, weakref_slot=True)
+        class User:
+            pass
+
+
+      `);
+  });
+  it("Throws error when order=True and eq=False", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          order: true,
+          eq: false
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 203,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 202,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/order=True requires eq=True/);
+  });
+  it("Creates a dataclass with order=True and no conflicting methods", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          order: true
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 215,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 214,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass(order=True)
+        class User:
+            pass
+
+
+      `);
+  });
+  it("Throws error when order=True and class defines __lt__", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          order: true,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__lt__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 240,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 239,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 238,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify order=True when the class already defines __lt__\(\)/);
+  });
+  it("Throws error when order=True and class defines __le__", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          order: true,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__le__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 257,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 256,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 255,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify order=True when the class already defines __le__\(\)/);
+  });
+  it("Throws error when order=True and class defines __gt__", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          order: true,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__gt__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 274,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 273,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 272,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify order=True when the class already defines __gt__\(\)/);
+  });
+  it("Throws error when order=True and class defines __ge__", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          order: true,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__ge__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 291,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 290,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 289,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify order=True when the class already defines __ge__\(\)/);
+  });
+  it("Throws error when order=True and a wrapper defines __lt__", () => {
+    function Wrapper() {
+      return _$createComponent(py.DunderMethodDeclaration, {
+        name: "__lt__"
+      }, {
+        fileName: import.meta.url,
+        lineNumber: 304,
+        columnNumber: 14
+      });
+    }
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          order: true,
+          get children() {
+            return _$createComponent(Wrapper, {}, {
+              fileName: import.meta.url,
+              lineNumber: 311,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 310,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 309,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify order=True when the class already defines __lt__\(\)/);
+  });
+  it("Throws error when unsafe_hash=True and class defines __hash__", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          unsafeHash: true,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__hash__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 328,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 327,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 326,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify unsafe_hash=True when the class already defines __hash__\(\)/);
+  });
+  it("Throws error when frozen=True and class defines __setattr__", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          frozen: true,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__setattr__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 345,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 344,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 343,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify frozen=True when the class already defines __setattr__\(\)/);
+  });
+  it("Throws errorwhen frozen=True and class defines __delattr__", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          frozen: true,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__delattr__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 362,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 361,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 360,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify frozen=True when the class already defines __delattr__\(\)/);
+  });
+  it("Throws error when slots=True and class defines __slots__", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          slots: true,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__slots__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 379,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 378,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 377,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Cannot specify slots=True when the class already defines __slots__\(\)/);
+  });
+  it("Creates a dataclass with kw_only=True on decorator (sentinel not used)", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          kwOnly: true,
+          get children() {
+            return _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "id",
+              type: "int"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 395,
+              columnNumber: 13
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 394,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 393,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass(kw_only=True)
+        class User:
+            id: int
+
+
+      `);
+  });
+  it("Creates a dataclass with base classes", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          bases: ["Base"]
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 424,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 423,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass
+        class User(Base):
+            pass
+
+
+      `);
+  });
+  it("Throws error when more than one KW_ONLY sentinel is present", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              get name() {
+                return namekey("_", {
+                  ignoreNamePolicy: true
+                });
+              },
+              get type() {
+                return dataclassesModule["."].KW_ONLY;
+              },
+              omitNone: true
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 450,
+              columnNumber: 15
+            }), _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              get name() {
+                return namekey("_", {
+                  ignoreNamePolicy: true
+                });
+              },
+              get type() {
+                return dataclassesModule["."].KW_ONLY;
+              },
+              omitNone: true
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 456,
+              columnNumber: 15
+            })];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 449,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 448,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
+  });
+  it("Will raise arg validation errors first over member conflicts", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          order: true,
+          eq: false,
+          get children() {
+            return _$createComponent(py.DunderMethodDeclaration, {
+              name: "__lt__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 476,
+              columnNumber: 15
+            });
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 475,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 474,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/order=True requires eq=True/);
+  });
+  it("Does not raise errors for member conflict checks without the equivalent kwargs", () => {
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          get children() {
+            return [_$createComponent(py.DunderMethodDeclaration, {
+              name: "__lt__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 491,
+              columnNumber: 15
+            }), _$createComponent(py.DunderMethodDeclaration, {
+              name: "__slots__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 492,
+              columnNumber: 15
+            }), _$createComponent(py.DunderMethodDeclaration, {
+              name: "__hash__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 493,
+              columnNumber: 15
+            }), _$createComponent(py.DunderMethodDeclaration, {
+              name: "__setattr__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 494,
+              columnNumber: 15
+            }), _$createComponent(py.DunderMethodDeclaration, {
+              name: "__delattr__"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 495,
+              columnNumber: 15
+            })];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 490,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 489,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).not.toThrow();
+  });
+  it("Allows unsafe_hash=True when no __hash__ is defined", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          unsafeHash: true
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 508,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 507,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass(unsafe_hash=True)
+        class User:
+            pass
+
+
+      `);
+  });
+  it("Counts KW_ONLY sentinels through wrappers (symbol-level)", () => {
+    function Wrapper() {
+      return _$createComponent(py.VariableDeclaration, {
+        instanceVariable: true,
+        get name() {
+          return namekey("_", {
+            ignoreNamePolicy: true
+          });
+        },
+        get type() {
+          return dataclassesModule["."].KW_ONLY;
+        },
+        omitNone: true
+      }, {
+        fileName: import.meta.url,
+        lineNumber: 530,
+        columnNumber: 9
+      });
+    }
+    expect(() => toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              get name() {
+                return namekey("_", {
+                  ignoreNamePolicy: true
+                });
+              },
+              get type() {
+                return dataclassesModule["."].KW_ONLY;
+              },
+              omitNone: true
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 543,
+              columnNumber: 15
+            }), _$createComponent(Wrapper, {}, {
+              fileName: import.meta.url,
+              lineNumber: 549,
+              columnNumber: 15
+            })];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 542,
+          columnNumber: 13
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 541,
+      columnNumber: 11
+    })], {
+      externals: [dataclassesModule]
+    })).toThrowError(/Only one KW_ONLY sentinel is allowed per dataclass body/);
+  });
+  it("Allows frozen=True when no conflicting dunders exist", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          frozen: true
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 562,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 561,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass(frozen=True)
+        class User:
+            pass
+
+
+      `);
+  });
+  it("Allows slots=True when no __slots__ is defined", () => {
+    const res = toSourceText([_$createComponent(py.SourceFile, {
+      path: "user.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          slots: true
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 585,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 584,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    expect(res).toRenderTo(d`
+        from dataclasses import dataclass
+
+
+        @dataclass(slots=True)
+        class User:
+            pass
+
+
+      `);
+  });
+  it("Forwards refkey prop for symbol resolution in type references", () => {
+    const userRefkey = refkey();
+    const res = toSourceTextMultiple([_$createComponent(py.SourceFile, {
+      path: "models.py",
+      get children() {
+        return _$createComponent(py.DataclassDeclaration, {
+          name: "User",
+          refkey: userRefkey,
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "id",
+              type: "int"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 610,
+              columnNumber: 13
+            }), _$createComponent(py.VariableDeclaration, {
+              instanceVariable: true,
+              omitNone: true,
+              name: "name",
+              type: "str"
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 616,
+              columnNumber: 13
+            })];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 609,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 608,
+      columnNumber: 9
+    }), _$createComponent(py.SourceFile, {
+      path: "services.py",
+      get children() {
+        return _$createComponent(py.FunctionDeclaration, {
+          name: "get_user",
+          returnType: userRefkey,
+          get children() {
+            return [_$createComponent(py.VariableDeclaration, {
+              name: "user",
+              type: userRefkey,
+              get initializer() {
+                return _$createComponent(py.ClassInstantiation, {
+                  target: userRefkey,
+                  args: ["1", '"Alice"']
+                }, {
+                  fileName: import.meta.url,
+                  lineNumber: 630,
+                  columnNumber: 17
+                });
+              }
+            }, {
+              fileName: import.meta.url,
+              lineNumber: 626,
+              columnNumber: 13
+            }), _$createIntrinsic("hbr", {}, {
+              fileName: import.meta.url,
+              lineNumber: 636,
+              columnNumber: 13
+            }), "return user"];
+          }
+        }, {
+          fileName: import.meta.url,
+          lineNumber: 625,
+          columnNumber: 11
+        });
+      }
+    }, {
+      fileName: import.meta.url,
+      lineNumber: 624,
+      columnNumber: 9
+    })], {
+      externals: [dataclassesModule]
+    });
+    assertFileContents(res, {
+      "models.py": `
+        from dataclasses import dataclass
+
+
+        @dataclass
+        class User:
+            id: int
+            name: str
+
+        `,
+      "services.py": `
+        from models import User
+
+
+        def get_user() -> User:
+            user: User = User(1, "Alice")
+            return user
+
+        `
+    });
+  });
+});
+//# sourceMappingURL=dataclassdeclarations.test.js.map