Implement Castable

Author: limbonaut

src/sentry/android/android_scope.h

@@ -5,6 +5,8 @@
 namespace sentry::android {
 
 class AndroidScope : public SentryScopeImpl {
+	SENTRY_CASTABLE(AndroidScope, SentryScopeImpl);
+
 private:
 	Object *android_plugin = nullptr;
 	int32_t handle = 0;

src/sentry/castable.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <type_traits>
+
+namespace sentry {
+
+// Casts between related classes without the cost of dynamic_cast.
+// Declare with SENTRY_CASTABLE in every participating class, naming Castable
+// as the base in the root class.
+class Castable {
+public:
+	struct TypeInfo {
+		const TypeInfo *parent;
+	};
+
+	static constexpr TypeInfo type_info{ nullptr };
+
+	// Returns true if p_from is a T, or derives from T. Null is safe and never matches.
+	template <typename T>
+	static bool is_class(const Castable *p_from) {
+		static_assert(std::is_same_v<typename T::castable_self, T>,
+				"T must declare SENTRY_CASTABLE");
+		if (!p_from) {
+			return false;
+		}
+		const TypeInfo *t = p_from->get_type_info();
+		while (t) {
+			if (t == &T::type_info) {
+				return true;
+			}
+			t = t->parent;
+		}
+		return false;
+	}
+
+	// Returns p_from as T, or null if it isn't one. Null is safe.
+	template <typename T>
+	static T *cast_to(Castable *p_from) {
+		return is_class<T>(p_from) ? static_cast<T *>(p_from) : nullptr;
+	}
+
+	// Returns p_from as T, or null if it isn't one. Null is safe.
+	template <typename T>
+	static const T *cast_to(const Castable *p_from) {
+		return is_class<T>(p_from) ? static_cast<const T *>(p_from) : nullptr;
+	}
+
+	virtual ~Castable() = default;
+
+protected:
+	virtual const TypeInfo *get_type_info() const = 0;
+};
+
+} //namespace sentry
+
+// Adds type info to a castable class. Add at the top of the class body.
+#define SENTRY_CASTABLE(m_class, m_base)                                           \
+public:                                                                            \
+	using castable_self = m_class;                                                 \
+	static constexpr ::sentry::Castable::TypeInfo type_info{ &m_base::type_info }; \
+                                                                                   \
+protected:                                                                         \
+	virtual const ::sentry::Castable::TypeInfo *get_type_info() const override {   \
+		static_assert(std::is_base_of_v<m_base, m_class>,                          \
+				#m_base " must be a base of " #m_class ".");                       \
+		return &type_info;                                                         \
+	}                                                                              \
+                                                                                   \
+private:

src/sentry/disabled/disabled_scope.h

@@ -5,6 +5,8 @@
 namespace sentry {
 
 class DisabledScope : public SentryScopeImpl {
+	SENTRY_CASTABLE(DisabledScope, SentryScopeImpl);
+
 public:
 	virtual void set_context(const String &p_key, const Dictionary &p_value) override {}
 	virtual void set_tag(const String &p_key, const String &p_value) override {}

src/sentry/javascript/javascript_scope.h

@@ -9,6 +9,8 @@ namespace sentry::javascript {
 // yield a DisabledScope instead.
 // See JavaScriptSDK::create_scope().
 class JavaScriptScope : public SentryScopeImpl {
+	SENTRY_CASTABLE(JavaScriptScope, SentryScopeImpl);
+
 private:
 	JSObjectPtr js_obj;
 

src/sentry/javascript/javascript_sdk.cpp

@@ -118,7 +118,7 @@ namespace {
 // Scope creation can fall back to DisabledScope, and null falls back to capture without passed scope.
 inline JSObjectPtr _get_scope_object(const Ref<SentryScope> &p_scope) {
 	ERR_FAIL_COND_V(p_scope.is_null(), nullptr);
-	JavaScriptScope *js_scope = dynamic_cast<JavaScriptScope *>(p_scope->get_implementation());
+	JavaScriptScope *js_scope = Castable::cast_to<JavaScriptScope>(p_scope->get_implementation());
 	return js_scope ? js_scope->get_js_object() : nullptr;
 }
 

src/sentry/native/native_scope.h

@@ -8,6 +8,8 @@ namespace sentry::native {
 
 // Thin wrapper around sentry-native scope used for SentryScope implementation on Windows and Linux.
 class NativeScope : public SentryScopeImpl {
+	SENTRY_CASTABLE(NativeScope, SentryScopeImpl);
+
 private:
 	sentry_scope_t *_scope;
 

src/sentry/sentry_scope_impl.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "sentry/castable.h"
 #include "sentry/level.h"
 #include "sentry/sentry_breadcrumb.h"
 #include "sentry/sentry_user.h"
@@ -17,7 +18,9 @@ namespace sentry {
 // Kept as a pure C++ class instead of a Godot class to avoid ClassDB
 // registration and reduce overhead.
 // Lifetime governed by SentryScope.
-class SentryScopeImpl {
+class SentryScopeImpl : public Castable {
+	SENTRY_CASTABLE(SentryScopeImpl, Castable);
+
 public:
 	virtual void set_context(const String &p_key, const Dictionary &p_value) = 0;
 	virtual void set_tag(const String &p_key, const String &p_value) = 0;