Remove star imports to make ruff check pass

Author: clarfonthey

src/etc/gdb_lookup.py

@@ -2,8 +2,8 @@
 import gdb.printing
 import re
 
-from gdb_providers import *
-from rust_types import *
+import gdb_providers as providers
+from rust_types import RustType, classify_struct, classify_union
 
 
 _gdb_version_matched = re.search("([0-9]+)\\.([0-9]+)", gdb.VERSION)
@@ -72,22 +72,23 @@ def __call__(self, valobj):
 
 
 printer = RustPrettyPrinter("rust")
-printer.add(RustType.STD_STRING, StdStringProvider)
-printer.add(RustType.STD_OS_STRING, StdOsStringProvider)
-printer.add(RustType.STD_STR, StdStrProvider)
-printer.add(RustType.STD_SLICE, StdSliceProvider)
-printer.add(RustType.STD_VEC, StdVecProvider)
-printer.add(RustType.STD_VEC_DEQUE, StdVecDequeProvider)
-printer.add(RustType.STD_BTREE_SET, StdBTreeSetProvider)
-printer.add(RustType.STD_BTREE_MAP, StdBTreeMapProvider)
-printer.add(RustType.STD_HASH_MAP, StdHashMapProvider)
-printer.add(RustType.STD_HASH_SET, StdHashSetProvider)
-printer.add(RustType.STD_RC, StdRcProvider)
-printer.add(RustType.STD_ARC, lambda valobj: StdRcProvider(valobj, is_atomic=True))
-
-printer.add(RustType.STD_CELL, StdCellProvider)
-printer.add(RustType.STD_REF, StdRefProvider)
-printer.add(RustType.STD_REF_MUT, StdRefProvider)
-printer.add(RustType.STD_REF_CELL, StdRefCellProvider)
-
-printer.add(RustType.STD_NONZERO_NUMBER, StdNonZeroNumberProvider)
+printer.add(RustType.STD_STRING, providers.StdStringProvider)
+printer.add(RustType.STD_OS_STRING, providers.StdOsStringProvider)
+printer.add(RustType.STD_STR, providers.StdStrProvider)
+printer.add(RustType.STD_SLICE, providers.StdSliceProvider)
+printer.add(RustType.STD_VEC, providers.StdVecProvider)
+printer.add(RustType.STD_VEC_DEQUE, providers.StdVecDequeProvider)
+printer.add(RustType.STD_BTREE_SET, providers.StdBTreeSetProvider)
+printer.add(RustType.STD_BTREE_MAP, providers.StdBTreeMapProvider)
+printer.add(RustType.STD_HASH_MAP, providers.StdHashMapProvider)
+printer.add(RustType.STD_HASH_SET, providers.StdHashSetProvider)
+printer.add(RustType.STD_RC, providers.StdRcProvider)
+printer.add(
+    RustType.STD_ARC, lambda valobj: providers.StdRcProvider(valobj, is_atomic=True)
+)
+
+printer.add(RustType.STD_CELL, providers.StdCellProvider)
+printer.add(RustType.STD_REF, providers.StdRefProvider)
+printer.add(RustType.STD_REF_MUT, providers.StdRefProvider)
+printer.add(RustType.STD_REF_CELL, providers.StdRefCellProvider)
+printer.add(RustType.STD_NONZERO_NUMBER, providers.StdNonZeroNumberProvider)

src/etc/lldb_lookup.py

@@ -1,6 +1,6 @@
 import lldb
 
-from lldb_providers import *
+import lldb_providers as providers
 from rust_types import RustType, classify_struct, classify_union
 
 
@@ -19,66 +19,66 @@ def classify_rust_type(type: lldb.SBType) -> str:
     return RustType.OTHER
 
 
-def summary_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> str:
+def summary_lookup(valobj: lldb.SBValue, _dict: providers.LLDBOpaque) -> str:
     """Returns the summary provider for the given value"""
     rust_type = classify_rust_type(valobj.GetType())
 
     if rust_type == RustType.STD_STRING:
-        return StdStringSummaryProvider(valobj, _dict)
+        return providers.StdStringSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_OS_STRING:
-        return StdOsStringSummaryProvider(valobj, _dict)
+        return providers.StdOsStringSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_STR:
-        return StdStrSummaryProvider(valobj, _dict)
+        return providers.StdStrSummaryProvider(valobj, _dict)
 
     if rust_type == RustType.STD_VEC:
-        return SizeSummaryProvider(valobj, _dict)
+        return providers.SizeSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_VEC_DEQUE:
-        return SizeSummaryProvider(valobj, _dict)
+        return providers.SizeSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_SLICE:
-        return SizeSummaryProvider(valobj, _dict)
+        return providers.SizeSummaryProvider(valobj, _dict)
 
     if rust_type == RustType.STD_HASH_MAP:
-        return SizeSummaryProvider(valobj, _dict)
+        return providers.SizeSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_HASH_SET:
-        return SizeSummaryProvider(valobj, _dict)
+        return providers.SizeSummaryProvider(valobj, _dict)
 
     if rust_type == RustType.STD_RC:
-        return StdRcSummaryProvider(valobj, _dict)
+        return providers.StdRcSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_ARC:
-        return StdRcSummaryProvider(valobj, _dict)
+        return providers.StdRcSummaryProvider(valobj, _dict)
 
     if rust_type == RustType.STD_REF:
-        return StdRefSummaryProvider(valobj, _dict)
+        return providers.StdRefSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_REF_MUT:
-        return StdRefSummaryProvider(valobj, _dict)
+        return providers.StdRefSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_REF_CELL:
-        return StdRefSummaryProvider(valobj, _dict)
+        return providers.StdRefSummaryProvider(valobj, _dict)
 
     if rust_type == RustType.STD_NONZERO_NUMBER:
-        return StdNonZeroNumberSummaryProvider(valobj, _dict)
+        return providers.StdNonZeroNumberSummaryProvider(valobj, _dict)
 
     if rust_type == RustType.STD_PATHBUF:
-        return StdPathBufSummaryProvider(valobj, _dict)
+        return providers.StdPathBufSummaryProvider(valobj, _dict)
     if rust_type == RustType.STD_PATH:
-        return StdPathSummaryProvider(valobj, _dict)
+        return providers.StdPathSummaryProvider(valobj, _dict)
 
     return ""
 
 
-def synthetic_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> object:
+def synthetic_lookup(valobj: lldb.SBValue, _dict: providers.LLDBOpaque) -> object:
     """Returns the synthetic provider for the given value"""
     rust_type = classify_rust_type(valobj.GetType())
 
     if rust_type == RustType.STRUCT:
-        return StructSyntheticProvider(valobj, _dict)
+        return providers.StructSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STRUCT_VARIANT:
-        return StructSyntheticProvider(valobj, _dict, is_variant=True)
+        return providers.StructSyntheticProvider(valobj, _dict, is_variant=True)
     if rust_type == RustType.TUPLE:
-        return TupleSyntheticProvider(valobj, _dict)
+        return providers.TupleSyntheticProvider(valobj, _dict)
     if rust_type == RustType.TUPLE_VARIANT:
-        return TupleSyntheticProvider(valobj, _dict, is_variant=True)
+        return providers.TupleSyntheticProvider(valobj, _dict, is_variant=True)
     if rust_type == RustType.EMPTY:
-        return EmptySyntheticProvider(valobj, _dict)
+        return providers.EmptySyntheticProvider(valobj, _dict)
     if rust_type == RustType.REGULAR_ENUM:
         discriminant = valobj.GetChildAtIndex(0).GetChildAtIndex(0).GetValueAsUnsigned()
         return synthetic_lookup(valobj.GetChildAtIndex(discriminant), _dict)
@@ -105,38 +105,42 @@ def synthetic_lookup(valobj: lldb.SBValue, _dict: LLDBOpaque) -> object:
                 ),
             )
 
-        return ClangEncodedEnumProvider(valobj, _dict)
+        return providers.ClangEncodedEnumProvider(valobj, _dict)
     if rust_type == RustType.STD_VEC:
-        return StdVecSyntheticProvider(valobj, _dict)
+        return providers.StdVecSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_VEC_DEQUE:
-        return StdVecDequeSyntheticProvider(valobj, _dict)
+        return providers.StdVecDequeSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_SLICE or rust_type == RustType.STD_STR:
-        return StdSliceSyntheticProvider(valobj, _dict)
+        return providers.StdSliceSyntheticProvider(valobj, _dict)
 
     if rust_type == RustType.STD_HASH_MAP:
         if is_hashbrown_hashmap(valobj):
-            return StdHashMapSyntheticProvider(valobj, _dict)
+            return providers.StdHashMapSyntheticProvider(valobj, _dict)
         else:
-            return StdOldHashMapSyntheticProvider(valobj, _dict)
+            return providers.StdOldHashMapSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_HASH_SET:
         hash_map = valobj.GetChildAtIndex(0)
         if is_hashbrown_hashmap(hash_map):
-            return StdHashMapSyntheticProvider(valobj, _dict, show_values=False)
+            return providers.StdHashMapSyntheticProvider(
+                valobj, _dict, show_values=False
+            )
         else:
-            return StdOldHashMapSyntheticProvider(hash_map, _dict, show_values=False)
+            return providers.StdOldHashMapSyntheticProvider(
+                hash_map, _dict, show_values=False
+            )
 
     if rust_type == RustType.STD_RC:
-        return StdRcSyntheticProvider(valobj, _dict)
+        return providers.StdRcSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_ARC:
-        return StdRcSyntheticProvider(valobj, _dict, is_atomic=True)
+        return providers.StdRcSyntheticProvider(valobj, _dict, is_atomic=True)
 
     if rust_type == RustType.STD_CELL:
-        return StdCellSyntheticProvider(valobj, _dict)
+        return providers.StdCellSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_REF:
-        return StdRefSyntheticProvider(valobj, _dict)
+        return providers.StdRefSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_REF_MUT:
-        return StdRefSyntheticProvider(valobj, _dict)
+        return providers.StdRefSyntheticProvider(valobj, _dict)
     if rust_type == RustType.STD_REF_CELL:
-        return StdRefSyntheticProvider(valobj, _dict, is_cell=True)
+        return providers.StdRefSyntheticProvider(valobj, _dict, is_cell=True)
 
-    return DefaultSyntheticProvider(valobj, _dict)
+    return providers.DefaultSyntheticProvider(valobj, _dict)