[lldb][bindings] Fix module_access handling of regex

[kastiglione]

Summary

Fixes broken support for: target.module[re.compile("libFoo")]

There were two issues:

1. The type check was expecting re.SRE_Pattern
2. The expression to search the module path had a typo

In the first case, re.SRE_Pattern does not exist in Python 3, and is replaced
with re.Pattern.

While editing this code, I changed the type checks to us isinstance, which is
the conventional way of type checking.

From the docs on type():

The isinstance() built-in function is recommended for testing the type of an object, because it takes subclasses into account.

[JDevlieghere]

Makes sense, LGTM.

[mib]

LGTM! I guess this API was not exercised (since no one noticed the path -> file typo) ... Could you add a test before landing this ? Thanks!

[kastiglione]

@mib will do

[kastiglione]

Add a test for subscripting a target.modules using regex

lldb/bindings/interface/SBTarget.i

%pythoncode %{
 
             def __len__(self):
                 if self.sbtarget:
                     return int(self.sbtarget.GetNumModules())
                 return 0
 
             def __getitem__(self, key):
                 num_modules = self.sbtarget.GetNumModules()
-                if type(key) is int:
+                if isinstance(key, int):
                     if key < num_modules:
                         return self.sbtarget.GetModuleAtIndex(key)
-                elif type(key) is str:
+                elif isinstance(key, str):
                     if key.find('/') == -1:
                         for idx in range(num_modules):
                             module = self.sbtarget.GetModuleAtIndex(idx)
                             if module.file.basename == key:
                                 return module
                     else:
                         for idx in range(num_modules):
                             module = self.sbtarget.GetModuleAtIndex(idx)
                             if module.file.fullpath == key:
                                 return module
                     # See if the string is a UUID
                     try:
                         the_uuid = uuid.UUID(key)
                         if the_uuid:
                             for idx in range(num_modules):
                                 module = self.sbtarget.GetModuleAtIndex(idx)
                                 if module.uuid == the_uuid:
                                     return module
                     except:
                         return None
-                elif type(key) is uuid.UUID:
+                elif isinstance(key, uuid.UUID):
                     for idx in range(num_modules):
                         module = self.sbtarget.GetModuleAtIndex(idx)
                         if module.uuid == key:
                             return module
-                elif type(key) is re.SRE_Pattern:
+                elif isinstance(key, re.Pattern):
                     matching_modules = []
                     for idx in range(num_modules):
                         module = self.sbtarget.GetModuleAtIndex(idx)
-                        re_match = key.search(module.path.fullpath)
+                        re_match = key.search(module.file.fullpath)
                         if re_match:
                             matching_modules.append(module)
                     return matching_modules
                 else:
                     print("error: unsupported item type: %s" % type(key))
                 return None
 
         def get_modules_access_object(self):

lldb/test/API/python_api/target/TestTargetAPI.py

 """
 Test SBTarget APIs.
 """
 
+import re
 import unittest2
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
def test_is_loaded(self):
 
         process = target.LaunchSimple(None, None,
                                       self.get_process_working_directory())
 
         for i in range(num_modules):
             module = target.GetModuleAtIndex(i)
             self.assertTrue(target.IsLoaded(module), "Running the target should "
                             "have loaded its modules.")
+
+    def test_module_subscript_regex(self):
+        """Exercise SBTarget.module subscripting with regex."""
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+        modules = target.module[re.compile(r"/a[.]out$")]
+        self.assertEqual(len(modules), 1)
+        exe_mod = modules[0]
+        self.assertEqual(exe_mod.file.fullpath, exe)