[lldb] Dynamically generate enum names in lldbutil

[kastiglione]

Summary

Change the <enum>_to_str functions in lldbutil to be dynamic.

Instead of a manually maintained if/elif switch, the functions now perform
lookup in a dynamically generated dict. The names are determined by stripping
the enum's prefix, and then lowercasing the remaining suffix, ex:

eStateRunning -> "running"

[JDevlieghere]

Nice. Thanks for taking care of this!

[mib]

This is awesome 🤩 ! I was also thinking of changing the way enums are exposed to python: instead of having everything added to the lldb python module, we could create a class per enum and have static attributes for each enum value so we could do something like lldb.StopReason.Breakpoint. That static variable could be a pair with the value/string representation or maybe we could use the __str__ method to make it very pythonic. Just throwing some ideas here for later, but this LGTM 😊 !

[kastiglione]

@mib I like that idea.

[jingham]

In D131138#3698508, @mib wrote:

This is awesome 🤩 ! I was also thinking of changing the way enums are exposed to python: instead of having everything added to the lldb python module, we could create a class per enum and have static attributes for each enum value so we could do something like lldb.StopReason.Breakpoint. That static variable could be a pair with the value/string representation or maybe we could use the __str__ method to make it very pythonic. Just throwing some ideas here for later, but this LGTM 😊 !

I'm not sure you could do this w/o breaking binary compatibility, since we pass these enums to a bunch of the SB API's. But if you can make that work, this would be nice.

[JDevlieghere]

In D131138#3702608, @jingham wrote:

In D131138#3698508, @mib wrote:

This is awesome 🤩 ! I was also thinking of changing the way enums are exposed to python: instead of having everything added to the lldb python module, we could create a class per enum and have static attributes for each enum value so we could do something like lldb.StopReason.Breakpoint. That static variable could be a pair with the value/string representation or maybe we could use the __str__ method to make it very pythonic. Just throwing some ideas here for later, but this LGTM 😊 !

I'm not sure you could do this w/o breaking binary compatibility, since we pass these enums to a bunch of the SB API's. But if you can make that work, this would be nice.

I don't think that's possible, at least not without having both, which then defeats the purpose. I suggested to Ismail that we should start a document to keep track of all the things we want to improve for a V2 of the SB API. These kind of ideas come up every once in a while and it would be good to have them tracked somewhere so they don't get lost with time if/when we ever decide to redo the stable API.

[kastiglione]

I wonder how much breakage there would be if you implemented a bunch of the dunder methods. Ex:

class StopReason:
    def __int__(self) -> int: ...
    def __eq__(self, other: StopReason | int) -> bool: ...
    # ...

This would cover many cases, but not all. For example 5 == StopReason.whatever would fail, even when StopReason.whatever == 5 passes.

[kastiglione]

Fix bug; Add type annotations

[kastiglione]

@JDevlieghere @mib what do you think of introducing type annotations as code is being touched?

[mib]

In D131138#3703554, @kastiglione wrote:

@JDevlieghere @mib what do you think of introducing type annotations as code is being touched?

Since we're basically building an API, it makes a lot of sense of add type annotations. I'm strongly in favor of doing it.

lldb/packages/Python/lldbsuite/test/lldbutil.py

 """
 This LLDB module contains miscellaneous utilities.
 Some of the test suite takes advantage of the utility functions defined here.
 They can also be useful for general purpose lldb scripting.
 """
 
 from __future__ import print_function
 from __future__ import absolute_import
 
 # System modules
 import errno
 import io
 import os
 import re
 import sys
 import subprocess
+from typing import Dict
 
 # LLDB modules
 import lldb
 from . import lldbtest_config
 from . import configuration
 
 # How often failed simulator process launches are retried.
 SIMULATOR_RETRY = 3
if not success:
         return None
     return stream.GetData()
 
 
 # =================================================
 # Convert some enum value to its string counterpart
 # =================================================
 
-def state_type_to_str(enum):
+def _enum_names(prefix: str) -> Dict[int, str]:
+    """Generate a mapping of enum value to name, for the enum prefix."""
+    suffix_start = len(prefix)
+    return {
+        getattr(lldb, attr): attr[suffix_start:].lower()
+        for attr in dir(lldb)
+        if attr.startswith(prefix)
+    }
+
+
+_STATE_NAMES = _enum_names(prefix="eState")
+
+def state_type_to_str(enum: int) -> str:
     """Returns the stateType string given an enum."""
-    if enum == lldb.eStateInvalid:
-        return "invalid"
-    elif enum == lldb.eStateUnloaded:
-        return "unloaded"
-    elif enum == lldb.eStateConnected:
-        return "connected"
-    elif enum == lldb.eStateAttaching:
-        return "attaching"
-    elif enum == lldb.eStateLaunching:
-        return "launching"
-    elif enum == lldb.eStateStopped:
-        return "stopped"
-    elif enum == lldb.eStateRunning:
-        return "running"
-    elif enum == lldb.eStateStepping:
-        return "stepping"
-    elif enum == lldb.eStateCrashed:
-        return "crashed"
-    elif enum == lldb.eStateDetached:
-        return "detached"
-    elif enum == lldb.eStateExited:
-        return "exited"
-    elif enum == lldb.eStateSuspended:
-        return "suspended"
-    else:
-        raise Exception("Unknown StateType enum: " + str(enum))
+    name = _STATE_NAMES.get(enum)
+    if name:
+        return name
+    raise Exception(f"Unknown StateType enum: {enum}")
+
 
+_STOP_REASON_NAMES = _enum_names(prefix="eStopReason")
 
-def stop_reason_to_str(enum):
+def stop_reason_to_str(enum: int) -> str:
     """Returns the stopReason string given an enum."""
-    if enum == lldb.eStopReasonInvalid:
-        return "invalid"
-    elif enum == lldb.eStopReasonNone:
-        return "none"
-    elif enum == lldb.eStopReasonTrace:
-        return "trace"
-    elif enum == lldb.eStopReasonBreakpoint:
-        return "breakpoint"
-    elif enum == lldb.eStopReasonWatchpoint:
-        return "watchpoint"
-    elif enum == lldb.eStopReasonExec:
-        return "exec"
-    elif enum == lldb.eStopReasonFork:
-        return "fork"
-    elif enum == lldb.eStopReasonVFork:
-        return "vfork"
-    elif enum == lldb.eStopReasonVForkDone:
-        return "vforkdone"
-    elif enum == lldb.eStopReasonSignal:
-        return "signal"
-    elif enum == lldb.eStopReasonException:
-        return "exception"
-    elif enum == lldb.eStopReasonPlanComplete:
-        return "plancomplete"
-    elif enum == lldb.eStopReasonThreadExiting:
-        return "threadexiting"
-    elif enum == lldb.eStopReasonInstrumentation:
-        return "instrumentation"
-    elif enum == lldb.eStopReasonProcessorTrace:
-        return "processortrace"
-    else:
-        raise Exception("Unknown StopReason enum")
+    name = _STOP_REASON_NAMES.get(enum)
+    if name:
+        return name
+    raise Exception(f"Unknown StopReason enum: {enum}")
+
 
+_SYMBOL_TYPE_NAMES = _enum_names(prefix="eSymbolType")
 
-def symbol_type_to_str(enum):
+def symbol_type_to_str(enum: int) -> str:
     """Returns the symbolType string given an enum."""
-    if enum == lldb.eSymbolTypeInvalid:
-        return "invalid"
-    elif enum == lldb.eSymbolTypeAbsolute:
-        return "absolute"
-    elif enum == lldb.eSymbolTypeCode:
-        return "code"
-    elif enum == lldb.eSymbolTypeData:
-        return "data"
-    elif enum == lldb.eSymbolTypeTrampoline:
-        return "trampoline"
-    elif enum == lldb.eSymbolTypeRuntime:
-        return "runtime"
-    elif enum == lldb.eSymbolTypeException:
-        return "exception"
-    elif enum == lldb.eSymbolTypeSourceFile:
-        return "sourcefile"
-    elif enum == lldb.eSymbolTypeHeaderFile:
-        return "headerfile"
-    elif enum == lldb.eSymbolTypeObjectFile:
-        return "objectfile"
-    elif enum == lldb.eSymbolTypeCommonBlock:
-        return "commonblock"
-    elif enum == lldb.eSymbolTypeBlock:
-        return "block"
-    elif enum == lldb.eSymbolTypeLocal:
-        return "local"
-    elif enum == lldb.eSymbolTypeParam:
-        return "param"
-    elif enum == lldb.eSymbolTypeVariable:
-        return "variable"
-    elif enum == lldb.eSymbolTypeVariableType:
-        return "variabletype"
-    elif enum == lldb.eSymbolTypeLineEntry:
-        return "lineentry"
-    elif enum == lldb.eSymbolTypeLineHeader:
-        return "lineheader"
-    elif enum == lldb.eSymbolTypeScopeBegin:
-        return "scopebegin"
-    elif enum == lldb.eSymbolTypeScopeEnd:
-        return "scopeend"
-    elif enum == lldb.eSymbolTypeAdditional:
-        return "additional"
-    elif enum == lldb.eSymbolTypeCompiler:
-        return "compiler"
-    elif enum == lldb.eSymbolTypeInstrumentation:
-        return "instrumentation"
-    elif enum == lldb.eSymbolTypeUndefined:
-        return "undefined"
+    name = _SYMBOL_TYPE_NAMES.get(enum)
+    if name:
+        return name
+    raise Exception(f"Unknown SymbolType enum: {enum}")
 
 
-def value_type_to_str(enum):
+_VALUE_TYPE_NAMES = _enum_names(prefix="eValueType")
+
+def value_type_to_str(enum: int) -> str:
     """Returns the valueType string given an enum."""
-    if enum == lldb.eValueTypeInvalid:
-        return "invalid"
-    elif enum == lldb.eValueTypeVariableGlobal:
-        return "global_variable"
-    elif enum == lldb.eValueTypeVariableStatic:
-        return "static_variable"
-    elif enum == lldb.eValueTypeVariableArgument:
-        return "argument_variable"
-    elif enum == lldb.eValueTypeVariableLocal:
-        return "local_variable"
-    elif enum == lldb.eValueTypeRegister:
-        return "register"
-    elif enum == lldb.eValueTypeRegisterSet:
-        return "register_set"
-    elif enum == lldb.eValueTypeConstResult:
-        return "constant_result"
-    else:
-        raise Exception("Unknown ValueType enum")
+    name = _VALUE_TYPE_NAMES.get(enum)
+    if name:
+        return name
+    raise Exception(f"Unknown ValueType enum: {enum}")
 
 
 # ==================================================
 # Get stopped threads due to each stop reason.
 # ==================================================
 
 def sort_stopped_threads(process,
                          breakpoint_threads=None,