[libc++] Pickle substitutions to pass them to dsl.sh.py

[ldionne]

Summary

This is less brittle than hand-picking the substitutions that we
pass to the test, since a config could theorically use non-base
substitutions as well (such as defining %{flags} in terms of another
substitution like %{include}).

Also, print the decoded substitutions, which makes it much easier
to debug the test when it fails.

[ldionne]

Pickle substitutions

libcxx/test/libcxx/selftest/dsl/dsl.sh.py

 #===----------------------------------------------------------------------===##
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
 # XFAIL: LIBCXX-WINDOWS-FIXME
 
 # Note: We prepend arguments with 'x' to avoid thinking there are too few
 #       arguments in case an argument is an empty string.
-# RUN: %{python} %s x%S \
-# RUN:              x%T \
-# RUN:              x%{escaped_exec} \
-# RUN:              x%{escaped_cxx} \
-# RUN:              x%{escaped_flags} \
-# RUN:              x%{escaped_compile_flags} \
-# RUN:              x%{escaped_link_flags}
-# END.
+# RUN: %{python} %s x%S x%T x%{substitutions}
 
 import base64
 import copy
 import os
+import pickle
 import platform
 import subprocess
 import sys
 import unittest
 from os.path import dirname
 
 # Allow importing 'lit' and the 'libcxx' module. Make sure we put the lit
 # path first so we don't find any system-installed version.
 monorepoRoot = dirname(dirname(dirname(dirname(dirname(dirname(__file__))))))
 sys.path = [os.path.join(monorepoRoot, 'libcxx', 'utils'),
             os.path.join(monorepoRoot, 'llvm', 'utils', 'lit')] + sys.path
 import libcxx.test.dsl as dsl
 import lit.LitConfig
 import lit.util
 
 # Steal some parameters from the config running this test so that we can
 # bootstrap our own TestingConfig.
 args = list(map(lambda s: s[1:], sys.argv[1:8])) # Remove the leading 'x'
-SOURCE_ROOT, EXEC_PATH, EXEC, CXX, FLAGS, COMPILE_FLAGS, LINK_FLAGS = args
+SOURCE_ROOT, EXEC_PATH, SUBSTITUTIONS = args
 sys.argv[1:8] = []
 
+# Decode the substitutions.
+SUBSTITUTIONS = pickle.loads(base64.b64decode(SUBSTITUTIONS))
+for s, sub in SUBSTITUTIONS:
+    print("Substitution '{}' is '{}'".format(s, sub))
+
 class SetupConfigs(unittest.TestCase):
     """
     Base class for the tests below -- it creates a fake TestingConfig.
     """
     def setUp(self):
         """
         Create a fake TestingConfig that can be populated however we wish for
         the purpose of running unit tests below. We pre-populate it with the
def setUp(self):
             debug=False,
             isWindows=platform.system() == 'Windows',
             params={})
 
         self.config = lit.TestingConfig.TestingConfig.fromdefaults(self.litConfig)
         self.config.test_source_root = SOURCE_ROOT
         self.config.test_exec_root = EXEC_PATH
         self.config.recursiveExpansionLimit = 10
-        base64Decode = lambda s: lit.util.to_string(base64.b64decode(s))
-        self.config.substitutions = [
-            ('%{cxx}', base64Decode(CXX)),
-            ('%{flags}', base64Decode(FLAGS)),
-            ('%{compile_flags}', base64Decode(COMPILE_FLAGS)),
-            ('%{link_flags}', base64Decode(LINK_FLAGS)),
-            ('%{exec}', base64Decode(EXEC))
-        ]
+        self.config.substitutions = copy.deepcopy(SUBSTITUTIONS)
 
     def getSubstitution(self, substitution):
         """
         Return a given substitution from the TestingConfig. It is an error if
         there is no such substitution.
         """
         found = [x for (s, x) in self.config.substitutions if s == substitution]
         assert len(found) == 1

libcxx/test/libcxx/selftest/dsl/lit.local.cfg

 # Since we try to pass substitutions as-is to some tests, we must "escape"
 # them in case they contain other substitutions. Otherwise, the substitutions
 # will be fully expanded when passed to the tests. For example, we want an
 # %{exec} substitution that contains `--execdir %T` to be passed as-is, without
 # substituting the directory. This way, the test itself can populate %T as it
 # sees fit, and %{exec} will respect it.
 #
-# To solve this problem, we add base64 encoded versions of substitutions just
-# in this directory. We then base64-decode them from the tests when we need to.
-# Another option would be to have a way to prevent expansion in Lit itself.
-import base64
-import lit.util
+# To solve this problem, we pickle the substitutions and base64 encode that
+# to pass it to the test, and we decode and unpickle the substitutions from
+# within the test.
+import base64, lit.util, pickle
 base64Encode = lambda s: lit.util.to_string(base64.b64encode(lit.util.to_bytes(s)))
-escaped = [(k.replace('%{', '%{escaped_'), base64Encode(v)) for (k, v) in config.substitutions]
-config.substitutions.extend(escaped)
+escapedSubstitutions = base64Encode(pickle.dumps(config.substitutions))
+config.substitutions.append(('%{substitutions}', escapedSubstitutions))
 
 # The tests in this directory need to run Python
-import pipes
-import sys
+import pipes, sys
 config.substitutions.append(('%{python}', pipes.quote(sys.executable)))