Use copy.deepcopy instead of doing it manually.

[EricWF]

This LGTM.

libcxx/trunk/test/libcxx/compiler.py

def __init__(self, path, flags=None, compile_flags=None, link_flags=None,
             self.compile_env = dict(compile_env)
         else:
             self.compile_env = None
         self.type = cxx_type
         self.version = cxx_version
         if self.type is None or self.version is None:
             self._initTypeAndVersion()
 
-    def copy(self):
-        new_cxx = CXXCompiler(
-            self.path, flags=self.flags, compile_flags=self.compile_flags,
-            link_flags=self.link_flags, warning_flags=self.warning_flags,
-            verify_supported=self.verify_supported,
-            verify_flags=self.verify_flags, use_verify=self.use_verify,
-            modules_flags=self.modules_flags, use_modules=self.use_modules,
-            use_ccache=self.use_ccache, use_warnings=self.use_warnings,
-            compile_env=self.compile_env, cxx_type=self.type,
-            cxx_version=self.version)
-        return new_cxx
-
     def isVerifySupported(self):
         if self.verify_supported is None:
             self.verify_supported = self.hasCompileFlag(['-Xclang',
                                         '-verify-ignore-unexpected'])
             if self.verify_supported:
                 self.verify_flags = [
                     '-Xclang', '-verify',
                     '-Xclang', '-verify-ignore-unexpected=note',

libcxx/trunk/test/libcxx/test/format.py

 #===----------------------------------------------------------------------===##
 #
 #                     The LLVM Compiler Infrastructure
 #
 # This file is dual licensed under the MIT and the University of Illinois Open
 # Source Licenses. See LICENSE.TXT for details.
 #
 #===----------------------------------------------------------------------===##
 
+import copy
 import errno
 import os
 import time
 import random
 
 import lit.Test        # pylint: disable=import-error
 import lit.TestRunner  # pylint: disable=import-error
 from lit.TestRunner import ParserKind, IntegratedTestKeywordParser  \
Tests fall into two categories:
       FOO.pass.cpp - Executable test which should compile, run, and exit with
                      code 0.
       FOO.fail.cpp - Negative test case which is expected to fail compilation.
       FOO.sh.cpp   - A test that uses LIT's ShTest format.
     """
 
     def __init__(self, cxx, use_verify_for_fail, execute_external,
                  executor, exec_env):
-        self.cxx = cxx.copy()
+        self.cxx = copy.deepcopy(cxx)
         self.use_verify_for_fail = use_verify_for_fail
         self.execute_external = execute_external
         self.executor = executor
         self.exec_env = dict(exec_env)
 
     @staticmethod
     def _make_custom_parsers():
         return [
def _execute(self, test, lit_config):
         if not is_sh_test and len(script) != 0:
             lit_config.fatal('Unsupported RUN line found in test %s' % name)
 
         tmpDir, tmpBase = lit.TestRunner.getTempPaths(test)
         substitutions = lit.TestRunner.getDefaultSubstitutions(test, tmpDir,
                                                                tmpBase)
         script = lit.TestRunner.applySubstitutions(script, substitutions)
 
-        test_cxx = self.cxx.copy()
+        test_cxx = copy.deepcopy(self.cxx)
         if is_fail_test:
             test_cxx.useCCache(False)
             test_cxx.useWarnings(False)
         extra_modules_defines = self._get_parser('MODULES_DEFINES:',
                                                  parsers).getValue()
         if '-fmodules' in test.config.available_features:
             test_cxx.compile_flags += [('-D%s' % mdef.strip()) for
                                        mdef in extra_modules_defines]