test/SemaCXX/blocks-1.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

// RUN: %clang_cc1 -fsyntax-only -verify %s -fblocks -std=c++1y

extern "C" int exit(int);

typedef struct {
    unsigned long ps[30];
    int qs[30];
} BobTheStruct;

int main (int argc, const char * argv[]) {
    BobTheStruct inny;
    BobTheStruct outty;
    BobTheStruct (^copyStruct)(BobTheStruct);
    int i;
    
    for(i=0; i<30; i++) {
        inny.ps[i] = i * i * i;
        inny.qs[i] = -i * i * i;
    }
    
    copyStruct = ^(BobTheStruct aBigStruct){ return aBigStruct; };  // pass-by-value intrinsically copies the argument
    
    outty = copyStruct(inny);

    if ( &inny == &outty ) {
        exit(1);
    }
    for(i=0; i<30; i++) {
        if ( (inny.ps[i] != outty.ps[i]) || (inny.qs[i] != outty.qs[i]) ) {
            exit(1);
        }
    }
    
    return 0;
}

namespace rdar8134521 {
  void foo() {
    int (^P)(int) = reinterpret_cast<int(^)(int)>(1);
    P = (int(^)(int))(1);
    
    P = reinterpret_cast<int(^)(int)>((void*)1);
    P = (int(^)(int))((void*)1);
  }
}

namespace rdar11055105 {
  struct A {
    void foo();
  };

  template <class T> void foo(T &x) noexcept(noexcept(x.foo()));

  void (^block)() = ^{
    A a;
    foo(a);
  };
}

namespace LocalDecls {
  void f() {
    (void) ^{
      extern int a; // expected-note {{previous}}
      extern int b(); // expected-note {{previous}}
    };
  }
  void g() {
    (void) ^{
      extern float a; // expected-error {{different type}}
      extern float b(); // expected-error {{cannot be overloaded}}
    };
  }
}