Automatically call Inode::flush_metadata() before an Inode is destroyed.

Use a little template magic to have Retainable::release() call out to
T::will_be_destroyed() if such a function exists before actually calling
the destructor. This gives us full access to virtual functions in the
pre-destruction code.

AK/Retainable.h

@@ -1,39 +1,54 @@
 #pragma once
 
 #include "Assertions.h"
+#include "StdLibExtras.h"
 
 namespace AK {
 
+template<class T>
+constexpr auto call_will_be_destroyed_if_present(T* object) -> decltype(object->will_be_destroyed(), TrueType { })
+{
+    object->will_be_destroyed();
+    return { };
+}
+
+constexpr auto call_will_be_destroyed_if_present(...) -> FalseType
+{
+    return { };
+}
+
 template<typename T>
 class Retainable {
 public:
     void retain()
     {
-        ASSERT(m_retainCount);
-        ++m_retainCount;
+        ASSERT(m_retain_count);
+        ++m_retain_count;
     }
 
     void release()
     {
-        ASSERT(m_retainCount);
-        if (!--m_retainCount)
+        ASSERT(m_retain_count);
+        if (!--m_retain_count) {
+            call_will_be_destroyed_if_present(static_cast<T*>(this));
             delete static_cast<T*>(this);
+        }
     }
 
-    int retainCount() const
+    int retain_count() const
     {
-        return m_retainCount;
+        return m_retain_count;
     }
 
 protected:
     Retainable() { }
     ~Retainable()
     {
-        ASSERT(!m_retainCount);
+        ASSERT(!m_retain_count);
     }
 
 private:
-    int m_retainCount { 1 };
+    int m_retain_count { 1 };
 };
 
 }