[lldb]/Tablegen] Use ElementType instead of DefaultValueUnsinged for Array and Dictionary

[JDevlieghere]

Summary

The fourth field in the property struct is the default unsigned or enum value for all types, except for Array and Dictionary types. For those, it is the element type. During the tablegen conversion, this was incorrectly translated to DefaultValueUnsigned with a value corresponding to the OptionValue: enum type. So for OptionValue::eTypeString this became DefaultUnsignedValue<16>. This patch extends the tablegen backend to understand ElementType to express this as ElementType<"String">.

lldb/include/lldb/Core/PropertiesBase.td

class DefaultUnsignedValue<int value> {
   int DefaultUnsignedValue = value;
   bit HasDefaultUnsignedValue = 1;
 }
 
 // Gives the property enum values.
 class EnumValues<string enum> {
   string EnumValues = enum;
 }
+
+// Determines the element type for arrays and dictionaries.
+class ElementType<string value> {
+  string ElementType = value;
+  bit HasElementType = 1;
+}

lldb/source/Target/TargetProperties.td

def BreakpointUseAvoidList: Property<"breakpoints-use-platform-avoid-list", "Boolean">,
     Desc<"Consult the platform module avoid list when setting non-module specific breakpoints.">;
   def Arg0: Property<"arg0", "String">,
     DefaultStringValue<"">,
     Desc<"The first argument passed to the program in the argument array which can be different from the executable itself.">;
   def RunArgs: Property<"run-args", "Args">,
     DefaultStringValue<"">,
     Desc<"A list containing all the arguments to be passed to the executable when it is run. Note that this does NOT include the argv[0] which is in target.arg0.">;
   def EnvVars: Property<"env-vars", "Dictionary">,
-    DefaultUnsignedValue<16>,
+    ElementType<"String">,
     Desc<"A list of all the environment variables to be passed to the executable's environment, and their values.">;
   def InheritEnv: Property<"inherit-env", "Boolean">,
     DefaultTrue,
     Desc<"Inherit the environment from the process that is running LLDB.">;
   def InputPath: Property<"input-path", "FileSpec">,
     DefaultStringValue<"">,
     Desc<"The file/path to be used by the executable program for reading its standard input.">;
   def OutputPath: Property<"output-path", "FileSpec">,
def MemoryModuleLoadLevel: Property<"memory-module-load-level", "Enum">,
     DefaultEnumValue<"eMemoryModuleLoadLevelComplete">,
     EnumValues<"OptionEnumValues(g_memory_module_load_level_values)">,
     Desc<"Loading modules from memory can be slow as reading the symbol tables and other data can take a long time depending on your connection to the debug target. This setting helps users control how much information gets loaded when loading modules from memory.'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). 'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). 'minimal' is the fastest setting and will load section data with no symbols, but should rarely be used as stack frames in these memory regions will be inaccurate and not provide any context (fastest). ">;
   def DisplayExpressionsInCrashlogs: Property<"display-expression-in-crashlogs", "Boolean">,
     DefaultFalse,
     Desc<"Expressions that crash will show up in crash logs if the host system supports executable specific crash log strings and this setting is set to true.">;
   def TrapHandlerNames: Property<"trap-handler-names", "Array">,
     Global,
-    DefaultUnsignedValue<16>,
+    ElementType<"String">,
     Desc<"A list of trap handler function names, e.g. a common Unix user process one is _sigtramp.">;
   def DisplayRuntimeSupportValues: Property<"display-runtime-support-values", "Boolean">,
     DefaultFalse,
     Desc<"If true, LLDB will show variables that are meant to support the operation of a language's runtime support.">;
   def DisplayRecognizedArguments: Property<"display-recognized-arguments", "Boolean">,
     DefaultFalse,
     Desc<"Show recognized arguments in variable listings by default.">;
   def NonStopModeEnabled: Property<"non-stop-mode", "Boolean">,
     DefaultFalse,
     Desc<"Disable lock-step debugging, instead control threads independently.">;
   def RequireHardwareBreakpoints: Property<"require-hardware-breakpoint", "Boolean">,
     DefaultFalse,
     Desc<"Require all breakpoints to be hardware breakpoints.">;
   def AutoInstallMainExecutable: Property<"auto-install-main-executable", "Boolean">,
     DefaultTrue,
     Desc<"Always install the main executable when connected to a remote platform.">;
 }
 
 let Definition = "process" in {
   def DisableMemCache: Property<"disable-memory-cache", "Boolean">,
     DefaultFalse,
     Desc<"Disable reading and caching of memory in fixed-size units.">;
   def ExtraStartCommand: Property<"extra-startup-command", "Array">,
-    DefaultUnsignedValue<16>,
+    ElementType<"String">,
     Desc<"A list containing extra commands understood by the particular process plugin used.  For instance, to turn on debugserver logging set this to 'QSetLogging:bitmask=LOG_DEFAULT;'">;
   def IgnoreBreakpointsInExpressions: Property<"ignore-breakpoints-in-expressions", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"If true, breakpoints will be ignored during expression evaluation.">;
   def UnwindOnErrorInExpressions: Property<"unwind-on-error-in-expressions", "Boolean">,
     Global,
     DefaultTrue,

lldb/utils/TableGen/LLDBPropertyDefEmitter.cpp

 static void emitProperty(Record *Property, raw_ostream &OS) {
   OS << "  {";
 
   // Emit the property name.
   OS << "\"" << Property->getValueAsString("Name") << "\"";
   OS << ", ";
 
   // Emit the property type.
+  llvm::StringRef type = Property->getValueAsString("Type");
   OS << "OptionValue::eType";
-  OS << Property->getValueAsString("Type");
+  OS << type;
   OS << ", ";
 
   // Emit the property's global value.
   OS << (Property->getValue("Global") ? "true" : "false");
   OS << ", ";
 
   bool hasDefaultUnsignedValue = Property->getValue("HasDefaultUnsignedValue");
   bool hasDefaultEnumValue = Property->getValue("HasDefaultEnumValue");
   bool hasDefaultStringValue = Property->getValue("HasDefaultStringValue");
+  bool hasElementType = Property->getValue("HasElementType");
 
   // Guarantee that every property has a default value.
   assert((hasDefaultUnsignedValue || hasDefaultEnumValue ||
-          hasDefaultStringValue) &&
-         "Property must have a default value");
+          hasDefaultStringValue || hasElementType) &&
+         "Property must have a default value or an element type");
 
   // Guarantee that no property has both a default unsigned value and a default
   // enum value, since they're bothed stored in the same field.
   assert(!(hasDefaultUnsignedValue && hasDefaultEnumValue) &&
          "Property cannot have both a unsigned and enum default value.");
 
   // Guarantee that every boolean property has a boolean default value.
   assert(!(Property->getValueAsString("Type") == "Boolean" &&
            !Property->getValue("HasDefaultBooleanValue")) &&
          "Boolean property must have a boolean default value.");
 
   // Guarantee that every string property has a string default value.
   assert(!(Property->getValueAsString("Type") == "String" &&
            !hasDefaultStringValue) &&
          "String property must have a string default value.");
 
   // Guarantee that every enum property has an enum default value.
   assert(
       !(Property->getValueAsString("Type") == "Enum" && !hasDefaultEnumValue) &&
       "Enum property must have a enum default value.");
 
+  // Guarantee that only arrays and dictionaries have an element type;
+  assert(((type != "Array" && type != "Dictionary") || hasElementType) &&
+         "Only dictionaries and arrays can have an element type.");
+
   // Emit the default uint value.
   if (hasDefaultUnsignedValue) {
     OS << std::to_string(Property->getValueAsInt("DefaultUnsignedValue"));
   } else if (hasDefaultEnumValue) {
     OS << Property->getValueAsString("DefaultEnumValue");
+  } else if (hasElementType) {
+    OS << "OptionValue::eType";
+    OS << Property->getValueAsString("ElementType");
   } else {
     OS << "0";
   }
   OS << ", ";
 
   // Emit the default string value.
   if (hasDefaultStringValue) {
     if (auto D = Property->getValue("DefaultStringValue")) {