fixup annotated

Author: 9il

source/mir/algebraic_alias/ion.d

@@ -133,4 +133,10 @@ unittest
     IonAlgebraic fromAA = ["a" : IonAlgebraic(3), "b" : IonAlgebraic("b")];
     assert(fromAA.get!(StringMap!IonAlgebraic)["a"] == 3);
     assert(fromAA.get!(StringMap!IonAlgebraic)["b"] == "b");
+
+    auto annotated = Annotated!IonAlgebraic(["birthday"], Timestamp("2001-01-01"));
+    value = annotated;
+    assert(value == annotated);
+    value = annotated.IonAlgebraic;
+    assert(value == annotated);
 }

source/mir/annotated.d

@@ -7,7 +7,7 @@ Macros:
 +/
 module mir.annotated;
 
-import mir.serde: serdeRegister, serdeAnnotation;
+import mir.serde: serdeRegister, serdeAnnotation, serdeIsDynamicAlgebraic;
 
 static immutable excMsg = "At least one annotation is required to create an annotated value.";
 version (D_Exceptions)
@@ -22,24 +22,51 @@ struct Annotated(T) {
     ///
     @serdeAnnotation
     string[] annotations;
-    static if (is(T == union) || is(T == struct))
+
+    static if (!(is(T == union) || is(T == struct)))
+        private enum _alloc_ = false;
+    else
+    static if (serdeIsDynamicAlgebraic!T)
+        private enum _alloc_ = true;
+    else
+    {
+        import mir.algebraic: isVariant;
+        static if (isVariant!T)
+            private enum _alloc_ = true;
+        else
+            private enum _alloc_ = false;
+    }
+
+    static if (_alloc_)
     {
         ///
-        private T* _value;
+        private T* _value_;
         ///
-        ref inout(T) value() inout @property
+        ref inout(T) _value() inout @property
         {
-            return *_value;
+            return *_value_;
+        }
+
+        ///
+        ref T _value(T value) @property
+        {
+            if (_value_ is null)
+            {
+                _value_ = new T;
+                import core.lifetime: move;
+                *_value_ = move(value);
+            }
+            return *_value_;
         }
     }
     else
     {
         ///
-        T value;
+        T _value;
     }
 
     ///
-    alias value this;
+    alias _value this;
 
     /++
     Params:
@@ -56,13 +83,16 @@ struct Annotated(T) {
         }
         import core.lifetime: forward;
         this.annotations = annotations;
-        static if (is(T == union) || is(T == struct))
-            this._value = new T(forward!args);
+        static if (_alloc_)
+            this._value_ = new T(forward!args);
         else
         static if (__traits(compiles, value = args))
-            this.value = args;
+            this._value = args;
+        else
+        static if (is(T == class))
+            this._value = new T(forward!args);
         else
-            this.value = new T(forward!args);
+            this._value = T(forward!args);
     }
 }
 
@@ -80,3 +110,19 @@ unittest
     assert(ac.annotations == annotations);
     assert(ac.x == 5);
 }
+
+///
+unittest
+{
+    import mir.algebraic;
+    auto annotations = ["annotation"];
+    static struct S {double x;}
+    auto as = Annotated!(Variant!S)(annotations, 5);
+    assert(as.annotations == annotations);
+    assert(as.x == 5);
+
+    static struct C {double x;}
+    auto ac = Annotated!(Variant!S)(annotations, 5);
+    assert(ac.annotations == annotations);
+    assert(ac.x == 5);
+}

source/mir/serde.d

@@ -1867,7 +1867,10 @@ package template isAlgebraicAliasThis(T)
         import mir.algebraic: isVariant;
         T* aggregate;
         alias A = typeof(__traits(getMember, aggregate, __traits(getAliasThis, T)));
-        enum isAlgebraicAliasThis = isVariant!A;
+        static if (isVariant!A)
+            enum isAlgebraicAliasThis = true;
+        else
+            enum isAlgebraicAliasThis = serdeIsDynamicAlgebraic!A;
     }
     else
     {