diff --git a/indra/llcommon/llsdutil.cpp b/indra/llcommon/llsdutil.cpp
index c243133402043a8eb4ce2302764c56801061de70..384b6cb8f774b0e7827f61c10c105ccbdbb19d96 100644
--- a/indra/llcommon/llsdutil.cpp
+++ b/indra/llcommon/llsdutil.cpp
@@ -500,7 +500,7 @@ bool filter_llsd_with_template(
 *   Helpers for llsd_matches()
 *****************************************************************************/
 // raw data used for LLSD::Type lookup
-struct Data
+struct LLSDTypeData
 {
     LLSD::Type type;
     const char* name;
@@ -529,7 +529,7 @@ class TypeLookup
 public:
     TypeLookup()
     {
-        for (const Data *di(boost::begin(typedata)), *dend(boost::end(typedata)); di != dend; ++di)
+        for (const LLSDTypeData *di(boost::begin(typedata)), *dend(boost::end(typedata)); di != dend; ++di)
         {
             mMap[di->type] = di->name;
         }
diff --git a/indra/llcommon/tests/llpounceable_test.cpp b/indra/llcommon/tests/llpounceable_test.cpp
index 707066e574ba174863138c7807101c0594769a0b..960e3042efa7a960aed7bb286a8351b2dcfa4a55 100644
--- a/indra/llcommon/tests/llpounceable_test.cpp
+++ b/indra/llcommon/tests/llpounceable_test.cpp
@@ -27,24 +27,24 @@ void append(std::string* dest, const std::string& src)
 }
 
 /*-------------------------- Data-struct testing ---------------------------*/
-struct Data
+struct PounceableData
 {
-    Data(const std::string& data):
+    PounceableData(const std::string& data):
         mData(data)
     {}
     const std::string mData;
 };
 
-void setter(Data** dest, Data* ptr)
+void setter(PounceableData** dest, PounceableData* ptr)
 {
     *dest = ptr;
 }
 
-static Data* static_check = 0;
+static PounceableData* static_check = 0;
 
 // Set up an extern pointer to an LLPounceableStatic so the linker will fill
 // in the forward reference from below, before runtime.
-extern LLPounceable<Data*, LLPounceableStatic> gForward;
+extern LLPounceable<PounceableData*, LLPounceableStatic> gForward;
 
 struct EnqueueCall
 {
@@ -64,7 +64,7 @@ struct EnqueueCall
 // to remark, we want this call not to crash.
 
 // Now declare gForward. Its constructor should not run until after nqcall's.
-LLPounceable<Data*, LLPounceableStatic> gForward;
+LLPounceable<PounceableData*, LLPounceableStatic> gForward;
 
 /*****************************************************************************
 *   TUT
@@ -90,7 +90,7 @@ namespace tut
         // implementing it with an LLSingleton queue. This models (say)
         // LLPounceableStatic<LLMessageSystem*, LLPounceableStatic>.
         ensure("static_check should still be null", ! static_check);
-        Data myData("test<1>");
+        PounceableData myData("test<1>");
         gForward = &myData;         // should run setter
         ensure_equals("static_check should be &myData", static_check, &myData);
     }
@@ -105,13 +105,13 @@ namespace tut
         // We expect that LLPounceable<T, LLPounceableQueue> should have
         // different queues because that specialization stores the queue
         // directly in the LLPounceable instance.
-        Data *aptr = 0, *bptr = 0;
-        LLPounceable<Data*> a, b;
+        PounceableData*aptr = 0, *bptr = 0;
+        LLPounceable<PounceableData*> a, b;
         a.callWhenReady(boost::bind(setter, &aptr, _1));
         b.callWhenReady(boost::bind(setter, &bptr, _1));
         ensure("aptr should be null", ! aptr);
         ensure("bptr should be null", ! bptr);
-        Data adata("a"), bdata("b");
+        PounceableData adata("a"), bdata("b");
         a = &adata;
         ensure_equals("aptr should be &adata", aptr, &adata);
         // but we haven't yet set b
@@ -127,13 +127,13 @@ namespace tut
         // LLPounceable<T, LLPounceableStatic> should also have a distinct
         // queue for each instance, but that engages an additional map lookup
         // because there's only one LLSingleton for each T.
-        Data *aptr = 0, *bptr = 0;
-        LLPounceable<Data*, LLPounceableStatic> a, b;
+        PounceableData*aptr = 0, *bptr = 0;
+        LLPounceable<PounceableData*, LLPounceableStatic> a, b;
         a.callWhenReady(boost::bind(setter, &aptr, _1));
         b.callWhenReady(boost::bind(setter, &bptr, _1));
         ensure("aptr should be null", ! aptr);
         ensure("bptr should be null", ! bptr);
-        Data adata("a"), bdata("b");
+        PounceableData adata("a"), bdata("b");
         a = &adata;
         ensure_equals("aptr should be &adata", aptr, &adata);
         // but we haven't yet set b
@@ -149,11 +149,11 @@ namespace tut
         // We want LLPounceable<T, TAG> to be drop-in replaceable for a plain
         // T for read constructs. In particular, it should behave like a dumb
         // pointer -- and with zero abstraction cost for such usage.
-        Data* aptr = 0;
-        Data a("a");
+        PounceableData* aptr = 0;
+        PounceableData a("a");
         // should be able to initialize a pounceable (when its constructor
         // runs)
-        LLPounceable<Data*> pounceable(&a);
+        LLPounceable<PounceableData*> pounceable(&a);
         // should be able to pass LLPounceable<T> to function accepting T
         setter(&aptr, pounceable);
         ensure_equals("aptr should be &a", aptr, &a);
@@ -170,9 +170,9 @@ namespace tut
     void object::test<5>()
     {
         set_test_name("Multiple callWhenReady() queue items");
-        Data *p1 = 0, *p2 = 0, *p3 = 0;
-        Data a("a");
-        LLPounceable<Data*> pounceable;
+        PounceableData*p1 = 0, *p2 = 0, *p3 = 0;
+        PounceableData a("a");
+        LLPounceable<PounceableData*> pounceable;
         // queue up a couple setter() calls for later
         pounceable.callWhenReady(boost::bind(setter, &p1, _1));
         pounceable.callWhenReady(boost::bind(setter, &p2, _1));