Format regression tests that were added or changed since #481.

- Run clang-format and apply exclusions as appropriate.

- Manually fix an over-length comment.

Author: mattmccutchen-cci

clang/test/3C/add_struct_init.c

@@ -5,15 +5,27 @@
 // RUN: 3c -base-dir=%S -alltypes -output-dir=%t.checked %s --
 // RUN: 3c -base-dir=%t.checked -alltypes %t.checked/add_struct_init.c -- | diff %t.checked/add_struct_init.c -
 
-
 struct foo {};
-struct bar { int *a; };
+struct bar {
+  int *a;
+};
 //CHECK: struct bar { _Ptr<int> a; };
-struct fiz { int *a; };
-struct buz { struct bar a; };
-struct baz { struct buz a; };
-struct fuz { struct baz a; struct fiz b; };
-struct biz { struct fiz b; };
+struct fiz {
+  int *a;
+};
+struct buz {
+  struct bar a;
+};
+struct baz {
+  struct buz a;
+};
+struct fuz {
+  struct baz a;
+  struct fiz b;
+};
+struct biz {
+  struct fiz b;
+};
 
 void test() {
   struct foo a;

clang/test/3C/arrctxsenbounds.c

@@ -6,32 +6,33 @@
 Context-sensitive array-bounds inference.
 */
 typedef long size_t;
-extern _Itype_for_any(T) void *malloc(size_t size) : itype(_Array_ptr<T>) byte_count(size);
+extern _Itype_for_any(T) void *malloc(size_t size)
+    : itype(_Array_ptr<T>) byte_count(size);
 struct foo {
-    int *x;
-    unsigned olol;
-    int *y;
-    unsigned fail_y_len;
+  int *x;
+  unsigned olol;
+  int *y;
+  unsigned fail_y_len;
 };
 //CHECK:    _Array_ptr<int> x : count(olol);
 //CHECK:    _Array_ptr<int> y;
 
 void ctx_(struct foo *f, struct foo *f2) {
-    f2->y = f->x;
-    f2->y[0] = 1;
+  f2->y = f->x;
+  f2->y[0] = 1;
 }
 //CHECK: void ctx_(_Ptr<struct foo> f, _Ptr<struct foo> f2) {
 
 int main(int argc, char **argv) {
-    char *PN = argv[0];
-    unsigned n = 10;
-    struct foo po, po2;
-    po.x = malloc(n*sizeof(int));
-    po.x[0] = 0;
-    po.olol = n;
-    po2.fail_y_len = n;
-    ctx_(&po, &po2);
-    return 0;
+  char *PN = argv[0];
+  unsigned n = 10;
+  struct foo po, po2;
+  po.x = malloc(n * sizeof(int));
+  po.x[0] = 0;
+  po.olol = n;
+  po2.fail_y_len = n;
+  ctx_(&po, &po2);
+  return 0;
 }
 //CHECK: int main(int argc, _Array_ptr<_Ptr<char>> argv : count(argc)) {
 //CHECK: _Ptr<char> PN = argv[0];

clang/test/3C/base_subdir/canwrite_constraints.c

@@ -36,12 +36,9 @@ int *bar(int *q) {
   return foo_var;
 }
 
-
 int gar(intptr a) {
-        int* b = a;
-        //CHECK_LOWER: int* b = a;
-        //CHECK_HIGHER: _Ptr<int> b = a;
-        return *b;
+  int *b = a;
+  //CHECK_LOWER: int* b = a;
+  //CHECK_HIGHER: _Ptr<int> b = a;
+  return *b;
 }
-
-

clang/test/3C/canwrite_constraints.h

@@ -20,7 +20,7 @@ int *foo_var = ((void *)0);
 void strtol_like(int *p : itype(_Ptr<int>));
 void atol_like() {
   // expected-warning@+1 {{Expression in non-writable file}}
-  strtol_like((int *) 0);
+  strtol_like((int *)0);
 }
 
 // Make sure we do not add checked regions in non-writable files. This happened
@@ -32,7 +32,7 @@ inline void no_op() {}
 // In the lower case, this should stay wild
 // In the higher case, this should solve to checked
 // expected-warning@+1 {{Declaration in non-writable file}}
-typedef int* intptr;
+typedef int *intptr;
 // CHECK_HIGHER: typedef _Ptr<int> intptr;
 // Test the unwritable cast internal warning
 // (https://github.com/correctcomputation/checkedc-clang/issues/454) using the

clang/test/3C/difftypes1b.c

@@ -4,4 +4,4 @@
 
 // The desired behavior in this case is to fail, so other checks are omitted
 
-int * foo(int, char *);
+int *foo(int, char *);

clang/test/3C/difftypes2.c

@@ -11,4 +11,3 @@ void foo(char *x);
 void foo(char **y) {
   // this is the body
 }
-

clang/test/3C/difftypes3.c

@@ -11,4 +11,3 @@ void foo(char **y) {
 }
 
 void foo(char *x);
-

clang/test/3C/inline_anon_structs.c

@@ -135,6 +135,10 @@ void foo2(int *x) {
   //CHECK:      struct {
   //CHECK-NEXT:   _Ptr<int> c;
   //CHECK-NEXT: } b = {};
-  struct {int *i;} *f;
-  struct {int *il} *g, *h, *i;
+  struct {
+    int *i;
+  } * f;
+  struct {
+    int *il
+  } * g, *h, *i;
 }

clang/test/3C/k_and_r.c

@@ -5,6 +5,10 @@
 // RUN: 3c -base-dir=%S -alltypes -output-dir=%t.checked %s --
 // RUN: 3c -base-dir=%t.checked -alltypes %t.checked/k_and_r.c -- | diff %t.checked/k_and_r.c -
 
+// clang-format doesn't seem to understand K&R function declarations and makes a
+// mess.
+// clang-format off
+
 void test0(a)
   int *a;
 {}
@@ -26,7 +30,7 @@ void test2(a, b)
 
 int *test3(a)
   int *a;
-{return a;}
+{ return a; }
 //CHECK: _Ptr<int> test3(_Ptr<int> a)
 //CHECK: _Checked {return a;}
 
@@ -55,9 +59,9 @@ void test5(a, b, c, d, e, f, g, h)
 struct yy_buffer_state {};
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
 #else
-void yy_init_buffer( b, file )
+void yy_init_buffer(b, file)
 YY_BUFFER_STATE b;
 int *file;
 //CHECK: void yy_init_buffer(YY_BUFFER_STATE b, _Ptr<int> file)
@@ -73,4 +77,6 @@ void compress_block(s, ltree, dtree)
     const ct_data *ltree;
     const ct_data *dtree;
 //CHECK: void compress_block(_Ptr<deflate_state> s, _Ptr<const ct_data> ltree, _Ptr<const ct_data> dtree)
- { }
+{}
+
+// clang-format on

clang/test/3C/liberal_itypes_fp.c

@@ -108,9 +108,7 @@ void fptr_itype_test(void) {
 }
 
 void fn_ptrptr(int **a) { *a = 1; }
-void fptr_ptrptr_test() {
-  void (*fn)(int **) = &fn_ptrptr;
-}
+void fptr_ptrptr_test() { void (*fn)(int **) = &fn_ptrptr; }
 //CHECK: void fn_ptrptr(int **a : itype(_Ptr<_Ptr<int>>)) { *a = 1; }
 //CHECK: void fptr_ptrptr_test() _Checked {
 //CHECK:   _Ptr<void (int ** : itype(_Ptr<_Ptr<int>>))> fn = &fn_ptrptr;

clang/test/3C/macro_function_call.c

@@ -17,10 +17,8 @@
 // Unsafe call in macro. This would require an _Assume_bounds_cast, but we
 // can't insert it.  Constraints are generated so that the cast isn't needed.
 
-#define macro0 \
-  void caller0(int *a) {\
-    fn0(a);\
-  }
+#define macro0                                                                 \
+  void caller0(int *a) { fn0(a); }
 void fn0(int *b) {}
 macro0
 
@@ -31,16 +29,21 @@ macro0
 //CHECK: void fn0(int *b) {}
 //CHECK: macro0
 
+// clang-format messes up this part of the file because it mistakes macro
+// references for other syntactic constructs.
+// clang-format off
 
-// Same as above, but the cast is requried on the return.
+// Same as above, but the cast is required on the return.
 
 #define macro1 fn1();
 int *fn1(void) { return 0; }
 void caller1() {
-  int *a = (int *) 1;
+  int *a = (int *)1;
   a = macro1
 }
 
+// clang-format on
+
 //CHECK: #define macro1 fn1();
 //CHECK: int *fn1(void) { return 0; }
 //CHECK: void caller1() {
@@ -53,22 +56,19 @@ void caller1() {
 
 #define macro2 fn2(a);
 void fn2(int *b) {}
-void caller2(int *a) {
-  macro2
-}
+void caller2(int *a) { macro2 }
 //CHECK: #define macro2 fn2(a);
 //CHECK: void fn2(_Ptr<int> b) _Checked {}
 //CHECK: void caller2(_Ptr<int> a) _Checked {
 //CHECK:   macro2
 //CHECK: }
 
-
 // Like the first test case, but pointer to a pointer.
 
 #define macro3 fn3(a);
 void fn3(int **g) {}
 void caller3() {
-  int **a = (int **) 1;
+  int **a = (int **)1;
   macro3
 }
 //CHECK: #define macro3 fn3(a);
@@ -83,8 +83,8 @@ void caller3() {
 void fn4a(int *g) {}
 void fn4b(int *g) {}
 void caller4() {
-  int *a = (int *) 1;
-  void (*fn)(int *) =  fn4a;
+  int *a = (int *)1;
+  void (*fn)(int *) = fn4a;
   if (0)
     fn = fn4b;
   macro4

clang/test/3C/merge_fp1_xfail.c

@@ -8,5 +8,5 @@
 // When this file is first it fails.
 
 // possible assert failure - nothing should merge into undeclared params
-int * primary_merge(int * (*secondary_merge)());
+int *primary_merge(int *(*secondary_merge)());
 // CHECK: _Ptr<int> primary_merge(_Ptr<_Ptr<int> (int *)> secondary_merge);

clang/test/3C/merge_fp2.c

@@ -5,12 +5,12 @@
 
 // When this file is first it succeeds, when second it fails.
 
-int * primary_merge(int * (*secondary_merge)(int*));
+int *primary_merge(int *(*secondary_merge)(int *));
 // CHECK: _Ptr<int> primary_merge(_Ptr<_Ptr<int> (int *)> secondary_merge);
 
 // need this to produce changes (0 is safe, and clang merged the declarations)
-int * primary_merge(int * (*secondary_merge)()) {
-// CHECK: _Ptr<int> primary_merge(_Ptr<_Ptr<int> (int *)> secondary_merge) {
+int *primary_merge(int *(*secondary_merge)()) {
+  // CHECK: _Ptr<int> primary_merge(_Ptr<_Ptr<int> (int *)> secondary_merge) {
 
   return ((*secondary_merge)(0));
 }

clang/test/3C/overconstrained_merge.c

@@ -4,8 +4,9 @@
 // RUN: 3c -base-dir=%S -output-dir=%t.checked -alltypes %s --
 // RUN: 3c -base-dir=%t.checked -alltypes %t.checked/overconstrained_merge.c -- | diff %t.checked/overconstrained_merge.c -
 
-// Test checks for merging a function after the generics code adds a constraint
-// The merge succeeds because it happens earlier in the codebase than the addition
+// Test checks for merging a function after the generics code adds a constraint.
+// The merge succeeds because it happens earlier in the codebase than the
+// addition.
 
 // This test only uses -alltypes because of the use of _Array_ptr in the example
 // (to distinguish from the _Ptr that will be added).

clang/test/3C/root_cause.c

@@ -50,4 +50,5 @@ void (*f)(void *); // expected-warning {{Default void* type}}
 typedef struct {
   int x;
   float f;
-} A, *PA; // expected-warning {{Unable to rewrite a typedef with multiple names}}
+} A, *PA;
+// expected-warning@-1 {{Unable to rewrite a typedef with multiple names}}

clang/test/3C/type_params_macro.c

@@ -8,9 +8,11 @@
 
 #define baz foo<int>(i);
 #define buz foo(i);
-#define buzzy foo(i); foo(j);
+#define buzzy                                                                  \
+  foo(i);                                                                      \
+  foo(j);
 
-_Itype_for_any(T) void foo(void *x  : itype(_Ptr<T>));
+_Itype_for_any(T) void foo(void *x : itype(_Ptr<T>));
 
 void test_none() {
   int *i = 0;
@@ -45,4 +47,3 @@ void test_two() {
 // CHECK:  int *i = 0;
 // CHECK:  int *j = 0;
 // CHECK:  buzzy
-

clang/test/3C/typedefs.c

@@ -31,7 +31,7 @@ intptr bar(intptr x) {
   return x;
 }
 
-typedef int* integer;
+typedef int *integer;
 //CHECK: typedef _Ptr<int> integer;
 int foo(void) {
   //CHECK: int foo(void) {
@@ -45,14 +45,13 @@ int foo(void) {
   bad b = (int *)3;
   //CHECK: bad b = (int *)3;
   badP b2 = (intptr *)3;
-    typedef int nat;
-    const nat z = 3;
-    const nat* cnstp = &z;
-    //CHECK: _Ptr<const nat> cnstp = &z;
-    int w = 34;
-    const integer c = &w;
-    //CHECK: const integer c = &w;
-
+  typedef int nat;
+  const nat z = 3;
+  const nat *cnstp = &z;
+  //CHECK: _Ptr<const nat> cnstp = &z;
+  int w = 34;
+  const integer c = &w;
+  //CHECK: const integer c = &w;
 
   return *p;
 }
@@ -75,14 +74,12 @@ void barfoo(intptr x) {
   *x = 5;
 }
 
-#define MYDECL typedef int* ZZZ;
+#define MYDECL typedef int *ZZZ;
 MYDECL
 void zzz(void) {
   int x = 3;
   ZZZ z = &x;
 }
-typedef int * * const a;
+typedef int **const a;
 //CHECK: typedef const _Ptr<_Ptr<int>> a;
-void xxx(void) {
-  a b;
-}
+void xxx(void) { a b; }