Some FormatEntity.cpp cleanup and unit testing

[nealsid]

Summary

Just fixing a few things I noticed as I am working on another feature for format strings in the prompt: forward decls, adding constexpr constructors, various checks, and unit tests for FormatEntity::Parse and new Definition constructors, etc.

[nealsid]

Rebased on HEAD

[nealsid]

Reuploading patch after I incorrectly set project repo.

[teemperor]

Thanks for cleaning this up! Are the if (!sc) ... stuff are missing nullptr checks that affect a normal LLDB session (not sure if we can ever have no SymbolContext) or is this just for the unit test?

Anyway, I have some small inline comments but otherwise this looks pretty good to me.

lldb/include/lldb/Core/FormatEntity.h

113

Can you doxygenify this when you anyway touch this code (/// An array of "num_children" Definition entries, before the member)?

144

I believe you could make this far less verbose with delegating constructors and using C++11 default member initializers.

lldb/source/Core/FormatEntity.cpp

1765

One-line if's don't have {} around the body according to LLVM code style (I know this is wrong in a lot of LLDB code, but newer code should follow that style). Just commenting this once but the same thing is happening above/below this change too.

[nealsid]

Thanks - all the comments sound good. I'll upload a new patch.

It seems like the pre-merge check failures are because I incorrectly set the project repo when I first created the revision. I noticed in the build commands here: https://buildkite.com/llvm-project/premerge-checks/builds/28649#b755747b-7673-4dbc-9189-2d6bbcd1fbd3 that the cmake command doesn't include 'lldb' as a project. I was able to repro the error on my Debian machine using those commands, and adding lldb to the cmake command seemed to make them go away (tbh, I'm not familiar enough with the normal output of clang-tidy to be sure)

Is there any way to fix that without creating a new revision or would that be easiest? Thanks, sorry about that.

[nealsid]

lldb/include/lldb/Core/FormatEntity.h

144

Makes sense - I used default member initializers but once I did that, delegating constructors seemed to add more code back in :) So I just stuck with the member initializers.

lldb/source/Core/FormatEntity.cpp

1765

Done, here and in other spots I noticed.

[nealsid]

In D98153#2610953, @teemperor wrote:

Thanks for cleaning this up! Are the if (!sc) ... stuff are missing nullptr checks that affect a normal LLDB session (not sure if we can ever have no SymbolContext) or is this just for the unit test?

Anyway, I have some small inline comments but otherwise this looks pretty good to me.

Missed this earlier - I think you're right, because the formatting code is used for thread/frame lists & information, so there will be a SymbolContext. But one my planned upcoming changes is to use it in the LLDB prompt, where a target might not be available. And it's also more consistent with formatting code for other Entry types.

[nealsid]

lldb/source/Core/FormatEntity.cpp

1560

Sorry, just caught this. Am uploading a new diff shortly.

[nealsid]

Fix regression introduced by removing return statement in case where we were able to format a function name.

[nealsid]

Rebased on HEAD

[nealsid]

In D98153#2610953, @teemperor wrote:

Thanks for cleaning this up! Are the if (!sc) ... stuff are missing nullptr checks that affect a normal LLDB session (not sure if we can ever have no SymbolContext) or is this just for the unit test?

Anyway, I have some small inline comments but otherwise this looks pretty good to me.

Thanks again for the review! I should have addressed everything with the new diff I just uploaded, but I'm still not sure about the pre-merge check failures because it looks (to me) like the build bot should have "lldb" in its cmake command, although I will freely admit zero experience with LLVM's build infrastructure :-)

[teemperor]

Sorry for the delay!

It seems like the pre-merge check failures are because I incorrectly set the project repo when I first created the revision. I noticed in the build commands here: https://buildkite.com/llvm-project/premerge-checks/builds/28649#b755747b-7673-4dbc-9189-2d6bbcd1fbd3 that the cmake command doesn't include 'lldb' as a project. I was able to repro the error on my Debian machine using those commands, and adding lldb to the cmake command seemed to make them go away (tbh, I'm not familiar enough with the normal output of clang-tidy to be sure)

You can ignore the clang-tidy errors as they look indeed like a setup problem on the bot. They won't prevent this from being merged.

I think this looks almost ready beside some small problems (some of which are maybe a bit subjective).

lldb/include/lldb/Core/FormatEntity.h

111

You can use \see FormatEntity::Entry::Type and this will be linked in doxygen.

119

Truncated comment? Also thanks for documenting this!

lldb/unittests/Core/FormatEntityTest.cpp

23

I think you can use EXPECT_* in all these tests.

154

You could just use llvm::StringRef here (it's shorter and more descriptive than the auto).

[nealsid]

Thanks for the review - addressed your comments here (I had to rely on Doxygen picking up the type reference automatically because I couldn't get the \see syntax to work correctly, though)

[teemperor]

LGTM, thanks for the patch (and especially the unit test)! Some two nits left but feel free to fix those when merging. If you don't have commit access I can also do that, just let me know.

lldb/include/lldb/Core/FormatEntity.h

120

Missing period

lldb/unittests/Core/FormatEntityTest.cpp

154

I actually meant llvm::StringRef as the whole type (StringRef references are not really useful as StringRef is already a lightweight String reference)

[nealsid]

CR feedback

[nealsid]

Fixed comment.

[nealsid]

Update type in for loop.

[nealsid]

lldb/unittests/Core/FormatEntityTest.cpp

154

Done - kept it const since StringRef appears to depend on that for some of its methods. I was looking through StringRef (and the use of optionals for something else) and as far as I understand, which could be entirely wrong, it's meant to provide a single interface over unowned character data whether it comes from a std::string or char*, and thought using string_view would be good, as well - is moving to C++17 on the roadmap? I know it's one of those things that everyone is in favor of and wants to do but nobody has time for :)

[nealsid]

Thanks for the review, and apologies for the delay in updating the diffs - seems like I haven't even had an hour to sit down at my dev machine for the past couple weeks, much less actually do any coding :) I don't have commit access, so if you could do that, that would be much appreciated.

[nealsid]

Small update of patch.

[teemperor]

Thanks for updating and thanks for the patch! I can land it right now.

lldb/unittests/Core/FormatEntityTest.cpp

154

It's on the roadmap but not sure when that will happen. I think that depends on when the interest in having C++17 features is bigger than the pain it will inflict on people stuck on outdated runtime environments that need bootstrapping for C++17.

lldb/include/lldb/Core/FormatEntity.h

 //===-- FormatEntity.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_FORMATENTITY_H
 #define LLDB_CORE_FORMATENTITY_H
 
-#include "lldb/Utility/CompletionRequest.h"
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/Status.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-types.h"
 #include <algorithm>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
 namespace lldb_private {
 class Address;
+class CompletionRequest;
 class ExecutionContext;
+class FileSpec;
+class Status;
 class Stream;
 class StringList;
 class SymbolContext;
 class ValueObject;
 }
+
 namespace llvm {
 class StringRef;
 }
 
 namespace lldb_private {
 class FormatEntity {
 public:
   struct Entry {
enum class Type {
       LineEntryLineNumber,
       LineEntryColumn,
       LineEntryStartAddress,
       LineEntryEndAddress,
       CurrentPCArrow
     };
 
     struct Definition {
+      /// The name/string placeholder that corresponds to this definition.
       const char *name;
-      const char *string; // Insert this exact string into the output
-      Entry::Type type;
-      uint64_t data;
-      uint32_t num_children;
-      Definition *children; // An array of "num_children" Definition entries,
-      bool keep_separator;
+      /// Insert this exact string into the output
+      const char *string = nullptr;
+      /// The type of the format string (see Type above)
+      const Entry::Type type;
+      /// Data that is returned as the value of the format string.
+      const uint64_t data = 0;
+      /// The number of children of this node in the tree of format strings.
+      const uint32_t num_children = 0;
+      /// An array of "num_children" Definition entries,
+      const Definition *children = nullptr;
+      /// Whether
+      const bool keep_separator = false;
+
+      constexpr Definition(const char *name, const FormatEntity::Entry::Type t)
+          : name(name), type(t) {}
+
+      constexpr Definition(const char *name, const char *string)
+          : name(name), string(string), type(Entry::Type::EscapeCode) {}
+
+      constexpr Definition(const char *name, const FormatEntity::Entry::Type t,
+                           const uint64_t data)
+          : name(name), string(nullptr), type(t), data(data) {}
+
+      constexpr Definition(const char *name, const FormatEntity::Entry::Type t,
+                           const uint64_t num_children,
+                           const Definition *children,
+                           const bool keep_separator = false)
+          : name(name), type(t), num_children(num_children), children(children),
+            keep_separator(keep_separator) {}
     };
 
+    template <size_t N>
+    static constexpr Definition
+    DefinitionWithChildren(const char *name, const FormatEntity::Entry::Type t,
+                           const Definition (&children)[N],
+                           bool keep_separator = false) {
+      return Definition(name, t, N, children, keep_separator);
+    }
+
     Entry(Type t = Type::Invalid, const char *s = nullptr,
           const char *f = nullptr)
-        : string(s ? s : ""), printf_format(f ? f : ""), children(),
-          definition(nullptr), type(t), fmt(lldb::eFormatDefault), number(0),
-          deref(false) {}
+        : string(s ? s : ""), printf_format(f ? f : ""), children(), type(t),
+          fmt(lldb::eFormatDefault), number(0), deref(false) {}
 
     Entry(llvm::StringRef s);
     Entry(char ch);
 
     void AppendChar(char ch);
 
     void AppendText(const llvm::StringRef &s);
 
     void AppendText(const char *cstr);
 
     void AppendEntry(const Entry &&entry) { children.push_back(entry); }
 
     void Clear() {
       string.clear();
       printf_format.clear();
       children.clear();
-      definition = nullptr;
       type = Type::Invalid;
       fmt = lldb::eFormatDefault;
       number = 0;
       deref = false;
     }
 
     static const char *TypeToCString(Type t);
 
     void Dump(Stream &s, int depth = 0) const;
 
     bool operator==(const Entry &rhs) const {
       if (string != rhs.string)
         return false;
       if (printf_format != rhs.printf_format)
         return false;
       const size_t n = children.size();
       const size_t m = rhs.children.size();
       for (size_t i = 0; i < std::min<size_t>(n, m); ++i) {
         if (!(children[i] == rhs.children[i]))
           return false;
       }
       if (children != rhs.children)
         return false;
-      if (definition != rhs.definition)
-        return false;
       if (type != rhs.type)
         return false;
       if (fmt != rhs.fmt)
         return false;
       if (deref != rhs.deref)
         return false;
       return true;
     }
 
     std::string string;
     std::string printf_format;
     std::vector<Entry> children;
-    Definition *definition;
     Type type;
     lldb::Format fmt;
     lldb::addr_t number;
     bool deref;
   };
 
   static bool Format(const Entry &entry, Stream &s, const SymbolContext *sc,
                      const ExecutionContext *exe_ctx, const Address *addr,

lldb/source/Core/FormatEntity.cpp

 //===-- FormatEntity.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/FormatEntity.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/DumpRegisterValue.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"

 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/AnsiTerminal.h"
 #include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-forward.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"

 }
 namespace lldb_private {
 struct RegisterInfo;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
-enum FileKind { FileError = 0, Basename, Dirname, Fullpath };
-
-#define ENTRY(n, t)                                                            \
-  { n, nullptr, FormatEntity::Entry::Type::t, 0, 0, nullptr, false }
-#define ENTRY_VALUE(n, t, v)                                                   \
-  { n, nullptr, FormatEntity::Entry::Type::t, v, 0, nullptr, false }
-#define ENTRY_CHILDREN(n, t, c)                                                \
-  {                                                                            \
-    n, nullptr, FormatEntity::Entry::Type::t, 0,                               \
-        static_cast<uint32_t>(llvm::array_lengthof(c)), c, false               \
-  }
-#define ENTRY_CHILDREN_KEEP_SEP(n, t, c)                                       \
-  {                                                                            \
-    n, nullptr, FormatEntity::Entry::Type::t, 0,                               \
-        static_cast<uint32_t>(llvm::array_lengthof(c)), c, true                \
-  }
-#define ENTRY_STRING(n, s)                                                     \
-  { n, s, FormatEntity::Entry::Type::EscapeCode, 0, 0, nullptr, false }
-static FormatEntity::Entry::Definition g_string_entry[] = {
-    ENTRY("*", ParentString)};
-
-static FormatEntity::Entry::Definition g_addr_entries[] = {
-    ENTRY("load", AddressLoad),
-    ENTRY("file", AddressFile),
-    ENTRY("load", AddressLoadOrFile),
-};
+using Definition = lldb_private::FormatEntity::Entry::Definition;
+using Entry = FormatEntity::Entry;
+using EntryType = FormatEntity::Entry::Type;
 
-static FormatEntity::Entry::Definition g_file_child_entries[] = {
-    ENTRY_VALUE("basename", ParentNumber, FileKind::Basename),
-    ENTRY_VALUE("dirname", ParentNumber, FileKind::Dirname),
-    ENTRY_VALUE("fullpath", ParentNumber, FileKind::Fullpath)};
-
-static FormatEntity::Entry::Definition g_frame_child_entries[] = {
-    ENTRY("index", FrameIndex),
-    ENTRY("pc", FrameRegisterPC),
-    ENTRY("fp", FrameRegisterFP),
-    ENTRY("sp", FrameRegisterSP),
-    ENTRY("flags", FrameRegisterFlags),
-    ENTRY("no-debug", FrameNoDebug),
-    ENTRY_CHILDREN("reg", FrameRegisterByName, g_string_entry),
-    ENTRY("is-artificial", FrameIsArtificial),
-};
+enum FileKind { FileError = 0, Basename, Dirname, Fullpath };
 
-static FormatEntity::Entry::Definition g_function_child_entries[] = {
-    ENTRY("id", FunctionID),
-    ENTRY("name", FunctionName),
-    ENTRY("name-without-args", FunctionNameNoArgs),
-    ENTRY("name-with-args", FunctionNameWithArgs),
-    ENTRY("mangled-name", FunctionMangledName),
-    ENTRY("addr-offset", FunctionAddrOffset),
-    ENTRY("concrete-only-addr-offset-no-padding", FunctionAddrOffsetConcrete),
-    ENTRY("line-offset", FunctionLineOffset),
-    ENTRY("pc-offset", FunctionPCOffset),
-    ENTRY("initial-function", FunctionInitial),
-    ENTRY("changed", FunctionChanged),
-    ENTRY("is-optimized", FunctionIsOptimized)};
-
-static FormatEntity::Entry::Definition g_line_child_entries[] = {
-    ENTRY_CHILDREN("file", LineEntryFile, g_file_child_entries),
-    ENTRY("number", LineEntryLineNumber),
-    ENTRY("column", LineEntryColumn),
-    ENTRY("start-addr", LineEntryStartAddress),
-    ENTRY("end-addr", LineEntryEndAddress),
-};
+constexpr Definition g_string_entry[] = {
+    Definition("*", EntryType::ParentString)};
 
-static FormatEntity::Entry::Definition g_module_child_entries[] = {
-    ENTRY_CHILDREN("file", ModuleFile, g_file_child_entries),
+constexpr Definition g_addr_entries[] = {
+    Definition("load", EntryType::AddressLoad),
+    Definition("file", EntryType::AddressFile)};
+
+constexpr Definition g_file_child_entries[] = {
+    Definition("basename", EntryType::ParentNumber, FileKind::Basename),
+    Definition("dirname", EntryType::ParentNumber, FileKind::Dirname),
+    Definition("fullpath", EntryType::ParentNumber, FileKind::Fullpath)};
+
+constexpr Definition g_frame_child_entries[] = {
+    Definition("index", EntryType::FrameIndex),
+    Definition("pc", EntryType::FrameRegisterPC),
+    Definition("fp", EntryType::FrameRegisterFP),
+    Definition("sp", EntryType::FrameRegisterSP),
+    Definition("flags", EntryType::FrameRegisterFlags),
+    Definition("no-debug", EntryType::FrameNoDebug),
+    Entry::DefinitionWithChildren("reg", EntryType::FrameRegisterByName,
+                                  g_string_entry),
+    Definition("is-artificial", EntryType::FrameIsArtificial),
 };
 
-static FormatEntity::Entry::Definition g_process_child_entries[] = {
-    ENTRY("id", ProcessID),
-    ENTRY_VALUE("name", ProcessFile, FileKind::Basename),
-    ENTRY_CHILDREN("file", ProcessFile, g_file_child_entries),
+constexpr Definition g_function_child_entries[] = {
+    Definition("id", EntryType::FunctionID),
+    Definition("name", EntryType::FunctionName),
+    Definition("name-without-args", EntryType::FunctionNameNoArgs),
+    Definition("name-with-args", EntryType::FunctionNameWithArgs),
+    Definition("mangled-name", EntryType::FunctionMangledName),
+    Definition("addr-offset", EntryType::FunctionAddrOffset),
+    Definition("concrete-only-addr-offset-no-padding",
+               EntryType::FunctionAddrOffsetConcrete),
+    Definition("line-offset", EntryType::FunctionLineOffset),
+    Definition("pc-offset", EntryType::FunctionPCOffset),
+    Definition("initial-function", EntryType::FunctionInitial),
+    Definition("changed", EntryType::FunctionChanged),
+    Definition("is-optimized", EntryType::FunctionIsOptimized)};
+
+constexpr Definition g_line_child_entries[] = {
+    Entry::DefinitionWithChildren("file", EntryType::LineEntryFile,
+                                  g_file_child_entries),
+    Definition("number", EntryType::LineEntryLineNumber),
+    Definition("column", EntryType::LineEntryColumn),
+    Definition("start-addr", EntryType::LineEntryStartAddress),
+    Definition("end-addr", EntryType::LineEntryEndAddress),
 };
 
-static FormatEntity::Entry::Definition g_svar_child_entries[] = {
-    ENTRY("*", ParentString)};
+constexpr Definition g_module_child_entries[] = {Entry::DefinitionWithChildren(
+    "file", EntryType::ModuleFile, g_file_child_entries)};
 
-static FormatEntity::Entry::Definition g_var_child_entries[] = {
-    ENTRY("*", ParentString)};
+constexpr Definition g_process_child_entries[] = {
+    Definition("id", EntryType::ProcessID),
+    Definition("name", EntryType::ProcessFile, FileKind::Basename),
+    Entry::DefinitionWithChildren("file", EntryType::ProcessFile,
+                                  g_file_child_entries)};
+
+constexpr Definition g_svar_child_entries[] = {
+    Definition("*", EntryType::ParentString)};
+
+constexpr Definition g_var_child_entries[] = {
+    Definition("*", EntryType::ParentString)};
+
+constexpr Definition g_thread_child_entries[] = {
+    Definition("id", EntryType::ThreadID),
+    Definition("protocol_id", EntryType::ThreadProtocolID),
+    Definition("index", EntryType::ThreadIndexID),
+    Entry::DefinitionWithChildren("info", EntryType::ThreadInfo,
+                                  g_string_entry),
+    Definition("queue", EntryType::ThreadQueue),
+    Definition("name", EntryType::ThreadName),
+    Definition("stop-reason", EntryType::ThreadStopReason),
+    Definition("stop-reason-raw", EntryType::ThreadStopReasonRaw),
+    Definition("return-value", EntryType::ThreadReturnValue),
+    Definition("completed-expression", EntryType::ThreadCompletedExpression)};
 
-static FormatEntity::Entry::Definition g_thread_child_entries[] = {
-    ENTRY("id", ThreadID),
-    ENTRY("protocol_id", ThreadProtocolID),
-    ENTRY("index", ThreadIndexID),
-    ENTRY_CHILDREN("info", ThreadInfo, g_string_entry),
-    ENTRY("queue", ThreadQueue),
-    ENTRY("name", ThreadName),
-    ENTRY("stop-reason", ThreadStopReason),
-    ENTRY("stop-reason-raw", ThreadStopReasonRaw),
-    ENTRY("return-value", ThreadReturnValue),
-    ENTRY("completed-expression", ThreadCompletedExpression),
-};
-
-static FormatEntity::Entry::Definition g_target_child_entries[] = {
-    ENTRY("arch", TargetArch),
-};
+constexpr Definition g_target_child_entries[] = {
+    Definition("arch", EntryType::TargetArch)};
 
 #define _TO_STR2(_val) #_val
 #define _TO_STR(_val) _TO_STR2(_val)
 
-static FormatEntity::Entry::Definition g_ansi_fg_entries[] = {
-    ENTRY_STRING("black",
-                 ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_BLACK) ANSI_ESC_END),
-    ENTRY_STRING("red", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_RED) ANSI_ESC_END),
-    ENTRY_STRING("green",
-                 ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_GREEN) ANSI_ESC_END),
-    ENTRY_STRING("yellow",
-                 ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_YELLOW) ANSI_ESC_END),
-    ENTRY_STRING("blue",
-                 ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_BLUE) ANSI_ESC_END),
-    ENTRY_STRING("purple",
-                 ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_PURPLE) ANSI_ESC_END),
-    ENTRY_STRING("cyan",
-                 ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_CYAN) ANSI_ESC_END),
-    ENTRY_STRING("white",
-                 ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_WHITE) ANSI_ESC_END),
+constexpr Definition g_ansi_fg_entries[] = {
+    Definition("black",
+    Definition("red", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_RED) ANSI_ESC_END),
+    Definition("green",
+    Definition("yellow",
+    Definition("blue", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_BLUE) ANSI_ESC_END),
+    Definition("purple",
+    Definition("cyan", ANSI_ESC_START _TO_STR(ANSI_FG_COLOR_CYAN) ANSI_ESC_END),
+    Definition("white",
 };
 
-static FormatEntity::Entry::Definition g_ansi_bg_entries[] = {
-    ENTRY_STRING("black",
-                 ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_BLACK) ANSI_ESC_END),
-    ENTRY_STRING("red", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_RED) ANSI_ESC_END),
-    ENTRY_STRING("green",
-                 ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_GREEN) ANSI_ESC_END),
-    ENTRY_STRING("yellow",
-                 ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_YELLOW) ANSI_ESC_END),
-    ENTRY_STRING("blue",
-                 ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_BLUE) ANSI_ESC_END),
-    ENTRY_STRING("purple",
-                 ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_PURPLE) ANSI_ESC_END),
-    ENTRY_STRING("cyan",
-                 ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_CYAN) ANSI_ESC_END),
-    ENTRY_STRING("white",
-                 ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_WHITE) ANSI_ESC_END),
+constexpr Definition g_ansi_bg_entries[] = {
+    Definition("black",
+    Definition("red", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_RED) ANSI_ESC_END),
+    Definition("green",
+    Definition("yellow",
+    Definition("blue", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_BLUE) ANSI_ESC_END),
+    Definition("purple",
+    Definition("cyan", ANSI_ESC_START _TO_STR(ANSI_BG_COLOR_CYAN) ANSI_ESC_END),
+    Definition("white",
 };
 
-static FormatEntity::Entry::Definition g_ansi_entries[] = {
-    ENTRY_CHILDREN("fg", Invalid, g_ansi_fg_entries),
-    ENTRY_CHILDREN("bg", Invalid, g_ansi_bg_entries),
-    ENTRY_STRING("normal",
-                 ANSI_ESC_START _TO_STR(ANSI_CTRL_NORMAL) ANSI_ESC_END),
-    ENTRY_STRING("bold", ANSI_ESC_START _TO_STR(ANSI_CTRL_BOLD) ANSI_ESC_END),
-    ENTRY_STRING("faint", ANSI_ESC_START _TO_STR(ANSI_CTRL_FAINT) ANSI_ESC_END),
-    ENTRY_STRING("italic",
-                 ANSI_ESC_START _TO_STR(ANSI_CTRL_ITALIC) ANSI_ESC_END),
-    ENTRY_STRING("underline",
-                 ANSI_ESC_START _TO_STR(ANSI_CTRL_UNDERLINE) ANSI_ESC_END),
-    ENTRY_STRING("slow-blink",
-                 ANSI_ESC_START _TO_STR(ANSI_CTRL_SLOW_BLINK) ANSI_ESC_END),
-    ENTRY_STRING("fast-blink",
-                 ANSI_ESC_START _TO_STR(ANSI_CTRL_FAST_BLINK) ANSI_ESC_END),
-    ENTRY_STRING("negative",
-                 ANSI_ESC_START _TO_STR(ANSI_CTRL_IMAGE_NEGATIVE) ANSI_ESC_END),
-    ENTRY_STRING("conceal",
-                 ANSI_ESC_START _TO_STR(ANSI_CTRL_CONCEAL) ANSI_ESC_END),
-    ENTRY_STRING("crossed-out",
-                 ANSI_ESC_START _TO_STR(ANSI_CTRL_CROSSED_OUT) ANSI_ESC_END),
+constexpr Definition g_ansi_entries[] = {
+    Entry::DefinitionWithChildren("fg", EntryType::Invalid, g_ansi_fg_entries),
+    Entry::DefinitionWithChildren("bg", EntryType::Invalid, g_ansi_bg_entries),
+    Definition("normal", ANSI_ESC_START _TO_STR(ANSI_CTRL_NORMAL) ANSI_ESC_END),
+    Definition("bold", ANSI_ESC_START _TO_STR(ANSI_CTRL_BOLD) ANSI_ESC_END),
+    Definition("faint", ANSI_ESC_START _TO_STR(ANSI_CTRL_FAINT) ANSI_ESC_END),
+    Definition("italic", ANSI_ESC_START _TO_STR(ANSI_CTRL_ITALIC) ANSI_ESC_END),
+    Definition("underline",
+    Definition("slow-blink",
+    Definition("fast-blink",
+    Definition("negative",
+    Definition("conceal",
+    Definition("crossed-out",
 };
 
-static FormatEntity::Entry::Definition g_script_child_entries[] = {
-    ENTRY("frame", ScriptFrame),   ENTRY("process", ScriptProcess),
-    ENTRY("target", ScriptTarget), ENTRY("thread", ScriptThread),
-    ENTRY("var", ScriptVariable),  ENTRY("svar", ScriptVariableSynthetic),
-    ENTRY("thread", ScriptThread),
-};
+constexpr Definition g_script_child_entries[] = {
+    Definition("frame", EntryType::ScriptFrame),
+    Definition("process", EntryType::ScriptProcess),
+    Definition("target", EntryType::ScriptTarget),
+    Definition("thread", EntryType::ScriptThread),
+    Definition("var", EntryType::ScriptVariable),
+    Definition("svar", EntryType::ScriptVariableSynthetic),
+    Definition("thread", EntryType::ScriptThread)};
+
+constexpr Definition g_top_level_entries[] = {
+    Entry::DefinitionWithChildren("addr", EntryType::AddressLoadOrFile,
+                                  g_addr_entries),
+    Definition("addr-file-or-load", EntryType::AddressLoadOrFile),
+    Entry::DefinitionWithChildren("ansi", EntryType::Invalid, g_ansi_entries),
+    Definition("current-pc-arrow", EntryType::CurrentPCArrow),
+    Entry::DefinitionWithChildren("file", EntryType::File,
+                                  g_file_child_entries),
+    Definition("language", EntryType::Lang),
+    Entry::DefinitionWithChildren("frame", EntryType::Invalid,
+                                  g_frame_child_entries),
+    Entry::DefinitionWithChildren("function", EntryType::Invalid,
+                                  g_function_child_entries),
+    Entry::DefinitionWithChildren("line", EntryType::Invalid,
+                                  g_line_child_entries),
+    Entry::DefinitionWithChildren("module", EntryType::Invalid,
+                                  g_module_child_entries),
+    Entry::DefinitionWithChildren("process", EntryType::Invalid,
+                                  g_process_child_entries),
+    Entry::DefinitionWithChildren("script", EntryType::Invalid,
+                                  g_script_child_entries),
+    Entry::DefinitionWithChildren("svar", EntryType::VariableSynthetic,
+                                  g_svar_child_entries, true),
+    Entry::DefinitionWithChildren("thread", EntryType::Invalid,
+                                  g_thread_child_entries),
+    Entry::DefinitionWithChildren("target", EntryType::Invalid,
+                                  g_target_child_entries),
+    Entry::DefinitionWithChildren("var", EntryType::Variable,
+                                  g_var_child_entries, true)};
 
-static FormatEntity::Entry::Definition g_top_level_entries[] = {
-    ENTRY_CHILDREN("addr", AddressLoadOrFile, g_addr_entries),
-    ENTRY("addr-file-or-load", AddressLoadOrFile),
-    ENTRY_CHILDREN("ansi", Invalid, g_ansi_entries),
-    ENTRY("current-pc-arrow", CurrentPCArrow),
-    ENTRY_CHILDREN("file", File, g_file_child_entries),
-    ENTRY("language", Lang),
-    ENTRY_CHILDREN("frame", Invalid, g_frame_child_entries),
-    ENTRY_CHILDREN("function", Invalid, g_function_child_entries),
-    ENTRY_CHILDREN("line", Invalid, g_line_child_entries),
-    ENTRY_CHILDREN("module", Invalid, g_module_child_entries),
-    ENTRY_CHILDREN("process", Invalid, g_process_child_entries),
-    ENTRY_CHILDREN("script", Invalid, g_script_child_entries),
-    ENTRY_CHILDREN_KEEP_SEP("svar", VariableSynthetic, g_svar_child_entries),
-    ENTRY_CHILDREN("thread", Invalid, g_thread_child_entries),
-    ENTRY_CHILDREN("target", Invalid, g_target_child_entries),
-    ENTRY_CHILDREN_KEEP_SEP("var", Variable, g_var_child_entries),
-};
-
-static FormatEntity::Entry::Definition g_root =
-    ENTRY_CHILDREN("<root>", Root, g_top_level_entries);
+constexpr Definition g_root = Entry::DefinitionWithChildren(
+    "<root>", EntryType::Root, g_top_level_entries);
 
 FormatEntity::Entry::Entry(llvm::StringRef s)
     : string(s.data(), s.size()), printf_format(), children(),
-      definition(nullptr), type(Type::String), fmt(lldb::eFormatDefault),
-      number(0), deref(false) {}
+      type(Type::String), fmt(lldb::eFormatDefault), number(0), deref(false) {}
 
 FormatEntity::Entry::Entry(char ch)
-    : string(1, ch), printf_format(), children(), definition(nullptr),
-      type(Type::String), fmt(lldb::eFormatDefault), number(0), deref(false) {}
+    : string(1, ch), printf_format(), children(), type(Type::String),
+      fmt(lldb::eFormatDefault), number(0), deref(false) {}
 
 void FormatEntity::Entry::AppendChar(char ch) {
   if (children.empty() || children.back().type != Entry::Type::String)
     children.push_back(Entry(ch));
   else
     children.back().string.append(1, ch);
 }
 
if (file) {
       return true;
     }
     break;
   }
   return false;
 }
 
 static bool DumpRegister(Stream &s, StackFrame *frame, RegisterKind reg_kind,
-                         uint32_t reg_num, Format format)
-
-{
+                         uint32_t reg_num, Format format) {
   if (frame) {
     RegisterContext *reg_ctx = frame->GetRegisterContext().get();
 
     if (reg_ctx) {
       const uint32_t lldb_reg_num =
           reg_ctx->ConvertRegisterKindToRegisterNumber(reg_kind, reg_num);
       if (lldb_reg_num != LLDB_INVALID_REGNUM) {
         const RegisterInfo *reg_info =
             reg_ctx->GetRegisterInfoAtIndex(lldb_reg_num);
         if (reg_info) {
           RegisterValue reg_value;
           if (reg_ctx->ReadRegister(reg_info, reg_value)) {
             DumpRegisterValue(reg_value, &s, reg_info, false, false, format);
             return true;
           }
         }
       }
     }
   }
   return false;
 }
 
 static ValueObjectSP ExpandIndexedExpression(ValueObject *valobj, size_t index,
-                                             StackFrame *frame,
                                              bool deref_pointer) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
   const char *ptr_deref_format = "[%d]";
   std::string ptr_deref_buffer(10, 0);
   ::sprintf(&ptr_deref_buffer[0], ptr_deref_format, index);
   LLDB_LOGF(log, "[ExpandIndexedExpression] name to deref: %s",
             ptr_deref_buffer.c_str());
   ValueObject::GetValueForExpressionPathOptions options;
if (!is_array_range) {
     if (index_higher < 0)
       index_higher = valobj->GetNumChildren() - 1;
 
     uint32_t max_num_children =
         target->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
 
     bool success = true;
     for (int64_t index = index_lower; index <= index_higher; ++index) {
-      ValueObject *item =
-          ExpandIndexedExpression(target, index, exe_ctx->GetFramePtr(), false)
-              .get();
+      ValueObject *item = ExpandIndexedExpression(target, index, false).get();
 
       if (!item) {
         LLDB_LOGF(log,
                   "[Debugger::FormatPrompt] ERROR in getting child item at "
                   "index %" PRId64,
                   index);
       } else {
         LLDB_LOGF(
bool FormatEntity::Format(const Entry &entry, Stream &s,
 
   case Entry::Type::FunctionDidChange:
     return function_changed;
 
   case Entry::Type::FunctionInitialFunction:
     return initial_function;
 
   case Entry::Type::FunctionName: {
+    if (!sc)
+      return false;
+
     Language *language_plugin = nullptr;
     bool language_plugin_handled = false;
     StreamString ss;
+
     if (sc->function)
       language_plugin = Language::FindPlugin(sc->function->GetLanguage());
     else if (sc->symbol)
       language_plugin = Language::FindPlugin(sc->symbol->GetLanguage());
-    if (language_plugin) {
+
+    if (language_plugin)
       language_plugin_handled = language_plugin->GetFunctionDisplayName(
           sc, exe_ctx, Language::FunctionNameRepresentation::eName, ss);
-    }
+
     if (language_plugin_handled) {
       s << ss.GetString();
       return true;
     } else {
       const char *name = nullptr;
       if (sc->function)
         name = sc->function->GetName().AsCString(nullptr);
       else if (sc->symbol)
         name = sc->symbol->GetName().AsCString(nullptr);
+
       if (name) {
         s.PutCString(name);
 
         if (sc->block) {
           Block *inline_block = sc->block->GetContainingInlinedBlock();
           if (inline_block) {
             const InlineFunctionInfo *inline_info =
                 sc->block->GetInlinedFunctionInfo();
             if (inline_info) {
               s.PutCString(" [inlined] ");
               inline_info->GetName().Dump(&s);
             }
           }
         }
         return true;
       }
     }
   }
     return false;
 
   case Entry::Type::FunctionNameNoArgs: {
+    if (!sc)
+      return false;
+
     Language *language_plugin = nullptr;
     bool language_plugin_handled = false;
     StreamString ss;
     if (sc->function)
       language_plugin = Language::FindPlugin(sc->function->GetLanguage());
     else if (sc->symbol)
       language_plugin = Language::FindPlugin(sc->symbol->GetLanguage());
-    if (language_plugin) {
+
+    if (language_plugin)
       language_plugin_handled = language_plugin->GetFunctionDisplayName(
           sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithNoArgs,
           ss);
-    }
+
     if (language_plugin_handled) {
       s << ss.GetString();
       return true;
     } else {
       ConstString name;
       if (sc->function)
         name = sc->function->GetNameNoArguments();
       else if (sc->symbol)
         name = sc->symbol->GetNameNoArguments();
       if (name) {
         s.PutCString(name.GetCString());
         return true;
       }
     }
   }
     return false;
 
   case Entry::Type::FunctionNameWithArgs: {
+    if (!sc)
+      return false;
+
     Language *language_plugin = nullptr;
     bool language_plugin_handled = false;
     StreamString ss;
     if (sc->function)
       language_plugin = Language::FindPlugin(sc->function->GetLanguage());
     else if (sc->symbol)
       language_plugin = Language::FindPlugin(sc->symbol->GetLanguage());
-    if (language_plugin) {
+
+    if (language_plugin)
       language_plugin_handled = language_plugin->GetFunctionDisplayName(
           sc, exe_ctx, Language::FunctionNameRepresentation::eNameWithArgs, ss);
-    }
+
     if (language_plugin_handled) {
       s << ss.GetString();
       return true;
     } else {
       // Print the function name with arguments in it
       if (sc->function) {
         ExecutionContextScope *exe_scope =
             exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
if (language_plugin_handled) {
           return true;
         }
       }
     }
   }
     return false;
 
   case Entry::Type::FunctionMangledName: {
+    if (!sc)
+      return false;
+
     const char *name = nullptr;
     if (sc->symbol)
       name =
           sc->symbol->GetMangled().GetName(Mangled::ePreferMangled).AsCString();
     else if (sc->function)
       name = sc->function->GetMangled()
                  .GetName(Mangled::ePreferMangled)
                  .AsCString();
 
     if (!name)
       return false;
     s.PutCString(name);
 
     if (sc->block && sc->block->GetContainingInlinedBlock()) {
       if (const InlineFunctionInfo *inline_info =
               sc->block->GetInlinedFunctionInfo()) {
         s.PutCString(" [inlined] ");
         inline_info->GetName().Dump(&s);
       }
     }
     return true;
   }
-
   case Entry::Type::FunctionAddrOffset:
     if (addr) {
       if (DumpAddressOffsetFromFunction(s, sc, exe_ctx, *addr, false, false,
                                         false))
         return true;
     }
     return false;
 
   case Entry::Type::FunctionAddrOffsetConcrete:
     if (addr) {
       if (DumpAddressOffsetFromFunction(s, sc, exe_ctx, *addr, true, true,
                                         true))
         return true;
     }
     return false;
 
   case Entry::Type::FunctionLineOffset:
-    return (DumpAddressOffsetFromFunction(s, sc, exe_ctx,
-                                          sc->line_entry.range.GetBaseAddress(),
-                                          false, false, false));
+    if (sc)
+      return (DumpAddressOffsetFromFunction(
+          s, sc, exe_ctx, sc->line_entry.range.GetBaseAddress(), false, false,
+          false));
+    return false;
 
   case Entry::Type::FunctionPCOffset:
     if (exe_ctx) {
       StackFrame *frame = exe_ctx->GetFramePtr();
       if (frame) {
         if (DumpAddressOffsetFromFunction(s, sc, exe_ctx,
                                           frame->GetFrameCodeAddress(), false,
                                           false, false))
           return true;
       }
     }
     return false;
 
   case Entry::Type::FunctionChanged:
     return function_changed;
 
   case Entry::Type::FunctionIsOptimized: {
     bool is_optimized = false;
-    if (sc->function && sc->function->GetIsOptimized()) {
+    if (sc && sc->function && sc->function->GetIsOptimized()) {
       is_optimized = true;
     }
     return is_optimized;
   }
 
   case Entry::Type::FunctionInitial:
     return initial_function;
 
if (addr && exe_ctx && exe_ctx->GetFramePtr()) {
       s.Printf("   ");
       return true;
     }
     return false;
   }
   return false;
 }
 
-static bool DumpCommaSeparatedChildEntryNames(
-    Stream &s, const FormatEntity::Entry::Definition *parent) {
+static bool DumpCommaSeparatedChildEntryNames(Stream &s,
+                                              const Definition *parent) {
   if (parent->children) {
     const size_t n = parent->num_children;
     for (size_t i = 0; i < n; ++i) {
       if (i > 0)
         s.PutCString(", ");
       s.Printf("\"%s\"", parent->children[i].name);
     }
     return true;
   }
   return false;
 }
 
 static Status ParseEntry(const llvm::StringRef &format_str,
-                         const FormatEntity::Entry::Definition *parent,
-                         FormatEntity::Entry &entry) {
+                         const Definition *parent, FormatEntity::Entry &entry) {
   Status error;
 
   const size_t sep_pos = format_str.find_first_of(".[:");
   const char sep_char =
       (sep_pos == llvm::StringRef::npos) ? '\0' : format_str[sep_pos];
   llvm::StringRef key = format_str.substr(0, sep_pos);
 
   const size_t n = parent->num_children;
   for (size_t i = 0; i < n; ++i) {
-    const FormatEntity::Entry::Definition *entry_def = parent->children + i;
+    const Definition *entry_def = parent->children + i;
     if (key.equals(entry_def->name) || entry_def->name[0] == '*') {
       llvm::StringRef value;
       if (sep_char)
         value =
             format_str.substr(sep_pos + (entry_def->keep_separator ? 0 : 1));
       switch (entry_def->type) {
       case FormatEntity::Entry::Type::ParentString:
         entry.string = format_str.str();
static Status ParseEntry(const llvm::StringRef &format_str,
   else
     error_strm.Printf("invalid member '%s' in '%s'. Valid members are: ",
                       key.str().c_str(), parent->name);
   DumpCommaSeparatedChildEntryNames(error_strm, parent);
   error.SetErrorStringWithFormat("%s", error_strm.GetData());
   return error;
 }
 
-static const FormatEntity::Entry::Definition *
-FindEntry(const llvm::StringRef &format_str,
-          const FormatEntity::Entry::Definition *parent,
+static const Definition *FindEntry(const llvm::StringRef &format_str,
+                                   const Definition *parent,
                                    llvm::StringRef &remainder) {
   Status error;
 
   std::pair<llvm::StringRef, llvm::StringRef> p = format_str.split('.');
   const size_t n = parent->num_children;
   for (size_t i = 0; i < n; ++i) {
-    const FormatEntity::Entry::Definition *entry_def = parent->children + i;
+    const Definition *entry_def = parent->children + i;
     if (p.first.equals(entry_def->name) || entry_def->name[0] == '*') {
       if (p.second.empty()) {
         if (format_str.back() == '.')
           remainder = format_str.drop_front(format_str.size() - 1);
         else
           remainder = llvm::StringRef(); // Exact match
         return entry_def;
       } else {

 
 static std::string MakeMatch(const llvm::StringRef &prefix,
                              const char *suffix) {
   std::string match(prefix.str());
   match.append(suffix);
   return match;
 }
 
-static void AddMatches(const FormatEntity::Entry::Definition *def,
-                       const llvm::StringRef &prefix,
+static void AddMatches(const Definition *def, const llvm::StringRef &prefix,
                        const llvm::StringRef &match_prefix,
                        StringList &matches) {
   const size_t n = def->num_children;
   if (n > 0) {
     for (size_t i = 0; i < n; ++i) {
       std::string match = prefix.str();
       if (match_prefix.empty())
         matches.AppendString(MakeMatch(prefix, def->children[i].name));
if (partial_variable.empty()) {
     StringList new_matches;
     AddMatches(&g_root, str, llvm::StringRef(), new_matches);
     request.AddCompletions(new_matches);
     return;
   }
 
   // We have a partially specified variable, find it
   llvm::StringRef remainder;
-  const FormatEntity::Entry::Definition *entry_def =
-      FindEntry(partial_variable, &g_root, remainder);
+  const Definition *entry_def = FindEntry(partial_variable, &g_root, remainder);
   if (!entry_def)
     return;
 
   const size_t n = entry_def->num_children;
 
   if (remainder.empty()) {
     // Exact match
     if (n > 0) {

lldb/unittests/Core/CMakeLists.txt

 add_lldb_unittest(LLDBCoreTests
   CommunicationTest.cpp
+  FormatEntityTest.cpp
   MangledTest.cpp
   ModuleSpecTest.cpp
   RichManglingContextTest.cpp
   SourceManagerTest.cpp
   StreamCallbackTest.cpp
   UniqueCStringMapTest.cpp
 
   LINK_LIBS

lldb/unittests/Core/FormatEntityTest.cpp

+//===-- FormatEntityTest.cpp ---------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/FormatEntity.h"
+#include "lldb/Utility/Status.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+
+using Definition = FormatEntity::Entry::Definition;
+using Entry = FormatEntity::Entry;
+
+TEST(FormatEntityTest, DefinitionConstructionNameAndType) {
+  Definition d("foo", FormatEntity::Entry::Type::Invalid);
+
+  ASSERT_EQ(d.name, "foo");
+  ASSERT_EQ(d.string, nullptr);
+  ASSERT_EQ(d.type, FormatEntity::Entry::Type::Invalid);
+  ASSERT_EQ(d.data, 0UL);
+  ASSERT_EQ(d.num_children, 0UL);
+  ASSERT_EQ(d.children, nullptr);
+  ASSERT_FALSE(d.keep_separator);
+}
+
+TEST(FormatEntityTest, DefinitionConstructionNameAndString) {
+  Definition d("foo", "string");
+
+  ASSERT_EQ(d.name, "foo");
+  ASSERT_EQ(d.string, "string");
+  ASSERT_EQ(d.type, FormatEntity::Entry::Type::EscapeCode);
+  ASSERT_EQ(d.data, 0UL);
+  ASSERT_EQ(d.num_children, 0UL);
+  ASSERT_EQ(d.children, nullptr);
+  ASSERT_FALSE(d.keep_separator);
+}
+
+TEST(FormatEntityTest, DefinitionConstructionNameTypeData) {
+  Definition d("foo", FormatEntity::Entry::Type::Invalid, 33);
+
+  ASSERT_EQ(d.name, "foo");
+  ASSERT_EQ(d.string, nullptr);
+  ASSERT_EQ(d.type, FormatEntity::Entry::Type::Invalid);
+  ASSERT_EQ(d.data, 33UL);
+  ASSERT_EQ(d.num_children, 0UL);
+  ASSERT_EQ(d.children, nullptr);
+  ASSERT_FALSE(d.keep_separator);
+}
+
+TEST(FormatEntityTest, DefinitionConstructionNameTypeChildren) {
+  Definition d("foo", FormatEntity::Entry::Type::Invalid, 33);
+  Definition parent("parent", FormatEntity::Entry::Type::Invalid, 1, &d);
+  ASSERT_EQ(parent.name, "parent");
+  ASSERT_EQ(parent.string, nullptr);
+  ASSERT_EQ(parent.type, FormatEntity::Entry::Type::Invalid);
+  ASSERT_EQ(parent.num_children, 1UL);
+  ASSERT_EQ(parent.children, &d);
+  ASSERT_FALSE(parent.keep_separator);
+
+  ASSERT_EQ(parent.children[0].name, "foo");
+  ASSERT_EQ(parent.children[0].string, nullptr);
+  ASSERT_EQ(parent.children[0].type, FormatEntity::Entry::Type::Invalid);
+  ASSERT_EQ(parent.children[0].data, 33UL);
+  ASSERT_EQ(parent.children[0].num_children, 0UL);
+  ASSERT_EQ(parent.children[0].children, nullptr);
+  ASSERT_FALSE(d.keep_separator);
+}
+
+constexpr llvm::StringRef lookupStrings[] = {
+    "${addr.load}",
+    "${addr.file}",
+    "${ansi.fg.black}",
+    "${ansi.fg.red}",
+    "${ansi.fg.green}",
+    "${ansi.fg.yellow}",
+    "${ansi.fg.blue}",
+    "${ansi.fg.purple}",
+    "${ansi.fg.cyan}",
+    "${ansi.fg.white}",
+    "${ansi.bg.black}",
+    "${ansi.bg.red}",
+    "${ansi.bg.green}",
+    "${ansi.bg.yellow}",
+    "${ansi.bg.blue}",
+    "${ansi.bg.purple}",
+    "${ansi.bg.cyan}",
+    "${ansi.bg.white}",
+    "${file.basename}",
+    "${file.dirname}",
+    "${file.fullpath}",
+    "${frame.index}",
+    "${frame.pc}",
+    "${frame.fp}",
+    "${frame.sp}",
+    "${frame.flags}",
+    "${frame.no-debug}",
+    "${frame.reg.*}",
+    "${frame.is-artificial}",
+    "${function.id}",
+    "${function.name}",
+    "${function.name-without-args}",
+    "${function.name-with-args}",
+    "${function.mangled-name}",
+    "${function.addr-offset}",
+    "${function.concrete-only-addr-offset-no-padding}",
+    "${function.line-offset}",
+    "${function.pc-offset}",
+    "${function.initial-function}",
+    "${function.changed}",
+    "${function.is-optimized}",
+    "${line.file.basename}",
+    "${line.file.dirname}",
+    "${line.file.fullpath}",
+    "${line.number}",
+    "${line.column}",
+    "${line.start-addr}",
+    "${line.end-addr}",
+    "${module.file.basename}",
+    "${module.file.dirname}",
+    "${module.file.fullpath}",
+    "${process.id}",
+    "${process.name}",
+    "${process.file.basename}",
+    "${process.file.dirname}",
+    "${process.file.fullpath}",
+    "${script.frame}",
+    "${script.process}",
+    "${script.target}",
+    "${script.thread}",
+    "${script.var}",
+    "${script.svar}",
+    "${script.thread}",
+    "${svar.dummy-svar-to-test-wildcard}",
+    "${thread.id}",
+    "${thread.protocol_id}",
+    "${thread.index}",
+    "${thread.info.*}",
+    "${thread.queue}",
+    "${thread.name}",
+    "${thread.stop-reason}",
+    "${thread.stop-reason-raw}",
+    "${thread.return-value}",
+    "${thread.completed-expression}",
+    "${target.arch}",
+    "${var.dummy-var-to-test-wildcard}"};
+
+TEST(FormatEntity, LookupAllEntriesInTree) {
+  for (const auto &testString : lookupStrings) {
+    Entry e;
+    EXPECT_TRUE(FormatEntity::Parse(testString, e).Success())
+        << "Formatting " << testString << " did not succeed";
+  }
+}