[libc++] Add support for .compile.pass.mm and .link.pass.mm tests

[philnik]

libcxx/utils/libcxx/test/format.py

121–123

Do we actually have any .link tests? I couldn't find anything other than the selftests.

[ldionne]

libcxx/utils/libcxx/test/format.py

121–123

No, I guess I originally provided them for completeness. I suggest keeping them since they could be useful, in theory, and they don't hurt to keep.

[ldionne]

Rebase

libcxx/test/libcxx/selftest/compile.pass.mm/compile-error.compile.pass.mm

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: objective-c++
+
+// XFAIL: *
+
+// Make sure the test DOES NOT pass if it fails at compile-time
+
+struct Foo { };
+typedef Foo::x x;
+
+int main(int, char**) { return 0; }

libcxx/test/libcxx/selftest/compile.pass.mm/compile-success.compile.pass.mm

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: objective-c++
+
+// Make sure the test passes if it succeeds to compile
+
+@interface I;
+@end
+
+int main(int, char**) { return 0; }

libcxx/test/libcxx/selftest/compile.pass.mm/link-error.compile.pass.mm

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: objective-c++
+
+// Make sure the test passes even if there's a link error, i.e. it isn't linked.
+
+@interface I;
+@end
+
+extern void this_is_an_undefined_symbol();
+
+int main(int, char**) {
+    this_is_an_undefined_symbol();
+    return 0;
+}

libcxx/test/libcxx/selftest/compile.pass.mm/run-error.compile.pass.mm

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: objective-c++
+
+// Make sure the test passes even if there's a runtime error, i.e. it isn't run.
+
+@interface I;
+@end
+
+int main(int, char**) {
+    return 1;
+}

libcxx/test/libcxx/selftest/link.pass.mm/compile-error.link.pass.mm

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: objective-c++
+
+// XFAIL: *
+
+// Make sure the test DOES NOT pass if it fails at compile-time.
+
+struct Foo { };
+typedef Foo::x x;
+
+int main(int, char**) { return 0; }

libcxx/test/libcxx/selftest/link.pass.mm/link-error.link.pass.mm

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: objective-c++
+
+// XFAIL: *
+
+// Make sure the test DOES NOT pass if it fails to link.
+
+extern void this_is_an_undefined_symbol();
+
+int main(int, char**) {
+    this_is_an_undefined_symbol();
+    return 0;
+}

libcxx/test/libcxx/selftest/link.pass.mm/link-success.link.pass.mm

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: objective-c++
+
+// Make sure the test passes if it succeeds to link.
+
+@interface I;
+@end
+
+int main(int, char**) { return 0; }

libcxx/test/libcxx/selftest/link.pass.mm/run-error.link.pass.mm

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// REQUIRES: objective-c++
+
+// Make sure the test passes if it succeeds to link, even though it would have
+// failed at runtime.
+
+@interface I;
+@end
+
+int main(int, char**) {
+    return 1;
+}

libcxx/test/std/utilities/meta/meta.trans/objc_support.compile.pass.mm

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: objective-c++
 
 // Simple test to check that type traits support Objective-C types.
 
 #include <type_traits>
 #include "test_macros.h"
 
 @interface I;
 @end
 
 // add_pointer
 static_assert(std::is_same<std::add_pointer<id>::type, id*>::value, "");
 static_assert(std::is_same<std::add_pointer<I>::type, I*>::value, "");
 
 // add_lvalue_reference
 static_assert(std::is_same<std::add_lvalue_reference<id>::type, id&>::value, "");
 static_assert(std::is_same<std::add_lvalue_reference<I>::type, I&>::value, "");
 
 // add_rvalue_reference
 static_assert(std::is_same<std::add_rvalue_reference<id>::type, id&&>::value, "");
 static_assert(std::is_same<std::add_rvalue_reference<I>::type, I&&>::value, "");
 
 // decay
 static_assert(std::is_same<std::decay<id>::type, id>::value, "");
 static_assert(std::is_same<std::decay<I>::type, I>::value, "");
 static_assert(std::is_same<std::decay<id(&)[5]>::type, id*>::value, "");
 
 // __libcpp_is_referenceable
 LIBCPP_STATIC_ASSERT(std::__libcpp_is_referenceable<id>::value, "");
 LIBCPP_STATIC_ASSERT(std::__libcpp_is_referenceable<id*>::value, "");
 LIBCPP_STATIC_ASSERT(std::__libcpp_is_referenceable<id&>::value, "");
 LIBCPP_STATIC_ASSERT(std::__libcpp_is_referenceable<id&&>::value, "");
 LIBCPP_STATIC_ASSERT(std::__libcpp_is_referenceable<I>::value, "");
 LIBCPP_STATIC_ASSERT(std::__libcpp_is_referenceable<I*>::value, "");
 LIBCPP_STATIC_ASSERT(std::__libcpp_is_referenceable<I&>::value, "");
 LIBCPP_STATIC_ASSERT(std::__libcpp_is_referenceable<I&&>::value, "");
 
 // remove_all_extents
 static_assert(std::is_same<std::remove_all_extents<id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_all_extents<id[5]>::type, id>::value, "");
 static_assert(std::is_same<std::remove_all_extents<id[5][10]>::type, id>::value, "");
 static_assert(std::is_same<std::remove_all_extents<I>::type, I>::value, "");
 
 // remove_const
 static_assert(std::is_same<std::remove_const<id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_const<const id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_const<I>::type, I>::value, "");
 static_assert(std::is_same<std::remove_const<const I>::type, I>::value, "");
 
 // remove_cv
 static_assert(std::is_same<std::remove_cv<id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_cv<const volatile id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_cv<I>::type, I>::value, "");
 static_assert(std::is_same<std::remove_cv<const volatile I>::type, I>::value, "");
 
 #if TEST_STD_VER >= 20
 // remove_cvref
 static_assert(std::is_same<std::remove_cvref<id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_cvref<const volatile id&>::type, id>::value, "");
 static_assert(std::is_same<std::remove_cvref<const volatile id&&>::type, id>::value, "");
 static_assert(std::is_same<std::remove_cvref<I>::type, I>::value, "");
 static_assert(std::is_same<std::remove_cvref<const volatile I&>::type, I>::value, "");
 static_assert(std::is_same<std::remove_cvref<const volatile I&&>::type, I>::value, "");
 #endif
 
 // remove_extent
 static_assert(std::is_same<std::remove_all_extents<id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_all_extents<id[5]>::type, id>::value, "");
 static_assert(std::is_same<std::remove_all_extents<I>::type, I>::value, "");
 
 // remove_pointer
 static_assert(!std::is_same<std::remove_pointer<id>::type, id>::value, "");
 // The result of removing and re-adding pointer to `id` should be still `id`.
 static_assert(std::is_same<std::remove_pointer<id>::type*, id>::value, "");
 static_assert(std::is_same<std::add_pointer<std::remove_pointer<id>::type>::type, id>::value, "");
 static_assert(std::is_same<std::remove_pointer<std::add_pointer<id>::type>::type, id>::value, "");
 
 // remove_reference
 static_assert(std::is_same<std::remove_reference<id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_reference<id&>::type, id>::value, "");
 static_assert(std::is_same<std::remove_reference<const id&>::type, const id>::value, "");
 static_assert(std::is_same<std::remove_reference<id&&>::type, id>::value, "");
 static_assert(std::is_same<std::remove_reference<const id&&>::type, const id>::value, "");
 static_assert(std::is_same<std::remove_reference<I>::type, I>::value, "");
 static_assert(std::is_same<std::remove_reference<I&>::type, I>::value, "");
 static_assert(std::is_same<std::remove_reference<const I&>::type, const I>::value, "");
 static_assert(std::is_same<std::remove_reference<I&&>::type, I>::value, "");
 static_assert(std::is_same<std::remove_reference<const I&&>::type, const I>::value, "");
 
 // remove_volatile
 static_assert(std::is_same<std::remove_volatile<id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_volatile<volatile id>::type, id>::value, "");
 static_assert(std::is_same<std::remove_volatile<I>::type, I>::value, "");
 static_assert(std::is_same<std::remove_volatile<volatile I>::type, I>::value, "");
 
 int main(int, char**) {
   return 0;
 }

libcxx/utils/libcxx/test/format.py

class CxxStandardLibraryTest(lit.formats.TestFormat):
     creates a shell script performing the right operations (compile/link/run)
     based on the extension of the test file it encounters. It supports files
     with the following extensions:
 
     FOO.pass.cpp            - Compiles, links and runs successfully
     FOO.pass.mm             - Same as .pass.cpp, but for Objective-C++
 
     FOO.compile.pass.cpp    - Compiles successfully, link and run not attempted
+    FOO.compile.pass.mm     - Same as .compile.pass.cpp, but for Objective-C++
     FOO.compile.fail.cpp    - Does not compile successfully
 
     FOO.link.pass.cpp       - Compiles and links successfully, run not attempted
+    FOO.link.pass.mm        - Same as .link.pass.cpp, but for Objective-C++
     FOO.link.fail.cpp       - Compiles successfully, but fails to link
 
     FOO.sh.<anything>       - A builtin Lit Shell test
 
     FOO.verify.cpp          - Compiles with clang-verify. This type of test is
                               automatically marked as UNSUPPORTED if the compiler
                               does not support Clang-verify.
 
     FOO.fail.cpp            - Compiled with clang-verify if clang-verify is
The test format will define the following substitutions for use inside tests:
             substitutions, and that produces an executable named %t.exe.
 
         %{run}
             Equivalent to `%{exec} %t.exe`. This is intended to be used
             in conjunction with the %{build} substitution.
     """
     def getTestsInDirectory(self, testSuite, pathInSuite, litConfig, localConfig):
         SUPPORTED_SUFFIXES = ['[.]pass[.]cpp$', '[.]pass[.]mm$',
-                              '[.]compile[.]pass[.]cpp$', '[.]compile[.]fail[.]cpp$',
-                              '[.]link[.]pass[.]cpp$', '[.]link[.]fail[.]cpp$',
+                              '[.]compile[.]pass[.]cpp$', '[.]compile[.]pass[.]mm$',
+                              '[.]compile[.]fail[.]cpp$',
+                              '[.]link[.]pass[.]cpp$', '[.]link[.]pass[.]mm$',
+                              '[.]link[.]fail[.]cpp$',
                               '[.]sh[.][^.]+$',
                               '[.]verify[.]cpp$',
                               '[.]fail[.]cpp$']
         sourcePath = testSuite.getSourcePath(pathInSuite)
         for filename in os.listdir(sourcePath):
             # Ignore dot files and excluded tests.
             if filename.startswith('.') or filename in localConfig.excludes:
                 continue
 
             filepath = os.path.join(sourcePath, filename)
             if not os.path.isdir(filepath):
                 if any([re.search(ext, filename) for ext in SUPPORTED_SUFFIXES]):
                     yield lit.Test.Test(testSuite, pathInSuite + (filename,), localConfig)
 
     def execute(self, test, litConfig):
         VERIFY_FLAGS = '-Xclang -verify -Xclang -verify-ignore-unexpected=note -ferror-limit=0'
         supportsVerify = 'verify-support' in test.config.available_features
         filename = test.path_in_suite[-1]
 
         if re.search('[.]sh[.][^.]+$', filename):
             steps = [ ] # The steps are already in the script
             return self._executeShTest(test, litConfig, steps)
-        elif filename.endswith('.compile.pass.cpp'):
+        elif filename.endswith('.compile.pass.cpp') or filename.endswith('.compile.pass.mm'):
             steps = [
                 "%dbg(COMPILED WITH) %{cxx} %s %{flags} %{compile_flags} -fsyntax-only"
             ]
             return self._executeShTest(test, litConfig, steps)
         elif filename.endswith('.compile.fail.cpp'):
             steps = [
                 "%dbg(COMPILED WITH) ! %{cxx} %s %{flags} %{compile_flags} -fsyntax-only"
             ]
             return self._executeShTest(test, litConfig, steps)
-        elif filename.endswith('.link.pass.cpp'):
+        elif filename.endswith('.link.pass.cpp') or filename.endswith('.link.pass.mm'):
             steps = [
                 "%dbg(COMPILED WITH) %{cxx} %s %{flags} %{compile_flags} %{link_flags} -o %t.exe"
             ]
             return self._executeShTest(test, litConfig, steps)
         elif filename.endswith('.link.fail.cpp'):
             steps = [
                 "%dbg(COMPILED WITH) %{cxx} %s %{flags} %{compile_flags} -c -o %t.o",
                 "%dbg(LINKED WITH) ! %{cxx} %t.o %{flags} %{link_flags} -o %t.exe"