Use list comprehension instead of map/filter to prepare Python2/3 compat

[labath]

I think this should be fine, modulo the typo. TBH, I was not even aware some of these files existed. The ones that are already used by people on a daily basis should by already python3-ready.

lldb/utils/lui/lldbutil.py

729 ↗

(On Diff #191441)

typo (in in)

packages/Python/lldbsuite/test/dotest.py

if args.event_add_entries and len(args.event_add_entries) > 0:
                 entries[key] = val
         # Tell the event builder to create all events with these
         # key/val pairs in them.
         if len(entries) > 0:
             EventBuilder.add_entries_to_all_events(entries)
 
     # Gather all the dirs passed on the command line.
     if len(args.args) > 0:
-        configuration.testdirs = list(
-            map(lambda x: os.path.realpath(os.path.abspath(x)), args.args))
+        configuration.testdirs = [os.path.realpath(os.path.abspath(x)) for x in args.args]
         # Shut off multiprocessing mode when test directories are specified.
         configuration.no_multiprocess_test_runner = True
 
     lldbtest_config.codesign_identity = args.codesign_identity
 
     #print("testdirs:", testdirs)
 
 

scripts/analyze-project-deps.py

with open(file) as f:
             elif relative != this_dir:
                 deps[relative] = 1
     if this_dir not in src_map and len(deps) > 0:
         src_map[this_dir] = deps
 
 for (base, dirs, files) in os.walk(inc_dir):
     dir = os.path.basename(base)
     relative = os.path.relpath(base, inc_dir)
-    inc_files = filter(lambda x : os.path.splitext(x)[1] in [".h"], files)
+    inc_files = [x for x in files if os.path.splitext(x)[1] in [".h"]]
     relative = relative.replace("\\", "/")
     for inc in inc_files:
         inc_path = os.path.join(base, inc)
         scan_deps(relative, inc_path)
 
 for (base, dirs, files) in os.walk(src_dir):
     dir = os.path.basename(base)
     relative = os.path.relpath(base, src_dir)
-    src_files = filter(lambda x : os.path.splitext(x)[1] in [".cpp", ".h", ".mm"], files)
+    src_files = [x for x in files if os.path.splitext(x)[1] in [".cpp", ".h", ".mm"]]
     norm_base_path = os.path.normpath(os.path.join("lldb", relative))
     norm_base_path = norm_base_path.replace("\\", "/")
     for src in src_files:
         src_path = os.path.join(base, src)
         scan_deps(norm_base_path, src_path)
     pass
 
 def is_existing_cycle(path, cycles):

scripts/swig_bot_lib/local.py

def pack_archive(bytes_io, src_root, filters):
     archive_entries = []
     if filters is not None:
         def filter_func(t):
             subfolder = t[0]
             ext = t[1]
             full_path = os.path.normpath(os.path.join(src_root, subfolder))
             candidates = [os.path.normpath(os.path.join(full_path, f))
                           for f in os.listdir(full_path)]
-            actual = filter(
-                lambda f: os.path.isfile(f) and os.path.splitext(f)[1] == ext,
-                candidates)
-            return (subfolder, map(lambda f: os.path.basename(f), actual))
+            actual = [f for f in candidates if os.path.isfile(f) and os.path.splitext(f)[1] == ext]
+            return (subfolder, [os.path.basename(f) for f in actual])
         archive_entries = map(filter_func, filters)
     else:
         for (root, dirs, files) in os.walk(src_root):
             logging.debug("Adding files {} from directory {} to output package"
                           .format(files, root))
             if len(files) > 0:
                 rel_root = os.path.relpath(root, src_root)
                 archive_entries.append((rel_root, files))

utils/lui/lldbutil.py

def int_to_bytearray(val, bytesize):
     elif bytesize == 4:
         fmt = template % 'i'
     elif bytesize == 4:
         fmt = template % 'q'
     else:
         return None
 
     packed = struct.pack(fmt, val)
-    return bytearray(map(ord, packed))
+    return bytearray(ord(x) for x in packed)
 
 
 def bytearray_to_int(bytes, bytesize):
     """Utility function to convert a bytearray into an integer.
 
     It interprets the bytearray in the little endian format. For a big endian
     bytearray, just do ba.reverse() on the object before passing it in.
     """

 
 def get_function_names(thread):
     """
     Returns a sequence of function names from the stack frames of this thread.
     """
     def GetFuncName(i):
         return thread.GetFrameAtIndex(i).GetFunctionName()
 
-    return map(GetFuncName, range(thread.GetNumFrames()))
+    return [GetFuncName(i) for i in range(thread.GetNumFrames())]
 
 
 def get_symbol_names(thread):
     """
     Returns a sequence of symbols for this thread.
     """
     def GetSymbol(i):
         return thread.GetFrameAtIndex(i).GetSymbol().GetName()
 
-    return map(GetSymbol, range(thread.GetNumFrames()))
+    return [GetSymbol(i) for i in range(thread.GetNumFrames())]
 
 
 def get_pc_addresses(thread):
     """
     Returns a sequence of pc addresses for this thread.
     """
     def GetPCAddress(i):
         return thread.GetFrameAtIndex(i).GetPCAddress()
 
-    return map(GetPCAddress, range(thread.GetNumFrames()))
+    return [GetPCAddress(i) for i in range(thread.GetNumFrames())]
 
 
 def get_filenames(thread):
     """
     Returns a sequence of file names from the stack frames of this thread.
     """
     def GetFilename(i):
         return thread.GetFrameAtIndex(
             i).GetLineEntry().GetFileSpec().GetFilename()
 
-    return map(GetFilename, range(thread.GetNumFrames()))
+    return [GetFilename(i) for i in range(thread.GetNumFrames())]
 
 
 def get_line_numbers(thread):
     """
     Returns a sequence of line numbers from the stack frames of this thread.
     """
     def GetLineNumber(i):
         return thread.GetFrameAtIndex(i).GetLineEntry().GetLine()
 
-    return map(GetLineNumber, range(thread.GetNumFrames()))
+    return [GetLineNumber(i) for i in range(thread.GetNumFrames())]
 
 
 def get_module_names(thread):
     """
     Returns a sequence of module names from the stack frames of this thread.
     """
     def GetModuleName(i):
         return thread.GetFrameAtIndex(
             i).GetModule().GetFileSpec().GetFilename()
 
-    return map(GetModuleName, range(thread.GetNumFrames()))
+    return [GetModuleName(i) for i in range(thread.GetNumFrames())]
 
 
 def get_stack_frames(thread):
     """
     Returns a sequence of stack frames for this thread.
     """
     def GetStackFrame(i):
         return thread.GetFrameAtIndex(i)
 
-    return map(GetStackFrame, range(thread.GetNumFrames()))
+    return [GetStackFrame(i) for i in range(thread.GetNumFrames())]
 
 
 def print_stacktrace(thread, string_buffer=False):
     """Prints a simple stack trace of this thread."""
 
     output = StringIO.StringIO() if string_buffer else sys.stdout
     target = thread.GetProcess().GetTarget()
 

utils/vim-lldb/python-vim-lldb/lldb_controller.py

def completeCommand(self, a, l, p):
             # FIXME: insert completion character... what's a completion
             # character?
             pass
         elif num == -2:
             # FIXME: replace line with result.GetStringAtIndex(0)
             pass
 
         if result.GetSize() > 0:
-            results = filter(None, [result.GetStringAtIndex(x)
-                                    for x in range(result.GetSize())])
+            results = [_f for _f in [result.GetStringAtIndex(x)
+                                    for x in range(result.GetSize())] if _f]
             return results
         else:
             return []
 
     def doStep(self, stepType):
         """ Perform a step command and block the UI for eventDelayStep seconds in order to process
             events on lldb's event queue.
             FIXME: if the step does not complete in eventDelayStep seconds, we relinquish control to