[libc++][NFC] Refactor helper method into the Lit test format

libcxx/utils/libcxx/test/dsl.py

def f(config, *args, **kwargs):
         cache[cacheKey] = function(config, *args, **kwargs)
         # Update the persistent cache so it knows about the new key
         with open(persistentCache, 'wb') as cacheFile:
           pickle.dump(cache, cacheFile)
       return cache[cacheKey]
     return f
   return decorator
 
-def _executeScriptInternal(test, commands):
+def _executeWithFakeConfig(test, commands):
   """
-  Returns (stdout, stderr, exitCode, timeoutInfo)
-
-  TODO: This really should be easier to access from Lit itself
+  Returns (stdout, stderr, exitCode, timeoutInfo, parsedCommands)
   """
-  parsedCommands = libcxx.test.format.parseScript(test, preamble=commands)
-
   litConfig = lit.LitConfig.LitConfig(
     progname='lit',
     path=[],
     quiet=False,
     useValgrind=False,
     valgrindLeakCheck=False,
     valgrindArgs=[],
     noExecute=False,
     debug=False,
     isWindows=platform.system() == 'Windows',
     order='smart',
     params={})
-  _, tmpBase = libcxx.test.format._getTempPaths(test)
-  execDir = os.path.dirname(test.getExecPath())
-  res = lit.TestRunner.executeScriptInternal(test, litConfig, tmpBase, parsedCommands, execDir)
-  if isinstance(res, lit.Test.Result): # Handle failure to parse the Lit test
-    res = ('', res.output, 127, None)
-  (out, err, exitCode, timeoutInfo) = res
-
-  # TODO: As a temporary workaround until https://reviews.llvm.org/D81892 lands, manually
-  #       split any stderr output that is included in stdout. It shouldn't be there, but
-  #       the Lit internal shell conflates stderr and stdout.
-  conflatedErrorOutput = re.search("(# command stderr:.+$)", out, flags=re.DOTALL)
-  if conflatedErrorOutput:
-    conflatedErrorOutput = conflatedErrorOutput.group(0)
-    out = out[:-len(conflatedErrorOutput)]
-    err += conflatedErrorOutput
-
-  return (out, err, exitCode, timeoutInfo, parsedCommands)
+  return libcxx.test.format._executeScriptInternal(test, litConfig, commands)
 
 def _makeConfigTest(config):
   # Make sure the support directories exist, which is needed to create
   # the temporary file %t below.
   sourceRoot = os.path.join(config.test_exec_root, '__config_src__')
   execRoot = os.path.join(config.test_exec_root, '__config_exec__')
   for supportDir in (sourceRoot, execRoot):
     if not os.path.exists(supportDir):
def sourceBuilds(config, source, additionalFlags=[]):
 
   This is done by compiling and linking a program that consists of the given
   source with the %{cxx} substitution, and seeing whether that succeeds. If
   any additional flags are passed, they are appended to the compiler invocation.
   """
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as sourceFile:
       sourceFile.write(source)
-    _, _, exitCode, _, _ = _executeScriptInternal(test, ['%{{build}} {}'.format(' '.join(additionalFlags))])
+    _, _, exitCode, _, _ = _executeWithFakeConfig(test, ['%{{build}} {}'.format(' '.join(additionalFlags))])
     return exitCode == 0
 
 @_memoizeExpensiveOperation(lambda c, p, args=None: (c.substitutions, c.environment, p, args))
 def programOutput(config, program, args=None):
   """
   Compiles a program for the test target, run it on the test target and return
   the output.
 
   Note that execution of the program is done through the %{exec} substitution,
   which means that the program may be run on a remote host depending on what
   %{exec} does.
   """
   if args is None:
     args = []
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as source:
       source.write(program)
-    _, err, exitCode, _, buildcmd = _executeScriptInternal(test, ['%{build}'])
+    _, err, exitCode, _, buildcmd = _executeWithFakeConfig(test, ['%{build}'])
     if exitCode != 0:
       raise ConfigurationCompilationError("Failed to build program, cmd:\n{}\nstderr is:\n{}".format(buildcmd, err))
 
-    out, err, exitCode, _, runcmd = _executeScriptInternal(test, ["%{{run}} {}".format(' '.join(args))])
+    out, err, exitCode, _, runcmd = _executeWithFakeConfig(test, ["%{{run}} {}".format(' '.join(args))])
     if exitCode != 0:
       raise ConfigurationRuntimeError("Failed to run program, cmd:\n{}\nstderr is:\n{}".format(runcmd, err))
 
     actualOut = re.search("# command output:\n(.+)\n$", out, flags=re.DOTALL)
     actualOut = actualOut.group(1) if actualOut else ""
     return actualOut
 
 @_memoizeExpensiveOperation(lambda c, p, args=None: (c.substitutions, c.environment, p, args))

 def hasCompileFlag(config, flag):
   """
   Return whether the compiler in the configuration supports a given compiler flag.
 
   This is done by executing the %{cxx} substitution with the given flag and
   checking whether that succeeds.
   """
   with _makeConfigTest(config) as test:
-    out, err, exitCode, timeoutInfo, _ = _executeScriptInternal(test, [
+    out, err, exitCode, timeoutInfo, _ = _executeWithFakeConfig(test, [
       "%{{cxx}} -xc++ {} -Werror -fsyntax-only %{{flags}} %{{compile_flags}} {}".format(os.devnull, flag)
     ])
     return exitCode == 0
 
 @_memoizeExpensiveOperation(lambda c, s: (c.substitutions, c.environment, s))
 def runScriptExitCode(config, script):
   """
   Runs the given script as a Lit test, and returns the exit code of the execution.
 
   The script must be a list of commands, each of which being something that
   could appear on the right-hand-side of a `RUN:` keyword.
   """
   with _makeConfigTest(config) as test:
-    _, _, exitCode, _, _ = _executeScriptInternal(test, script)
+    _, _, exitCode, _, _ = _executeWithFakeConfig(test, script)
     return exitCode
 
 @_memoizeExpensiveOperation(lambda c, s: (c.substitutions, c.environment, s))
 def commandOutput(config, command):
   """
   Runs the given script as a Lit test, and returns the output.
   If the exit code isn't 0 an exception is raised.
 
   The script must be a list of commands, each of which being something that
   could appear on the right-hand-side of a `RUN:` keyword.
   """
   with _makeConfigTest(config) as test:
-    out, err, exitCode, _, cmd = _executeScriptInternal(test, command)
+    out, err, exitCode, _, cmd = _executeWithFakeConfig(test, command)
     if exitCode != 0:
      raise ConfigurationRuntimeError("Failed to run command: {}\nstderr is:\n{}".format(cmd, err))
     return out
 
 @_memoizeExpensiveOperation(lambda c, l: (c.substitutions, c.environment, l))
 def hasAnyLocale(config, locales):
   """
   Return whether the runtime execution environment supports a given locale.
def compilerMacros(config, flags=''):
   """
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as sourceFile:
       sourceFile.write("""
       #if __has_include(<__config_site>)
       #  include <__config_site>
       #endif
       """)
-    unparsedOutput, err, exitCode, _, cmd = _executeScriptInternal(test, [
+    unparsedOutput, err, exitCode, _, cmd = _executeWithFakeConfig(test, [
       "%{{cxx}} %s -dM -E %{{flags}} %{{compile_flags}} {}".format(flags)
     ])
     if exitCode != 0:
       raise ConfigurationCompilationError("Failed to retrieve compiler macros, compiler invocation is:\n{}\nstderr is:\n{}".format(cmd, err))
     parsedMacros = dict()
     defines = (l.strip() for l in unparsedOutput.split('\n') if l.startswith('#define '))
     for line in defines:
       line = line[len('#define '):]

libcxx/utils/libcxx/test/format.py

def _getTempPaths(test):
     tmpBase = os.path.join(tmpDir, 't')
     return tmpDir, tmpBase
 
 def _checkBaseSubstitutions(substitutions):
     substitutions = [s for (s, _) in substitutions]
     for s in ['%{cxx}', '%{compile_flags}', '%{link_flags}', '%{flags}', '%{exec}']:
         assert s in substitutions, "Required substitution {} was not provided".format(s)
 
+def _executeScriptInternal(test, litConfig, commands):
+  """
+  Returns (stdout, stderr, exitCode, timeoutInfo, parsedCommands)
+
+  TODO: This really should be easier to access from Lit itself
+  """
+  parsedCommands = parseScript(test, preamble=commands)
+
+  _, tmpBase = _getTempPaths(test)
+  execDir = os.path.dirname(test.getExecPath())
+  res = lit.TestRunner.executeScriptInternal(test, litConfig, tmpBase, parsedCommands, execDir)
+  if isinstance(res, lit.Test.Result): # Handle failure to parse the Lit test
+    res = ('', res.output, 127, None)
+  (out, err, exitCode, timeoutInfo) = res
+
+  # TODO: As a temporary workaround until https://reviews.llvm.org/D81892 lands, manually
+  #       split any stderr output that is included in stdout. It shouldn't be there, but
+  #       the Lit internal shell conflates stderr and stdout.
+  conflatedErrorOutput = re.search("(# command stderr:.+$)", out, flags=re.DOTALL)
+  if conflatedErrorOutput:
+    conflatedErrorOutput = conflatedErrorOutput.group(0)
+    out = out[:-len(conflatedErrorOutput)]
+    err += conflatedErrorOutput
+
+  return (out, err, exitCode, timeoutInfo, parsedCommands)
+
 def parseScript(test, preamble):
     """
     Extract the script from a test, with substitutions applied.
 
     Returns a list of commands ready to be executed.
 
     - test
         The lit.Test to parse.