Fix etl::typed_storage by supporting omitted destructors

In a recent change to alignment.h, the etl::typed_storage was
changed in a way that in case of an already constructed object,
the object is created via assignment.

However, this contradicts the original use case that led to
etl::typed_storage in the first place:
ETLCPP#1023

The goal is to omit destructors (and at the same time support
classes with deleted assignment operators), so they can be optimized out
at link time.

This change reverts commit ac7b268 to restore the original
functionality and changes the test to reflect the original
use case.

Author: rolandreichweinbmw

include/etl/alignment.h

@@ -450,17 +450,9 @@ namespace etl
     template <typename... TArgs>
     reference create(TArgs&&... args) ETL_NOEXCEPT_EXPR(ETL_NOT_USING_EXCEPTIONS)
     {
-      if (has_value())
-      {
-        storage.value = T(args...);
-      }
-      else
-      {
-        valid = true;
-        ::new (&storage.value) value_type(etl::forward<TArgs>(args)...);
-      }
-
-      return storage.value;
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (&storage.value) value_type(etl::forward<TArgs>(args)...);
     }
 #else
     //***************************************************************************
@@ -470,17 +462,9 @@ namespace etl
     template <typename T1>
     reference create(const T1& t1)
     {
-      if (has_value())
-      {
-        storage.value = T(t1);
-      }
-      else
-      {
-        valid = true;
-        ::new (&storage.value) value_type(t1);
-      }
-
-      return storage.value;
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (&storage.value) value_type(t1);
     }
 
     //***************************************************************************
@@ -490,17 +474,9 @@ namespace etl
     template <typename T1, typename T2>
     reference create(const T1& t1, const T2& t2)
     {
-      if (has_value())
-      {
-        storage.value = T(t1, t2);
-      }
-      else
-      {
-        valid = true;
-        ::new (&storage.value) value_type(t1, t2);
-      }
-
-      return storage.value;
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (&storage.value) value_type(t1, t2);
     }
 
     //***************************************************************************
@@ -510,17 +486,9 @@ namespace etl
     template <typename T1, typename T2, typename T3>
     reference create(const T1& t1, const T2& t2, const T3& t3)
     {
-      if (has_value())
-      {
-        storage.value = T(t1, t2, t3);
-      }
-      else
-      {
-        valid = true;
-        ::new (&storage.value) value_type(t1, t2, t3);
-      }
-
-      return storage.value;
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (&storage.value) value_type(t1, t2, t3);
     }
 
     //***************************************************************************
@@ -530,17 +498,9 @@ namespace etl
     template <typename T1, typename T2, typename T3, typename T4>
     reference create(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
     {
-      if (has_value())
-      {
-        storage.value = T(t1, t2, t3, t4);
-      }
-      else
-      {
-        valid = true;
-        ::new (&storage.value) value_type(t1, t2, t3, t4);
-      }
-
-      return storage.value;
+      ETL_ASSERT(!has_value(), ETL_ERROR(etl::typed_storage_error));
+      valid = true;
+      return *::new (&storage.value) value_type(t1, t2, t3, t4);
     }
 #endif
 

test/test_alignment.cpp

@@ -48,6 +48,7 @@ void f(int)
 {
 }
 
+// Demonstrator class for etl::typed_storage tests
 struct A_t
 {
   A_t(uint32_t v_x, uint8_t v_y)
@@ -56,12 +57,21 @@ struct A_t
   {
   }
 
+  // Just for test purpose. In production code, etl::typed_storage
+  // actually supports the use case of destructors being optimized
+  // away since they are not necessary for global objects that are
+  // never destroyed
   ~A_t()
   {
     x = 0;
     y = 0;
   }
 
+  // etl::typed_storage helps implementing the use case of becoming
+  // independent of the destructor. By deleting the assignment operator,
+  // we make sure that the destructor is not linked
+  A_t& operator=(A_t& other) = delete;
+
   bool operator==(A_t& other)
   {
     return other.x == x && other.y == y;