Add target and host platform enums so we're not using strings everywhere

[zturner]

Summary

The original motivation for this came when I tried to combine two decorators:

@expectedFailureDarwin
@expectedFailureLinux

into a single decorator:

@expectedFailureAll(oslist=...)

This results in a really ugly syntax, because @expectedFailureDarwin calls getDarwinOsTriples() which is itself a list. So you would have to do something like this:

@expectedFailureAll(oslist=getDarwinOsTriples()+["linux"])

Not the end of the world, but not ideal either. Then I remembered that we've all had this ugliness surrounding the translation of python api calls such as sys.name, os.platform, and target names and host names into something consistent, so it occurred to me that many things would become cleaner and more elegant if we had actual enums for everything, and a centralized place where we can convert between enums and strings or whatever else we need.

So this patch introduces two enums. target and host, updates the common decorator to support these values from these enums, and changes two decorators to using these new values as a proof of concept.

One nice thing about these enums is that we can make standardized enum values for "combinations" of targets or hosts where it makes sense (such as is the case of with darwin, which is why the getDarwinOsTriples() function existed in the first place. So in that sense it works similarly to a flags enum in C / C++.

Eventually it would be nice if we could start using these enums all over the codebase instead of using strings everywhere, but this patch does not attempt to solve that problem.

[labath]

I like the idea. I think this could help us with the linux vs. android dilemma we've been having recently: currently, we consider android to be a flavour of linux, which means it's not possible to XFAIL tests passing on android but failing on linux. This should make expressing something like that easier.

I wonder, however, whether you need separate enums for host and target. I mean, any system can be used as one or the other, right? (Granted, nobody has tried bringing up lldb client on e.g., android, but I actually don't expect it would be so hard, and I don't see a reason to not support it here). What would you say to merging the two enums and calling it simply os, platform or something?

[zturner]

I think technically there are some platforms that cannot be both a host and a target. ios and anything involving a simulator comes to mind. But, if the only "gotcha" to having both of them be in the same enum is that it's up to the programmer to make sure he's using the right value in the context, then perhaps it's not the end of the world.

BTW, there were some things I wasn't sure whether to add to the enum here. android, remote_android, ios-simulator, etc. Should I add them, or should I leave it as is for now and let other people fix up their own platforms?

[labath]

In D17088#350005, @zturner wrote:

I think technically there are some platforms that cannot be both a host and a target. ios and anything involving a simulator comes to mind. But, if the only "gotcha" to having both of them be in the same enum is that it's up to the programmer to make sure he's using the right value in the context, then perhaps it's not the end of the world.

Although unlikely, I don't think there is an inherent reason lldb could not run there, so yeah, I think one list is better.

BTW, there were some things I wasn't sure whether to add to the enum here. android, remote_android, ios-simulator, etc. Should I add them, or should I leave it as is for now and let other people fix up their own platforms?

I think we should let people add targets when they need to, so let's leave these out for now. As I said, right now we treat android as a flavour of linux. When we change that we can add android and linux_all (or something like that) to the list.

[zturner]

Merged into one list. Also moved code into a new module lldbplatform.

[labath]

looks good.

[tfiala]

LGTM. Having the single list to cover host and target is a good way to go here, too.

packages/Python/lldbsuite/test/decorators.py

 # System modules
 from distutils.version import LooseVersion, StrictVersion
 from functools import wraps
+import itertools
 import os
 import re
 import sys

 from . import test_categories
 from .result_formatter import EventBuilder
 from lldbsuite.support import funcutils
+from lldbsuite.test import lldbplatform
 from lldbsuite.test import lldbplatformutil
 
 class DecorateMode:

                  swig_version=None, py_version=None,
                  remote=None):
     def fn(self):
-        skip_for_os = _match_decorator_property(oslist, self.getPlatform())
-        skip_for_hostos = _match_decorator_property(hostoslist, lldbplatformutil.getHostPlatform())
+        skip_for_os = _match_decorator_property(lldbplatform.translate(oslist), self.getPlatform())
+        skip_for_hostos = _match_decorator_property(lldbplatform.translate(hostoslist), lldbplatformutil.getHostPlatform())
         skip_for_compiler = _match_decorator_property(compiler, self.getCompiler()) and self.expectedCompilerVersion(compiler_version)
         skip_for_arch = _match_decorator_property(archs, self.getArchitecture())
         skip_for_debug_info = _match_decorator_property(debug_info, self.debug_info)

 
 def expectedFailureDarwin(bugnumber=None, compilers=None, debug_info=None):
     # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
-    return expectedFailureOS(lldbplatformutil.getDarwinOSTriples(), bugnumber, compilers, debug_info=debug_info)
+    return expectedFailureOS(lldbplatform.darwin_all, bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureFreeBSD(bugnumber=None, compilers=None, debug_info=None):
-    return expectedFailureOS(['freebsd'], bugnumber, compilers, debug_info=debug_info)
+    return expectedFailureOS(lldbplatform.freebsd, bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureAndroid(bugnumber=None, api_levels=None, archs=None):
     """ Mark a test as xfail for Android.

 
 def skipIfDarwin(func):
     """Decorate the item to skip tests that should be skipped on Darwin."""
-    return skipIfPlatform(lldbplatformutil.getDarwinOSTriples())(func)
+    return skipIfPlatform(lldbplatform.translate(lldbplatform.darwin_all))(func)
 
 def skipIfLinux(func):
     """Decorate the item to skip tests that should be skipped on Linux."""

packages/Python/lldbsuite/test/functionalities/asan/TestMemoryHistory.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbplatform
 from lldbsuite.test import lldbutil
 
 class AsanTestCase(TestBase):

     @skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessCompilerRt
-    @expectedFailureDarwin
+    @expectedFailureAll(oslist=lldbplatform.darwin_all)
     def test (self):
         self.build ()
         self.asan_tests ()

packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbplatform
 from lldbsuite.test import lldbutil
 
 class CommandLineCompletionTestCase(TestBase):

         self.complete_from_to('target va', 'target variable ')
 
     @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
-    @expectedFailureDarwin("llvm.org/pr25485")
+    @expectedFailureAll(oslist=lldbplatform.darwin_all, bugnumber="llvm.org/pr25485")
     def test_symbol_name(self):
         self.build()
         self.complete_from_to('''file a.out

packages/Python/lldbsuite/test/lldbplatform.py

+""" This module represents an abstraction of an lldb target / host platform. """
+
+from __future__ import absolute_import
+
+# System modules
+import itertools
+
+# Third-party modules
+import six
+
+# LLDB modules
+import use_lldb_suite
+import lldb
+
+windows, linux, macosx, darwin, ios, darwin_all, freebsd, netbsd, bsd_all, android = range(10)
+
+__name_lookup = {
+    windows : ["windows"],
+    linux : ["linux"],
+    macosx : ["macosx"],
+    darwin : ["darwin"],
+    ios : ["ios"],
+    darwin_all : ["macosx", "darwin", "ios"],
+    freebsd : ["freebsd"],
+    netbsd : ["netbsd"],
+    bsd_all : ["freebsd", "netbsd"],
+    android : ["android"]
+}
+
+
+def translate(values):
+
+    if isinstance(values, six.integer_types):
+        # This is a value from the platform enumeration, translate it.
+        return __name_lookup[values]
+    elif isinstance(values, six.string_types):
+        # This is a raw string, return it.
+        return [values]
+    elif hasattr(values, "__iter__"):
+        # This is an iterable, convert each item.
+        result = [translate(x) for x in values]
+        result = list(itertools.chain(*result))
+        return result
+    return values

packages/Python/lldbsuite/test/lldbplatformutil.py

 from __future__ import absolute_import
 
 # System modules
+import itertools
 import re
 import subprocess
 import sys
 
 # Third-party modules
+import six
 from six.moves.urllib import parse as urlparse
 
 # LLDB modules