Fix a few tests that were missing ':' on CHECK lines and weren't testing anything.

[thakis]

Summary

Found by git grep '\/\/ CHECK-[^: ]* ' clang/test/ | grep -v RUN:.

Also tweak CodeGenCXX/arm-swiftcall.cpp to still pass now that it checks more.

[rjmccall]

Good catch! Is there a reasonable way to just make FileCheck itself enforce this, or does that cause too many false positives with tests that are using e.g. x86_64 as the entire prefix?

If we were starting over again, I think ideally the check-prefix would be unconditionally treated as flagging something for FileCheck, so that any sort of unrecognized command after it would produce an error. I doubt there's any real use-case for writing e.g. CHECK in a test case. But that's no longer possible because of the widespread idiom of using things like CHECK-NATIVE as conditionally-enabled prefixes, which is of course ambiguous with typoing a command like CHECK-NEXT or thinking that CHECK-CONT should exist. But it'd be nice to get as close to that as we can without rewriting ten thousand FileCheck tests.

[probinson]

There has been some progress recently on better FileCheck diagnosis of likely test-writing issues, although to date it mostly requires the human to ask "what is going on here?" explicitly. I can see adding a check to detect the missing-colon-on-otherwise-valid-directive case (including the usual suffixes), and my guess is that isn't too likely to cause excessive churn. The deeper we go into typo-detection the more likely we are to trip over false positives, but this small step seems like a worthy change.
Happy to review such a patch, or somebody can file a PR and CC me.

test/AST/ast-dump-attr.cpp

 namespace TestSuppress {
   [[gsl::suppress("at-namespace")]];
   // CHECK: NamespaceDecl{{.*}} TestSuppress
   // CHECK-NEXT: EmptyDecl{{.*}}
   // CHECK-NEXT: SuppressAttr{{.*}} at-namespace
   [[gsl::suppress("on-decl")]]
   void TestSuppressFunction();
   // CHECK: FunctionDecl{{.*}} TestSuppressFunction
-  // CHECK-NEXT SuppressAttr{{.*}} on-decl
+  // CHECK-NEXT: SuppressAttr{{.*}} on-decl
 
   void f() {
       int *i;
 
       [[gsl::suppress("on-stmt")]] {
       // CHECK: AttributedStmt
       // CHECK-NEXT: SuppressAttr{{.*}} on-stmt
       // CHECK-NEXT: CompoundStmt

test/CodeGenCXX/arm-swiftcall.cpp

 // CHECK-LABEL: define {{.*}} void @take_struct_indirect_1({{.*}}*{{( %.*)?}})
 
 // Do a simple standalone test here of a function definition to ensure that
 // we don't have problems due to failure to eagerly synthesize a copy
 // constructor declaration.
 class struct_trivial {
   int x;
 };
-// CHECK-LABEL define void @test_struct_trivial(i32{{( %.*)?}})
+// CHECK-LABEL: define swiftcc void @test_struct_trivial(i32{{( %.*)?}})
 extern "C" SWIFTCALL
 void test_struct_trivial(struct_trivial triv) {}

test/CodeGenCXX/cxx1z-init-statement.cpp

 // RUN: %clang_cc1 -std=c++1z -triple x86_64-apple-macosx10.7.0 -emit-llvm -o - %s -w | FileCheck %s
 
 typedef int T;
 void f() {
   // CHECK:      %[[A:.*]] = alloca i32, align 4
   // CHECK-NEXT: store i32 5, i32* %[[A]], align 4
   // CHECK-NEXT: %[[B:.*]] = load i32, i32* %[[A]], align 4
-  // CHECK-NEXT  %[[C:.*]] = icmp slt i32 %[[B]], 8
+  // CHECK-NEXT: %[[C:.*]] = icmp slt i32 %[[B]], 8
   if (int a = 5; a < 8)
     ;
 }
 
 void f1() {
   // CHECK:      %[[A:.*]] = alloca i32, align 4
   // CHECK-NEXT: %[[B:.*]] = alloca i32, align 4
   // CHECK-NEXT: %[[C:.*]] = alloca i32, align 4

test/CodeGenCXX/cxx2a-compare.cpp

 
 // CHECK-LABEL: @_Z12mem_ptr_testM6MemPtrFvvES1_
 auto mem_ptr_test(MemPtrT x, MemPtrT y) {
   // CHECK: %[[DEST:retval|agg.result]]
   // CHECK: %cmp.ptr = icmp eq [[TY:i[0-9]+]] %lhs.memptr.ptr, %rhs.memptr.ptr
   // CHECK: %cmp.ptr.null = icmp eq [[TY]] %lhs.memptr.ptr, 0
   // CHECK: %cmp.adj = icmp eq [[TY]] %lhs.memptr.adj, %rhs.memptr.adj
   // CHECK: %[[OR:.*]] = or i1
-  // CHECK-SAME %cmp.adj
+  // CHECK-SAME: %cmp.adj
   // CHECK: %memptr.eq = and i1 %cmp.ptr, %[[OR]]
   // CHECK: %sel.eq = select i1 %memptr.eq, i8 [[EQ]], i8 [[NE]]
   // CHECK: %__value_ = getelementptr inbounds %[[SE]], %[[SE]]* %[[DEST]]
   // CHECK: store i8 %sel.eq, i8* %__value_, align 1
   // CHECK: ret
   return x <=> y;
 }
 

test/CodeGenCXX/debug-info-inheriting-constructor.cpp

 // RUN: %clang_cc1 -debug-info-kind=standalone -std=c++11 -triple x86_64-darwin -emit-llvm -o - %s | FileCheck %s
 
 struct A {
   A(int, ...);
 };
 struct B : A {
   using A::A;
 };
 
 A::A(int i, ...) {}
 // CHECK: define void @{{.*}}foo
-// CHECK-NOT ret void
+// CHECK-NOT: ret void
 // CHECK: call void @llvm.dbg.declare
-// CHECK-NOT ret void
+// CHECK-NOT: ret void
 // CHECK: call void @llvm.dbg.declare(metadata %{{.*}}** %{{[^,]+}},
 // CHECK-SAME: metadata ![[THIS:[0-9]+]], metadata !DIExpression()), !dbg ![[LOC:[0-9]+]]
 // CHECK: ret void, !dbg ![[NOINL:[0-9]+]]
 // CHECK: ![[FOO:.*]] = distinct !DISubprogram(name: "foo"
 // CHECK-DAG: ![[A:.*]] = distinct !DISubprogram(name: "A", linkageName: "_ZN1BCI11AEiz"
 void foo() {
 // CHECK-DAG: ![[LOC]] = !DILocation(line: 0, scope: ![[A]], inlinedAt: ![[INL:[0-9]+]])
 // CHECK-DAG: ![[INL]] = !DILocation(line: [[@LINE+1]], scope: ![[FOO]])
   B b(0);
 // CHECK: ![[NOINL]] = !DILocation(line: [[@LINE+1]], scope: !{{[0-9]+}})
 }

test/CodeGenCXX/vtable-layout.cpp

 // CHECK-35-NEXT:    9 | void Test28::A::a()
 // CHECK-35-NEXT:   10 | void Test28::C::c()
 // CHECK-35-NEXT:   11 | offset_to_top (-16)
 // CHECK-35-NEXT:   12 | Test28::E RTTI
 // CHECK-35-NEXT:        -- (Test28::B, 16) vtable address --
 // CHECK-35-NEXT:   13 | void Test28::B::b()
 //
 // CHECK-35:      VTable indices for 'Test28::E' (1 entries).
-// CHECK-35-NEXT :   0 | void Test28::E::e()
+// CHECK-35-NEXT:    0 | void Test28::E::e()
 
 // CHECK-35:      Construction vtable for ('Test28::D', 0) in 'Test28::E' (13 entries).
 // CHECK-35-NEXT:    0 | vbase_offset (8)
 // CHECK-35-NEXT:    1 | offset_to_top (0)
 // CHECK-35-NEXT:    2 | Test28::D RTTI
 // CHECK-35-NEXT:        -- (Test28::D, 0) vtable address --
 // CHECK-35-NEXT:    3 | vcall_offset (8)
 // CHECK-35-NEXT:    4 | vcall_offset (0)

test/CodeGenObjC/gnu-init.m

 // RUN: %clang_cc1 -triple x86_64-unknown-freebsd -S -emit-llvm -fobjc-runtime=gnustep-2.0 -o - %s | FileCheck %s -check-prefix=CHECK-NEW
 // RUN: %clang_cc1 -triple x86_64-pc-windows-msvc -S -emit-llvm -fobjc-runtime=gnustep-2.0 -o - %s | FileCheck %s -check-prefix=CHECK-WIN
 // RUN: %clang_cc1 -triple x86_64-unknown-freebsd -S -emit-llvm -fobjc-runtime=gnustep-1.8 -o - %s | FileCheck %s -check-prefix=CHECK-OLD
 
 // Almost minimal Objective-C file, check that it emits calls to the correct
 // runtime entry points.
 @interface X @end
 @implementation X @end
 
 
 // Check that we emit a class ref
 // CHECK-NEW: @._OBJC_REF_CLASS_X 
 // CHECK-NEW-SAME: section "__objc_class_refs"
 
 // Check that we get a class ref to the defined class.
 // CHECK-NEW: @._OBJC_INIT_CLASS_X = global 
-// CHECK-NEW-SAME* @._OBJC_CLASS_X, section "__objc_classes"
+// CHECK-NEW-SAME: @._OBJC_CLASS_X, section "__objc_classes"
 
 // Check that we emit the section start and end symbols as hidden globals.
 // CHECK-NEW: @__start___objc_selectors = external hidden global i8*
 // CHECK-NEW: @__stop___objc_selectors = external hidden global i8*
 // CHECK-NEW: @__start___objc_classes = external hidden global i8*
 // CHECK-NEW: @__stop___objc_classes = external hidden global i8*
 // CHECK-NEW: @__start___objc_class_refs = external hidden global i8*
 // CHECK-NEW: @__stop___objc_class_refs = external hidden global i8*

test/CodeGenObjC/os_log.m

void *test_builtin_os_log(void *buf) {
   // CHECK-O0: %[[V0:.*]] = load i8*, i8** %[[BUF_ADDR]], align 8
   // CHECK-O0: %[[CALL:.*]] = call %[[TY0:.*]]* (...) @GenString()
   // CHECK-O0: %[[V1:.*]] = bitcast %[[TY0]]* %[[CALL]] to i8*
   // CHECK-O0: %[[V2:.*]] = call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* %[[V1]])
   // CHECK-O0: %[[V3:.*]] = bitcast i8* %[[V2]] to %[[TY0]]*
   // CHECK-O0: %[[V4:.*]] = ptrtoint %[[TY0]]* %[[V3]] to i64
   // CHECK-O0: call void @__os_log_helper_1_2_1_8_64(i8* %[[V0]], i64 %[[V4]])
   // CHECK-O0: %[[V5:.*]] = bitcast %[[TY0]]* %[[V3]] to i8*
-  // CHECK-O0-NOT call void (...) @llvm.objc.clang.arc.use({{.*}}
+  // CHECK-O0-NOT: call void (...) @llvm.objc.clang.arc.use({{.*}}
   // CHECK-O0: call void @llvm.objc.release(i8* %[[V5]])
   // CHECK-O0: ret i8* %[[V0]]
 }
 
 // CHECK-O0-LABEL: define linkonce_odr hidden void @__os_log_helper_1_2_1_8_64
 // CHECK-O0: (i8* %[[BUFFER:.*]], i64 %[[ARG0:.*]])
 
 // CHECK-O0: %[[BUFFER_ADDR:.*]] = alloca i8*, align 8