[lldb][NFC] Format lldb/include/lldb/Symbol/Type.h

[teemperor]

I guess that's just clang-format ran over the file? If yes, then LGTM

lldb/include/lldb/Symbol/Type.h

70–90

FWIW, we usually update the comments to something less >squished< such as:

///< This type is the type whose UID is m_encoding_uid
eEcodingIsUID.
/// This type is the type whose UID is m_encoding_uid with the const qualifier added
eEncodingIsConstUID,

I think this patch is good as-is, but there would be bonus points for fixing up the comment style :)

[teemperor]

lldb/include/lldb/Symbol/Type.h

70–90

I meant

/// This type is the type whose UID is m_encoding_uid
eEcodingIsUID.
/// This type is the type whose UID is m_encoding_uid with the const qualifier added
eEncodingIsConstUID,

[ljmf00]

Can you check now? If looks good, can you land it please?

lldb/include/lldb/Symbol/Type.h

70–90

Done

[ljmf00]

Friendly ping, maybe you forgot this, can you check it now @teemperor ? :)

[JDevlieghere]

LGTM modulo the inline comment.

lldb/include/lldb/Symbol/Type.h

204

Since you're touching this line... The coding standards say that StringRefs should always be passed by-value:

StringRef is small and pervasive enough in LLVM that it should always be passed by value.

https://llvm.org/docs/ProgrammersManual.html#the-stringref-class

[ljmf00]

In D113604#3138107, @JDevlieghere wrote:

LGTM modulo the inline comment.

I addressed what you requested. Please review. If it is good to land, please do, as I don't have permissions.

[dblaikie]

lldb/include/lldb/Symbol/Type.h

207–208

Looks like this could've broken some tests - might be best to revert and retest?

The const StringRef& should've been changed to StringRef per @JDevlieghere's comment, but the non-const StringRef& were/are probably load-bearing - they're the result of calling this function (using mutable ref parameters as "out" parameters) & passing them by value breaks that.

[dblaikie]

lldb/include/lldb/Symbol/Type.h

206–207

lldb/source/Symbol/Type.cpp

667–668

[ljmf00]

Sorry for the delay. Can you re-review this @dblaikie ?

[dblaikie]

Looks alright

lldb/include/lldb/Symbol/Type.h

protected:
   SymbolFile &m_symbol_file;
   lldb::TypeSP m_type_sp;
 };
 
 class Type : public std::enable_shared_from_this<Type>, public UserID {
 public:
   enum EncodingDataType {
     eEncodingInvalid,
-    eEncodingIsUID,      ///< This type is the type whose UID is m_encoding_uid
-    eEncodingIsConstUID, ///< This type is the type whose UID is m_encoding_uid
-                         /// with the const qualifier added
-    eEncodingIsRestrictUID, ///< This type is the type whose UID is
-                            /// m_encoding_uid with the restrict qualifier added
-    eEncodingIsVolatileUID, ///< This type is the type whose UID is
-                            /// m_encoding_uid with the volatile qualifier added
-    eEncodingIsTypedefUID,  ///< This type is pointer to a type whose UID is
-                            /// m_encoding_uid
-    eEncodingIsPointerUID,  ///< This type is pointer to a type whose UID is
-                            /// m_encoding_uid
-    eEncodingIsLValueReferenceUID, ///< This type is L value reference to a type
-                                   /// whose UID is m_encoding_uid
-    eEncodingIsRValueReferenceUID, ///< This type is R value reference to a type
-                                   /// whose UID is m_encoding_uid,
-    eEncodingIsAtomicUID,          ///< This type is the type whose UID is
-                                   /// m_encoding_uid as an atomic type.
+    /// This type is the type whose UID is m_encoding_uid.
+    eEncodingIsUID,
+    /// This type is the type whose UID is m_encoding_uid with the const
+    /// qualifier added.
+    eEncodingIsConstUID,
+    /// This type is the type whose UID is m_encoding_uid with the restrict
+    /// qualifier added.
+    eEncodingIsRestrictUID,
+    /// This type is the type whose UID is m_encoding_uid with the volatile
+    /// qualifier added.
+    eEncodingIsVolatileUID,
+    /// This type is pointer to a type whose UID is m_encoding_uid.
+    eEncodingIsTypedefUID,
+    /// This type is pointer to a type whose UID is m_encoding_uid.
+    eEncodingIsPointerUID,
+    /// This type is L value reference to a type whose UID is m_encoding_uid.
+    eEncodingIsLValueReferenceUID,
+    /// This type is R value reference to a type whose UID is m_encoding_uid.
+    eEncodingIsRValueReferenceUID,
+    /// This type is the type whose UID is m_encoding_uid as an atomic type.
+    eEncodingIsAtomicUID,
     eEncodingIsSyntheticUID
   };
 
   enum class ResolveState : unsigned char {
     Unresolved = 0,
     Forward = 1,
     Layout = 2,
     Full = 3
public:
   // Get the clang type and leave class/struct/union/enum types as forward
   // declarations if they haven't already been fully defined.
   CompilerType GetForwardCompilerType();
 
   static int Compare(const Type &a, const Type &b);
 
   // From a fully qualified typename, split the type into the type basename and
   // the remaining type scope (namespaces/classes).
-  static bool GetTypeScopeAndBasename(const llvm::StringRef& name,
+  static bool GetTypeScopeAndBasename(llvm::StringRef name,
                                       llvm::StringRef &scope,
                                       llvm::StringRef &basename,
                                       lldb::TypeClass &type_class);
   void SetEncodingType(Type *encoding_type) { m_encoding_type = encoding_type; }
 
   uint32_t GetEncodingMask();
 
   typedef uint32_t Payload;
   /// Return the language-specific payload.
   Payload GetPayload() { return m_payload; }
   /// Return the language-specific payload.
   void SetPayload(Payload opaque_payload) { m_payload = opaque_payload; }
private:
   ConstString m_name;
   lldb::MemberFunctionKind m_kind = lldb::eMemberFunctionKindUnknown;
 };
 
 class TypeEnumMemberImpl {
 public:
   TypeEnumMemberImpl() : m_integer_type_sp(), m_name("<invalid>"), m_value() {}
 
-  TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
-                     ConstString name, const llvm::APSInt &value);
+  TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp, ConstString name,
+                     const llvm::APSInt &value);
 
   TypeEnumMemberImpl(const TypeEnumMemberImpl &rhs) = default;
 
   TypeEnumMemberImpl &operator=(const TypeEnumMemberImpl &rhs);
 
   bool IsValid() { return m_valid; }
 
   ConstString GetName() const { return m_name; }

lldb/source/Symbol/Type.cpp

CompilerType Type::GetForwardCompilerType() {
   ResolveCompilerType(ResolveState::Forward);
   return m_compiler_type;
 }
 
 ConstString Type::GetQualifiedName() {
   return GetForwardCompilerType().GetTypeName();
 }
 
-bool Type::GetTypeScopeAndBasename(const llvm::StringRef& name,
+bool Type::GetTypeScopeAndBasename(llvm::StringRef name,
                                    llvm::StringRef &scope,
                                    llvm::StringRef &basename,
                                    TypeClass &type_class) {
   type_class = eTypeClassAny;
 
   if (name.empty())
     return false;
 
   basename = name;
   if (basename.consume_front("struct "))
     type_class = eTypeClassStruct;