// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -Wthread-safety-negative -fcxx-exceptions -DUSE_CAPABILITY=0 %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -Wthread-safety-negative -fcxx-exceptions -DUSE_CAPABILITY=1 %s

// FIXME: should also run  %clang_cc1 -fsyntax-only -verify -Wthread-safety -std=c++11 -Wc++98-compat %s
// FIXME: should also run  %clang_cc1 -fsyntax-only -verify -Wthread-safety %s

#include "thread-safety-annotations.h"

class LOCKABLE Mutex {
 public:
  void Lock() EXCLUSIVE_LOCK_FUNCTION();
  void ReaderLock() SHARED_LOCK_FUNCTION();
  void Unlock() UNLOCK_FUNCTION();
  bool TryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true);
  bool ReaderTryLock() SHARED_TRYLOCK_FUNCTION(true);

  // for negative capabilities
  const Mutex& operator!() const { return *this; }

  void AssertHeld()       ASSERT_EXCLUSIVE_LOCK();
  void AssertReaderHeld() ASSERT_SHARED_LOCK();
};

class LOCKABLE REENTRANT_CAPABILITY ReentrantMutex {
public:
  void Lock() EXCLUSIVE_LOCK_FUNCTION();
  void Unlock() UNLOCK_FUNCTION();

  // for negative capabilities
  const ReentrantMutex& operator!() const { return *this; }
};

class SCOPED_LOCKABLE MutexLock {
public:
  MutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu);
  MutexLock(Mutex *mu, bool adopt) EXCLUSIVE_LOCKS_REQUIRED(mu);
  ~MutexLock() UNLOCK_FUNCTION();
};

namespace SimpleTest {

class Bar {
  Mutex mu;
  int a GUARDED_BY(mu);

public:
  void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
    mu.Lock();
    a = 0;
    mu.Unlock();
  }
};


class Foo {
  Mutex mu;
  int a GUARDED_BY(mu);

public:
  void foo() {
    mu.Lock();    // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}}
    baz();        // expected-warning {{cannot call function 'baz' while mutex 'mu' is held}}
    bar();
    mu.Unlock();
  }

  void bar() {
    baz();        // expected-warning {{calling function 'baz' requires negative capability '!mu'}}
  }

  void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
    mu.Lock();
    a = 0;
    mu.Unlock();
  }

  void test() {
    Bar b;
    b.baz();     // no warning -- in different class.
  }

  void test2() {
    mu.Lock();   // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}}
    a = 0;
    mu.Unlock();
    baz();       // no warning -- !mu in set.
  }

  void test3() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
    mu.Lock();
    a = 0;
    mu.Unlock();
    baz();       // no warning -- !mu in set.
  }

  void test4() {
    MutexLock lock(&mu); // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}}
  }
};

class Reentrant {
  ReentrantMutex mu;

public:
  void acquire() {
    mu.Lock();   // no warning -- reentrant mutex
    mu.Unlock();
  }

  void requireNegative() EXCLUSIVE_LOCKS_REQUIRED(!mu) { // warning?
    mu.Lock();
    mu.Unlock();
  }

  void callRequireNegative() {
    requireNegative(); // expected-warning{{calling function 'requireNegative' requires negative capability '!mu'}}
  }

  void callHaveNegative() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
    requireNegative();
  }
};

}  // end namespace SimpleTest

Mutex globalMutex;

namespace ScopeTest {

void f() EXCLUSIVE_LOCKS_REQUIRED(!globalMutex);
void fq() EXCLUSIVE_LOCKS_REQUIRED(!::globalMutex);

namespace ns {
  Mutex globalMutex;
  void f() EXCLUSIVE_LOCKS_REQUIRED(!globalMutex);
  void fq() EXCLUSIVE_LOCKS_REQUIRED(!ns::globalMutex);
}

void testGlobals() EXCLUSIVE_LOCKS_REQUIRED(!ns::globalMutex) {
  f();     // expected-warning {{calling function 'f' requires negative capability '!globalMutex'}}
  fq();    // expected-warning {{calling function 'fq' requires negative capability '!globalMutex'}}
  ns::f();
  ns::fq();
}

void testNamespaceGlobals() EXCLUSIVE_LOCKS_REQUIRED(!globalMutex) {
  f();
  fq();
  ns::f();  // expected-warning {{calling function 'f' requires negative capability '!globalMutex'}}
  ns::fq(); // expected-warning {{calling function 'fq' requires negative capability '!globalMutex'}}
}

class StaticMembers {
public:
  void pub() EXCLUSIVE_LOCKS_REQUIRED(!publicMutex);
  void prot() EXCLUSIVE_LOCKS_REQUIRED(!protectedMutex);
  void priv() EXCLUSIVE_LOCKS_REQUIRED(!privateMutex);
  void test() {
    pub();
    prot();
    priv();
  }

  static Mutex publicMutex;

protected:
  static Mutex protectedMutex;

private:
  static Mutex privateMutex;
};

void testStaticMembers() {
  StaticMembers x;
  x.pub();
  x.prot();
  x.priv();
}

}  // end namespace ScopeTest

namespace DoubleAttribute {

struct Foo {
  Mutex &mutex();
};

template <typename A>
class TemplateClass {
  template <typename B>
  static void Function(Foo *F)
      EXCLUSIVE_LOCKS_REQUIRED(F->mutex()) UNLOCK_FUNCTION(F->mutex()) {}
};

void test() { TemplateClass<int> TC; }

}  // end namespace DoubleAttribute
