New feature CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR

Changes `OPERATOR_DEEPCOPY` into a new `OPERATOR_SERIALIZE`.

Since `deepcopy` can be implemented in terms of `tp_serialize` (since `CONFIG_EXPERIMENTAL_SERIALIZED_DEEPCOPY`), this feature expands on that idea by starting the process of getting rid of the old `tp_deep_copy` callback, and `operator deepcopy` in user-code. The former has already been replaced with `tp_serialize`, and the later is now available, though its semantics (i.e. the arguments it takes, as well as its intended return value) are yet to-be determined.

Author: GrieferAtWork

include/deemon/api.h

@@ -420,6 +420,23 @@ __pragma_GCC_diagnostic_ignored(Walloc_size_larger_than)
 /* EXPERIMENTAL/WIP FEATURES                                            */
 /************************************************************************/
 
+/* NOTES:
+ * - All of these features will eventually become mandatory
+ * - Some features may prevent deemon from compiling when enabled/disabled
+ * - Deviate from the defaults encoded here at your own risk
+ */
+
+#if 0
+#if (!defined(CONFIG_EXPERIMENTAL_MY_FEATURE) && \
+     !defined(CONFIG_NO_EXPERIMENTAL_MY_FEATURE))
+#if 1
+#define CONFIG_EXPERIMENTAL_MY_FEATURE
+#else
+#define CONFIG_NO_EXPERIMENTAL_MY_FEATURE
+#endif
+#endif /* !CONFIG_[NO_]EXPERIMENTAL_MY_FEATURE */
+#endif
+
 /* Experimental feature switch: use altered status codes for "boundattr" / "bounditem".
  * When enabled, "hasitem"/"hasattr" can be implemented by aliasing "bounditem"/"boundattr" */
 #if (!defined(CONFIG_EXPERIMENTAL_ALTERED_BOUND_CONSTANTS) && \
@@ -455,7 +472,7 @@ __pragma_GCC_diagnostic_ignored(Walloc_size_larger_than)
 
 /* Experimental feature switch: ST_ISDIR can be imported as a module, and modules
  * whose names match an equally named directory within the same containing directory
- * also expose all the symbols from that directory within themselves:
+ * also expose all the files from that directory as symbols:
  * Files:
  * - mylib/foo.dee          >> global final symbolFromFoo = 42;
  * - mylib/foo/bar.dee      >> global final symbolFromBar = "Wow!";
@@ -511,6 +528,18 @@ __pragma_GCC_diagnostic_ignored(Walloc_size_larger_than)
 #define CONFIG_NO_EXPERIMENTAL_SERIALIZED_DEEPCOPY
 #endif
 #endif /* !CONFIG_[NO_]EXPERIMENTAL_SERIALIZED_DEEPCOPY */
+
+
+/* Experimental feature switch: Replace "OPERATOR_DEEPCOPY" with "OPERATOR_SERIALIZE"
+ * TODO: When this one becomes mandatory, "tp_deep_copy" and "tp_deepload" will be removed! */
+#if (!defined(CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR) && \
+     !defined(CONFIG_NO_EXPERIMENTAL_SERIALIZE_OPERATOR))
+#if defined(CONFIG_EXPERIMENTAL_SERIALIZED_DEEPCOPY) && 1
+#define CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+#else
+#define CONFIG_NO_EXPERIMENTAL_SERIALIZE_OPERATOR
+#endif
+#endif /* !CONFIG_[NO_]EXPERIMENTAL_SERIALIZE_OPERATOR */
 /************************************************************************/
 
 

include/deemon/class.h

@@ -937,22 +937,24 @@ INTDEF WUNUSED NONNULL((1)) int DCALL instance_builtin_inherited_initkw(DeeObjec
 /* Builtin (pre-defined) hooks that are used when the user-class doesn't override these operators. */
 INTDEF WUNUSED NONNULL((1, 2, 3)) int DCALL instance_builtin_tcopy(DeeTypeObject *tp_self, DeeObject *__restrict self, DeeObject *other);
 INTDEF WUNUSED NONNULL((1, 2)) int DCALL instance_builtin_copy(DeeObject *__restrict self, DeeObject *__restrict other);
+#ifndef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
 INTDEF WUNUSED NONNULL((1, 2)) int DCALL instance_builtin_tdeepload(DeeTypeObject *tp_self, DeeObject *__restrict self);
 INTDEF WUNUSED NONNULL((1)) int DCALL instance_builtin_deepload(DeeObject *__restrict self);
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #ifdef CONFIG_NOBASE_OPTIMIZED_CLASS_OPERATORS
 INTDEF WUNUSED NONNULL((1, 2, 3)) int DCALL instance_builtin_nobase_tcopy(DeeTypeObject *tp_self, DeeObject *__restrict self, DeeObject *other);
 INTDEF WUNUSED NONNULL((1, 2)) int DCALL instance_builtin_nobase_copy(DeeObject *__restrict self, DeeObject *__restrict other);
+#ifndef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
 INTDEF WUNUSED NONNULL((1)) int DCALL instance_builtin_nobase_deepload(DeeObject *__restrict self);
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #endif /* CONFIG_NOBASE_OPTIMIZED_CLASS_OPERATORS */
 INTDEF NONNULL((1)) void DCALL instance_builtin_destructor(DeeObject *__restrict self); /* No t-variant, because types are unwound automatically during destruction. */
 INTDEF WUNUSED NONNULL((1, 2, 3)) int DCALL instance_builtin_tassign(DeeTypeObject *tp_self, DeeObject *self, DeeObject *other);
 INTDEF WUNUSED NONNULL((1, 2)) int DCALL instance_builtin_assign(DeeObject *self, DeeObject *other);
 INTDEF WUNUSED NONNULL((1, 2, 3)) int DCALL instance_builtin_tmoveassign(DeeTypeObject *tp_self, DeeObject *self, DeeObject *other);
 INTDEF WUNUSED NONNULL((1, 2)) int DCALL instance_builtin_moveassign(DeeObject *self, DeeObject *other);
-#if 0
 struct Dee_serial;
 INTDEF WUNUSED NONNULL((1)) int DCALL instance_builtin_serialize(DeeObject *__restrict self, struct Dee_serial *__restrict writer, Dee_seraddr_t addr);
-#endif
 
 #ifdef Dee_TP_FCLASS_AUTOINIT
 /* No predefined construction operators (with `Dee_TP_FCLASS_AUTOINIT'). */
@@ -990,8 +992,10 @@ INTDEF WUNUSED NONNULL((1, 2)) Dee_ssize_t DCALL instance_builtin_auto_printrepr
 /* Hooks when the user-class overrides the associated operator. */
 INTDEF WUNUSED NONNULL((1, 2, 3)) int DCALL instance_tcopy(DeeTypeObject *tp_self, DeeObject *__restrict self, DeeObject *other);
 INTDEF WUNUSED NONNULL((1, 2)) int DCALL instance_copy(DeeObject *__restrict self, DeeObject *__restrict other);
+#ifndef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
 INTDEF WUNUSED NONNULL((1, 2, 3)) int DCALL instance_tdeepcopy(DeeTypeObject *tp_self, DeeObject *__restrict self, DeeObject *other);
 INTDEF WUNUSED NONNULL((1, 2)) int DCALL instance_deepcopy(DeeObject *__restrict self, DeeObject *__restrict other);
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 INTDEF NONNULL((1)) void DCALL instance_destructor(DeeObject *__restrict self); /* No t-variant, because types are unwound automatically during destruction. */
 
 /* GC support for class objects. */

include/deemon/compiler/ast.h

@@ -405,15 +405,18 @@ struct ast {
                                         *        >> --sym_read;
                                         *        >> ++sym_write;
                                         *        This way, symbols can track how often they are written to, or read from. */
-#   define AST_FACTION_ASSERT   0x1013 /* `assert <act0>'               - Assert that <act0> evaluates to true at runtime. */
-#   define AST_FACTION_ASSERT_M 0x2014 /* `assert <act0>, <act1>'       - Assert that <act0> evaluates to true at runtime,
-                                        *                                 <act1> is a message that is evaluated and added
-                                        *                                 to the error message when the assertion fails. */
+#   define AST_FACTION_ASSERT   0x1013 /* `assert <act0>'             - Assert that <act0> evaluates to true at runtime. */
+#   define AST_FACTION_ASSERT_M 0x2014 /* `assert <act0>, <act1>'     - Assert that <act0> evaluates to true at runtime,
+                                        *                               <act1> is a message that is evaluated and added
+                                        *                               to the error message when the assertion fails. */
 #   define AST_FACTION_BOUNDATTR 0x2015/* `<act0>.operator . (<act1>) is bound' - Check if the attribute `<act1>' of `<act0>' is currently bound. */
 #   define AST_FACTION_BOUNDITEM 0x2016/* `<act0>.operator [] (<act1>) is bound' - Check if the item `<act1>' of `<act0>' is currently bound. */
-#   define AST_FACTION_SAMEOBJ  0x2017 /* `<act0> === <act1>'           - Check if <act0> and <act1> are the same object */
-#   define AST_FACTION_DIFFOBJ  0x2018 /* `<act0> !== <act1>'           - Check if <act0> and <act1> are the different objects */
+#   define AST_FACTION_SAMEOBJ  0x2017 /* `<act0> === <act1>'         - Check if <act0> and <act1> are the same object */
+#   define AST_FACTION_DIFFOBJ  0x2018 /* `<act0> !== <act1>'         - Check if <act0> and <act1> are the different objects */
 #   define AST_FACTION_CALL_KW  0x3019 /* `<act0>(<act1>..., **<act2>)' - Call `act0' with `act1', while also passing keywords from `act2' */
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+#   define AST_FACTION_DEEPCOPY 0x101a /* `deepcopy <act0>'           - Create a deep copy of `act0' */
+#endif /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 		struct {
 			DREF struct ast    *a_act0; /* [0..1] Primary action operand or NULL when not used. */
 			DREF struct ast    *a_act1; /* [0..1] Secondary action operand or NULL when not used. */
@@ -628,10 +631,16 @@ struct ast {
 
 /* Automatically generate moveassign operations when the
  * right-hand-size has been modulated using a copy/deepcopy operator. */
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+#define AST_SHOULD_MOVEASSIGN(x)                                      \
+	(((x)->a_type == AST_OPERATOR && (x)->a_flag == OPERATOR_COPY) || \
+	 ((x)->a_type == AST_ACTION && (x)->a_flag == AST_FACTION_DEEPCOPY))
+#else /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define AST_SHOULD_MOVEASSIGN(x)      \
 	((x)->a_type == AST_OPERATOR &&   \
 	 ((x)->a_flag == OPERATOR_COPY || \
 	  (x)->a_flag == OPERATOR_DEEPCOPY))
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define AST_ISNONE(x) ((x)->a_type == AST_CONSTEXPR && DeeNone_Check((x)->a_constexpr))
 #define AST_HASDDI(x) ((x)->ast_ddi.l_file != NULL)
 

include/deemon/compiler/lexer.def

@@ -207,6 +207,14 @@ DEF_M_IF(__POSIX__, HAS(EXT_SYSTEM_MACROS)) /* DEPRECATED! */
 DEF_M_IF(__unix__, HAS(EXT_SYSTEM_MACROS))
 #endif /* CONFIG_HOST_UNIX */
 
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+#undef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+/* Don't use this macro in user-code -- only here for compat
+ * in standard library until this feature becomes mandatory! */
+DEF_M(CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR)
+#define CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+#endif /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
+
 
 WGROUP(WG_SYMBOL, "symbol", WSTATE_FATAL)
 WGROUP(WG_IMPLICIT, "implicit", WSTATE_FATAL)

include/deemon/object.h

@@ -1771,7 +1771,11 @@ struct Dee_type_constructor {
 		struct {
 			WUNUSED_T NONNULL_T((1))                  int (DCALL *tp_ctor)(DeeObject *__restrict self);
 			WUNUSED_T NONNULL_T((1, 2))               int (DCALL *tp_copy_ctor)(DeeObject *__restrict self, DeeObject *__restrict other);
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+			Dee_funptr_t                                  _unused_tp_deep_ctor;
+#else /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 			WUNUSED_T NONNULL_T((1, 2))               int (DCALL *tp_deep_ctor)(DeeObject *__restrict self, DeeObject *__restrict other);
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 			WUNUSED_T NONNULL_T((1)) ATTR_INS_T(3, 2) int (DCALL *tp_any_ctor)(DeeObject *__restrict self, size_t argc, DeeObject *const *argv);
 
 			/* WARNING: `tp_any_ctor_kw' may be invoked with `argc == 0 && kw == NULL',
@@ -1830,7 +1834,11 @@ struct Dee_type_constructor {
 			 */
 			WUNUSED_T                  DREF DeeObject *(DCALL *tp_ctor)(void);
 			WUNUSED_T NONNULL_T((1))   DREF DeeObject *(DCALL *tp_copy_ctor)(DeeObject *__restrict other);
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+			Dee_funptr_t                               _unused_tp_deep_ctor;
+#else /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 			WUNUSED_T NONNULL_T((1))   DREF DeeObject *(DCALL *tp_deep_ctor)(DeeObject *__restrict other);
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 			WUNUSED_T ATTR_INS_T(2, 1) DREF DeeObject *(DCALL *tp_any_ctor)(size_t argc, DeeObject *const *argv);
 			/* WARNING: `tp_any_ctor_kw' may be invoked with `argc == 0 && kw == NULL',
 			 *          even when `tp_ctor' or `tp_any_ctor' has been defined as non-NULL! */
@@ -1866,6 +1874,9 @@ struct Dee_type_constructor {
 	WUNUSED_T NONNULL_T((1, 2)) int (DCALL *tp_assign)(DeeObject *self, DeeObject *some_object);
 	WUNUSED_T NONNULL_T((1, 2)) int (DCALL *tp_move_assign)(DeeObject *self, DeeObject *other);
 
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+	WUNUSED_T NONNULL_T((1)) int (DCALL *_unused_tp_deepload)(DeeObject *__restrict self);
+#else /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 	/* Following a previously successful construction using the `tp_deep_ctor' operator,
 	 * go through all member objects of the type and replace them with deep copies.
 	 * This operator is required to provide a safe way for GC objects to be
@@ -1915,6 +1926,7 @@ struct Dee_type_constructor {
 	 * @return: == 0: Success
 	 * @return: != 0: Error was thrown */
 	WUNUSED_T NONNULL_T((1)) int (DCALL *tp_deepload)(DeeObject *__restrict self);
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 
 	/* Callback for `DeeObject_Destroy()' (usually auto-assigned by
 	 * `DeeType_RequireDestroy()', but can be overwritten with a
@@ -3255,7 +3267,9 @@ template<class _TSelf> Dee_boundmethod_t _Dee_RequiresBoundMethod(WUNUSED_T NONN
 #define Dee_METHOD_FCONSTCALL_IF_THISELEM_CONSTSTR          0x00000200 /* >> (for (local x: thisarg) IS_CONSTEXPR(x.operator str)) && ...; */
 #define Dee_METHOD_FCONSTCALL_IF_THISELEM_CONSTREPR         0x00000300 /* >> (for (local x: thisarg) IS_CONSTEXPR(x.operator repr)) && ...; */
 #define Dee_METHOD_FCONSTCALL_IF_THISELEM_CONSTHASH         0x00000400 /* >> (for (local x: thisarg) IS_CONSTEXPR(x.operator hash)) && ...; */
+#ifndef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
 #define Dee_METHOD_FCONSTCALL_IF_THISELEM_CONSTDEEP         0x00000500 /* >> (for (local x: thisarg) IS_CONSTEXPR(x.operator deepcopy)) && ...; */
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define Dee_METHOD_FCONSTCALL_IF_SEQ_CONSTCMPEQ             0x00000600 /* >> (for (local arg: ...) IS_CONSTEXPR(arg.operator iter) && (for (local a, b: zip(thisarg, arg)) IS_CONSTEXPR(a == b, a != b, [a.operator hash(), b.operator hash()]))) && ...; */
 #define Dee_METHOD_FCONSTCALL_IF_SEQ_CONSTCMP               0x00000700 /* >> (for (local arg: ...) IS_CONSTEXPR(arg.operator iter) && (for (local a, b: zip(thisarg, arg)) IS_CONSTEXPR(a == b, a != b, a < b, a > b, a <= b, a >= b))) && ...; */
 #define Dee_METHOD_FCONSTCALL_IF_SEQ_CONSTCONTAINS          0x00000800 /* >> (for (local arg: ...) for (local elem: thisarg) IS_CONSTEXPR(elem == arg)) && ...; */
@@ -3288,7 +3302,9 @@ template<class _TSelf> Dee_boundmethod_t _Dee_RequiresBoundMethod(WUNUSED_T NONN
 #define METHOD_FCONSTCALL_IF_THISELEM_CONSTSTR          Dee_METHOD_FCONSTCALL_IF_THISELEM_CONSTSTR
 #define METHOD_FCONSTCALL_IF_THISELEM_CONSTREPR         Dee_METHOD_FCONSTCALL_IF_THISELEM_CONSTREPR
 #define METHOD_FCONSTCALL_IF_THISELEM_CONSTHASH         Dee_METHOD_FCONSTCALL_IF_THISELEM_CONSTHASH
+#ifndef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
 #define METHOD_FCONSTCALL_IF_THISELEM_CONSTDEEP         Dee_METHOD_FCONSTCALL_IF_THISELEM_CONSTDEEP
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define METHOD_FCONSTCALL_IF_SEQ_CONSTCMPEQ             Dee_METHOD_FCONSTCALL_IF_SEQ_CONSTCMPEQ
 #define METHOD_FCONSTCALL_IF_SEQ_CONSTCMP               Dee_METHOD_FCONSTCALL_IF_SEQ_CONSTCMP
 #define METHOD_FCONSTCALL_IF_SEQ_CONSTCONTAINS          Dee_METHOD_FCONSTCALL_IF_SEQ_CONSTCONTAINS
@@ -3767,7 +3783,11 @@ typedef uint16_t Dee_operator_t;
 /* Universal operator codes. */
 #define OPERATOR_CONSTRUCTOR  0x0000 /* `operator this(args...)'                                    - `__constructor__' - `tp_any_ctor'. */
 #define OPERATOR_COPY         0x0001 /* `operator copy(other: type(this))'                          - `__copy__'        - `tp_copy_ctor'. */
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+#define OPERATOR_SERIALIZE    0x0002 /* `operator serialize(TODO)'                                  - `__serialize__'   - `tp_serialize'. */
+#else /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define OPERATOR_DEEPCOPY     0x0002 /* `operator deepcopy(other: type(this))'                      - `__deepcopy__'    - `tp_deep_ctor'. */
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define OPERATOR_DESTRUCTOR   0x0003 /* `operator ~this()'                                          - `__destructor__'  - `tp_dtor'. */
 #define OPERATOR_ASSIGN       0x0004 /* `operator := (other: Object)'                               - `__assign__'      - `tp_assign'. */
 #define OPERATOR_MOVEASSIGN   0x0005 /* `operator move := (other: type(this))'                      - `__moveassign__'  - `tp_move_assign'. */
@@ -3864,7 +3884,11 @@ typedef uint16_t Dee_operator_t;
  * a lexicographical line sort. */
 #define OPERATOR_0000_CONSTRUCTOR  OPERATOR_CONSTRUCTOR
 #define OPERATOR_0001_COPY         OPERATOR_COPY
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+#define OPERATOR_0002_SERIALIZE    OPERATOR_SERIALIZE
+#else /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define OPERATOR_0002_DEEPCOPY     OPERATOR_DEEPCOPY
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define OPERATOR_0003_DESTRUCTOR   OPERATOR_DESTRUCTOR
 #define OPERATOR_0004_ASSIGN       OPERATOR_ASSIGN
 #define OPERATOR_0005_MOVEASSIGN   OPERATOR_MOVEASSIGN
@@ -4346,7 +4370,11 @@ struct Dee_type_object {
 #define DeeType_IsNoArgConstructible(x)  (Dee_REQUIRES_OBJECT(DeeTypeObject const, x)->tp_init.tp_alloc.tp_ctor != NULL)
 #define DeeType_IsVarArgConstructible(x) (Dee_REQUIRES_OBJECT(DeeTypeObject const, x)->tp_init.tp_alloc.tp_any_ctor != NULL || ((DeeTypeObject const *)(x))->tp_init.tp_alloc.tp_any_ctor_kw != NULL)
 #define DeeType_IsConstructible(x)       (DeeType_IsSuperConstructible(x) || DeeType_IsNoArgConstructible(x) || DeeType_IsVarArgConstructible(x))
-#define DeeType_IsCopyable(x)            (Dee_REQUIRES_OBJECT(DeeTypeObject const, x)->tp_init.tp_alloc.tp_copy_ctor != NULL || ((DeeTypeObject const *)(x))->tp_init.tp_alloc.tp_deep_ctor != NULL)
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+#define DeeType_IsCopyable(x)            (Dee_REQUIRES_OBJECT(DeeTypeObject const, x)->tp_init.tp_alloc.tp_copy_ctor != NULL) /* TODO: What about inherited copyability? (Dee_TP_FINHERITCTOR) */
+#else /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
+#define DeeType_IsCopyable(x)            (Dee_REQUIRES_OBJECT(DeeTypeObject const, x)->tp_init.tp_alloc.tp_copy_ctor != NULL || ((DeeTypeObject const *)(x))->tp_init.tp_alloc.tp_deep_ctor != NULL) /* TODO: What about inherited copyability? (Dee_TP_FINHERITCTOR) */
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 #define DeeType_IsNamespace(x)           ((Dee_REQUIRES_OBJECT(DeeTypeObject const, x)->tp_flags & (Dee_TP_FFINAL | Dee_TP_FABSTRACT)) == (Dee_TP_FFINAL | Dee_TP_FABSTRACT) && (((DeeTypeObject const *)(x))->tp_features & Dee_TF_SINGLETON))
 #define DeeType_Base(x)                  (Dee_REQUIRES_OBJECT(DeeTypeObject const, x)->tp_base)
 #define DeeType_GCPriority(x)            (Dee_REQUIRES_OBJECT(DeeTypeObject const, x)->tp_gc ? ((DeeTypeObject const *)(x))->tp_gc->tp_gcprio : Dee_GC_PRIORITY_LATE)

lib/operators.dee

@@ -58,7 +58,11 @@ function bind(tp: Type, operator_function: Callable): Callable {
  * still something they're allowed to do. */
 varying function constructor(self, args...): none -> self.operator constructor(args...);
 varying function copy(self) -> copy self;
+#ifdef CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR
+varying function serialize(self, args...) -> self.operator serialize(args...);
+#else /* CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 varying function deepcopy(self) -> deepcopy self;
+#endif /* !CONFIG_EXPERIMENTAL_SERIALIZE_OPERATOR */
 varying function destructor(self): none -> self.operator destructor();
 varying function assign(self, other) -> self := other;
 varying function moveassign(self, other) -> self.operator move := (other);