From 5d7b3abe7759545b5ff12dc8ae5a6de9ed258953 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 25 Sep 2024 10:15:20 -0400
Subject: Explain why apparently redundant LLPointer methods are necessary.

Given templated constructors and assignment operators, it's tempting to remove
specific constructors and assignment operators with the same LLPointer<Type>
parameters. That turns out to be a mistake. Add comments to warn future
maintainers.
---
 indra/llcommon/llpointer.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/indra/llcommon/llpointer.h b/indra/llcommon/llpointer.h
index c5dd5532cc..71c955c4c5 100644
--- a/indra/llcommon/llpointer.h
+++ b/indra/llcommon/llpointer.h
@@ -61,6 +61,13 @@ public:
         ref();
     }
 
+    // Even though the template constructors below accepting
+    // (const LLPointer<Subclass>&) and (LLPointer<Subclass>&&) appear to
+    // subsume these specific (const LLPointer<Type>&) and (LLPointer<Type>&&)
+    // constructors, the compiler recognizes these as The Copy Constructor and
+    // The Move Constructor, respectively. In other words, even in the
+    // presence of the LLPointer<Subclass> constructors, we still must specify
+    // the LLPointer<Type> constructors.
     LLPointer(const LLPointer<Type>& ptr) :
         mPointer(ptr.mPointer)
     {
@@ -126,6 +133,13 @@ public:
         return *this;
     }
 
+    // Even though the template assignment operators below accepting
+    // (const LLPointer<Subclass>&) and (LLPointer<Subclass>&&) appear to
+    // subsume these specific (const LLPointer<Type>&) and (LLPointer<Type>&&)
+    // assignment operators, the compiler recognizes these as Copy Assignment
+    // and Move Assignment, respectively. In other words, even in the presence
+    // of the LLPointer<Subclass> assignment operators, we still must specify
+    // the LLPointer<Type> operators.
     LLPointer<Type>& operator =(const LLPointer<Type>& ptr)
     {
         LLPointer temp(ptr);
-- 
cgit v1.2.3