Add m-esr52 at 52.6.0

34 files changed, 3455 insertions, 0 deletions

diff --git a/build/clang-plugin/tests/Makefile.in b/build/clang-plugin/tests/Makefile.in
new file mode 100644
index 000000000..74faf065c
--- /dev/null
+++ b/build/clang-plugin/tests/Makefile.in
@@ -0,0 +1,18 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# Build without any warning flags, and with clang verify flag for a
+# syntax-only build (no codegen), without a limit on the number of errors.
+OS_CFLAGS := $(filter-out -W%,$(OS_CFLAGS)) -fsyntax-only -Xclang -verify -ferror-limit=0 -std=c11
+OS_CXXFLAGS := $(filter-out -W%,$(OS_CXXFLAGS)) -fsyntax-only -Xclang -verify -ferror-limit=0
+
+include $(topsrcdir)/config/rules.mk
+
+target:: $(OBJS)
+
+# We don't actually build anything.
+.PHONY: $(OBJS)
+
+# Don't actually build a library, since we don't actually build objects.
+$(LIBRARY): EXPAND_LIBS_GEN=true
diff --git a/build/clang-plugin/tests/NonParameterTestCases.h b/build/clang-plugin/tests/NonParameterTestCases.h
new file mode 100644
index 000000000..d38a14d94
--- /dev/null
+++ b/build/clang-plugin/tests/NonParameterTestCases.h
@@ -0,0 +1,61 @@
+MAYBE_STATIC void raw(Param x) {}
+
+MAYBE_STATIC void raw(NonParam x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void raw(NonParamUnion x) {} //expected-error {{Type 'NonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void raw(NonParamClass x) {} //expected-error {{Type 'NonParamClass' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void raw(NonParamEnum x) {} //expected-error {{Type 'NonParamEnum' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void raw(NonParamEnumClass x) {} //expected-error {{Type 'NonParamEnumClass' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void raw(HasNonParamStruct x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void raw(HasNonParamUnion x) {} //expected-error {{Type 'HasNonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void raw(HasNonParamStructUnion x) {} //expected-error {{Type 'HasNonParamStructUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+
+MAYBE_STATIC void const_(const NonParam x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void const_(const NonParamUnion x) {} //expected-error {{Type 'NonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void const_(const NonParamClass x) {} //expected-error {{Type 'NonParamClass' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void const_(const NonParamEnum x) {} //expected-error {{Type 'NonParamEnum' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void const_(const NonParamEnumClass x) {} //expected-error {{Type 'NonParamEnumClass' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void const_(const HasNonParamStruct x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void const_(const HasNonParamUnion x) {} //expected-error {{Type 'HasNonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC void const_(const HasNonParamStructUnion x) {} //expected-error {{Type 'HasNonParamStructUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+
+MAYBE_STATIC void array(NonParam x[]) {}
+MAYBE_STATIC void array(NonParamUnion x[]) {}
+MAYBE_STATIC void array(NonParamClass x[]) {}
+MAYBE_STATIC void array(NonParamEnum x[]) {}
+MAYBE_STATIC void array(NonParamEnumClass x[]) {}
+MAYBE_STATIC void array(HasNonParamStruct x[]) {}
+MAYBE_STATIC void array(HasNonParamUnion x[]) {}
+MAYBE_STATIC void array(HasNonParamStructUnion x[]) {}
+
+MAYBE_STATIC void ptr(NonParam* x) {}
+MAYBE_STATIC void ptr(NonParamUnion* x) {}
+MAYBE_STATIC void ptr(NonParamClass* x) {}
+MAYBE_STATIC void ptr(NonParamEnum* x) {}
+MAYBE_STATIC void ptr(NonParamEnumClass* x) {}
+MAYBE_STATIC void ptr(HasNonParamStruct* x) {}
+MAYBE_STATIC void ptr(HasNonParamUnion* x) {}
+MAYBE_STATIC void ptr(HasNonParamStructUnion* x) {}
+
+MAYBE_STATIC void ref(NonParam& x) {}
+MAYBE_STATIC void ref(NonParamUnion& x) {}
+MAYBE_STATIC void ref(NonParamClass& x) {}
+MAYBE_STATIC void ref(NonParamEnum& x) {}
+MAYBE_STATIC void ref(NonParamEnumClass& x) {}
+MAYBE_STATIC void ref(HasNonParamStruct& x) {}
+MAYBE_STATIC void ref(HasNonParamUnion& x) {}
+MAYBE_STATIC void ref(HasNonParamStructUnion& x) {}
+
+MAYBE_STATIC void constRef(const NonParam& x) {}
+MAYBE_STATIC void constRef(const NonParamUnion& x) {}
+MAYBE_STATIC void constRef(const NonParamClass& x) {}
+MAYBE_STATIC void constRef(const NonParamEnum& x) {}
+MAYBE_STATIC void constRef(const NonParamEnumClass& x) {}
+MAYBE_STATIC void constRef(const HasNonParamStruct& x) {}
+MAYBE_STATIC void constRef(const HasNonParamUnion& x) {}
+MAYBE_STATIC void constRef(const HasNonParamStructUnion& x) {}
+
+MAYBE_STATIC inline void inlineRaw(NonParam x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC inline void inlineRaw(NonParamUnion x) {} //expected-error {{Type 'NonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC inline void inlineRaw(NonParamClass x) {} //expected-error {{Type 'NonParamClass' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC inline void inlineRaw(NonParamEnum x) {} //expected-error {{Type 'NonParamEnum' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+MAYBE_STATIC inline void inlineRaw(NonParamEnumClass x) {} //expected-error {{Type 'NonParamEnumClass' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
diff --git a/build/clang-plugin/tests/TestAssertWithAssignment.cpp b/build/clang-plugin/tests/TestAssertWithAssignment.cpp
new file mode 100644
index 000000000..f0f049e4a
--- /dev/null
+++ b/build/clang-plugin/tests/TestAssertWithAssignment.cpp
@@ -0,0 +1,68 @@
+#include "mozilla/MacroArgs.h"
+
+static __attribute__((always_inline)) bool MOZ_AssertAssignmentTest(bool expr) {
+  return expr;
+}
+
+#define MOZ_UNLIKELY(x) (__builtin_expect(!!(x), 0))
+#define MOZ_CRASH() do { } while(0)
+#define MOZ_CHECK_ASSERT_ASSIGNMENT(expr) MOZ_AssertAssignmentTest(!!(expr))
+
+#define MOZ_ASSERT_HELPER1(expr) \
+  do { \
+    if (MOZ_UNLIKELY(!MOZ_CHECK_ASSERT_ASSIGNMENT(expr))) { \
+      MOZ_CRASH();\
+    } \
+  } while(0) \
+
+/* Now the two-argument form. */
+#define MOZ_ASSERT_HELPER2(expr, explain) \
+  do { \
+    if (MOZ_UNLIKELY(!MOZ_CHECK_ASSERT_ASSIGNMENT(expr))) { \
+      MOZ_CRASH();\
+    } \
+  } while(0) \
+
+#define MOZ_RELEASE_ASSERT_GLUE(a, b) a b
+#define MOZ_RELEASE_ASSERT(...) \
+  MOZ_RELEASE_ASSERT_GLUE( \
+    MOZ_PASTE_PREFIX_AND_ARG_COUNT(MOZ_ASSERT_HELPER, __VA_ARGS__), \
+    (__VA_ARGS__))
+
+#define MOZ_ASSERT(...) MOZ_RELEASE_ASSERT(__VA_ARGS__)
+
+void FunctionTest(int p) {
+  MOZ_ASSERT(p = 1); // expected-error {{Forbidden assignment in assert expression}}
+}
+
+void FunctionTest2(int p) {
+  MOZ_ASSERT(((p = 1)));  // expected-error {{Forbidden assignment in assert expression}}
+}
+
+void FunctionTest3(int p) {
+  MOZ_ASSERT(p != 3);
+}
+
+class TestOverloading {
+  int value;
+public:
+  explicit TestOverloading(int _val) : value(_val) {}
+  // different operators
+  explicit operator bool() const { return true; }
+  TestOverloading& operator=(const int _val) { value = _val; return *this; }
+
+  int& GetInt() {return value;}
+};
+
+void TestOverloadingFunc() {
+  TestOverloading p(2);
+  int f;
+
+  MOZ_ASSERT(p);
+  MOZ_ASSERT(p = 3); // expected-error {{Forbidden assignment in assert expression}}
+  MOZ_ASSERT(p, "p is not valid");
+  MOZ_ASSERT(p = 3, "p different than 3"); // expected-error {{Forbidden assignment in assert expression}}
+  MOZ_ASSERT(p.GetInt() = 2); // expected-error {{Forbidden assignment in assert expression}}
+  MOZ_ASSERT(p.GetInt() == 2);
+  MOZ_ASSERT(p.GetInt() == 2, f = 3);
+}
diff --git a/build/clang-plugin/tests/TestBadImplicitConversionCtor.cpp b/build/clang-plugin/tests/TestBadImplicitConversionCtor.cpp
new file mode 100644
index 000000000..ca2472582
--- /dev/null
+++ b/build/clang-plugin/tests/TestBadImplicitConversionCtor.cpp
@@ -0,0 +1,50 @@
+#define MOZ_IMPLICIT __attribute__((annotate("moz_implicit")))
+
+struct Foo {
+  Foo(int); // expected-error {{bad implicit conversion constructor for 'Foo'}} expected-note {{consider adding the explicit keyword to the constructor}}
+  Foo(int, char=0); // expected-error {{bad implicit conversion constructor for 'Foo'}} expected-note {{consider adding the explicit keyword to the constructor}}
+  Foo(...); // expected-error {{bad implicit conversion constructor for 'Foo'}} expected-note {{consider adding the explicit keyword to the constructor}}
+  template<class T>
+  Foo(float); // expected-error {{bad implicit conversion constructor for 'Foo'}} expected-note {{consider adding the explicit keyword to the constructor}}
+  Foo(int, unsigned);
+  Foo(Foo&);
+  Foo(const Foo&);
+  Foo(volatile Foo&);
+  Foo(const volatile Foo&);
+  Foo(Foo&&);
+  Foo(const Foo&&);
+  Foo(volatile Foo&&);
+  Foo(const volatile Foo&&);
+};
+
+struct Bar {
+  explicit Bar(int);
+  explicit Bar(int, char=0);
+  explicit Bar(...);
+};
+
+struct Baz {
+  MOZ_IMPLICIT Baz(int);
+  MOZ_IMPLICIT Baz(int, char=0);
+  MOZ_IMPLICIT Baz(...);
+};
+
+struct Barn {
+  Barn(int) = delete;
+  Barn(int, char=0) = delete;
+  Barn(...) = delete;
+};
+
+struct Abstract {
+  Abstract(int);
+  Abstract(int, char=0);
+  Abstract(...);
+  virtual void f() = 0;
+};
+
+template<class T>
+struct Template {
+  Template(int); // expected-error {{bad implicit conversion constructor for 'Template'}} expected-note {{consider adding the explicit keyword to the constructor}}
+  template<class U>
+  Template(float); // expected-error {{bad implicit conversion constructor for 'Template'}} expected-note {{consider adding the explicit keyword to the constructor}}
+};
diff --git a/build/clang-plugin/tests/TestCustomHeap.cpp b/build/clang-plugin/tests/TestCustomHeap.cpp
new file mode 100644
index 000000000..9514ff2c4
--- /dev/null
+++ b/build/clang-plugin/tests/TestCustomHeap.cpp
@@ -0,0 +1,28 @@
+#define MOZ_NONHEAP_CLASS __attribute__((annotate("moz_nonheap_class")))
+#define MOZ_HEAP_ALLOCATOR \
+  _Pragma("GCC diagnostic push") \
+  _Pragma("GCC diagnostic ignored \"-Wgcc-compat\"") \
+  __attribute__((annotate("moz_heap_allocator"))) \
+  _Pragma("GCC diagnostic pop")
+
+#include <stdlib.h>
+#include <memory>
+
+struct MOZ_NONHEAP_CLASS X {
+};
+
+void *operator new(size_t x, int qual) MOZ_HEAP_ALLOCATOR {
+  return ::operator new(x);
+}
+
+template <typename T>
+T *customAlloc() MOZ_HEAP_ALLOCATOR {
+  T *arg =  static_cast<T*>(malloc(sizeof(T)));
+  return new (arg) T();
+}
+
+template <typename T>
+void misuseX(T q) {
+  X *foo = customAlloc<X>(); // expected-error {{variable of type 'X' is not valid on the heap}} expected-note {{value incorrectly allocated on the heap}}
+  X *foo2 = new (100) X(); // expected-error {{variable of type 'X' is not valid on the heap}} expected-note {{value incorrectly allocated on the heap}}
+}
diff --git a/build/clang-plugin/tests/TestExplicitOperatorBool.cpp b/build/clang-plugin/tests/TestExplicitOperatorBool.cpp
new file mode 100644
index 000000000..bc4b43a7d
--- /dev/null
+++ b/build/clang-plugin/tests/TestExplicitOperatorBool.cpp
@@ -0,0 +1,11 @@
+#define MOZ_IMPLICIT __attribute__((annotate("moz_implicit")))
+
+struct Bad {
+  operator bool(); // expected-error {{bad implicit conversion operator for 'Bad'}} expected-note {{consider adding the explicit keyword to 'operator bool'}}
+};
+struct Good {
+  explicit operator bool();
+};
+struct Okay {
+  MOZ_IMPLICIT operator bool();
+};
diff --git a/build/clang-plugin/tests/TestGlobalClass.cpp b/build/clang-plugin/tests/TestGlobalClass.cpp
new file mode 100644
index 000000000..1825b9707
--- /dev/null
+++ b/build/clang-plugin/tests/TestGlobalClass.cpp
@@ -0,0 +1,52 @@
+#define MOZ_GLOBAL_CLASS __attribute__((annotate("moz_global_class")))
+#include <stddef.h>
+
+struct MOZ_GLOBAL_CLASS Global {
+  int i;
+  void *operator new(size_t x) throw() { return 0; }
+  void *operator new(size_t blah, char *buffer) { return buffer; }
+};
+
+template <class T>
+struct MOZ_GLOBAL_CLASS TemplateClass {
+  T i;
+};
+
+void gobble(void *) { }
+
+void misuseGlobalClass(int len) {
+  Global notValid; // expected-error {{variable of type 'Global' only valid as global}} expected-note {{value incorrectly allocated in an automatic variable}}
+  Global alsoNotValid[2]; // expected-error {{variable of type 'Global [2]' only valid as global}} expected-note {{'Global [2]' is a global type because it is an array of global type 'Global'}} expected-note {{value incorrectly allocated in an automatic variable}}
+  static Global valid;
+  static Global alsoValid[2];
+
+  gobble(&notValid);
+  gobble(&valid);
+  gobble(&alsoValid[0]);
+
+  gobble(new Global); // expected-error {{variable of type 'Global' only valid as global}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(new Global[10]); // expected-error {{variable of type 'Global' only valid as global}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(new TemplateClass<int>); // expected-error {{variable of type 'TemplateClass<int>' only valid as global}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(len <= 5 ? &valid : new Global); // expected-error {{variable of type 'Global' only valid as global}} expected-note {{value incorrectly allocated on the heap}}
+
+  char buffer[sizeof(Global)];
+  gobble(new (buffer) Global);
+}
+
+Global valid;
+struct RandomClass {
+  Global nonstaticMember; // expected-note {{'RandomClass' is a global type because member 'nonstaticMember' is a global type 'Global'}}
+  static Global staticMember;
+};
+struct MOZ_GLOBAL_CLASS RandomGlobalClass {
+  Global nonstaticMember;
+  static Global staticMember;
+};
+
+struct BadInherit : Global {}; // expected-note {{'BadInherit' is a global type because it inherits from a global type 'Global'}}
+struct MOZ_GLOBAL_CLASS GoodInherit : Global {};
+
+void misuseGlobalClassEvenMore(int len) {
+  BadInherit moreInvalid; // expected-error {{variable of type 'BadInherit' only valid as global}} expected-note {{value incorrectly allocated in an automatic variable}}
+  RandomClass evenMoreInvalid; // expected-error {{variable of type 'RandomClass' only valid as global}} expected-note {{value incorrectly allocated in an automatic variable}}
+}
diff --git a/build/clang-plugin/tests/TestHeapClass.cpp b/build/clang-plugin/tests/TestHeapClass.cpp
new file mode 100644
index 000000000..36e762973
--- /dev/null
+++ b/build/clang-plugin/tests/TestHeapClass.cpp
@@ -0,0 +1,64 @@
+#define MOZ_HEAP_CLASS __attribute__((annotate("moz_heap_class")))
+#define MOZ_IMPLICIT __attribute__((annotate("moz_implicit")))
+
+#include <stddef.h>
+
+struct MOZ_HEAP_CLASS Heap {
+  int i;
+  Heap() {}
+  MOZ_IMPLICIT Heap(int a) {}
+  Heap(int a, int b) {}
+  void *operator new(size_t x) throw() { return 0; }
+  void *operator new(size_t blah, char *buffer) { return buffer; }
+};
+
+template <class T>
+struct MOZ_HEAP_CLASS TemplateClass {
+  T i;
+};
+
+void gobble(void *) { }
+
+void gobbleref(const Heap&) { }
+
+void misuseHeapClass(int len) {
+  Heap invalid; // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in an automatic variable}}
+  Heap alsoInvalid[2]; // expected-error {{variable of type 'Heap [2]' only valid on the heap}} expected-note {{value incorrectly allocated in an automatic variable}} expected-note {{'Heap [2]' is a heap type because it is an array of heap type 'Heap'}}
+  static Heap invalidStatic; // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a global variable}}
+  static Heap alsoInvalidStatic[2]; // expected-error {{variable of type 'Heap [2]' only valid on the heap}} expected-note {{value incorrectly allocated in a global variable}} expected-note {{'Heap [2]' is a heap type because it is an array of heap type 'Heap'}}
+
+  gobble(&invalid);
+  gobble(&invalidStatic);
+  gobble(&alsoInvalid[0]);
+
+  gobbleref(Heap()); // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a temporary}}
+  gobbleref(Heap(10, 20)); // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a temporary}}
+  gobbleref(Heap(10)); // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a temporary}}
+  gobbleref(10); // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a temporary}}
+
+  gobble(new Heap);
+  gobble(new Heap[10]);
+  gobble(new TemplateClass<int>);
+  gobble(len <= 5 ? &invalid : new Heap);
+
+  char buffer[sizeof(Heap)];
+  gobble(new (buffer) Heap);
+}
+
+Heap invalidStatic; // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a global variable}}
+struct RandomClass {
+  Heap nonstaticMember; // expected-note {{'RandomClass' is a heap type because member 'nonstaticMember' is a heap type 'Heap'}}
+  static Heap staticMember; // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a global variable}}
+};
+struct MOZ_HEAP_CLASS RandomHeapClass {
+  Heap nonstaticMember;
+  static Heap staticMember; // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a global variable}}
+};
+
+struct BadInherit : Heap {}; // expected-note {{'BadInherit' is a heap type because it inherits from a heap type 'Heap'}}
+struct MOZ_HEAP_CLASS GoodInherit : Heap {};
+
+void useStuffWrongly() {
+  BadInherit i; // expected-error {{variable of type 'BadInherit' only valid on the heap}} expected-note {{value incorrectly allocated in an automatic variable}}
+  RandomClass r; // expected-error {{variable of type 'RandomClass' only valid on the heap}} expected-note {{value incorrectly allocated in an automatic variable}}
+}
diff --git a/build/clang-plugin/tests/TestInheritTypeAnnotationsFromTemplateArgs.cpp b/build/clang-plugin/tests/TestInheritTypeAnnotationsFromTemplateArgs.cpp
new file mode 100644
index 000000000..a46ff39fd
--- /dev/null
+++ b/build/clang-plugin/tests/TestInheritTypeAnnotationsFromTemplateArgs.cpp
@@ -0,0 +1,46 @@
+#define MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS                 \
+  __attribute__((annotate("moz_inherit_type_annotations_from_template_args")))
+#define MOZ_STACK_CLASS __attribute__((annotate("moz_stack_class")))
+#define MOZ_NON_MEMMOVABLE __attribute__((annotate("moz_non_memmovable")))
+#define MOZ_NEEDS_MEMMOVABLE_TYPE __attribute__((annotate("moz_needs_memmovable_type")))
+
+class Normal {};
+class MOZ_STACK_CLASS Stack {};
+class IndirectStack : Stack {}; // expected-note {{'IndirectStack' is a stack type because it inherits from a stack type 'Stack'}}
+class ContainsStack { Stack m; }; // expected-note {{'ContainsStack' is a stack type because member 'm' is a stack type 'Stack'}}
+class MOZ_NON_MEMMOVABLE Pointery {};
+class IndirectPointery : Pointery {}; // expected-note {{'IndirectPointery' is a non-memmove()able type because it inherits from a non-memmove()able type 'Pointery'}}
+class ContainsPointery { Pointery m; }; // expected-note {{'ContainsPointery' is a non-memmove()able type because member 'm' is a non-memmove()able type 'Pointery'}}
+
+template<class T>
+class MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS Template {}; // expected-note-re 5 {{'Template<{{.*}}>' is a stack type because it has a template argument stack type '{{.*}}'}} expected-note-re 5 {{'Template<{{.*}}>' is a non-memmove()able type because it has a template argument non-memmove()able type '{{.*}}'}}
+class IndirectTemplate : Template<Stack> {}; // expected-note {{'IndirectTemplate' is a stack type because it inherits from a stack type 'Template<Stack>'}}
+class ContainsTemplate { Template<Stack> m; }; // expected-note {{'ContainsTemplate' is a stack type because member 'm' is a stack type 'Template<Stack>'}}
+
+static Template<Stack> a; // expected-error {{variable of type 'Template<Stack>' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+static Template<IndirectStack> b; // expected-error {{variable of type 'Template<IndirectStack>' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+static Template<ContainsStack> c; // expected-error {{variable of type 'Template<ContainsStack>' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+static IndirectTemplate d; // expected-error {{variable of type 'IndirectTemplate' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+static ContainsTemplate e; // expected-error {{variable of type 'ContainsTemplate' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+static Template<Normal> f;
+
+template<class T>
+class MOZ_NEEDS_MEMMOVABLE_TYPE Mover { // expected-error-re 8 {{Cannot instantiate 'Mover<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+  char mForceInstantiation[sizeof(T)];
+};
+class IndirectTemplatePointery : Template<Pointery> {}; // expected-note {{'IndirectTemplatePointery' is a non-memmove()able type because it inherits from a non-memmove()able type 'Template<Pointery>'}}
+class ContainsTemplatePointery { Template<Pointery> m; }; // expected-note {{'ContainsTemplatePointery' is a non-memmove()able type because member 'm' is a non-memmove()able type 'Template<Pointery>'}}
+
+static Mover<Template<Pointery>> n; // expected-note {{instantiation of 'Mover<Template<Pointery> >' requested here}}
+static Mover<Template<IndirectPointery>> o; // expected-note {{instantiation of 'Mover<Template<IndirectPointery> >' requested here}}
+static Mover<Template<ContainsPointery>> p; // expected-note {{instantiation of 'Mover<Template<ContainsPointery> >' requested here}}
+static Mover<IndirectTemplatePointery> q; // expected-note {{instantiation of 'Mover<IndirectTemplatePointery>' requested here}}
+static Mover<ContainsTemplatePointery> r; // expected-note {{instantiation of 'Mover<ContainsTemplatePointery>' requested here}}
+static Mover<Template<Normal>> s;
+
+template<class T, class... Ts>
+class MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS ManyTs {}; // expected-note-re 3 {{'ManyTs<{{.*}}>' is a non-memmove()able type because it has a template argument non-memmove()able type '{{.*}}'}}
+
+static Mover<ManyTs<Pointery>> t; // expected-note {{instantiation of 'Mover<ManyTs<Pointery> >' requested here}}
+static Mover<ManyTs<Normal, Pointery>> u; // expected-note {{instantiation of 'Mover<ManyTs<Normal, Pointery> >' requested here}}
+static Mover<ManyTs<Normal, Normal, Pointery>> v; // expected-note {{instantiation of 'Mover<ManyTs<Normal, Normal, Pointery> >' requested here}}
diff --git a/build/clang-plugin/tests/TestKungFuDeathGrip.cpp b/build/clang-plugin/tests/TestKungFuDeathGrip.cpp
new file mode 100644
index 000000000..0b94d8a88
--- /dev/null
+++ b/build/clang-plugin/tests/TestKungFuDeathGrip.cpp
@@ -0,0 +1,107 @@
+#define MOZ_IMPLICIT __attribute__((annotate("moz_implicit")))
+
+template <typename T>
+class already_AddRefed {
+public:
+  already_AddRefed();
+  T* mPtr;
+};
+
+template <typename T>
+class RefPtr {
+public:
+  RefPtr();
+  MOZ_IMPLICIT RefPtr(T* aIn);
+  MOZ_IMPLICIT RefPtr(already_AddRefed<T> aIn);
+  ~RefPtr();
+  T* mPtr;
+};
+
+template <typename T>
+class nsCOMPtr {
+public:
+  nsCOMPtr();
+  MOZ_IMPLICIT nsCOMPtr(T* aIn);
+  MOZ_IMPLICIT nsCOMPtr(already_AddRefed<T> aIn);
+  ~nsCOMPtr();
+  T* mPtr;
+};
+
+class Type {
+public:
+  static nsCOMPtr<Type> someStaticCOMPtr;
+
+  void f(nsCOMPtr<Type> ignoredArgument, Type *param) {
+    nsCOMPtr<Type> never_referenced;
+    nsCOMPtr<Type> kfdg_t1(this);
+    nsCOMPtr<Type> kfdg_t2 = this;
+
+    nsCOMPtr<Type> kfdg_m1(p); // expected-error {{Unused "kungFuDeathGrip" 'nsCOMPtr<Type>' objects constructed from members are prohibited}} expected-note {{Please switch all accesses to this member to go through 'kfdg_m1', or explicitly pass 'kfdg_m1' to `mozilla::Unused`}}
+    nsCOMPtr<Type> kfdg_m2 = p; // expected-error {{Unused "kungFuDeathGrip" 'nsCOMPtr<Type>' objects constructed from members are prohibited}} expected-note {{Please switch all accesses to this member to go through 'kfdg_m2', or explicitly pass 'kfdg_m2' to `mozilla::Unused`}}
+    nsCOMPtr<Type> kfdg_m3(p);
+    kfdg_m3.mPtr->f(nullptr, nullptr);
+    nsCOMPtr<Type> kfdg_m4 = p;
+    kfdg_m4.mPtr->f(nullptr, nullptr);
+
+    nsCOMPtr<Type> kfdg_a1((already_AddRefed<Type>()));
+    nsCOMPtr<Type> kfdg_a2 = already_AddRefed<Type>();
+
+    nsCOMPtr<Type> kfdg_p1(param);
+    nsCOMPtr<Type> kfdg_p2 = param;
+
+
+    RefPtr<Type> never_referenced2;
+    RefPtr<Type> kfdg_t3(this);
+    RefPtr<Type> kfdg_t4 = this;
+
+    RefPtr<Type> kfdg_m5(p); // expected-error {{Unused "kungFuDeathGrip" 'RefPtr<Type>' objects constructed from members are prohibited}} expected-note {{Please switch all accesses to this member to go through 'kfdg_m5', or explicitly pass 'kfdg_m5' to `mozilla::Unused`}}
+    RefPtr<Type> kfdg_m6 = p; // expected-error {{Unused "kungFuDeathGrip" 'RefPtr<Type>' objects constructed from members are prohibited}} expected-note {{Please switch all accesses to this member to go through 'kfdg_m6', or explicitly pass 'kfdg_m6' to `mozilla::Unused`}}
+    RefPtr<Type> kfdg_m7(p);
+    kfdg_m7.mPtr->f(nullptr, nullptr);
+    RefPtr<Type> kfdg_m8 = p;
+    kfdg_m8.mPtr->f(nullptr, nullptr);
+
+    RefPtr<Type> kfdg_a3((already_AddRefed<Type>()));
+    RefPtr<Type> kfdg_a4 = already_AddRefed<Type>();
+
+    RefPtr<Type> kfdg_p3(param);
+    RefPtr<Type> kfdg_p4 = param;
+  }
+
+  Type *p;
+};
+
+void f(nsCOMPtr<Type> ignoredArgument, Type *param) {
+  nsCOMPtr<Type> never_referenced;
+  Type t;
+  // Type *p = nullptr;
+  nsCOMPtr<Type> kfdg_m1(t.p); // expected-error {{Unused "kungFuDeathGrip" 'nsCOMPtr<Type>' objects constructed from members are prohibited}} expected-note {{Please switch all accesses to this member to go through 'kfdg_m1', or explicitly pass 'kfdg_m1' to `mozilla::Unused`}}
+  nsCOMPtr<Type> kfdg_m2 = t.p; // expected-error {{Unused "kungFuDeathGrip" 'nsCOMPtr<Type>' objects constructed from members are prohibited}} expected-note {{Please switch all accesses to this member to go through 'kfdg_m2', or explicitly pass 'kfdg_m2' to `mozilla::Unused`}}
+  nsCOMPtr<Type> kfdg_m3(t.p);
+  kfdg_m3.mPtr->f(nullptr, nullptr);
+  nsCOMPtr<Type> kfdg_m4 = t.p;
+  kfdg_m4.mPtr->f(nullptr, nullptr);
+
+  nsCOMPtr<Type> kfdg_a1((already_AddRefed<Type>()));
+  nsCOMPtr<Type> kfdg_a2 = already_AddRefed<Type>();
+
+  nsCOMPtr<Type> kfdg_p1(param);
+  nsCOMPtr<Type> kfdg_p2 = param;
+
+
+  RefPtr<Type> never_referenced2;
+  RefPtr<Type> kfdg_m5(t.p); // expected-error {{Unused "kungFuDeathGrip" 'RefPtr<Type>' objects constructed from members are prohibited}} expected-note {{Please switch all accesses to this member to go through 'kfdg_m5', or explicitly pass 'kfdg_m5' to `mozilla::Unused`}}
+  RefPtr<Type> kfdg_m6 = t.p; // expected-error {{Unused "kungFuDeathGrip" 'RefPtr<Type>' objects constructed from members are prohibited}} expected-note {{Please switch all accesses to this member to go through 'kfdg_m6', or explicitly pass 'kfdg_m6' to `mozilla::Unused`}}
+  RefPtr<Type> kfdg_m7(t.p);
+  kfdg_m7.mPtr->f(nullptr, nullptr);
+  RefPtr<Type> kfdg_m8 = t.p;
+  kfdg_m8.mPtr->f(nullptr, nullptr);
+
+  RefPtr<Type> kfdg_a3((already_AddRefed<Type>()));
+  RefPtr<Type> kfdg_a4 = already_AddRefed<Type>();
+
+  RefPtr<Type> kfdg_p3(param);
+  RefPtr<Type> kfdg_p4 = param;
+}
+
+nsCOMPtr<Type> Type::someStaticCOMPtr(nullptr);
diff --git a/build/clang-plugin/tests/TestMultipleAnnotations.cpp b/build/clang-plugin/tests/TestMultipleAnnotations.cpp
new file mode 100644
index 000000000..aa927259d
--- /dev/null
+++ b/build/clang-plugin/tests/TestMultipleAnnotations.cpp
@@ -0,0 +1,17 @@
+#define MOZ_MUST_USE_TYPE __attribute__((annotate("moz_must_use_type")))
+#define MOZ_STACK_CLASS __attribute__((annotate("moz_stack_class")))
+
+class MOZ_MUST_USE_TYPE MOZ_STACK_CLASS TestClass {};
+
+TestClass foo; // expected-error {{variable of type 'TestClass' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+
+TestClass f()
+{
+  TestClass bar;
+  return bar;
+}
+
+void g()
+{
+  f(); // expected-error {{Unused value of must-use type 'TestClass'}}
+}
diff --git a/build/clang-plugin/tests/TestMustOverride.cpp b/build/clang-plugin/tests/TestMustOverride.cpp
new file mode 100644
index 000000000..8e053f6c2
--- /dev/null
+++ b/build/clang-plugin/tests/TestMustOverride.cpp
@@ -0,0 +1,63 @@
+#define MOZ_MUST_OVERRIDE __attribute__((annotate("moz_must_override")))
+// Ignore warnings not related to static analysis here
+#pragma GCC diagnostic ignored "-Woverloaded-virtual"
+
+struct S {
+  virtual void f() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+  virtual void g() MOZ_MUST_OVERRIDE;
+  virtual void h() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+};
+struct C : S { // expected-error {{'C' must override 'f'}} expected-error {{'C' must override 'h'}}
+  virtual void g() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+  virtual void h(int);
+  void q() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+};
+struct D : C { // expected-error {{'D' must override 'g'}} expected-error {{'D' must override 'q'}}
+  virtual void f();
+};
+
+struct Base {
+  virtual void VirtMethod() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+  void NonVirtMethod() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+  static void StaticMethod() MOZ_MUST_OVERRIDE;
+};
+
+struct DoesNotPropagate : Base {
+  virtual void VirtMethod();
+  void NonVirtMethod();
+  static void StaticMethod();
+};
+
+struct Final : DoesNotPropagate { };
+
+struct Propagates : Base {
+  virtual void VirtMethod() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+  void NonVirtMethod() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+  static void StaticMethod() MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+};
+
+struct FailsFinal : Propagates { }; // expected-error {{'FailsFinal' must override 'VirtMethod'}} expected-error {{'FailsFinal' must override 'NonVirtMethod'}} expected-error {{'FailsFinal' must override 'StaticMethod'}}
+
+struct WrongOverload : Base { // expected-error {{'WrongOverload' must override 'VirtMethod'}} expected-error {{'WrongOverload' must override 'NonVirtMethod'}}
+  virtual void VirtMethod() const;
+  void NonVirtMethod(int param);
+  static void StaticMethod();
+};
+
+namespace A { namespace B { namespace C {
+  struct Param {};
+  struct Base {
+    void f(Param p) MOZ_MUST_OVERRIDE; // expected-note {{function to override is here}}
+  };
+}}}
+
+struct Param {};
+
+struct Derived : A::B::C::Base {
+  typedef A::B::C::Param Typedef;
+  void f(Typedef t);
+};
+
+struct BadDerived : A::B::C::Base { // expected-error {{'BadDerived' must override 'f'}}
+  void f(Param p);
+};
diff --git a/build/clang-plugin/tests/TestMustUse.cpp b/build/clang-plugin/tests/TestMustUse.cpp
new file mode 100644
index 000000000..7878a4cde
--- /dev/null
+++ b/build/clang-plugin/tests/TestMustUse.cpp
@@ -0,0 +1,201 @@
+#define MOZ_MUST_USE_TYPE __attribute__((annotate("moz_must_use_type")))
+
+struct Temporary { ~Temporary(); };
+class MOZ_MUST_USE_TYPE MustUse {};
+class MayUse {};
+
+MustUse producesMustUse();
+MustUse *producesMustUsePointer();
+MustUse &producesMustUseRef();
+
+MustUse producesMustUse(const Temporary& t);
+MustUse *producesMustUsePointer(const Temporary& t);
+MustUse &producesMustUseRef(const Temporary& t);
+
+MayUse producesMayUse();
+MayUse *producesMayUsePointer();
+MayUse &producesMayUseRef();
+
+void use(MustUse*);
+void use(MustUse&);
+void use(MustUse&&);
+void use(MayUse*);
+void use(MayUse&);
+void use(MayUse&&);
+void use(bool);
+
+void foo() {
+  MustUse u;
+
+  producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  producesMustUsePointer();
+  producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  producesMayUse();
+  producesMayUsePointer();
+  producesMayUseRef();
+  u = producesMustUse();
+  u = producesMustUse(Temporary());
+  {
+    producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMustUsePointer();
+    producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMayUse();
+    producesMayUsePointer();
+    producesMayUseRef();
+    u = producesMustUse();
+    u = producesMustUse(Temporary());
+  }
+  if (true) {
+    producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMustUsePointer();
+    producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMayUse();
+    producesMayUsePointer();
+    producesMayUseRef();
+    u = producesMustUse();
+    u = producesMustUse(Temporary());
+  } else {
+    producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMustUsePointer();
+    producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMayUse();
+    producesMayUsePointer();
+    producesMayUseRef();
+    u = producesMustUse();
+    u = producesMustUse(Temporary());
+  }
+
+  if(true) producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  else producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  if(true) producesMustUsePointer();
+  else producesMustUsePointer();
+  if(true) producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  else producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  if(true) producesMayUse();
+  else producesMayUse();
+  if(true) producesMayUsePointer();
+  else producesMayUsePointer();
+  if(true) producesMayUseRef();
+  else producesMayUseRef();
+  if(true) u = producesMustUse();
+  else u = producesMustUse();
+  if(true) u = producesMustUse(Temporary());
+  else u = producesMustUse(Temporary());
+
+  while (true) producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  while (true) producesMustUsePointer();
+  while (true) producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  while (true) producesMayUse();
+  while (true) producesMayUsePointer();
+  while (true) producesMayUseRef();
+  while (true) u = producesMustUse();
+  while (true) u = producesMustUse(Temporary());
+
+  do producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  while (true);
+  do producesMustUsePointer();
+  while (true);
+  do producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  while (true);
+  do producesMayUse();
+  while (true);
+  do producesMayUsePointer();
+  while (true);
+  do producesMayUseRef();
+  while (true);
+  do u = producesMustUse();
+  while (true);
+  do u = producesMustUse(Temporary());
+  while (true);
+
+  for (;;) producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  for (;;) producesMustUsePointer();
+  for (;;) producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  for (;;) producesMayUse();
+  for (;;) producesMayUsePointer();
+  for (;;) producesMayUseRef();
+  for (;;) u = producesMustUse();
+  for (;;) u = producesMustUse(Temporary());
+
+  for (producesMustUse();;); // expected-error {{Unused value of must-use type 'MustUse'}}
+  for (producesMustUsePointer();;);
+  for (producesMustUseRef();;); // expected-error {{Unused value of must-use type 'MustUse'}}
+  for (producesMayUse();;);
+  for (producesMayUsePointer();;);
+  for (producesMayUseRef();;);
+  for (u = producesMustUse();;);
+  for (u = producesMustUse(Temporary());;);
+
+  for (;;producesMustUse()); // expected-error {{Unused value of must-use type 'MustUse'}}
+  for (;;producesMustUsePointer());
+  for (;;producesMustUseRef()); // expected-error {{Unused value of must-use type 'MustUse'}}
+  for (;;producesMayUse());
+  for (;;producesMayUsePointer());
+  for (;;producesMayUseRef());
+  for (;;u = producesMustUse());
+  for (;;u = producesMustUse(Temporary()));
+
+  use((producesMustUse(), false)); // expected-error {{Unused value of must-use type 'MustUse'}}
+  use((producesMustUsePointer(), false));
+  use((producesMustUseRef(), false)); // expected-error {{Unused value of must-use type 'MustUse'}}
+  use((producesMayUse(), false));
+  use((producesMayUsePointer(), false));
+  use((producesMayUseRef(), false));
+  use((u = producesMustUse(), false));
+  use((u = producesMustUse(Temporary()), false));
+
+  switch (1) {
+  case 1:
+    producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMustUsePointer();
+    producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMayUse();
+    producesMayUsePointer();
+    producesMayUseRef();
+    u = producesMustUse();
+    u = producesMustUse(Temporary());
+  case 2:
+    producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  case 3:
+    producesMustUsePointer();
+  case 4:
+    producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+  case 5:
+    producesMayUse();
+  case 6:
+    producesMayUsePointer();
+  case 7:
+    producesMayUseRef();
+  case 8:
+    u = producesMustUse();
+  case 9:
+    u = producesMustUse(Temporary());
+  default:
+    producesMustUse(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMustUsePointer();
+    producesMustUseRef(); // expected-error {{Unused value of must-use type 'MustUse'}}
+    producesMayUse();
+    producesMayUsePointer();
+    producesMayUseRef();
+    u = producesMustUse();
+    u = producesMustUse(Temporary());
+  }
+
+  use(producesMustUse());
+  use(producesMustUsePointer());
+  use(producesMustUseRef());
+  use(producesMayUse());
+  use(producesMayUsePointer());
+  use(producesMayUseRef());
+  use(u = producesMustUse());
+  use(u = producesMustUse(Temporary()));
+
+  MustUse a = producesMustUse();
+  MustUse *b = producesMustUsePointer();
+  MustUse &c = producesMustUseRef();
+  MayUse d = producesMayUse();
+  MayUse *e = producesMayUsePointer();
+  MayUse &f = producesMayUseRef();
+  MustUse g = u = producesMustUse();
+  MustUse h = u = producesMustUse(Temporary());
+}
diff --git a/build/clang-plugin/tests/TestNANTestingExpr.cpp b/build/clang-plugin/tests/TestNANTestingExpr.cpp
new file mode 100644
index 000000000..943577d4a
--- /dev/null
+++ b/build/clang-plugin/tests/TestNANTestingExpr.cpp
@@ -0,0 +1,16 @@
+void test(bool x);
+void foo() {
+  float f, f2;
+  typedef double mydouble;
+  mydouble d;
+  double d2;
+  test(f == f); // expected-error{{comparing a floating point value to itself for NaN checking can lead to incorrect results}} expected-note{{consider using mozilla::IsNaN instead}}
+  test(d == d); // expected-error{{comparing a floating point value to itself for NaN checking can lead to incorrect results}} expected-note{{consider using mozilla::IsNaN instead}}
+  test(f != f); // expected-error{{comparing a floating point value to itself for NaN checking can lead to incorrect results}} expected-note{{consider using mozilla::IsNaN instead}}
+  test(d != d); // expected-error{{comparing a floating point value to itself for NaN checking can lead to incorrect results}} expected-note{{consider using mozilla::IsNaN instead}}
+  test(f != d);
+  test(d == (d - f));
+  test(f == f2);
+  test(d == d2);
+  test(d + 1 == d);
+}
diff --git a/build/clang-plugin/tests/TestNANTestingExprC.c b/build/clang-plugin/tests/TestNANTestingExprC.c
new file mode 100644
index 000000000..ab2fead22
--- /dev/null
+++ b/build/clang-plugin/tests/TestNANTestingExprC.c
@@ -0,0 +1,17 @@
+/* expected-no-diagnostics */
+void test(int x);
+void foo() {
+  float f, f2;
+  typedef double mydouble;
+  mydouble d;
+  double d2;
+  test(f == f);
+  test(d == d);
+  test(f != f);
+  test(d != d);
+  test(f != d);
+  test(d == (d - f));
+  test(f == f2);
+  test(d == d2);
+  test(d + 1 == d);
+}
diff --git a/build/clang-plugin/tests/TestNeedsNoVTableType.cpp b/build/clang-plugin/tests/TestNeedsNoVTableType.cpp
new file mode 100644
index 000000000..531a1c82a
--- /dev/null
+++ b/build/clang-plugin/tests/TestNeedsNoVTableType.cpp
@@ -0,0 +1,94 @@
+#define MOZ_NEEDS_NO_VTABLE_TYPE __attribute__((annotate("moz_needs_no_vtable_type")))
+
+template <class T>
+struct MOZ_NEEDS_NO_VTABLE_TYPE PickyConsumer { // expected-error {{'PickyConsumer<B>' cannot be instantiated because 'B' has a VTable}} expected-error {{'PickyConsumer<E>' cannot be instantiated because 'E' has a VTable}} expected-error {{'PickyConsumer<F>' cannot be instantiated because 'F' has a VTable}} expected-error {{'PickyConsumer<G>' cannot be instantiated because 'G' has a VTable}}
+  T *m;
+};
+
+template <class T>
+struct MOZ_NEEDS_NO_VTABLE_TYPE PickyConsumer_A { // expected-error {{'PickyConsumer_A<B>' cannot be instantiated because 'B' has a VTable}} expected-error {{'PickyConsumer_A<E>' cannot be instantiated because 'E' has a VTable}} expected-error {{'PickyConsumer_A<F>' cannot be instantiated because 'F' has a VTable}} expected-error {{'PickyConsumer_A<G>' cannot be instantiated because 'G' has a VTable}}
+  T *m;
+};
+template <class T>
+struct PickyConsumerWrapper {
+  PickyConsumer_A<T> m; // expected-note {{bad instantiation of 'PickyConsumer_A<B>' requested here}} expected-note {{bad instantiation of 'PickyConsumer_A<E>' requested here}} expected-note {{bad instantiation of 'PickyConsumer_A<F>' requested here}} expected-note {{bad instantiation of 'PickyConsumer_A<G>' requested here}}
+};
+
+template <class T>
+struct MOZ_NEEDS_NO_VTABLE_TYPE PickyConsumer_B { // expected-error {{'PickyConsumer_B<B>' cannot be instantiated because 'B' has a VTable}} expected-error {{'PickyConsumer_B<E>' cannot be instantiated because 'E' has a VTable}} expected-error {{'PickyConsumer_B<F>' cannot be instantiated because 'F' has a VTable}} expected-error {{'PickyConsumer_B<G>' cannot be instantiated because 'G' has a VTable}}
+  T *m;
+};
+template <class T>
+struct PickyConsumerSubclass : PickyConsumer_B<T> {}; // expected-note {{bad instantiation of 'PickyConsumer_B<B>' requested here}} expected-note {{bad instantiation of 'PickyConsumer_B<E>' requested here}} expected-note {{bad instantiation of 'PickyConsumer_B<F>' requested here}} expected-note {{bad instantiation of 'PickyConsumer_B<G>' requested here}}
+
+template <class T>
+struct NonPickyConsumer {
+  T *m;
+};
+
+struct A {};
+struct B : virtual A {};
+struct C : A {};
+struct D {
+  void d();
+};
+struct E {
+  virtual void e();
+};
+struct F : E {
+  virtual void e() final;
+};
+struct G {
+  virtual void e() = 0;
+};
+
+void f() {
+  {
+    PickyConsumer<A> a1;
+    PickyConsumerWrapper<A> a2;
+    PickyConsumerSubclass<A> a3;
+    NonPickyConsumer<A> a4;
+  }
+
+  {
+    PickyConsumer<B> a1; // expected-note {{bad instantiation of 'PickyConsumer<B>' requested here}}
+    PickyConsumerWrapper<B> a2;
+    PickyConsumerSubclass<B> a3;
+    NonPickyConsumer<B> a4;
+  }
+
+  {
+    PickyConsumer<C> a1;
+    PickyConsumerWrapper<C> a2;
+    PickyConsumerSubclass<C> a3;
+    NonPickyConsumer<C> a4;
+  }
+
+  {
+    PickyConsumer<D> a1;
+    PickyConsumerWrapper<D> a2;
+    PickyConsumerSubclass<D> a3;
+    NonPickyConsumer<D> a4;
+  }
+
+  {
+    PickyConsumer<E> a1; // expected-note {{bad instantiation of 'PickyConsumer<E>' requested here}}
+    PickyConsumerWrapper<E> a2;
+    PickyConsumerSubclass<E> a3;
+    NonPickyConsumer<E> a4;
+  }
+
+  {
+    PickyConsumer<F> a1; // expected-note {{bad instantiation of 'PickyConsumer<F>' requested here}}
+    PickyConsumerWrapper<F> a2;
+    PickyConsumerSubclass<F> a3;
+    NonPickyConsumer<F> a4;
+  }
+
+  {
+    PickyConsumer<G> a1; // expected-note {{bad instantiation of 'PickyConsumer<G>' requested here}}
+    PickyConsumerWrapper<G> a2;
+    PickyConsumerSubclass<G> a3;
+    NonPickyConsumer<G> a4;
+  }
+}
diff --git a/build/clang-plugin/tests/TestNoAddRefReleaseOnReturn.cpp b/build/clang-plugin/tests/TestNoAddRefReleaseOnReturn.cpp
new file mode 100644
index 000000000..2e1f83377
--- /dev/null
+++ b/build/clang-plugin/tests/TestNoAddRefReleaseOnReturn.cpp
@@ -0,0 +1,110 @@
+#define MOZ_NO_ADDREF_RELEASE_ON_RETURN __attribute__((annotate("moz_no_addref_release_on_return")))
+
+struct Test {
+  void AddRef();
+  void Release();
+  void foo();
+};
+
+struct TestD : Test {};
+
+struct S {
+  Test* f() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+  Test& g() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+  Test  h() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+};
+
+struct SD {
+  TestD* f() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+  TestD& g() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+  TestD  h() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+};
+
+template<class T>
+struct X {
+  T* f() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+  T& g() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+  T  h() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+};
+
+template<class T>
+struct SP {
+  T* operator->() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+};
+
+Test* f() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+Test& g() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+Test  h() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+
+TestD* fd() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+TestD& gd() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+TestD  hd() MOZ_NO_ADDREF_RELEASE_ON_RETURN;
+
+void test() {
+  S s;
+  s.f()->AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'f'}}
+  s.f()->Release(); // expected-error{{'Release' cannot be called on the return value of 'f'}}
+  s.f()->foo();
+  s.g().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'g'}}
+  s.g().Release(); // expected-error{{'Release' cannot be called on the return value of 'g'}}
+  s.g().foo();
+  s.h().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'h'}}
+  s.h().Release(); // expected-error{{'Release' cannot be called on the return value of 'h'}}
+  s.h().foo();
+  SD sd;
+  sd.f()->AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'f'}}
+  sd.f()->Release(); // expected-error{{'Release' cannot be called on the return value of 'f'}}
+  sd.f()->foo();
+  sd.g().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'g'}}
+  sd.g().Release(); // expected-error{{'Release' cannot be called on the return value of 'g'}}
+  sd.g().foo();
+  sd.h().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'h'}}
+  sd.h().Release(); // expected-error{{'Release' cannot be called on the return value of 'h'}}
+  sd.h().foo();
+  X<Test> x;
+  x.f()->AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'f'}}
+  x.f()->Release(); // expected-error{{'Release' cannot be called on the return value of 'f'}}
+  x.f()->foo();
+  x.g().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'g'}}
+  x.g().Release(); // expected-error{{'Release' cannot be called on the return value of 'g'}}
+  x.g().foo();
+  x.h().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'h'}}
+  x.h().Release(); // expected-error{{'Release' cannot be called on the return value of 'h'}}
+  x.h().foo();
+  X<TestD> xd;
+  xd.f()->AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'f'}}
+  xd.f()->Release(); // expected-error{{'Release' cannot be called on the return value of 'f'}}
+  xd.f()->foo();
+  xd.g().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'g'}}
+  xd.g().Release(); // expected-error{{'Release' cannot be called on the return value of 'g'}}
+  xd.g().foo();
+  xd.h().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'h'}}
+  xd.h().Release(); // expected-error{{'Release' cannot be called on the return value of 'h'}}
+  xd.h().foo();
+  SP<Test> sp;
+  sp->AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'operator->'}}
+  sp->Release(); // expected-error{{'Release' cannot be called on the return value of 'operator->'}}
+  sp->foo();
+  SP<TestD> spd;
+  spd->AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'operator->'}}
+  spd->Release(); // expected-error{{'Release' cannot be called on the return value of 'operator->'}}
+  spd->foo();
+  f()->AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'f'}}
+  f()->Release(); // expected-error{{'Release' cannot be called on the return value of 'f'}}
+  f()->foo();
+  g().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'g'}}
+  g().Release(); // expected-error{{'Release' cannot be called on the return value of 'g'}}
+  g().foo();
+  h().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'h'}}
+  h().Release(); // expected-error{{'Release' cannot be called on the return value of 'h'}}
+  h().foo();
+  fd()->AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'fd'}}
+  fd()->Release(); // expected-error{{'Release' cannot be called on the return value of 'fd'}}
+  fd()->foo();
+  gd().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'gd'}}
+  gd().Release(); // expected-error{{'Release' cannot be called on the return value of 'gd'}}
+  gd().foo();
+  hd().AddRef(); // expected-error{{'AddRef' cannot be called on the return value of 'hd'}}
+  hd().Release(); // expected-error{{'Release' cannot be called on the return value of 'hd'}}
+  hd().foo();
+}
diff --git a/build/clang-plugin/tests/TestNoArithmeticExprInArgument.cpp b/build/clang-plugin/tests/TestNoArithmeticExprInArgument.cpp
new file mode 100644
index 000000000..d147b1701
--- /dev/null
+++ b/build/clang-plugin/tests/TestNoArithmeticExprInArgument.cpp
@@ -0,0 +1,32 @@
+#define MOZ_NO_ARITHMETIC_EXPR_IN_ARGUMENT __attribute__((annotate("moz_no_arith_expr_in_arg")))
+
+struct X {
+  explicit X(int) MOZ_NO_ARITHMETIC_EXPR_IN_ARGUMENT;
+  void baz(int) MOZ_NO_ARITHMETIC_EXPR_IN_ARGUMENT;
+};
+
+int operator+(int, X);
+int operator+(X, int);
+int operator++(X);
+
+void badArithmeticsInArgs() {
+  int a = 1;
+  typedef int myint;
+  myint b = 2;
+  X goodObj1(a);
+  goodObj1.baz(b);
+  X badObj1(a + b); // expected-error{{cannot pass an arithmetic expression of built-in types to 'X'}}
+  X badObj2 = X(a ? 0 : ++a); // expected-error{{cannot pass an arithmetic expression of built-in types to 'X'}}
+  X badObj3(~a); // expected-error{{cannot pass an arithmetic expression of built-in types to 'X'}}
+  badObj1.baz(a - 1 - b); // expected-error{{cannot pass an arithmetic expression of built-in types to 'baz'}}
+  badObj1.baz(++a); // expected-error{{cannot pass an arithmetic expression of built-in types to 'baz'}}
+  badObj1.baz(a++); // expected-error{{cannot pass an arithmetic expression of built-in types to 'baz'}}
+  badObj1.baz(a || b);
+  badObj1.baz(a + goodObj1);
+  badObj1.baz(goodObj1 + a);
+  badObj1.baz(++goodObj1);
+  badObj1.baz(-1);
+  badObj1.baz(-1.0);
+  badObj1.baz(1 + 2);
+  badObj1.baz(1 << (sizeof(int)/2));
+}
diff --git a/build/clang-plugin/tests/TestNoAutoType.cpp b/build/clang-plugin/tests/TestNoAutoType.cpp
new file mode 100644
index 000000000..6c6e65f24
--- /dev/null
+++ b/build/clang-plugin/tests/TestNoAutoType.cpp
@@ -0,0 +1,41 @@
+#define MOZ_NON_AUTOABLE __attribute__((annotate("moz_non_autoable")))
+
+template<class T>
+struct MOZ_NON_AUTOABLE ExplicitTypeTemplate {};
+struct MOZ_NON_AUTOABLE ExplicitType {};
+struct NonExplicitType {};
+
+void f() {
+  {
+    ExplicitType a;
+    auto b = a; // expected-error {{Cannot use auto to declare a variable of type 'ExplicitType'}} expected-note {{Please write out this type explicitly}}
+    auto &br = a; // expected-error {{Cannot use auto to declare a variable of type 'ExplicitType &'}} expected-note {{Please write out this type explicitly}}
+    const auto &brc = a; // expected-error {{Cannot use auto to declare a variable of type 'const ExplicitType &'}} expected-note {{Please write out this type explicitly}}
+    auto *bp = &a; // expected-error {{Cannot use auto to declare a variable of type 'ExplicitType *'}} expected-note {{Please write out this type explicitly}}
+    const auto *bpc = &a; // expected-error {{Cannot use auto to declare a variable of type 'const ExplicitType *'}} expected-note {{Please write out this type explicitly}}
+  }
+
+  {
+    ExplicitTypeTemplate<int> a;
+    auto b = a; // expected-error {{Cannot use auto to declare a variable of type 'ExplicitTypeTemplate<int>'}} expected-note {{Please write out this type explicitly}}
+    auto &br = a; // expected-error {{Cannot use auto to declare a variable of type 'ExplicitTypeTemplate<int> &'}} expected-note {{Please write out this type explicitly}}
+    const auto &brc = a; // expected-error {{Cannot use auto to declare a variable of type 'const ExplicitTypeTemplate<int> &'}} expected-note {{Please write out this type explicitly}}
+    auto *bp = &a; // expected-error {{Cannot use auto to declare a variable of type 'ExplicitTypeTemplate<int> *'}} expected-note {{Please write out this type explicitly}}
+    const auto *bpc = &a; // expected-error {{Cannot use auto to declare a variable of type 'const ExplicitTypeTemplate<int> *'}} expected-note {{Please write out this type explicitly}}
+  }
+
+  {
+    NonExplicitType c;
+    auto d = c;
+    auto &dr = c;
+    const auto &drc = c;
+    auto *dp = &c;
+    const auto *dpc = &c;
+  }
+}
+
+ExplicitType A;
+auto B = A; // expected-error {{Cannot use auto to declare a variable of type 'ExplicitType'}} expected-note {{Please write out this type explicitly}}
+
+NonExplicitType C;
+auto D = C;
diff --git a/build/clang-plugin/tests/TestNoDuplicateRefCntMember.cpp b/build/clang-plugin/tests/TestNoDuplicateRefCntMember.cpp
new file mode 100644
index 000000000..ff68e4fc7
--- /dev/null
+++ b/build/clang-plugin/tests/TestNoDuplicateRefCntMember.cpp
@@ -0,0 +1,49 @@
+class C1 {};
+
+class RC1 {
+public:
+  virtual void AddRef();
+  virtual void Release();
+
+private:
+  int mRefCnt; // expected-note 2 {{Superclass 'RC1' also has an mRefCnt member}} expected-note 3 {{Superclass 'RC1' has an mRefCnt member}}
+};
+
+class RC2 : public RC1 { // expected-error {{Refcounted record 'RC2' has multiple mRefCnt members}}
+public:
+  virtual void AddRef();
+  virtual void Release();
+
+private:
+  int mRefCnt; // expected-note {{Consider using the _INHERITED macros for AddRef and Release here}}
+};
+
+class C2 : public RC1 {};
+
+class RC3 : public RC1 {};
+
+class RC4 : public RC3, public C2 {}; // expected-error {{Refcounted record 'RC4' has multiple superclasses with mRefCnt members}}
+
+class RC5 : public RC1 {};
+
+class RC6 : public C1, public RC5 { // expected-error {{Refcounted record 'RC6' has multiple mRefCnt members}}
+public:
+  virtual void AddRef();
+  virtual void Release();
+
+private:
+  int mRefCnt; // expected-note {{Consider using the _INHERITED macros for AddRef and Release here}}
+};
+
+class Predecl;
+
+class OtherRC {
+public:
+  virtual void AddRef();
+  virtual void Release();
+
+private:
+  int mRefCnt; // expected-note {{Superclass 'OtherRC' has an mRefCnt member}}
+};
+
+class MultRCSuper : public RC1, public OtherRC {}; // expected-error {{Refcounted record 'MultRCSuper' has multiple superclasses with mRefCnt members}}
diff --git a/build/clang-plugin/tests/TestNoExplicitMoveConstructor.cpp b/build/clang-plugin/tests/TestNoExplicitMoveConstructor.cpp
new file mode 100644
index 000000000..5aea6b1a7
--- /dev/null
+++ b/build/clang-plugin/tests/TestNoExplicitMoveConstructor.cpp
@@ -0,0 +1,25 @@
+class Foo {
+  Foo(Foo&& f);
+};
+
+class Bar {
+  explicit Bar(Bar&& f); // expected-error {{Move constructors may not be marked explicit}}
+};
+
+class Baz {
+  template<typename T>
+  explicit Baz(T&& f) {};
+};
+
+class Quxx {
+  Quxx();
+  Quxx(Quxx& q) = delete;
+  template<typename T>
+  explicit Quxx(T&& f) {};
+};
+
+void f() {
+  // Move a quxx into a quxx! (This speciailizes Quxx's constructor to look like
+  // a move constructor - to make sure it doesn't trigger)
+  Quxx(Quxx());
+}
diff --git a/build/clang-plugin/tests/TestNoRefcountedInsideLambdas.cpp b/build/clang-plugin/tests/TestNoRefcountedInsideLambdas.cpp
new file mode 100644
index 000000000..2c74a34ba
--- /dev/null
+++ b/build/clang-plugin/tests/TestNoRefcountedInsideLambdas.cpp
@@ -0,0 +1,651 @@
+#include <functional>
+#include "mozilla/Function.h"
+#define MOZ_STRONG_REF __attribute__((annotate("moz_strong_ref")))
+
+struct RefCountedBase {
+  void AddRef();
+  void Release();
+};
+
+template <class T>
+struct SmartPtr {
+  T* MOZ_STRONG_REF t;
+  T* operator->() const;
+};
+
+struct R : RefCountedBase {
+  void method();
+};
+
+void take(...);
+void foo() {
+  R* ptr;
+  SmartPtr<R> sp;
+  take([&](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  take([&](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  take([&](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  take([&](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  take([=](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  take([=](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  take([=](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  take([=](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  take([ptr](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  take([sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  take([ptr](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  take([sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  take([&ptr](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  take([&sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  take([&ptr](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  take([&sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+}
+
+void b() {
+  R* ptr;
+  SmartPtr<R> sp;
+  std::function<void(R*)>([&](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  std::function<void(SmartPtr<R>)>([&](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  std::function<void(R*)>([&](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  std::function<void(SmartPtr<R>)>([&](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  std::function<void(R*)>([=](R* argptr) {
+    R* localptr;
+    ptr->method(); // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    argptr->method();
+    localptr->method();
+  });
+  std::function<void(SmartPtr<R>)>([=](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  std::function<void(R*)>([=](R* argptr) {
+    R* localptr;
+    take(ptr); // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    take(argptr);
+    take(localptr);
+  });
+  std::function<void(SmartPtr<R>)>([=](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  std::function<void(R*)>([ptr](R* argptr) { // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  std::function<void(SmartPtr<R>)>([sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  std::function<void(R*)>([ptr](R* argptr) { // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  std::function<void(SmartPtr<R>)>([sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  std::function<void(R*)>([&ptr](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  std::function<void(SmartPtr<R>)>([&sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  std::function<void(R*)>([&ptr](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  std::function<void(SmartPtr<R>)>([&sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+}
+
+void c() {
+  R* ptr;
+  SmartPtr<R> sp;
+  mozilla::function<void(R*)>([&](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  mozilla::function<void(SmartPtr<R>)>([&](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  mozilla::function<void(R*)>([&](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  mozilla::function<void(SmartPtr<R>)>([&](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  mozilla::function<void(R*)>([=](R* argptr) {
+    R* localptr;
+    ptr->method(); // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    argptr->method();
+    localptr->method();
+  });
+  mozilla::function<void(SmartPtr<R>)>([=](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  mozilla::function<void(R*)>([=](R* argptr) {
+    R* localptr;
+    take(ptr); // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    take(argptr);
+    take(localptr);
+  });
+  mozilla::function<void(SmartPtr<R>)>([=](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  mozilla::function<void(R*)>([ptr](R* argptr) { // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  mozilla::function<void(SmartPtr<R>)>([sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  mozilla::function<void(R*)>([ptr](R* argptr) { // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  mozilla::function<void(SmartPtr<R>)>([sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+  mozilla::function<void(R*)>([&ptr](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+  mozilla::function<void(SmartPtr<R>)>([&sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+  mozilla::function<void(R*)>([&ptr](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+  mozilla::function<void(SmartPtr<R>)>([&sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+}
+
+// These tests would check c++14 deduced return types, if they were supported in
+// our codebase. They are being kept here for convenience in the future if we do
+// add support for c++14 deduced return types
+#if 0
+auto d1() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([&](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+}
+auto d2() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([&](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+}
+auto d3() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([&](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+}
+auto d4() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([&](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+}
+auto d5() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([=](R* argptr) {
+    R* localptr;
+    ptr->method(); // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    argptr->method();
+    localptr->method();
+  });
+}
+auto d6() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([=](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+}
+auto d8() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([=](R* argptr) {
+    R* localptr;
+    take(ptr); // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    take(argptr);
+    take(localptr);
+  });
+}
+auto d9() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([=](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+}
+auto d10() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([ptr](R* argptr) { // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+}
+auto d11() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+}
+auto d12() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([ptr](R* argptr) { // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+}
+auto d13() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+}
+auto d14() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([&ptr](R* argptr) {
+    R* localptr;
+    ptr->method();
+    argptr->method();
+    localptr->method();
+  });
+}
+auto d15() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([&sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    sp->method();
+    argsp->method();
+    localsp->method();
+  });
+}
+auto d16() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([&ptr](R* argptr) {
+    R* localptr;
+    take(ptr);
+    take(argptr);
+    take(localptr);
+  });
+}
+auto d17() {
+  R* ptr;
+  SmartPtr<R> sp;
+  return ([&sp](SmartPtr<R> argsp) {
+    SmartPtr<R> localsp;
+    take(sp);
+    take(argsp);
+    take(localsp);
+  });
+}
+#endif
+
+void e() {
+  auto e1 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([&](R* argptr) {
+      R* localptr;
+      ptr->method();
+      argptr->method();
+      localptr->method();
+    });
+  };
+  auto e2 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([&](SmartPtr<R> argsp) {
+      SmartPtr<R> localsp;
+      sp->method();
+      argsp->method();
+      localsp->method();
+    });
+  };
+  auto e3 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([&](R* argptr) {
+      R* localptr;
+      take(ptr);
+      take(argptr);
+      take(localptr);
+    });
+  };
+  auto e4 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([&](SmartPtr<R> argsp) {
+      SmartPtr<R> localsp;
+      take(sp);
+      take(argsp);
+      take(localsp);
+    });
+  };
+  auto e5 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([=](R* argptr) {
+      R* localptr;
+      ptr->method(); // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+      argptr->method();
+      localptr->method();
+    });
+  };
+  auto e6 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([=](SmartPtr<R> argsp) {
+      SmartPtr<R> localsp;
+      sp->method();
+      argsp->method();
+      localsp->method();
+    });
+  };
+  auto e8 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([=](R* argptr) {
+      R* localptr;
+      take(ptr); // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+      take(argptr);
+      take(localptr);
+    });
+  };
+  auto e9 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([=](SmartPtr<R> argsp) {
+      SmartPtr<R> localsp;
+      take(sp);
+      take(argsp);
+      take(localsp);
+    });
+  };
+  auto e10 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([ptr](R* argptr) { // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+      R* localptr;
+      ptr->method();
+      argptr->method();
+      localptr->method();
+    });
+  };
+  auto e11 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([sp](SmartPtr<R> argsp) {
+      SmartPtr<R> localsp;
+      sp->method();
+      argsp->method();
+      localsp->method();
+    });
+  };
+  auto e12 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([ptr](R* argptr) { // expected-error{{Refcounted variable 'ptr' of type 'R' cannot be captured by a lambda}} expected-note{{Please consider using a smart pointer}}
+      R* localptr;
+      take(ptr);
+      take(argptr);
+      take(localptr);
+    });
+  };
+  auto e13 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([sp](SmartPtr<R> argsp) {
+      SmartPtr<R> localsp;
+      take(sp);
+      take(argsp);
+      take(localsp);
+    });
+  };
+  auto e14 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([&ptr](R* argptr) {
+      R* localptr;
+      ptr->method();
+      argptr->method();
+      localptr->method();
+    });
+  };
+  auto e15 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([&sp](SmartPtr<R> argsp) {
+      SmartPtr<R> localsp;
+      sp->method();
+      argsp->method();
+      localsp->method();
+    });
+  };
+  auto e16 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([&ptr](R* argptr) {
+      R* localptr;
+      take(ptr);
+      take(argptr);
+      take(localptr);
+    });
+  };
+  auto e17 = []() {
+    R* ptr;
+    SmartPtr<R> sp;
+    return ([&sp](SmartPtr<R> argsp) {
+      SmartPtr<R> localsp;
+      take(sp);
+      take(argsp);
+      take(localsp);
+    });
+  };
+}
diff --git a/build/clang-plugin/tests/TestNonHeapClass.cpp b/build/clang-plugin/tests/TestNonHeapClass.cpp
new file mode 100644
index 000000000..26fe6404e
--- /dev/null
+++ b/build/clang-plugin/tests/TestNonHeapClass.cpp
@@ -0,0 +1,62 @@
+#define MOZ_NONHEAP_CLASS __attribute__((annotate("moz_nonheap_class")))
+#define MOZ_STACK_CLASS __attribute__((annotate("moz_stack_class")))
+#include <stddef.h>
+
+struct MOZ_NONHEAP_CLASS NonHeap {
+  int i;
+  void *operator new(size_t x) throw() { return 0; }
+  void *operator new(size_t blah, char *buffer) { return buffer; }
+};
+
+template <class T>
+struct MOZ_NONHEAP_CLASS TemplateClass {
+  T i;
+};
+
+void gobble(void *) { }
+
+void misuseNonHeapClass(int len) {
+  NonHeap valid;
+  NonHeap alsoValid[2];
+  static NonHeap validStatic;
+  static NonHeap alsoValidStatic[2];
+
+  gobble(&valid);
+  gobble(&validStatic);
+  gobble(&alsoValid[0]);
+
+  gobble(new NonHeap); // expected-error {{variable of type 'NonHeap' is not valid on the heap}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(new NonHeap[10]); // expected-error {{variable of type 'NonHeap' is not valid on the heap}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(new TemplateClass<int>); // expected-error {{variable of type 'TemplateClass<int>' is not valid on the heap}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(len <= 5 ? &valid : new NonHeap); // expected-error {{variable of type 'NonHeap' is not valid on the heap}} expected-note {{value incorrectly allocated on the heap}}
+
+  char buffer[sizeof(NonHeap)];
+  gobble(new (buffer) NonHeap);
+}
+
+NonHeap validStatic;
+struct RandomClass {
+  NonHeap nonstaticMember; // expected-note {{'RandomClass' is a non-heap type because member 'nonstaticMember' is a non-heap type 'NonHeap'}}
+  static NonHeap staticMember;
+};
+struct MOZ_NONHEAP_CLASS RandomNonHeapClass {
+  NonHeap nonstaticMember;
+  static NonHeap staticMember;
+};
+
+struct BadInherit : NonHeap {}; // expected-note {{'BadInherit' is a non-heap type because it inherits from a non-heap type 'NonHeap'}}
+struct MOZ_NONHEAP_CLASS GoodInherit : NonHeap {};
+
+void useStuffWrongly() {
+  gobble(new BadInherit); // expected-error {{variable of type 'BadInherit' is not valid on the heap}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(new RandomClass); // expected-error {{variable of type 'RandomClass' is not valid on the heap}} expected-note {{value incorrectly allocated on the heap}}
+}
+
+// Stack class overrides non-heap typees.
+struct MOZ_STACK_CLASS StackClass {};
+struct MOZ_NONHEAP_CLASS InferredStackClass : GoodInherit {
+  NonHeap nonstaticMember;
+  StackClass stackClass; // expected-note {{'InferredStackClass' is a stack type because member 'stackClass' is a stack type 'StackClass'}}
+};
+
+InferredStackClass global; // expected-error {{variable of type 'InferredStackClass' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
diff --git a/build/clang-plugin/tests/TestNonMemMovable.cpp b/build/clang-plugin/tests/TestNonMemMovable.cpp
new file mode 100644
index 000000000..a726d0ab6
--- /dev/null
+++ b/build/clang-plugin/tests/TestNonMemMovable.cpp
@@ -0,0 +1,830 @@
+#define MOZ_NON_MEMMOVABLE __attribute__((annotate("moz_non_memmovable")))
+#define MOZ_NEEDS_MEMMOVABLE_TYPE __attribute__((annotate("moz_needs_memmovable_type")))
+#define MOZ_NEEDS_MEMMOVABLE_MEMBERS __attribute__((annotate("moz_needs_memmovable_members")))
+
+/*
+  These are a bunch of structs with variable levels of memmovability.
+  They will be used as template parameters to the various NeedyTemplates
+*/
+struct MOZ_NON_MEMMOVABLE NonMovable {};
+struct Movable {};
+
+// Subclasses
+struct S_NonMovable : NonMovable {}; // expected-note 51 {{'S_NonMovable' is a non-memmove()able type because it inherits from a non-memmove()able type 'NonMovable'}}
+struct S_Movable : Movable {};
+
+// Members
+struct W_NonMovable {
+  NonMovable m; // expected-note 34 {{'W_NonMovable' is a non-memmove()able type because member 'm' is a non-memmove()able type 'NonMovable'}}
+};
+struct W_Movable {
+  Movable m;
+};
+
+// Wrapped Subclasses
+struct WS_NonMovable {
+  S_NonMovable m; // expected-note 34 {{'WS_NonMovable' is a non-memmove()able type because member 'm' is a non-memmove()able type 'S_NonMovable'}}
+};
+struct WS_Movable {
+  S_Movable m;
+};
+
+// Combinations of the above
+struct SW_NonMovable : W_NonMovable {}; // expected-note 17 {{'SW_NonMovable' is a non-memmove()able type because it inherits from a non-memmove()able type 'W_NonMovable'}}
+struct SW_Movable : W_Movable {};
+
+struct SWS_NonMovable : WS_NonMovable {}; // expected-note 17 {{'SWS_NonMovable' is a non-memmove()able type because it inherits from a non-memmove()able type 'WS_NonMovable'}}
+struct SWS_Movable : WS_Movable {};
+
+// Basic templated wrapper
+template <class T>
+struct Template_Inline {
+  T m; // expected-note-re 56 {{'Template_Inline<{{.*}}>' is a non-memmove()able type because member 'm' is a non-memmove()able type '{{.*}}'}}
+};
+
+template <class T>
+struct Template_Ref {
+  T* m;
+};
+
+template <class T>
+struct Template_Unused {};
+
+template <class T>
+struct MOZ_NON_MEMMOVABLE Template_NonMovable {};
+
+/*
+  These tests take the following form:
+  DECLARATIONS => Declarations of the templates which are either marked with MOZ_NEEDS_MEMMOVABLE_TYPE
+                  or which instantiate a MOZ_NEEDS_MEMMOVABLE_TYPE through some mechanism.
+  BAD N        => Instantiations of the wrapper template with each of the non-memmovable types.
+                  The prefix S_ means subclass, W_ means wrapped. Each of these rows should produce an error
+                  on the NeedyTemplate in question, and a note at the instantiation location of that template.
+                  Unfortunately, on every case more complicated than bad1, the instantiation location is
+                  within another template. Thus, the notes are expected on the template in question which
+                  actually instantiates the MOZ_NEEDS_MEMMOVABLE_TYPE template.
+  GOOD N       => Instantiations of the wrapper template with each of the memmovable types.
+                  This is meant as a sanity check to ensure that we don't reject valid instantiations of
+                  templates.
+
+
+  Note 1: Each set uses it's own types to ensure that they don't re-use each-other's template specializations.
+  If they did, then some of the error messages would not be emitted (as error messages are emitted for template
+  specializations, rather than for variable declarations)
+
+  Note 2: Every instance of NeedyTemplate contains a member of type T. This is to ensure that T is actually
+  instantiated (if T is a template) by clang. If T isn't instantiated, then we can't actually tell if it is
+  NON_MEMMOVABLE. (This is OK in practice, as you cannot memmove a type which you don't know the size of).
+
+  Note 3: There are a set of tests for specializations of NeedyTemplate at the bottom. For each set of tests,
+  these tests contribute two expected errors to the templates.
+*/
+
+//
+// 1 - Unwrapped MOZ_NEEDS_MEMMOVABLE_TYPE
+//
+
+template <class T>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE NeedyTemplate1 {T m;}; // expected-error-re 26 {{Cannot instantiate 'NeedyTemplate1<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+
+void bad1() {
+  NeedyTemplate1<NonMovable> a1; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<S_NonMovable> a2; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<W_NonMovable> a3; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<WS_NonMovable> a4; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<SW_NonMovable> a5; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<SWS_NonMovable> a6; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+
+  NeedyTemplate1<Template_Inline<NonMovable> > b1; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_Inline<S_NonMovable> > b2; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_Inline<W_NonMovable> > b3; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_Inline<WS_NonMovable> > b4; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_Inline<SW_NonMovable> > b5; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_Inline<SWS_NonMovable> > b6; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+
+  NeedyTemplate1<Template_NonMovable<NonMovable> > c1; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<S_NonMovable> > c2; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<W_NonMovable> > c3; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<WS_NonMovable> > c4; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<SW_NonMovable> > c5; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<SWS_NonMovable> > c6; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<Movable> > c7; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<S_Movable> > c8; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<W_Movable> > c9; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<WS_Movable> > c10; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<SW_Movable> > c11; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+  NeedyTemplate1<Template_NonMovable<SWS_Movable> > c12; // expected-note-re {{instantiation of 'NeedyTemplate1<{{.*}}>' requested here}}
+}
+
+void good1() {
+  NeedyTemplate1<Movable> a1;
+  NeedyTemplate1<S_Movable> a2;
+  NeedyTemplate1<W_Movable> a3;
+  NeedyTemplate1<WS_Movable> a4;
+  NeedyTemplate1<SW_Movable> a5;
+  NeedyTemplate1<SWS_Movable> a6;
+
+  NeedyTemplate1<Template_Inline<Movable> > b1;
+  NeedyTemplate1<Template_Inline<S_Movable> > b2;
+  NeedyTemplate1<Template_Inline<W_Movable> > b3;
+  NeedyTemplate1<Template_Inline<WS_Movable> > b4;
+  NeedyTemplate1<Template_Inline<SW_Movable> > b5;
+  NeedyTemplate1<Template_Inline<SWS_Movable> > b6;
+
+  NeedyTemplate1<Template_Unused<Movable> > c1;
+  NeedyTemplate1<Template_Unused<S_Movable> > c2;
+  NeedyTemplate1<Template_Unused<W_Movable> > c3;
+  NeedyTemplate1<Template_Unused<WS_Movable> > c4;
+  NeedyTemplate1<Template_Unused<SW_Movable> > c5;
+  NeedyTemplate1<Template_Unused<SWS_Movable> > c6;
+  NeedyTemplate1<Template_Unused<NonMovable> > c7;
+  NeedyTemplate1<Template_Unused<S_NonMovable> > c8;
+  NeedyTemplate1<Template_Unused<W_NonMovable> > c9;
+  NeedyTemplate1<Template_Unused<WS_NonMovable> > c10;
+  NeedyTemplate1<Template_Unused<SW_NonMovable> > c11;
+  NeedyTemplate1<Template_Unused<SWS_NonMovable> > c12;
+
+  NeedyTemplate1<Template_Ref<Movable> > d1;
+  NeedyTemplate1<Template_Ref<S_Movable> > d2;
+  NeedyTemplate1<Template_Ref<W_Movable> > d3;
+  NeedyTemplate1<Template_Ref<WS_Movable> > d4;
+  NeedyTemplate1<Template_Ref<SW_Movable> > d5;
+  NeedyTemplate1<Template_Ref<SWS_Movable> > d6;
+  NeedyTemplate1<Template_Ref<NonMovable> > d7;
+  NeedyTemplate1<Template_Ref<S_NonMovable> > d8;
+  NeedyTemplate1<Template_Ref<W_NonMovable> > d9;
+  NeedyTemplate1<Template_Ref<WS_NonMovable> > d10;
+  NeedyTemplate1<Template_Ref<SW_NonMovable> > d11;
+  NeedyTemplate1<Template_Ref<SWS_NonMovable> > d12;
+}
+
+//
+// 2 - Subclassed MOZ_NEEDS_MEMMOVABLE_TYPE
+//
+
+template <class T>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE NeedyTemplate2 {T m;}; // expected-error-re 26 {{Cannot instantiate 'NeedyTemplate2<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+template <class T>
+struct S_NeedyTemplate2 : NeedyTemplate2<T> {}; // expected-note-re 26 {{instantiation of 'NeedyTemplate2<{{.*}}>' requested here}}
+
+void bad2() {
+  S_NeedyTemplate2<NonMovable> a1;
+  S_NeedyTemplate2<S_NonMovable> a2;
+  S_NeedyTemplate2<W_NonMovable> a3;
+  S_NeedyTemplate2<WS_NonMovable> a4;
+  S_NeedyTemplate2<SW_NonMovable> a5;
+  S_NeedyTemplate2<SWS_NonMovable> a6;
+
+  S_NeedyTemplate2<Template_Inline<NonMovable> > b1;
+  S_NeedyTemplate2<Template_Inline<S_NonMovable> > b2;
+  S_NeedyTemplate2<Template_Inline<W_NonMovable> > b3;
+  S_NeedyTemplate2<Template_Inline<WS_NonMovable> > b4;
+  S_NeedyTemplate2<Template_Inline<SW_NonMovable> > b5;
+  S_NeedyTemplate2<Template_Inline<SWS_NonMovable> > b6;
+
+  S_NeedyTemplate2<Template_NonMovable<NonMovable> > c1;
+  S_NeedyTemplate2<Template_NonMovable<S_NonMovable> > c2;
+  S_NeedyTemplate2<Template_NonMovable<W_NonMovable> > c3;
+  S_NeedyTemplate2<Template_NonMovable<WS_NonMovable> > c4;
+  S_NeedyTemplate2<Template_NonMovable<SW_NonMovable> > c5;
+  S_NeedyTemplate2<Template_NonMovable<SWS_NonMovable> > c6;
+  S_NeedyTemplate2<Template_NonMovable<Movable> > c7;
+  S_NeedyTemplate2<Template_NonMovable<S_Movable> > c8;
+  S_NeedyTemplate2<Template_NonMovable<W_Movable> > c9;
+  S_NeedyTemplate2<Template_NonMovable<WS_Movable> > c10;
+  S_NeedyTemplate2<Template_NonMovable<SW_Movable> > c11;
+  S_NeedyTemplate2<Template_NonMovable<SWS_Movable> > c12;
+}
+
+void good2() {
+  S_NeedyTemplate2<Movable> a1;
+  S_NeedyTemplate2<S_Movable> a2;
+  S_NeedyTemplate2<W_Movable> a3;
+  S_NeedyTemplate2<WS_Movable> a4;
+  S_NeedyTemplate2<SW_Movable> a5;
+  S_NeedyTemplate2<SWS_Movable> a6;
+
+  S_NeedyTemplate2<Template_Inline<Movable> > b1;
+  S_NeedyTemplate2<Template_Inline<S_Movable> > b2;
+  S_NeedyTemplate2<Template_Inline<W_Movable> > b3;
+  S_NeedyTemplate2<Template_Inline<WS_Movable> > b4;
+  S_NeedyTemplate2<Template_Inline<SW_Movable> > b5;
+  S_NeedyTemplate2<Template_Inline<SWS_Movable> > b6;
+
+  S_NeedyTemplate2<Template_Unused<Movable> > c1;
+  S_NeedyTemplate2<Template_Unused<S_Movable> > c2;
+  S_NeedyTemplate2<Template_Unused<W_Movable> > c3;
+  S_NeedyTemplate2<Template_Unused<WS_Movable> > c4;
+  S_NeedyTemplate2<Template_Unused<SW_Movable> > c5;
+  S_NeedyTemplate2<Template_Unused<SWS_Movable> > c6;
+  S_NeedyTemplate2<Template_Unused<NonMovable> > c7;
+  S_NeedyTemplate2<Template_Unused<S_NonMovable> > c8;
+  S_NeedyTemplate2<Template_Unused<W_NonMovable> > c9;
+  S_NeedyTemplate2<Template_Unused<WS_NonMovable> > c10;
+  S_NeedyTemplate2<Template_Unused<SW_NonMovable> > c11;
+  S_NeedyTemplate2<Template_Unused<SWS_NonMovable> > c12;
+
+  S_NeedyTemplate2<Template_Ref<Movable> > d1;
+  S_NeedyTemplate2<Template_Ref<S_Movable> > d2;
+  S_NeedyTemplate2<Template_Ref<W_Movable> > d3;
+  S_NeedyTemplate2<Template_Ref<WS_Movable> > d4;
+  S_NeedyTemplate2<Template_Ref<SW_Movable> > d5;
+  S_NeedyTemplate2<Template_Ref<SWS_Movable> > d6;
+  S_NeedyTemplate2<Template_Ref<NonMovable> > d7;
+  S_NeedyTemplate2<Template_Ref<S_NonMovable> > d8;
+  S_NeedyTemplate2<Template_Ref<W_NonMovable> > d9;
+  S_NeedyTemplate2<Template_Ref<WS_NonMovable> > d10;
+  S_NeedyTemplate2<Template_Ref<SW_NonMovable> > d11;
+  S_NeedyTemplate2<Template_Ref<SWS_NonMovable> > d12;
+}
+
+//
+// 3 - Wrapped MOZ_NEEDS_MEMMOVABLE_TYPE
+//
+
+template <class T>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE NeedyTemplate3 {T m;}; // expected-error-re 26 {{Cannot instantiate 'NeedyTemplate3<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+template <class T>
+struct W_NeedyTemplate3 {
+  NeedyTemplate3<T> m; // expected-note-re 26 {{instantiation of 'NeedyTemplate3<{{.*}}>' requested here}}
+};
+void bad3() {
+  W_NeedyTemplate3<NonMovable> a1;
+  W_NeedyTemplate3<S_NonMovable> a2;
+  W_NeedyTemplate3<W_NonMovable> a3;
+  W_NeedyTemplate3<WS_NonMovable> a4;
+  W_NeedyTemplate3<SW_NonMovable> a5;
+  W_NeedyTemplate3<SWS_NonMovable> a6;
+
+  W_NeedyTemplate3<Template_Inline<NonMovable> > b1;
+  W_NeedyTemplate3<Template_Inline<S_NonMovable> > b2;
+  W_NeedyTemplate3<Template_Inline<W_NonMovable> > b3;
+  W_NeedyTemplate3<Template_Inline<WS_NonMovable> > b4;
+  W_NeedyTemplate3<Template_Inline<SW_NonMovable> > b5;
+  W_NeedyTemplate3<Template_Inline<SWS_NonMovable> > b6;
+
+  W_NeedyTemplate3<Template_NonMovable<NonMovable> > c1;
+  W_NeedyTemplate3<Template_NonMovable<S_NonMovable> > c2;
+  W_NeedyTemplate3<Template_NonMovable<W_NonMovable> > c3;
+  W_NeedyTemplate3<Template_NonMovable<WS_NonMovable> > c4;
+  W_NeedyTemplate3<Template_NonMovable<SW_NonMovable> > c5;
+  W_NeedyTemplate3<Template_NonMovable<SWS_NonMovable> > c6;
+  W_NeedyTemplate3<Template_NonMovable<Movable> > c7;
+  W_NeedyTemplate3<Template_NonMovable<S_Movable> > c8;
+  W_NeedyTemplate3<Template_NonMovable<W_Movable> > c9;
+  W_NeedyTemplate3<Template_NonMovable<WS_Movable> > c10;
+  W_NeedyTemplate3<Template_NonMovable<SW_Movable> > c11;
+  W_NeedyTemplate3<Template_NonMovable<SWS_Movable> > c12;
+}
+
+void good3() {
+  W_NeedyTemplate3<Movable> a1;
+  W_NeedyTemplate3<S_Movable> a2;
+  W_NeedyTemplate3<W_Movable> a3;
+  W_NeedyTemplate3<WS_Movable> a4;
+  W_NeedyTemplate3<SW_Movable> a5;
+  W_NeedyTemplate3<SWS_Movable> a6;
+
+  W_NeedyTemplate3<Template_Inline<Movable> > b1;
+  W_NeedyTemplate3<Template_Inline<S_Movable> > b2;
+  W_NeedyTemplate3<Template_Inline<W_Movable> > b3;
+  W_NeedyTemplate3<Template_Inline<WS_Movable> > b4;
+  W_NeedyTemplate3<Template_Inline<SW_Movable> > b5;
+  W_NeedyTemplate3<Template_Inline<SWS_Movable> > b6;
+
+  W_NeedyTemplate3<Template_Unused<Movable> > c1;
+  W_NeedyTemplate3<Template_Unused<S_Movable> > c2;
+  W_NeedyTemplate3<Template_Unused<W_Movable> > c3;
+  W_NeedyTemplate3<Template_Unused<WS_Movable> > c4;
+  W_NeedyTemplate3<Template_Unused<SW_Movable> > c5;
+  W_NeedyTemplate3<Template_Unused<SWS_Movable> > c6;
+  W_NeedyTemplate3<Template_Unused<NonMovable> > c7;
+  W_NeedyTemplate3<Template_Unused<S_NonMovable> > c8;
+  W_NeedyTemplate3<Template_Unused<W_NonMovable> > c9;
+  W_NeedyTemplate3<Template_Unused<WS_NonMovable> > c10;
+  W_NeedyTemplate3<Template_Unused<SW_NonMovable> > c11;
+  W_NeedyTemplate3<Template_Unused<SWS_NonMovable> > c12;
+
+  W_NeedyTemplate3<Template_Ref<Movable> > d1;
+  W_NeedyTemplate3<Template_Ref<S_Movable> > d2;
+  W_NeedyTemplate3<Template_Ref<W_Movable> > d3;
+  W_NeedyTemplate3<Template_Ref<WS_Movable> > d4;
+  W_NeedyTemplate3<Template_Ref<SW_Movable> > d5;
+  W_NeedyTemplate3<Template_Ref<SWS_Movable> > d6;
+  W_NeedyTemplate3<Template_Ref<NonMovable> > d7;
+  W_NeedyTemplate3<Template_Ref<S_NonMovable> > d8;
+  W_NeedyTemplate3<Template_Ref<W_NonMovable> > d9;
+  W_NeedyTemplate3<Template_Ref<WS_NonMovable> > d10;
+  W_NeedyTemplate3<Template_Ref<SW_NonMovable> > d11;
+  W_NeedyTemplate3<Template_Ref<SWS_NonMovable> > d12;
+}
+
+//
+// 4 - Wrapped Subclassed MOZ_NEEDS_MEMMOVABLE_TYPE
+//
+
+template <class T>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE NeedyTemplate4 {T m;}; // expected-error-re 26 {{Cannot instantiate 'NeedyTemplate4<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+template <class T>
+struct S_NeedyTemplate4 : NeedyTemplate4<T> {}; // expected-note-re 26 {{instantiation of 'NeedyTemplate4<{{.*}}>' requested here}}
+template <class T>
+struct WS_NeedyTemplate4 {
+  S_NeedyTemplate4<T> m;
+};
+void bad4() {
+  WS_NeedyTemplate4<NonMovable> a1;
+  WS_NeedyTemplate4<S_NonMovable> a2;
+  WS_NeedyTemplate4<W_NonMovable> a3;
+  WS_NeedyTemplate4<WS_NonMovable> a4;
+  WS_NeedyTemplate4<SW_NonMovable> a5;
+  WS_NeedyTemplate4<SWS_NonMovable> a6;
+
+  WS_NeedyTemplate4<Template_Inline<NonMovable> > b1;
+  WS_NeedyTemplate4<Template_Inline<S_NonMovable> > b2;
+  WS_NeedyTemplate4<Template_Inline<W_NonMovable> > b3;
+  WS_NeedyTemplate4<Template_Inline<WS_NonMovable> > b4;
+  WS_NeedyTemplate4<Template_Inline<SW_NonMovable> > b5;
+  WS_NeedyTemplate4<Template_Inline<SWS_NonMovable> > b6;
+
+  WS_NeedyTemplate4<Template_NonMovable<NonMovable> > c1;
+  WS_NeedyTemplate4<Template_NonMovable<S_NonMovable> > c2;
+  WS_NeedyTemplate4<Template_NonMovable<W_NonMovable> > c3;
+  WS_NeedyTemplate4<Template_NonMovable<WS_NonMovable> > c4;
+  WS_NeedyTemplate4<Template_NonMovable<SW_NonMovable> > c5;
+  WS_NeedyTemplate4<Template_NonMovable<SWS_NonMovable> > c6;
+  WS_NeedyTemplate4<Template_NonMovable<Movable> > c7;
+  WS_NeedyTemplate4<Template_NonMovable<S_Movable> > c8;
+  WS_NeedyTemplate4<Template_NonMovable<W_Movable> > c9;
+  WS_NeedyTemplate4<Template_NonMovable<WS_Movable> > c10;
+  WS_NeedyTemplate4<Template_NonMovable<SW_Movable> > c11;
+  WS_NeedyTemplate4<Template_NonMovable<SWS_Movable> > c12;
+}
+
+void good4() {
+  WS_NeedyTemplate4<Movable> a1;
+  WS_NeedyTemplate4<S_Movable> a2;
+  WS_NeedyTemplate4<W_Movable> a3;
+  WS_NeedyTemplate4<WS_Movable> a4;
+  WS_NeedyTemplate4<SW_Movable> a5;
+  WS_NeedyTemplate4<SWS_Movable> a6;
+
+  WS_NeedyTemplate4<Template_Inline<Movable> > b1;
+  WS_NeedyTemplate4<Template_Inline<S_Movable> > b2;
+  WS_NeedyTemplate4<Template_Inline<W_Movable> > b3;
+  WS_NeedyTemplate4<Template_Inline<WS_Movable> > b4;
+  WS_NeedyTemplate4<Template_Inline<SW_Movable> > b5;
+  WS_NeedyTemplate4<Template_Inline<SWS_Movable> > b6;
+
+  WS_NeedyTemplate4<Template_Unused<Movable> > c1;
+  WS_NeedyTemplate4<Template_Unused<S_Movable> > c2;
+  WS_NeedyTemplate4<Template_Unused<W_Movable> > c3;
+  WS_NeedyTemplate4<Template_Unused<WS_Movable> > c4;
+  WS_NeedyTemplate4<Template_Unused<SW_Movable> > c5;
+  WS_NeedyTemplate4<Template_Unused<SWS_Movable> > c6;
+  WS_NeedyTemplate4<Template_Unused<NonMovable> > c7;
+  WS_NeedyTemplate4<Template_Unused<S_NonMovable> > c8;
+  WS_NeedyTemplate4<Template_Unused<W_NonMovable> > c9;
+  WS_NeedyTemplate4<Template_Unused<WS_NonMovable> > c10;
+  WS_NeedyTemplate4<Template_Unused<SW_NonMovable> > c11;
+  WS_NeedyTemplate4<Template_Unused<SWS_NonMovable> > c12;
+
+  WS_NeedyTemplate4<Template_Ref<Movable> > d1;
+  WS_NeedyTemplate4<Template_Ref<S_Movable> > d2;
+  WS_NeedyTemplate4<Template_Ref<W_Movable> > d3;
+  WS_NeedyTemplate4<Template_Ref<WS_Movable> > d4;
+  WS_NeedyTemplate4<Template_Ref<SW_Movable> > d5;
+  WS_NeedyTemplate4<Template_Ref<SWS_Movable> > d6;
+  WS_NeedyTemplate4<Template_Ref<NonMovable> > d7;
+  WS_NeedyTemplate4<Template_Ref<S_NonMovable> > d8;
+  WS_NeedyTemplate4<Template_Ref<W_NonMovable> > d9;
+  WS_NeedyTemplate4<Template_Ref<WS_NonMovable> > d10;
+  WS_NeedyTemplate4<Template_Ref<SW_NonMovable> > d11;
+  WS_NeedyTemplate4<Template_Ref<SWS_NonMovable> > d12;
+}
+
+//
+// 5 - Subclassed Wrapped MOZ_NEEDS_MEMMOVABLE_TYPE
+//
+
+template <class T>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE NeedyTemplate5 {T m;}; // expected-error-re 26 {{Cannot instantiate 'NeedyTemplate5<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+template <class T>
+struct W_NeedyTemplate5 {
+  NeedyTemplate5<T> m; // expected-note-re 26 {{instantiation of 'NeedyTemplate5<{{.*}}>' requested here}}
+};
+template <class T>
+struct SW_NeedyTemplate5 : W_NeedyTemplate5<T> {};
+void bad5() {
+  SW_NeedyTemplate5<NonMovable> a1;
+  SW_NeedyTemplate5<S_NonMovable> a2;
+  SW_NeedyTemplate5<W_NonMovable> a3;
+  SW_NeedyTemplate5<WS_NonMovable> a4;
+  SW_NeedyTemplate5<SW_NonMovable> a5;
+  SW_NeedyTemplate5<SWS_NonMovable> a6;
+
+  SW_NeedyTemplate5<Template_Inline<NonMovable> > b1;
+  SW_NeedyTemplate5<Template_Inline<S_NonMovable> > b2;
+  SW_NeedyTemplate5<Template_Inline<W_NonMovable> > b3;
+  SW_NeedyTemplate5<Template_Inline<WS_NonMovable> > b4;
+  SW_NeedyTemplate5<Template_Inline<SW_NonMovable> > b5;
+  SW_NeedyTemplate5<Template_Inline<SWS_NonMovable> > b6;
+
+  SW_NeedyTemplate5<Template_NonMovable<NonMovable> > c1;
+  SW_NeedyTemplate5<Template_NonMovable<S_NonMovable> > c2;
+  SW_NeedyTemplate5<Template_NonMovable<W_NonMovable> > c3;
+  SW_NeedyTemplate5<Template_NonMovable<WS_NonMovable> > c4;
+  SW_NeedyTemplate5<Template_NonMovable<SW_NonMovable> > c5;
+  SW_NeedyTemplate5<Template_NonMovable<SWS_NonMovable> > c6;
+  SW_NeedyTemplate5<Template_NonMovable<Movable> > c7;
+  SW_NeedyTemplate5<Template_NonMovable<S_Movable> > c8;
+  SW_NeedyTemplate5<Template_NonMovable<W_Movable> > c9;
+  SW_NeedyTemplate5<Template_NonMovable<WS_Movable> > c10;
+  SW_NeedyTemplate5<Template_NonMovable<SW_Movable> > c11;
+  SW_NeedyTemplate5<Template_NonMovable<SWS_Movable> > c12;
+}
+
+void good5() {
+  SW_NeedyTemplate5<Movable> a1;
+  SW_NeedyTemplate5<S_Movable> a2;
+  SW_NeedyTemplate5<W_Movable> a3;
+  SW_NeedyTemplate5<WS_Movable> a4;
+  SW_NeedyTemplate5<SW_Movable> a5;
+  SW_NeedyTemplate5<SWS_Movable> a6;
+
+  SW_NeedyTemplate5<Template_Inline<Movable> > b1;
+  SW_NeedyTemplate5<Template_Inline<S_Movable> > b2;
+  SW_NeedyTemplate5<Template_Inline<W_Movable> > b3;
+  SW_NeedyTemplate5<Template_Inline<WS_Movable> > b4;
+  SW_NeedyTemplate5<Template_Inline<SW_Movable> > b5;
+  SW_NeedyTemplate5<Template_Inline<SWS_Movable> > b6;
+
+  SW_NeedyTemplate5<Template_Unused<Movable> > c1;
+  SW_NeedyTemplate5<Template_Unused<S_Movable> > c2;
+  SW_NeedyTemplate5<Template_Unused<W_Movable> > c3;
+  SW_NeedyTemplate5<Template_Unused<WS_Movable> > c4;
+  SW_NeedyTemplate5<Template_Unused<SW_Movable> > c5;
+  SW_NeedyTemplate5<Template_Unused<SWS_Movable> > c6;
+  SW_NeedyTemplate5<Template_Unused<NonMovable> > c7;
+  SW_NeedyTemplate5<Template_Unused<S_NonMovable> > c8;
+  SW_NeedyTemplate5<Template_Unused<W_NonMovable> > c9;
+  SW_NeedyTemplate5<Template_Unused<WS_NonMovable> > c10;
+  SW_NeedyTemplate5<Template_Unused<SW_NonMovable> > c11;
+  SW_NeedyTemplate5<Template_Unused<SWS_NonMovable> > c12;
+
+  SW_NeedyTemplate5<Template_Ref<Movable> > d1;
+  SW_NeedyTemplate5<Template_Ref<S_Movable> > d2;
+  SW_NeedyTemplate5<Template_Ref<W_Movable> > d3;
+  SW_NeedyTemplate5<Template_Ref<WS_Movable> > d4;
+  SW_NeedyTemplate5<Template_Ref<SW_Movable> > d5;
+  SW_NeedyTemplate5<Template_Ref<SWS_Movable> > d6;
+  SW_NeedyTemplate5<Template_Ref<NonMovable> > d7;
+  SW_NeedyTemplate5<Template_Ref<S_NonMovable> > d8;
+  SW_NeedyTemplate5<Template_Ref<W_NonMovable> > d9;
+  SW_NeedyTemplate5<Template_Ref<WS_NonMovable> > d10;
+  SW_NeedyTemplate5<Template_Ref<SW_NonMovable> > d11;
+  SW_NeedyTemplate5<Template_Ref<SWS_NonMovable> > d12;
+}
+
+//
+// 6 - MOZ_NEEDS_MEMMOVABLE_TYPE instantiated with default template argument
+//
+// Note: This has an extra error, because it also includes a test with the default template argument.
+//
+
+template <class T>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE NeedyTemplate6 {T m;}; // expected-error-re 27 {{Cannot instantiate 'NeedyTemplate6<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+template <class T>
+struct W_NeedyTemplate6 {
+  NeedyTemplate6<T> m; // expected-note-re 27 {{instantiation of 'NeedyTemplate6<{{.*}}>' requested here}}
+};
+template <class T>
+struct SW_NeedyTemplate6 : W_NeedyTemplate6<T> {};
+// We create a different NonMovable type here, as NeedyTemplate6 will already be instantiated with NonMovable
+struct MOZ_NON_MEMMOVABLE NonMovable2 {};
+template <class T = NonMovable2>
+struct Defaulted_SW_NeedyTemplate6 {
+  SW_NeedyTemplate6<T> m;
+};
+void bad6() {
+  Defaulted_SW_NeedyTemplate6<NonMovable> a1;
+  Defaulted_SW_NeedyTemplate6<S_NonMovable> a2;
+  Defaulted_SW_NeedyTemplate6<W_NonMovable> a3;
+  Defaulted_SW_NeedyTemplate6<WS_NonMovable> a4;
+  Defaulted_SW_NeedyTemplate6<SW_NonMovable> a5;
+  Defaulted_SW_NeedyTemplate6<SWS_NonMovable> a6;
+
+  Defaulted_SW_NeedyTemplate6<Template_Inline<NonMovable> > b1;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<S_NonMovable> > b2;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<W_NonMovable> > b3;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<WS_NonMovable> > b4;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<SW_NonMovable> > b5;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<SWS_NonMovable> > b6;
+
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<NonMovable> > c1;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<S_NonMovable> > c2;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<W_NonMovable> > c3;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<WS_NonMovable> > c4;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<SW_NonMovable> > c5;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<SWS_NonMovable> > c6;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<Movable> > c7;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<S_Movable> > c8;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<W_Movable> > c9;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<WS_Movable> > c10;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<SW_Movable> > c11;
+  Defaulted_SW_NeedyTemplate6<Template_NonMovable<SWS_Movable> > c12;
+
+  Defaulted_SW_NeedyTemplate6<> c13;
+}
+
+void good6() {
+  Defaulted_SW_NeedyTemplate6<Movable> a1;
+  Defaulted_SW_NeedyTemplate6<S_Movable> a2;
+  Defaulted_SW_NeedyTemplate6<W_Movable> a3;
+  Defaulted_SW_NeedyTemplate6<WS_Movable> a4;
+  Defaulted_SW_NeedyTemplate6<SW_Movable> a5;
+  Defaulted_SW_NeedyTemplate6<SWS_Movable> a6;
+
+  Defaulted_SW_NeedyTemplate6<Template_Inline<Movable> > b1;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<S_Movable> > b2;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<W_Movable> > b3;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<WS_Movable> > b4;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<SW_Movable> > b5;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<SWS_Movable> > b6;
+
+  Defaulted_SW_NeedyTemplate6<Template_Unused<Movable> > c1;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<S_Movable> > c2;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<W_Movable> > c3;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<WS_Movable> > c4;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<SW_Movable> > c5;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<SWS_Movable> > c6;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<NonMovable> > c7;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<S_NonMovable> > c8;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<W_NonMovable> > c9;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<WS_NonMovable> > c10;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<SW_NonMovable> > c11;
+  Defaulted_SW_NeedyTemplate6<Template_Unused<SWS_NonMovable> > c12;
+
+  Defaulted_SW_NeedyTemplate6<Template_Ref<Movable> > d1;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<S_Movable> > d2;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<W_Movable> > d3;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<WS_Movable> > d4;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<SW_Movable> > d5;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<SWS_Movable> > d6;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<NonMovable> > d7;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<S_NonMovable> > d8;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<W_NonMovable> > d9;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<WS_NonMovable> > d10;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<SW_NonMovable> > d11;
+  Defaulted_SW_NeedyTemplate6<Template_Ref<SWS_NonMovable> > d12;
+}
+
+//
+// 7 - MOZ_NEEDS_MEMMOVABLE_TYPE instantiated as default template argument
+//
+
+template <class T>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE NeedyTemplate7 {T m;}; // expected-error-re 26 {{Cannot instantiate 'NeedyTemplate7<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+template <class T, class Q = NeedyTemplate7<T> >
+struct Defaulted_Templated_NeedyTemplate7 {Q m;}; // expected-note-re 26 {{instantiation of 'NeedyTemplate7<{{.*}}>' requested here}}
+void bad7() {
+  Defaulted_Templated_NeedyTemplate7<NonMovable> a1;
+  Defaulted_Templated_NeedyTemplate7<S_NonMovable> a2;
+  Defaulted_Templated_NeedyTemplate7<W_NonMovable> a3;
+  Defaulted_Templated_NeedyTemplate7<WS_NonMovable> a4;
+  Defaulted_Templated_NeedyTemplate7<SW_NonMovable> a5;
+  Defaulted_Templated_NeedyTemplate7<SWS_NonMovable> a6;
+
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<NonMovable> > b1;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<S_NonMovable> > b2;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<W_NonMovable> > b3;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<WS_NonMovable> > b4;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<SW_NonMovable> > b5;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<SWS_NonMovable> > b6;
+
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<NonMovable> > c1;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<S_NonMovable> > c2;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<W_NonMovable> > c3;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<WS_NonMovable> > c4;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<SW_NonMovable> > c5;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<SWS_NonMovable> > c6;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<Movable> > c7;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<S_Movable> > c8;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<W_Movable> > c9;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<WS_Movable> > c10;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<SW_Movable> > c11;
+  Defaulted_Templated_NeedyTemplate7<Template_NonMovable<SWS_Movable> > c12;
+}
+
+void good7() {
+  Defaulted_Templated_NeedyTemplate7<Movable> a1;
+  Defaulted_Templated_NeedyTemplate7<S_Movable> a2;
+  Defaulted_Templated_NeedyTemplate7<W_Movable> a3;
+  Defaulted_Templated_NeedyTemplate7<WS_Movable> a4;
+  Defaulted_Templated_NeedyTemplate7<SW_Movable> a5;
+  Defaulted_Templated_NeedyTemplate7<SWS_Movable> a6;
+
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<Movable> > b1;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<S_Movable> > b2;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<W_Movable> > b3;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<WS_Movable> > b4;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<SW_Movable> > b5;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<SWS_Movable> > b6;
+
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<Movable> > c1;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<S_Movable> > c2;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<W_Movable> > c3;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<WS_Movable> > c4;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<SW_Movable> > c5;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<SWS_Movable> > c6;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<NonMovable> > c7;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<S_NonMovable> > c8;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<W_NonMovable> > c9;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<WS_NonMovable> > c10;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<SW_NonMovable> > c11;
+  Defaulted_Templated_NeedyTemplate7<Template_Unused<SWS_NonMovable> > c12;
+
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<Movable> > d1;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<S_Movable> > d2;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<W_Movable> > d3;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<WS_Movable> > d4;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<SW_Movable> > d5;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<SWS_Movable> > d6;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<NonMovable> > d7;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<S_NonMovable> > d8;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<W_NonMovable> > d9;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<WS_NonMovable> > d10;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<SW_NonMovable> > d11;
+  Defaulted_Templated_NeedyTemplate7<Template_Ref<SWS_NonMovable> > d12;
+}
+
+//
+// 8 - Wrapped MOZ_NEEDS_MEMMOVABLE_TYPE instantiated as default template argument
+//
+
+template <class T>
+struct MOZ_NEEDS_MEMMOVABLE_TYPE NeedyTemplate8 {T m;}; // expected-error-re 26 {{Cannot instantiate 'NeedyTemplate8<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+template <class T, class Q = NeedyTemplate8<T> >
+struct Defaulted_Templated_NeedyTemplate8 {Q m;}; // expected-note-re 26 {{instantiation of 'NeedyTemplate8<{{.*}}>' requested here}}
+template <class T>
+struct W_Defaulted_Templated_NeedyTemplate8 {
+  Defaulted_Templated_NeedyTemplate8<T> m;
+};
+void bad8() {
+  W_Defaulted_Templated_NeedyTemplate8<NonMovable> a1;
+  W_Defaulted_Templated_NeedyTemplate8<S_NonMovable> a2;
+  W_Defaulted_Templated_NeedyTemplate8<W_NonMovable> a3;
+  W_Defaulted_Templated_NeedyTemplate8<WS_NonMovable> a4;
+  W_Defaulted_Templated_NeedyTemplate8<SW_NonMovable> a5;
+  W_Defaulted_Templated_NeedyTemplate8<SWS_NonMovable> a6;
+
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<NonMovable> > b1;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<S_NonMovable> > b2;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<W_NonMovable> > b3;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<WS_NonMovable> > b4;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<SW_NonMovable> > b5;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<SWS_NonMovable> > b6;
+
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<NonMovable> > c1;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<S_NonMovable> > c2;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<W_NonMovable> > c3;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<WS_NonMovable> > c4;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<SW_NonMovable> > c5;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<SWS_NonMovable> > c6;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<Movable> > c7;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<S_Movable> > c8;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<W_Movable> > c9;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<WS_Movable> > c10;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<SW_Movable> > c11;
+  W_Defaulted_Templated_NeedyTemplate8<Template_NonMovable<SWS_Movable> > c12;
+}
+
+void good8() {
+  W_Defaulted_Templated_NeedyTemplate8<Movable> a1;
+  W_Defaulted_Templated_NeedyTemplate8<S_Movable> a2;
+  W_Defaulted_Templated_NeedyTemplate8<W_Movable> a3;
+  W_Defaulted_Templated_NeedyTemplate8<WS_Movable> a4;
+  W_Defaulted_Templated_NeedyTemplate8<SW_Movable> a5;
+  W_Defaulted_Templated_NeedyTemplate8<SWS_Movable> a6;
+
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<Movable> > b1;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<S_Movable> > b2;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<W_Movable> > b3;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<WS_Movable> > b4;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<SW_Movable> > b5;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<SWS_Movable> > b6;
+
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<Movable> > c1;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<S_Movable> > c2;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<W_Movable> > c3;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<WS_Movable> > c4;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<SW_Movable> > c5;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<SWS_Movable> > c6;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<NonMovable> > c7;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<S_NonMovable> > c8;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<W_NonMovable> > c9;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<WS_NonMovable> > c10;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<SW_NonMovable> > c11;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Unused<SWS_NonMovable> > c12;
+
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<Movable> > d1;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<S_Movable> > d2;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<W_Movable> > d3;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<WS_Movable> > d4;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<SW_Movable> > d5;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<SWS_Movable> > d6;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<NonMovable> > d7;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<S_NonMovable> > d8;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<W_NonMovable> > d9;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<WS_NonMovable> > d10;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<SW_NonMovable> > d11;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Ref<SWS_NonMovable> > d12;
+}
+
+/*
+  SpecializedNonMovable is a non-movable class which has an explicit specialization of NeedyTemplate
+  for it. Instantiations of NeedyTemplateN<SpecializedNonMovable> should be legal as the explicit
+  specialization isn't annotated with MOZ_NEEDS_MEMMOVABLE_TYPE.
+
+  However, as it is MOZ_NON_MEMMOVABLE, derived classes and members shouldn't be able to be used to
+  instantiate NeedyTemplate.
+*/
+
+struct MOZ_NON_MEMMOVABLE SpecializedNonMovable {};
+struct S_SpecializedNonMovable : SpecializedNonMovable {}; // expected-note 8 {{'S_SpecializedNonMovable' is a non-memmove()able type because it inherits from a non-memmove()able type 'SpecializedNonMovable'}}
+
+// Specialize all of the NeedyTemplates with SpecializedNonMovable.
+template <>
+struct NeedyTemplate1<SpecializedNonMovable> {};
+template <>
+struct NeedyTemplate2<SpecializedNonMovable> {};
+template <>
+struct NeedyTemplate3<SpecializedNonMovable> {};
+template <>
+struct NeedyTemplate4<SpecializedNonMovable> {};
+template <>
+struct NeedyTemplate5<SpecializedNonMovable> {};
+template <>
+struct NeedyTemplate6<SpecializedNonMovable> {};
+template <>
+struct NeedyTemplate7<SpecializedNonMovable> {};
+template <>
+struct NeedyTemplate8<SpecializedNonMovable> {};
+
+void specialization() {
+  /*
+    SpecializedNonMovable has a specialization for every variant of NeedyTemplate,
+    so these templates are valid, even though SpecializedNonMovable isn't
+    memmovable
+  */
+  NeedyTemplate1<SpecializedNonMovable> a1;
+  S_NeedyTemplate2<SpecializedNonMovable> a2;
+  W_NeedyTemplate3<SpecializedNonMovable> a3;
+  WS_NeedyTemplate4<SpecializedNonMovable> a4;
+  SW_NeedyTemplate5<SpecializedNonMovable> a5;
+  Defaulted_SW_NeedyTemplate6<SpecializedNonMovable> a6;
+  Defaulted_Templated_NeedyTemplate7<SpecializedNonMovable> a7;
+  W_Defaulted_Templated_NeedyTemplate8<SpecializedNonMovable> a8;
+
+  /*
+    These entries contain an element which is SpecializedNonMovable, and are non-movable
+    as there is no valid specialization, and their member is non-memmovable
+  */
+  NeedyTemplate1<Template_Inline<SpecializedNonMovable> > b1;  // expected-note {{instantiation of 'NeedyTemplate1<Template_Inline<SpecializedNonMovable> >' requested here}}
+  S_NeedyTemplate2<Template_Inline<SpecializedNonMovable> > b2;
+  W_NeedyTemplate3<Template_Inline<SpecializedNonMovable> > b3;
+  WS_NeedyTemplate4<Template_Inline<SpecializedNonMovable> > b4;
+  SW_NeedyTemplate5<Template_Inline<SpecializedNonMovable> > b5;
+  Defaulted_SW_NeedyTemplate6<Template_Inline<SpecializedNonMovable> > b6;
+  Defaulted_Templated_NeedyTemplate7<Template_Inline<SpecializedNonMovable> > b7;
+  W_Defaulted_Templated_NeedyTemplate8<Template_Inline<SpecializedNonMovable> > b8;
+
+  /*
+    The subclass of SpecializedNonMovable, is also non-memmovable,
+    as there is no valid specialization.
+  */
+  NeedyTemplate1<S_SpecializedNonMovable> c1; // expected-note {{instantiation of 'NeedyTemplate1<S_SpecializedNonMovable>' requested here}}
+  S_NeedyTemplate2<S_SpecializedNonMovable> c2;
+  W_NeedyTemplate3<S_SpecializedNonMovable> c3;
+  WS_NeedyTemplate4<S_SpecializedNonMovable> c4;
+  SW_NeedyTemplate5<S_SpecializedNonMovable> c5;
+  Defaulted_SW_NeedyTemplate6<S_SpecializedNonMovable> c6;
+  Defaulted_Templated_NeedyTemplate7<S_SpecializedNonMovable> c7;
+  W_Defaulted_Templated_NeedyTemplate8<S_SpecializedNonMovable> c8;
+}
+
+class MOZ_NEEDS_MEMMOVABLE_MEMBERS NeedsMemMovableMembers {
+  Movable m1;
+  NonMovable m2; // expected-error {{class 'NeedsMemMovableMembers' cannot have non-memmovable member 'm2' of type 'NonMovable'}}
+  S_Movable sm1;
+  S_NonMovable sm2; // expected-error {{class 'NeedsMemMovableMembers' cannot have non-memmovable member 'sm2' of type 'S_NonMovable'}}
+  W_Movable wm1;
+  W_NonMovable wm2; // expected-error {{class 'NeedsMemMovableMembers' cannot have non-memmovable member 'wm2' of type 'W_NonMovable'}}
+  SW_Movable swm1;
+  SW_NonMovable swm2; // expected-error {{class 'NeedsMemMovableMembers' cannot have non-memmovable member 'swm2' of type 'SW_NonMovable'}}
+  WS_Movable wsm1;
+  WS_NonMovable wsm2; // expected-error {{class 'NeedsMemMovableMembers' cannot have non-memmovable member 'wsm2' of type 'WS_NonMovable'}}
+  SWS_Movable swsm1;
+  SWS_NonMovable swsm2; // expected-error {{class 'NeedsMemMovableMembers' cannot have non-memmovable member 'swsm2' of type 'SWS_NonMovable'}}
+};
+
+class NeedsMemMovableMembersDerived : public NeedsMemMovableMembers {};
diff --git a/build/clang-plugin/tests/TestNonMemMovableStd.cpp b/build/clang-plugin/tests/TestNonMemMovableStd.cpp
new file mode 100644
index 000000000..9fce52496
--- /dev/null
+++ b/build/clang-plugin/tests/TestNonMemMovableStd.cpp
@@ -0,0 +1,21 @@
+#define MOZ_NEEDS_MEMMOVABLE_TYPE __attribute__((annotate("moz_needs_memmovable_type")))
+
+template<class T>
+class MOZ_NEEDS_MEMMOVABLE_TYPE Mover { T mForceInst; }; // expected-error-re 4 {{Cannot instantiate 'Mover<{{.*}}>' with non-memmovable template argument '{{.*}}'}}
+
+namespace std {
+// In theory defining things in std:: like this invokes undefined
+// behavior, but in practice it's good enough for this test case.
+template<class C> class basic_string { };
+typedef basic_string<char> string;
+template<class T, class U> class pair { T mT; U mU; }; // expected-note {{std::pair<bool, std::basic_string<char> >' is a non-memmove()able type because member 'mU' is a non-memmove()able type 'std::basic_string<char>'}}
+class arbitrary_name { };
+}
+
+class HasString { std::string m; }; // expected-note {{'HasString' is a non-memmove()able type because member 'm' is a non-memmove()able type 'std::string' (aka 'basic_string<char>')}}
+
+static Mover<std::string> bad; // expected-note {{instantiation of 'Mover<std::basic_string<char> >' requested here}}
+static Mover<HasString> bad_mem; // expected-note {{instantiation of 'Mover<HasString>' requested here}}
+static Mover<std::arbitrary_name> assumed_bad; // expected-note {{instantiation of 'Mover<std::arbitrary_name>' requested here}}
+static Mover<std::pair<bool, int>> good;
+static Mover<std::pair<bool, std::string>> not_good; // expected-note {{instantiation of 'Mover<std::pair<bool, std::basic_string<char> > >' requested here}}
diff --git a/build/clang-plugin/tests/TestNonParameterChecker.cpp b/build/clang-plugin/tests/TestNonParameterChecker.cpp
new file mode 100644
index 000000000..87ff89238
--- /dev/null
+++ b/build/clang-plugin/tests/TestNonParameterChecker.cpp
@@ -0,0 +1,179 @@
+#define MOZ_NON_PARAM __attribute__((annotate("moz_non_param")))
+
+struct Param {};
+struct MOZ_NON_PARAM NonParam {};
+union MOZ_NON_PARAM NonParamUnion {};
+class MOZ_NON_PARAM NonParamClass {};
+enum MOZ_NON_PARAM NonParamEnum { X, Y, Z };
+enum class MOZ_NON_PARAM NonParamEnumClass { X, Y, Z };
+
+struct HasNonParamStruct { NonParam x; int y; };
+union HasNonParamUnion { NonParam x; int y; };
+struct HasNonParamStructUnion { HasNonParamUnion z; };
+
+#define MAYBE_STATIC
+#include "NonParameterTestCases.h"
+#undef MAYBE_STATIC
+
+// Do not check typedef and using.
+typedef void (*funcTypeParam)(Param x);
+typedef void (*funcTypeNonParam)(NonParam x);
+
+using usingFuncTypeParam = void (*)(Param x);
+using usingFuncTypeNonParam = void (*)(NonParam x);
+
+class class_
+{
+    explicit class_(Param x) {}
+    explicit class_(NonParam x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    explicit class_(HasNonParamStruct x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    explicit class_(HasNonParamUnion x) {} //expected-error {{Type 'HasNonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    explicit class_(HasNonParamStructUnion x) {} //expected-error {{Type 'HasNonParamStructUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+
+#define MAYBE_STATIC
+#include "NonParameterTestCases.h"
+#undef MAYBE_STATIC
+};
+
+class classWithStatic
+{
+#define MAYBE_STATIC static
+#include "NonParameterTestCases.h"
+#undef MAYBE_STATIC
+};
+
+template <typename T>
+class tmplClassForParam
+{
+public:
+    void raw(T x) {}
+    void rawDefault(T x = T()) {}
+    void const_(const T x) {}
+    void ptr(T* x) {}
+    void ref(T& x) {}
+    void constRef(const T& x) {}
+
+    void notCalled(T x) {}
+};
+
+template <typename T>
+class tmplClassForNonParam
+{
+public:
+    void raw(T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    void rawDefault(T x = T()) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    void const_(const T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    void ptr(T* x) {}
+    void ref(T& x) {}
+    void constRef(const T& x) {}
+
+    void notCalled(T x) {}
+};
+
+template <typename T>
+class tmplClassForHasNonParamStruct
+{
+public:
+    void raw(T x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    void rawDefault(T x = T()) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    void const_(const T x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    void ptr(T* x) {}
+    void ref(T& x) {}
+    void constRef(const T& x) {}
+
+    void notCalled(T x) {}
+};
+
+void testTemplateClass()
+{
+    tmplClassForParam<Param> paramClass;
+    Param param;
+    paramClass.raw(param);
+    paramClass.rawDefault();
+    paramClass.const_(param);
+    paramClass.ptr(&param);
+    paramClass.ref(param);
+    paramClass.constRef(param);
+
+    tmplClassForNonParam<NonParam> nonParamClass; //expected-note 3 {{The bad argument was passed to 'tmplClassForNonParam' here}}
+    NonParam nonParam;
+    nonParamClass.raw(nonParam);
+    nonParamClass.rawDefault();
+    nonParamClass.const_(nonParam);
+    nonParamClass.ptr(&nonParam);
+    nonParamClass.ref(nonParam);
+    nonParamClass.constRef(nonParam);
+
+    tmplClassForHasNonParamStruct<HasNonParamStruct> hasNonParamStructClass;//expected-note 3 {{The bad argument was passed to 'tmplClassForHasNonParamStruct' here}}
+    HasNonParamStruct hasNonParamStruct;
+    hasNonParamStructClass.raw(hasNonParamStruct);
+    hasNonParamStructClass.rawDefault();
+    hasNonParamStructClass.const_(hasNonParamStruct);
+    hasNonParamStructClass.ptr(&hasNonParamStruct);
+    hasNonParamStructClass.ref(hasNonParamStruct);
+    hasNonParamStructClass.constRef(hasNonParamStruct);
+}
+
+template <typename T>
+class NestedTemplateInner
+{
+public:
+    void raw(T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+};
+
+template <typename T>
+class nestedTemplateOuter
+{
+public:
+    void constRef(const T& x) {
+        NestedTemplateInner<T> inner; //expected-note {{The bad argument was passed to 'NestedTemplateInner' here}}
+        inner.raw(x);
+    }
+};
+
+void testNestedTemplateClass()
+{
+    nestedTemplateOuter<NonParam> outer;
+    NonParam nonParam;
+    outer.constRef(nonParam); // FIXME: this line needs note "The bad argument was passed to 'constRef' here"
+}
+
+template <typename T>
+void tmplFuncForParam(T x) {}
+template <typename T>
+void tmplFuncForNonParam(T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+template <typename T>
+void tmplFuncForNonParamImplicit(T x) {} //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+template <typename T>
+void tmplFuncForHasNonParamStruct(T x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+template <typename T>
+void tmplFuncForHasNonParamStructImplicit(T x) {} //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+
+void testTemplateFunc()
+{
+    Param param;
+    tmplFuncForParam<Param>(param);
+
+    NonParam nonParam;
+    tmplFuncForNonParam<NonParam>(nonParam); // FIXME: this line needs note "The bad argument was passed to 'tmplFuncForNonParam' here"
+    tmplFuncForNonParamImplicit(nonParam); // FIXME: this line needs note "The bad argument was passed to 'tmplFuncForNonParamImplicit' here"
+
+    HasNonParamStruct hasNonParamStruct;
+    tmplFuncForHasNonParamStruct<HasNonParamStruct>(hasNonParamStruct); // FIXME: this line needs note "The bad argument was passed to 'tmplFuncForHasNonParamStruct' here"
+    tmplFuncForHasNonParamStructImplicit(hasNonParamStruct); // FIXME: this line needs note "The bad argument was passed to 'tmplFuncForHasNonParamStructImplicit' here"
+}
+
+void testLambda()
+{
+    auto paramLambda = [](Param x) -> void {};
+    auto nonParamLambda = [](NonParam x) -> void {}; //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    auto nonParamStructLambda = [](HasNonParamStruct x) -> void {}; //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    auto nonParamUnionLambda = [](HasNonParamUnion x) -> void {}; //expected-error {{Type 'HasNonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    auto nonParamStructUnionLambda = [](HasNonParamStructUnion x) -> void {}; //expected-error {{Type 'HasNonParamStructUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+
+    (void)[](Param x) -> void {};
+    (void)[](NonParam x) -> void {}; //expected-error {{Type 'NonParam' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    (void)[](HasNonParamStruct x) -> void {}; //expected-error {{Type 'HasNonParamStruct' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    (void)[](HasNonParamUnion x) -> void {}; //expected-error {{Type 'HasNonParamUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+    (void)[](HasNonParamStructUnion x) -> void {}; //expected-error {{Type 'HasNonParamStructUnion' must not be used as parameter}} expected-note {{Please consider passing a const reference instead}}
+}
diff --git a/build/clang-plugin/tests/TestNonTemporaryClass.cpp b/build/clang-plugin/tests/TestNonTemporaryClass.cpp
new file mode 100644
index 000000000..682c8ad53
--- /dev/null
+++ b/build/clang-plugin/tests/TestNonTemporaryClass.cpp
@@ -0,0 +1,70 @@
+#define MOZ_NON_TEMPORARY_CLASS __attribute__((annotate("moz_non_temporary_class")))
+#define MOZ_IMPLICIT __attribute__((annotate("moz_implicit")))
+
+#include <stddef.h>
+
+struct MOZ_NON_TEMPORARY_CLASS NonTemporary {
+  int i;
+  NonTemporary() {}
+  MOZ_IMPLICIT NonTemporary(int a) {}
+  NonTemporary(int a, int b) {}
+  void *operator new(size_t x) throw() { return 0; }
+  void *operator new(size_t blah, char *buffer) { return buffer; }
+};
+
+template <class T>
+struct MOZ_NON_TEMPORARY_CLASS TemplateClass {
+  T i;
+};
+
+void gobble(void *) { }
+
+void gobbleref(const NonTemporary&) { }
+
+template <class T>
+void gobbleanyref(const T&) { }
+
+void misuseNonTemporaryClass(int len) {
+  NonTemporary invalid;
+  NonTemporary alsoInvalid[2];
+  static NonTemporary invalidStatic;
+  static NonTemporary alsoInvalidStatic[2];
+
+  gobble(&invalid);
+  gobble(&invalidStatic);
+  gobble(&alsoInvalid[0]);
+
+  gobbleref(NonTemporary()); // expected-error {{variable of type 'NonTemporary' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
+  gobbleref(NonTemporary(10, 20)); // expected-error {{variable of type 'NonTemporary' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
+  gobbleref(NonTemporary(10)); // expected-error {{variable of type 'NonTemporary' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
+  gobbleref(10); // expected-error {{variable of type 'NonTemporary' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
+  gobbleanyref(TemplateClass<int>()); // expected-error {{variable of type 'TemplateClass<int>' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
+
+  gobble(new NonTemporary);
+  gobble(new NonTemporary[10]);
+  gobble(new TemplateClass<int>);
+  gobble(len <= 5 ? &invalid : new NonTemporary);
+
+  char buffer[sizeof(NonTemporary)];
+  gobble(new (buffer) NonTemporary);
+}
+
+void defaultArg(const NonTemporary& arg = NonTemporary()) {
+}
+
+NonTemporary invalidStatic;
+struct RandomClass {
+  NonTemporary nonstaticMember; // expected-note {{'RandomClass' is a non-temporary type because member 'nonstaticMember' is a non-temporary type 'NonTemporary'}}
+  static NonTemporary staticMember;
+};
+struct MOZ_NON_TEMPORARY_CLASS RandomNonTemporaryClass {
+  NonTemporary nonstaticMember;
+  static NonTemporary staticMember;
+};
+
+struct BadInherit : NonTemporary {}; // expected-note {{'BadInherit' is a non-temporary type because it inherits from a non-temporary type 'NonTemporary'}}
+
+void useStuffWrongly() {
+  gobbleanyref(BadInherit()); // expected-error {{variable of type 'BadInherit' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
+  gobbleanyref(RandomClass()); // expected-error {{variable of type 'RandomClass' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
+}
diff --git a/build/clang-plugin/tests/TestOverrideBaseCall.cpp b/build/clang-plugin/tests/TestOverrideBaseCall.cpp
new file mode 100644
index 000000000..6fdaaad04
--- /dev/null
+++ b/build/clang-plugin/tests/TestOverrideBaseCall.cpp
@@ -0,0 +1,175 @@
+#define MOZ_REQUIRED_BASE_METHOD __attribute__((annotate("moz_required_base_method")))
+
+class Base {
+public:
+  virtual void fo() MOZ_REQUIRED_BASE_METHOD {
+  }
+
+  virtual int foRet() MOZ_REQUIRED_BASE_METHOD {
+    return 0;
+  }
+};
+
+class BaseOne : public Base {
+public:
+  virtual void fo() MOZ_REQUIRED_BASE_METHOD {
+    Base::fo();
+  }
+};
+
+class BaseSecond : public Base {
+public:
+  virtual void fo() MOZ_REQUIRED_BASE_METHOD {
+   Base::fo();
+  }
+};
+
+class Deriv : public BaseOne, public BaseSecond {
+public:
+  void func() {
+  }
+
+  void fo() {
+    func();
+    BaseSecond::fo();
+    BaseOne::fo();
+  }
+};
+
+class DerivSimple : public Base {
+public:
+  void fo() { // expected-error {{Method Base::fo must be called in all overrides, but is not called in this override defined for class DerivSimple}}
+  }
+};
+
+class BaseVirtualOne : public virtual Base {
+};
+
+class BaseVirtualSecond: public virtual Base {
+};
+
+class DerivVirtual : public BaseVirtualOne, public BaseVirtualSecond {
+public:
+  void fo() {
+    Base::fo();
+  }
+};
+
+class DerivIf : public Base {
+public:
+  void fo() {
+    if (true) {
+      Base::fo();
+    }
+  }
+};
+
+class DerivIfElse : public Base {
+public:
+  void fo() {
+    if (true) {
+      Base::fo();
+    } else {
+      Base::fo();
+    }
+  }
+};
+
+class DerivFor : public Base {
+public:
+  void fo() {
+    for (int i = 0; i < 10; i++) {
+      Base::fo();
+    }
+  }
+};
+
+class DerivDoWhile : public Base {
+public:
+  void fo() {
+    do {
+      Base::fo();
+    } while(false);
+  }
+};
+
+class DerivWhile : public Base {
+public:
+  void fo() {
+    while (true) {
+      Base::fo();
+      break;
+    }
+  }
+};
+
+class DerivAssignment : public Base {
+public:
+  int foRet() {
+    return foRet();
+  }
+};
+
+class BaseOperator {
+private:
+  int value;
+public:
+  BaseOperator() : value(0) {
+  }
+  virtual BaseOperator& operator++() MOZ_REQUIRED_BASE_METHOD {
+    value++;
+    return *this;
+  }
+};
+
+class DerivOperatorErr : public BaseOperator {
+private:
+  int value;
+public:
+  DerivOperatorErr() : value(0) {
+  }
+  DerivOperatorErr& operator++() { // expected-error {{Method BaseOperator::operator++ must be called in all overrides, but is not called in this override defined for class DerivOperatorErr}}
+    value++;
+    return *this;
+  }
+};
+
+class DerivOperator : public BaseOperator {
+private:
+  int value;
+public:
+  DerivOperator() : value(0) {
+  }
+  DerivOperator& operator++() {
+    BaseOperator::operator++();
+    value++;
+    return *this;
+  }
+};
+
+class DerivPrime : public Base {
+public:
+  void fo() {
+    Base::fo();
+  }
+};
+
+class DerivSecondErr : public DerivPrime {
+public:
+  void fo() { // expected-error {{Method Base::fo must be called in all overrides, but is not called in this override defined for class DerivSecondErr}}
+  }
+};
+
+class DerivSecond : public DerivPrime {
+public:
+  void fo() {
+    Base::fo();
+  }
+};
+
+class DerivSecondIndirect : public DerivPrime {
+public:
+  void fo() {
+    DerivPrime::fo();
+  }
+};
diff --git a/build/clang-plugin/tests/TestOverrideBaseCallAnnotation.cpp b/build/clang-plugin/tests/TestOverrideBaseCallAnnotation.cpp
new file mode 100644
index 000000000..e268122c6
--- /dev/null
+++ b/build/clang-plugin/tests/TestOverrideBaseCallAnnotation.cpp
@@ -0,0 +1,47 @@
+#define MOZ_REQUIRED_BASE_METHOD __attribute__((annotate("moz_required_base_method")))
+
+class Base {
+public:
+  virtual void fo() MOZ_REQUIRED_BASE_METHOD {
+  }
+};
+
+class BaseNonVirtual {
+public:
+  void fo() MOZ_REQUIRED_BASE_METHOD { // expected-error {{MOZ_REQUIRED_BASE_METHOD can be used only on virtual methods}}
+  }
+};
+
+class Deriv : public BaseNonVirtual {
+public:
+  virtual void fo() MOZ_REQUIRED_BASE_METHOD {
+  }
+};
+
+class DerivVirtual : public Base {
+public:
+  void fo() MOZ_REQUIRED_BASE_METHOD {
+    Base::fo();
+  }
+};
+
+class BaseOperator {
+public:
+  BaseOperator& operator++() MOZ_REQUIRED_BASE_METHOD { // expected-error {{MOZ_REQUIRED_BASE_METHOD can be used only on virtual methods}}
+    return *this;
+  }
+};
+
+class DerivOperator : public BaseOperator {
+public:
+  virtual DerivOperator& operator++() {
+    return *this;
+  }
+};
+
+class DerivPrimeOperator : public DerivOperator {
+public:
+  DerivPrimeOperator& operator++() {
+    return *this;
+  }
+};
diff --git a/build/clang-plugin/tests/TestRefCountedCopyConstructor.cpp b/build/clang-plugin/tests/TestRefCountedCopyConstructor.cpp
new file mode 100644
index 000000000..d3bd73084
--- /dev/null
+++ b/build/clang-plugin/tests/TestRefCountedCopyConstructor.cpp
@@ -0,0 +1,25 @@
+// Implicit copy construct which is unused
+class RC1 {
+  void AddRef();
+  void Release();
+  int mRefCnt;
+};
+
+// Explicit copy constructor which is used
+class RC2 {
+public:
+  RC2();
+  RC2(const RC2&);
+private:
+  void AddRef();
+  void Release();
+  int mRefCnt;
+};
+
+void f() {
+  RC1* r1 = new RC1();
+  RC1* r1p = new RC1(*r1); // expected-error {{Invalid use of compiler-provided copy constructor on refcounted type}} expected-note {{The default copy constructor also copies the default mRefCnt property, leading to reference count imbalance issues. Please provide your own copy constructor which only copies the fields which need to be copied}}
+
+  RC2* r2 = new RC2();
+  RC2* r2p = new RC2(*r2);
+}
diff --git a/build/clang-plugin/tests/TestSprintfLiteral.cpp b/build/clang-plugin/tests/TestSprintfLiteral.cpp
new file mode 100644
index 000000000..9b7675433
--- /dev/null
+++ b/build/clang-plugin/tests/TestSprintfLiteral.cpp
@@ -0,0 +1,47 @@
+#include <cstdio>
+
+void bad() {
+  char x[100];
+  snprintf(x, sizeof(x), "bar"); // expected-error {{Use SprintfLiteral instead of snprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to snprintf accidentally.}}
+  snprintf(x, 100, "bar"); // expected-error {{Use SprintfLiteral instead of snprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to snprintf accidentally.}}
+  snprintf(x, 101, "bar"); // expected-error {{Use SprintfLiteral instead of snprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to snprintf accidentally.}}
+  const int hundred = 100;
+  snprintf(x, hundred, "bar"); // expected-error {{Use SprintfLiteral instead of snprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to snprintf accidentally.}}
+  const int hundredandone = 101;
+  snprintf(x, hundredandone, "bar"); // expected-error {{Use SprintfLiteral instead of snprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to snprintf accidentally.}}
+}
+
+void ok() {
+  char x[100];
+  int y;
+  snprintf(x, sizeof(y), "what");
+
+  snprintf(x, 50, "what");
+
+  int nothundred = 100;
+  nothundred = 99;
+  snprintf(x, nothundred, "what");
+}
+
+void vargs_bad(va_list args) {
+  char x[100];
+  vsnprintf(x, sizeof(x), "bar", args); // expected-error {{Use VsprintfLiteral instead of vsnprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to vsnprintf accidentally.}}
+  vsnprintf(x, 100, "bar", args); // expected-error {{Use VsprintfLiteral instead of vsnprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to vsnprintf accidentally.}}
+  vsnprintf(x, 101, "bar", args); // expected-error {{Use VsprintfLiteral instead of vsnprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to vsnprintf accidentally.}}
+  const int hundred = 100;
+  vsnprintf(x, hundred, "bar", args); // expected-error {{Use VsprintfLiteral instead of vsnprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to vsnprintf accidentally.}}
+  const int hundredandone = 101;
+  vsnprintf(x, hundredandone, "bar", args); // expected-error {{Use VsprintfLiteral instead of vsnprintf when writing into a character array.}} expected-note {{This will prevent passing in the wrong size to vsnprintf accidentally.}}
+}
+
+void vargs_good(va_list args) {
+  char x[100];
+  int y;
+  vsnprintf(x, sizeof(y), "what", args);
+
+  vsnprintf(x, 50, "what", args);
+
+  int nothundred = 100;
+  nothundred = 99;
+  vsnprintf(x, nothundred, "what", args);
+}
diff --git a/build/clang-plugin/tests/TestStackClass.cpp b/build/clang-plugin/tests/TestStackClass.cpp
new file mode 100644
index 000000000..41afa39e1
--- /dev/null
+++ b/build/clang-plugin/tests/TestStackClass.cpp
@@ -0,0 +1,50 @@
+#define MOZ_STACK_CLASS __attribute__((annotate("moz_stack_class")))
+#include <stddef.h>
+
+struct MOZ_STACK_CLASS Stack {
+  int i;
+  void *operator new(size_t x) throw() { return 0; }
+  void *operator new(size_t blah, char *buffer) { return buffer; }
+};
+
+template <class T>
+struct MOZ_STACK_CLASS TemplateClass {
+  T i;
+};
+
+void gobble(void *) { }
+
+void misuseStackClass(int len) {
+  Stack valid;
+  Stack alsoValid[2];
+  static Stack notValid; // expected-error {{variable of type 'Stack' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+  static Stack alsoNotValid[2]; // expected-error {{variable of type 'Stack [2]' only valid on the stack}} expected-note {{'Stack [2]' is a stack type because it is an array of stack type 'Stack'}} expected-note {{value incorrectly allocated in a global variable}}
+
+  gobble(&valid);
+  gobble(&notValid);
+  gobble(&alsoValid[0]);
+
+  gobble(new Stack); // expected-error {{variable of type 'Stack' only valid on the stack}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(new Stack[10]); // expected-error {{variable of type 'Stack' only valid on the stack}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(new TemplateClass<int>); // expected-error {{variable of type 'TemplateClass<int>' only valid on the stack}} expected-note {{value incorrectly allocated on the heap}}
+  gobble(len <= 5 ? &valid : new Stack); // expected-error {{variable of type 'Stack' only valid on the stack}} expected-note {{value incorrectly allocated on the heap}}
+
+  char buffer[sizeof(Stack)];
+  gobble(new (buffer) Stack);
+}
+
+Stack notValid; // expected-error {{variable of type 'Stack' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+struct RandomClass {
+  Stack nonstaticMember; // expected-note {{'RandomClass' is a stack type because member 'nonstaticMember' is a stack type 'Stack'}}
+  static Stack staticMember; // expected-error {{variable of type 'Stack' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+};
+struct MOZ_STACK_CLASS RandomStackClass {
+  Stack nonstaticMember;
+  static Stack staticMember; // expected-error {{variable of type 'Stack' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+};
+
+struct BadInherit : Stack {}; // expected-note {{'BadInherit' is a stack type because it inherits from a stack type 'Stack'}}
+struct MOZ_STACK_CLASS GoodInherit : Stack {};
+
+BadInherit moreInvalid; // expected-error {{variable of type 'BadInherit' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
+RandomClass evenMoreInvalid; // expected-error {{variable of type 'RandomClass' only valid on the stack}} expected-note {{value incorrectly allocated in a global variable}}
diff --git a/build/clang-plugin/tests/TestTrivialCtorDtor.cpp b/build/clang-plugin/tests/TestTrivialCtorDtor.cpp
new file mode 100644
index 000000000..cef06b0ac
--- /dev/null
+++ b/build/clang-plugin/tests/TestTrivialCtorDtor.cpp
@@ -0,0 +1,83 @@
+#define MOZ_TRIVIAL_CTOR_DTOR __attribute__((annotate("moz_trivial_ctor_dtor")))
+
+struct MOZ_TRIVIAL_CTOR_DTOR EmptyClass{};
+
+template <class T>
+struct MOZ_TRIVIAL_CTOR_DTOR TemplateEmptyClass{};
+
+struct MOZ_TRIVIAL_CTOR_DTOR NonEmptyClass {
+  void *m;
+};
+
+template <class T>
+struct MOZ_TRIVIAL_CTOR_DTOR TemplateNonEmptyClass {
+  T* m;
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR BadUserDefinedCtor { // expected-error {{class 'BadUserDefinedCtor' must have trivial constructors and destructors}}
+  BadUserDefinedCtor() {}
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR BadUserDefinedDtor { // expected-error {{class 'BadUserDefinedDtor' must have trivial constructors and destructors}}
+  ~BadUserDefinedDtor() {}
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR BadVirtualDtor { // expected-error {{class 'BadVirtualDtor' must have trivial constructors and destructors}}
+  virtual ~BadVirtualDtor() {}
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR OkVirtualMember {
+  virtual void f();
+};
+
+void foo();
+struct MOZ_TRIVIAL_CTOR_DTOR BadNonEmptyCtorDtor { // expected-error {{class 'BadNonEmptyCtorDtor' must have trivial constructors and destructors}}
+  BadNonEmptyCtorDtor() { foo(); }
+  ~BadNonEmptyCtorDtor() { foo(); }
+};
+
+struct NonTrivialCtor {
+  NonTrivialCtor() { foo(); }
+};
+
+struct NonTrivialDtor {
+  ~NonTrivialDtor() { foo(); }
+};
+
+struct VirtualMember {
+  virtual void f();
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR BadNonTrivialCtorInBase : NonTrivialCtor { // expected-error {{class 'BadNonTrivialCtorInBase' must have trivial constructors and destructors}}
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR BadNonTrivialDtorInBase : NonTrivialDtor { // expected-error {{class 'BadNonTrivialDtorInBase' must have trivial constructors and destructors}}
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR BadNonTrivialCtorInMember { // expected-error {{class 'BadNonTrivialCtorInMember' must have trivial constructors and destructors}}
+  NonTrivialCtor m;
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR BadNonTrivialDtorInMember { // expected-error {{class 'BadNonTrivialDtorInMember' must have trivial constructors and destructors}}
+  NonTrivialDtor m;
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR OkVirtualMemberInMember {
+  VirtualMember m;
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR OkConstExprConstructor {
+  constexpr OkConstExprConstructor() {}
+};
+
+struct MOZ_TRIVIAL_CTOR_DTOR OkConstExprConstructorInMember {
+  OkConstExprConstructor m;
+};
+
+// XXX: This error is unfortunate, but is unlikely to come up in real code.
+// In this situation, it should be possible to define a constexpr constructor
+// which explicitly initializes the members.
+struct MOZ_TRIVIAL_CTOR_DTOR BadUnfortunateError { // expected-error {{class 'BadUnfortunateError' must have trivial constructors and destructors}}
+  OkConstExprConstructor m;
+  void *n;
+};
diff --git a/build/clang-plugin/tests/moz.build b/build/clang-plugin/tests/moz.build
new file mode 100644
index 000000000..3f7bdcba1
--- /dev/null
+++ b/build/clang-plugin/tests/moz.build
@@ -0,0 +1,45 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+# dummy library name to avoid skipping building the sources here.
+Library('clang-plugin-tests')
+
+SOURCES += [
+    'TestAssertWithAssignment.cpp',
+    'TestBadImplicitConversionCtor.cpp',
+    'TestCustomHeap.cpp',
+    'TestExplicitOperatorBool.cpp',
+    'TestGlobalClass.cpp',
+    'TestHeapClass.cpp',
+    'TestInheritTypeAnnotationsFromTemplateArgs.cpp',
+    'TestKungFuDeathGrip.cpp',
+    'TestMultipleAnnotations.cpp',
+    'TestMustOverride.cpp',
+    'TestMustUse.cpp',
+    'TestNANTestingExpr.cpp',
+    'TestNANTestingExprC.c',
+    'TestNeedsNoVTableType.cpp',
+    'TestNoAddRefReleaseOnReturn.cpp',
+    'TestNoArithmeticExprInArgument.cpp',
+    'TestNoAutoType.cpp',
+    'TestNoDuplicateRefCntMember.cpp',
+    'TestNoExplicitMoveConstructor.cpp',
+    'TestNonHeapClass.cpp',
+    'TestNonMemMovable.cpp',
+    'TestNonMemMovableStd.cpp',
+    'TestNonParameterChecker.cpp',
+    'TestNonTemporaryClass.cpp',
+    'TestNoRefcountedInsideLambdas.cpp',
+    'TestOverrideBaseCall.cpp',
+    'TestOverrideBaseCallAnnotation.cpp',
+    'TestRefCountedCopyConstructor.cpp',
+    'TestSprintfLiteral.cpp',
+    'TestStackClass.cpp',
+    'TestTrivialCtorDtor.cpp',
+]
+
+DISABLE_STL_WRAPPING = True
+NO_VISIBILITY_FLAGS = True