[llvm][ADT] Fix Any with msvc and lto

[sebastian-ne]

Summary

llvm::Any had and has several bugs, so we eventually want to replace it
with std::any.

Unfortunately, we cannot do that right now because of bugs in the msvc
standard library that are only fixed in VS 2022 17.4.

When lto is enabled in msvc, constant symbols end up at the same
address, breaking the TypeId implementation of llvm::Any.
Make the TypeId<T>::Id non-const to fix this.

I was able to find an easy reproducer (tried in godbolt with
x64 msvc v19.32 and /GL as compiler flags to enable lto):

c++

template <typename T> struct TypeId {
  // Remove the const here and below to make it work.
  static const char Id;
};

template <typename T> const char TypeId<T>::Id = 0;

template <typename A, typename B>
bool isSame() {
  return &TypeId<A>::Id == &TypeId<B>::Id;
}

class A {};
class B {};

int main() {
  // This should output "is same 0" because the addresses of A's and B's
  // TypeId::Id should be different.
  printf("is same %d\n", isSame<A, B>());
  return 0;
}

[aeubanks]

doesn't this basically doom anybody not using MSVC 2022 17.4? I don't think conditionally using something that may be buggy makes sense if we claim to support older MSVC versions

[dblaikie]

In D139974#3993357, @aeubanks wrote:

doesn't this basically doom anybody not using MSVC 2022 17.4? I don't think conditionally using something that may be buggy makes sense if we claim to support older MSVC versions

+1 to that. If we've got to keep the whole implementation around anyway, best we use it all the time than use it in only some configurations, lest it bitrot/become undermaintained.

[sebastian-ne]

I found a different way to fix the problem with msvc.
Marking the TypeId as non-const fixes the problem, at least in godbolt.

[jloser]

LGTM with just removing the const. Please add a comment though as we don't have an existing regression test to show this (i.e. prevent someone from adding const back IIUC).

llvm/include/llvm/ADT/Any.h

 namespace llvm {
 
 class LLVM_EXTERNAL_VISIBILITY Any {
 
   // The `Typeid<T>::Id` static data member below is a globally unique
   // identifier for the type `T`. It is explicitly marked with default
   // visibility so that when `-fvisibility=hidden` is used, the loader still
   // merges duplicate definitions across DSO boundaries.
-  template <typename T> struct TypeId {
-    static const char Id;
-  };
+  // We also cannot mark it as `const`, otherwise msvc merges all definitions
+  // when lto is enabled, making any comparison return true.
+  template <typename T> struct TypeId { static char Id; };
 
   struct StorageBase {
     virtual ~StorageBase() = default;
     virtual std::unique_ptr<StorageBase> clone() const = 0;
     virtual const void *id() const = 0;
   };
 
   template <typename T> struct StorageImpl : public StorageBase {
private:
   template <class T> friend T any_cast(Any &&Value);
   template <class T> friend const T *any_cast(const Any *Value);
   template <class T> friend T *any_cast(Any *Value);
   template <typename T> friend bool any_isa(const Any &Value);
 
   std::unique_ptr<StorageBase> Storage;
 };
 
-template <typename T> const char Any::TypeId<T>::Id = 0;
+template <typename T> char Any::TypeId<T>::Id = 0;
 
 template <typename T> bool any_isa(const Any &Value) {
   if (!Value.Storage)
     return false;
   return Value.Storage->id() == &Any::TypeId<remove_cvref_t<T>>::Id;
 }
 
 template <class T> T any_cast(const Any &Value) {