vendor/lldb/lldb-trunk-r256945

1 files changed, 181 insertions, 0 deletions

diff --git a/packages/Python/lldbsuite/test/lldb_pylint_helper.py b/packages/Python/lldbsuite/test/lldb_pylint_helper.py
new file mode 100644
index 0000000000000..1cc09441a2d69
--- /dev/null
+++ b/packages/Python/lldbsuite/test/lldb_pylint_helper.py
@@ -0,0 +1,181 @@
+"""
+                     The LLVM Compiler Infrastructure
+
+This file is distributed under the University of Illinois Open Source
+License. See LICENSE.TXT for details.
+
+Sync lldb and related source from a local machine to a remote machine.
+
+This facilitates working on the lldb sourcecode on multiple machines
+and multiple OS types, verifying changes across all.
+
+Provides helper support for adding lldb test paths to the python path.
+"""
+
+from __future__ import print_function
+from __future__ import absolute_import
+
+# System modules
+import os
+import platform
+import subprocess
+import sys
+
+# Third-party modules
+
+# LLDB modules
+
+
+def add_lldb_test_paths(check_dir):
+    # pylint: disable=line-too-long
+    """Adds lldb test-related paths to the python path.
+
+    Starting with the given directory and working upward through
+    each parent directory up to the root, it looks for the lldb
+    test directory.  When found, the lldb test directory and its
+    child test_runner/lib directory will be added to the python
+    system path.
+
+    Instructions for use:
+
+    This method supports a simple way of getting pylint to be able
+    to reliably lint lldb python test scripts (including the test
+    infrastructure itself).  To do so, add the following to a
+    .pylintrc file in your home directory:
+
+    [Master]
+    init-hook='import os; import sys; sys.path.append(os.path.expanduser("~/path/to/lldb/packages/Python/lldbsuite/test")); import lldb_pylint_helper; lldb_pylint_helper.add_lldb_test_paths(os.getcwd()); print("sys.path={}\n".format(sys.path))'
+
+    Replace ~/path/to/lldb with a valid path to your local lldb source
+    tree.  Note you can have multiple lldb source trees on your system, and
+    this will work just fine.  The path in your .pylintrc is just needed to
+    find the paths needed for pylint in whatever lldb source tree you're in.
+    pylint will use the python files in whichever tree it is run from.
+
+    Note it is critical that the init-hook line be contained on a single line.
+    You can remove the print line at the end once you know the pythonpath is
+    getting set up the way you expect.
+
+    With these changes, you will be able to run the following, for example.
+
+    cd lldb/sourcetree/1-of-many/test/lang/c/anonymous
+    pylint TestAnonymous.py
+
+    This will work, and include all the lldb/sourcetree/1-of-many lldb-specific
+    python directories to your path.
+
+    You can then run it in another lldb source tree on the same machine like
+    so:
+
+    cd lldb/sourcetree/2-of-many/test/functionalities/inferior-assert
+    pyline TestInferiorAssert.py
+
+    and this will properly lint that file, using the lldb-specific python
+    directories from the 2-of-many source tree.
+
+    Note at the time I'm writing this, our tests are in pretty sad shape
+    as far as a stock pylint setup goes.  But we need to start somewhere :-)
+
+    @param check_dir specifies a directory that will be used to start
+    looking for the lldb test infrastructure python library paths.
+    """
+    # Add the test-related packages themselves.
+    add_lldb_test_package_paths(check_dir)
+
+    # Add the lldb directory itself
+    add_lldb_module_directory()
+
+
+def add_lldb_module_directory():
+    """
+    Desired Approach:
+
+    Part A: find an lldb
+
+    1. Walk up the parent chain from the current directory, looking for
+    a directory matching *build*.  If we find that, use it as the
+    root of a directory search for an lldb[.exe] executable.
+
+    2. If 1 fails, use the path and look for an lldb[.exe] in there.
+
+    If Part A ends up with an lldb, go to part B.  Otherwise, give up
+    on the lldb python module path.
+
+    Part B: use the output from 'lldb[.exe] -P' to find the lldb dir.
+
+    Current approach:
+    If Darwin, use 'xcrun lldb -P'; others: find lldb on path.
+
+    Drawback to current approach:
+    If the tester is changing the SB API (adding new methods), pylint
+    will not know about them as it is using the wrong lldb python module.
+    In practice, this should be minor.
+    """
+    try:
+        lldb_module_path = None
+
+        if platform.system() == 'Darwin':
+            # Use xcrun to find the selected lldb.
+            lldb_module_path = subprocess.check_output(["xcrun", "lldb", "-P"])
+        elif platform.system() == 'Windows':
+            lldb_module_path = subprocess.check_output(
+                ["lldb.exe", "-P"], shell=True)
+        else:
+            # Use the shell to run lldb from the path.
+            lldb_module_path = subprocess.check_output(
+                ["lldb", "-P"], shell=True)
+
+        # Trim the result.
+        if lldb_module_path is not None:
+            lldb_module_path = lldb_module_path.strip()
+
+        # If we have a result, add it to the path
+        if lldb_module_path is not None and len(lldb_module_path) > 0:
+            sys.path.insert(0, lldb_module_path)
+    # pylint: disable=broad-except
+    except Exception as exception:
+        print("failed to find python path: {}".format(exception))
+
+
+def add_lldb_test_package_paths(check_dir):
+    """Adds the lldb test infrastructure modules to the python path.
+
+    See add_lldb_test_paths for more details.
+
+    @param check_dir the directory of the test.
+    """
+
+    def child_dirs(parent_dir):
+        return [os.path.join(parent_dir, child)
+                for child in os.listdir(parent_dir)
+                if os.path.isdir(os.path.join(parent_dir, child))]
+
+    check_dir = os.path.realpath(check_dir)
+    while check_dir and len(check_dir) > 0:
+        # If the current directory contains a packages/Python
+        # directory, add that directory to the path.
+        packages_python_child_dir = os.path.join(
+            check_dir, "packages", "Python")
+        if os.path.exists(packages_python_child_dir):
+            sys.path.insert(0, packages_python_child_dir)
+            sys.path.insert(0, os.path.join(
+                packages_python_child_dir, "test_runner", "lib"))
+
+            # Handle third_party module/package directory.
+            third_party_module_dir = os.path.join(
+                check_dir, "third_party", "Python", "module")
+            for child_dir in child_dirs(third_party_module_dir):
+                # Yes, we embed the module in the module parent dir
+                sys.path.insert(0, child_dir)
+
+            # We're done.
+            break
+
+        # Continue looking up the parent chain until we have no more
+        # directories to check.
+        new_check_dir = os.path.dirname(check_dir)
+        # We're done when the new check dir is not different
+        # than the current one.
+        if new_check_dir == check_dir:
+            break
+        check_dir = new_check_dir