Bug 1410472 - clang-plugin follows the LLVM coding style for real r=mystor
authorSylvestre Ledru <sledru@mozilla.com>
Fri, 20 Oct 2017 19:11:50 +0200
changeset 387474 88c9b8587db69f36601f45e6584ac2d1c5e459b5
parent 387473 bf168e36be08b031d517eb10c649e5d327a41f00
child 387475 5934eecb4afc3650da52044346124cb2979937d6
push id32720
push userarchaeopteryx@coole-files.de
push dateSat, 21 Oct 2017 08:58:11 +0000
treeherdermozilla-central@383d53a70a81 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmystor
bugs1410472
milestone58.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1410472 - clang-plugin follows the LLVM coding style for real r=mystor MozReview-Commit-ID: AXrQEjWzxvg
build/clang-plugin/ArithmeticArgChecker.cpp
build/clang-plugin/ArithmeticArgChecker.h
build/clang-plugin/AssertAssignmentChecker.cpp
build/clang-plugin/AssertAssignmentChecker.h
build/clang-plugin/BaseCheck.h
build/clang-plugin/CanRunScriptChecker.cpp
build/clang-plugin/CanRunScriptChecker.h
build/clang-plugin/CustomMatchers.h
build/clang-plugin/CustomTypeAnnotation.cpp
build/clang-plugin/CustomTypeAnnotation.h
build/clang-plugin/DanglingOnTemporaryChecker.cpp
build/clang-plugin/DiagnosticsMatcher.cpp
build/clang-plugin/DiagnosticsMatcher.h
build/clang-plugin/ExplicitImplicitChecker.cpp
build/clang-plugin/ExplicitImplicitChecker.h
build/clang-plugin/ExplicitOperatorBoolChecker.cpp
build/clang-plugin/ExplicitOperatorBoolChecker.h
build/clang-plugin/KungFuDeathGripChecker.cpp
build/clang-plugin/KungFuDeathGripChecker.h
build/clang-plugin/MemMoveAnnotation.h
build/clang-plugin/MozCheckAction.cpp
build/clang-plugin/MozillaTidyModule.cpp
build/clang-plugin/MustOverrideChecker.cpp
build/clang-plugin/MustOverrideChecker.h
build/clang-plugin/MustReturnFromCallerChecker.cpp
build/clang-plugin/MustReturnFromCallerChecker.h
build/clang-plugin/MustUseChecker.cpp
build/clang-plugin/MustUseChecker.h
build/clang-plugin/NaNExprChecker.cpp
build/clang-plugin/NaNExprChecker.h
build/clang-plugin/NeedsNoVTableTypeChecker.cpp
build/clang-plugin/NeedsNoVTableTypeChecker.h
build/clang-plugin/NoAddRefReleaseOnReturnChecker.cpp
build/clang-plugin/NoAddRefReleaseOnReturnChecker.h
build/clang-plugin/NoAutoTypeChecker.cpp
build/clang-plugin/NoAutoTypeChecker.h
build/clang-plugin/NoDuplicateRefCntMemberChecker.cpp
build/clang-plugin/NoDuplicateRefCntMemberChecker.h
build/clang-plugin/NoExplicitMoveConstructorChecker.cpp
build/clang-plugin/NoExplicitMoveConstructorChecker.h
build/clang-plugin/NonMemMovableMemberChecker.cpp
build/clang-plugin/NonMemMovableMemberChecker.h
build/clang-plugin/NonMemMovableTemplateArgChecker.cpp
build/clang-plugin/NonMemMovableTemplateArgChecker.h
build/clang-plugin/NonParamInsideFunctionDeclChecker.cpp
build/clang-plugin/NonParamInsideFunctionDeclChecker.h
build/clang-plugin/OverrideBaseCallChecker.cpp
build/clang-plugin/OverrideBaseCallChecker.h
build/clang-plugin/OverrideBaseCallUsageChecker.cpp
build/clang-plugin/OverrideBaseCallUsageChecker.h
build/clang-plugin/RecurseGuard.h
build/clang-plugin/RefCountedCopyConstructorChecker.cpp
build/clang-plugin/RefCountedCopyConstructorChecker.h
build/clang-plugin/RefCountedInsideLambdaChecker.cpp
build/clang-plugin/RefCountedInsideLambdaChecker.h
build/clang-plugin/ScopeChecker.cpp
build/clang-plugin/ScopeChecker.h
build/clang-plugin/SprintfLiteralChecker.cpp
build/clang-plugin/SprintfLiteralChecker.h
build/clang-plugin/StmtToBlockMap.h
build/clang-plugin/ThirdPartyPaths.h
build/clang-plugin/TrivialCtorDtorChecker.cpp
build/clang-plugin/TrivialCtorDtorChecker.h
build/clang-plugin/Utils.h
build/clang-plugin/VariableUsageHelpers.cpp
build/clang-plugin/VariableUsageHelpers.h
build/clang-plugin/plugin.h
--- a/build/clang-plugin/ArithmeticArgChecker.cpp
+++ b/build/clang-plugin/ArithmeticArgChecker.cpp
@@ -1,16 +1,16 @@
 /* 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/. */
 
 #include "ArithmeticArgChecker.h"
 #include "CustomMatchers.h"
 
-void ArithmeticArgChecker::registerMatchers(MatchFinder* AstMatcher) {
+void ArithmeticArgChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
       callExpr(allOf(hasDeclaration(noArithmeticExprInArgs()),
                      anyOf(hasDescendant(
                                binaryOperator(
                                    allOf(binaryArithmeticOperator(),
                                          hasLHS(hasDescendant(declRefExpr())),
                                          hasRHS(hasDescendant(declRefExpr()))))
                                    .bind("node")),
@@ -40,19 +40,21 @@ void ArithmeticArgChecker::registerMatch
                                         hasType(builtinType()),
                                         anyOf(hasDescendant(declRefExpr()),
                                               declRefExpr())))))
                               .bind("node")))))
           .bind("call"),
       this);
 }
 
-void ArithmeticArgChecker::check(
-    const MatchFinder::MatchResult &Result) {
-  const char* Error = "cannot pass an arithmetic expression of built-in types to %0";
+void ArithmeticArgChecker::check(const MatchFinder::MatchResult &Result) {
+  const char *Error =
+      "cannot pass an arithmetic expression of built-in types to %0";
   const Expr *Expression = Result.Nodes.getNodeAs<Expr>("node");
   if (const CallExpr *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
-    diag(Expression->getLocStart(), Error, DiagnosticIDs::Error) << Call->getDirectCallee();
+    diag(Expression->getLocStart(), Error, DiagnosticIDs::Error)
+        << Call->getDirectCallee();
   } else if (const CXXConstructExpr *Ctr =
                  Result.Nodes.getNodeAs<CXXConstructExpr>("call")) {
-    diag(Expression->getLocStart(), Error, DiagnosticIDs::Error) << Ctr->getConstructor();
+    diag(Expression->getLocStart(), Error, DiagnosticIDs::Error)
+        << Ctr->getConstructor();
   }
 }
--- a/build/clang-plugin/ArithmeticArgChecker.h
+++ b/build/clang-plugin/ArithmeticArgChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef ArithmeticArgChecker_h__
 #define ArithmeticArgChecker_h__
 
 #include "plugin.h"
 
 class ArithmeticArgChecker : public BaseCheck {
 public:
-  ArithmeticArgChecker(StringRef CheckName,
-                       ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  ArithmeticArgChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/AssertAssignmentChecker.cpp
+++ b/build/clang-plugin/AssertAssignmentChecker.cpp
@@ -1,23 +1,20 @@
 /* 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/. */
 
 #include "AssertAssignmentChecker.h"
 #include "CustomMatchers.h"
 
-void AssertAssignmentChecker::registerMatchers(MatchFinder* AstMatcher) {
+void AssertAssignmentChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
-      callExpr(isAssertAssignmentTestFunc()).bind("funcCall"),
-      this);
+      callExpr(isAssertAssignmentTestFunc()).bind("funcCall"), this);
 }
 
-void AssertAssignmentChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void AssertAssignmentChecker::check(const MatchFinder::MatchResult &Result) {
   const CallExpr *FuncCall = Result.Nodes.getNodeAs<CallExpr>("funcCall");
 
   if (FuncCall && hasSideEffectAssignment(FuncCall)) {
-    diag(FuncCall->getLocStart(),
-         "Forbidden assignment in assert expression",
+    diag(FuncCall->getLocStart(), "Forbidden assignment in assert expression",
          DiagnosticIDs::Error);
   }
 }
--- a/build/clang-plugin/AssertAssignmentChecker.h
+++ b/build/clang-plugin/AssertAssignmentChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef AssertAssignmentChecker_h__
 #define AssertAssignmentChecker_h__
 
 #include "plugin.h"
 
 class AssertAssignmentChecker : public BaseCheck {
 public:
-  AssertAssignmentChecker(StringRef CheckName,
-                          ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  AssertAssignmentChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/BaseCheck.h
+++ b/build/clang-plugin/BaseCheck.h
@@ -5,30 +5,30 @@
 #ifndef BaseCheck_h__
 #define BaseCheck_h__
 
 class MozContext {};
 typedef MozContext ContextType;
 
 class BaseCheck : public MatchFinder::MatchCallback {
 public:
-  BaseCheck(StringRef CheckName, ContextType* Context) {}
+  BaseCheck(StringRef CheckName, ContextType *Context) {}
   virtual void registerMatchers(MatchFinder *Finder) {}
-  virtual void registerPPCallbacks(CompilerInstance& CI) {}
+  virtual void registerPPCallbacks(CompilerInstance &CI) {}
   virtual void check(const MatchFinder::MatchResult &Result) {}
   DiagnosticBuilder diag(SourceLocation Loc, StringRef Description,
                          DiagnosticIDs::Level Level = DiagnosticIDs::Warning) {
     DiagnosticsEngine &Diag = Context->getDiagnostics();
     unsigned ID = Diag.getDiagnosticIDs()->getCustomDiagID(Level, Description);
     return Diag.Report(Loc, ID);
   }
 
 private:
   void run(const MatchFinder::MatchResult &Result) override {
     Context = Result.Context;
     check(Result);
   }
 
 private:
-  ASTContext* Context;
+  ASTContext *Context;
 };
 
 #endif
--- a/build/clang-plugin/CanRunScriptChecker.cpp
+++ b/build/clang-plugin/CanRunScriptChecker.cpp
@@ -1,204 +1,195 @@
 /* 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/. */
 
 #include "CanRunScriptChecker.h"
 #include "CustomMatchers.h"
 
-void CanRunScriptChecker::registerMatchers(MatchFinder* AstMatcher) {
+void CanRunScriptChecker::registerMatchers(MatchFinder *AstMatcher) {
   auto InvalidArg =
       // We want to find any expression,
       ignoreTrivials(expr(
           // which has a refcounted pointer type,
           hasType(pointerType(
               pointee(hasDeclaration(cxxRecordDecl(isRefCounted()))))),
           // and which is not this,
           unless(cxxThisExpr()),
           // and which is not a method call on a smart ptr,
           unless(cxxMemberCallExpr(on(hasType(isSmartPtrToRefCounted())))),
           // and which is not a parameter of the parent function,
           unless(declRefExpr(to(parmVarDecl()))),
           // and which is not a MOZ_KnownLive wrapped value.
-          unless(callExpr(callee(
-            functionDecl(hasName("MOZ_KnownLive"))))),
+          unless(callExpr(callee(functionDecl(hasName("MOZ_KnownLive"))))),
           expr().bind("invalidArg")));
 
-  auto OptionalInvalidExplicitArg =
-      anyOf(
-          // We want to find any argument which is invalid.
-          hasAnyArgument(InvalidArg),
+  auto OptionalInvalidExplicitArg = anyOf(
+      // We want to find any argument which is invalid.
+      hasAnyArgument(InvalidArg),
 
-          // This makes this matcher optional.
-          anything());
+      // This makes this matcher optional.
+      anything());
 
   // Please not that the hasCanRunScriptAnnotation() matchers are not present
   // directly in the cxxMemberCallExpr, callExpr and constructExpr matchers
   // because we check that the corresponding functions can run script later in
   // the checker code.
   AstMatcher->addMatcher(
       expr(
           anyOf(
               // We want to match a method call expression,
               cxxMemberCallExpr(
                   // which optionally has an invalid arg,
                   OptionalInvalidExplicitArg,
                   // or which optionally has an invalid implicit this argument,
                   anyOf(
                       // which derefs into an invalid arg,
                       on(cxxOperatorCallExpr(
-                          anyOf(
-                              hasAnyArgument(InvalidArg),
-                              anything()))),
+                          anyOf(hasAnyArgument(InvalidArg), anything()))),
                       // or is an invalid arg.
                       on(InvalidArg),
 
                       anything()),
                   expr().bind("callExpr")),
               // or a regular call expression,
               callExpr(
                   // which optionally has an invalid arg.
-                  OptionalInvalidExplicitArg,
-                  expr().bind("callExpr")),
+                  OptionalInvalidExplicitArg, expr().bind("callExpr")),
               // or a construct expression,
               cxxConstructExpr(
                   // which optionally has an invalid arg.
-                  OptionalInvalidExplicitArg,
-                  expr().bind("constructExpr"))),
+                  OptionalInvalidExplicitArg, expr().bind("constructExpr"))),
 
           anyOf(
               // We want to match the parent function.
               forFunction(functionDecl().bind("nonCanRunScriptParentFunction")),
 
               // ... optionally.
               anything())),
       this);
 }
 
 void CanRunScriptChecker::onStartOfTranslationUnit() {
   IsFuncSetBuilt = false;
   CanRunScriptFuncs.clear();
 }
 
 namespace {
-  /// This class is a callback used internally to match function declarations
-  /// with the MOZ_CAN_RUN_SCRIPT annotation, adding these functions and all
-  /// the methods they override to the can-run-script function set.
-  class FuncSetCallback : public MatchFinder::MatchCallback {
-  public:
-    FuncSetCallback(std::unordered_set<const FunctionDecl*> &FuncSet)
+/// This class is a callback used internally to match function declarations
+/// with the MOZ_CAN_RUN_SCRIPT annotation, adding these functions and all
+/// the methods they override to the can-run-script function set.
+class FuncSetCallback : public MatchFinder::MatchCallback {
+public:
+  FuncSetCallback(std::unordered_set<const FunctionDecl *> &FuncSet)
       : CanRunScriptFuncs(FuncSet) {}
 
-    void run(const MatchFinder::MatchResult &Result) override;
+  void run(const MatchFinder::MatchResult &Result) override;
 
-  private:
-    /// This method recursively adds all the methods overriden by the given
-    /// paremeter.
-    void addAllOverriddenMethodsRecursively(const CXXMethodDecl* Method);
+private:
+  /// This method recursively adds all the methods overriden by the given
+  /// paremeter.
+  void addAllOverriddenMethodsRecursively(const CXXMethodDecl *Method);
 
-    std::unordered_set<const FunctionDecl*> &CanRunScriptFuncs;
-  };
+  std::unordered_set<const FunctionDecl *> &CanRunScriptFuncs;
+};
 
-  void FuncSetCallback::run(const MatchFinder::MatchResult &Result) {
-    const FunctionDecl* Func =
+void FuncSetCallback::run(const MatchFinder::MatchResult &Result) {
+  const FunctionDecl *Func =
       Result.Nodes.getNodeAs<FunctionDecl>("canRunScriptFunction");
 
-    CanRunScriptFuncs.insert(Func);
+  CanRunScriptFuncs.insert(Func);
 
-    // If this is a method, we check the methods it overrides.
-    if (auto* Method = dyn_cast<CXXMethodDecl>(Func)) {
-      addAllOverriddenMethodsRecursively(Method);
-    }
+  // If this is a method, we check the methods it overrides.
+  if (auto *Method = dyn_cast<CXXMethodDecl>(Func)) {
+    addAllOverriddenMethodsRecursively(Method);
   }
+}
 
-  void FuncSetCallback::addAllOverriddenMethodsRecursively(
-      const CXXMethodDecl* Method) {
-    for (auto OverriddenMethod : Method->overridden_methods()) {
-      CanRunScriptFuncs.insert(OverriddenMethod);
+void FuncSetCallback::addAllOverriddenMethodsRecursively(
+    const CXXMethodDecl *Method) {
+  for (auto OverriddenMethod : Method->overridden_methods()) {
+    CanRunScriptFuncs.insert(OverriddenMethod);
 
-      // If this is not the definition, we also add the definition (if it
-      // exists) to the set.
-      if (!OverriddenMethod->isThisDeclarationADefinition()) {
-        if (auto Def = OverriddenMethod->getDefinition()) {
-          CanRunScriptFuncs.insert(Def);
-        }
+    // If this is not the definition, we also add the definition (if it
+    // exists) to the set.
+    if (!OverriddenMethod->isThisDeclarationADefinition()) {
+      if (auto Def = OverriddenMethod->getDefinition()) {
+        CanRunScriptFuncs.insert(Def);
       }
+    }
 
-      addAllOverriddenMethodsRecursively(OverriddenMethod);
-    }
+    addAllOverriddenMethodsRecursively(OverriddenMethod);
   }
+}
 } // namespace
 
 void CanRunScriptChecker::buildFuncSet(ASTContext *Context) {
   // We create a match finder.
   MatchFinder Finder;
   // We create the callback which will be called when we find a function with
   // a MOZ_CAN_RUN_SCRIPT annotation.
   FuncSetCallback Callback(CanRunScriptFuncs);
   // We add the matcher to the finder, linking it to our callback.
-  Finder.addMatcher(functionDecl(hasCanRunScriptAnnotation())
-                      .bind("canRunScriptFunction"),
-                    &Callback);
+  Finder.addMatcher(
+      functionDecl(hasCanRunScriptAnnotation()).bind("canRunScriptFunction"),
+      &Callback);
 
   // We start the analysis, given the ASTContext our main checker is in.
   Finder.matchAST(*Context);
 }
 
-void CanRunScriptChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void CanRunScriptChecker::check(const MatchFinder::MatchResult &Result) {
 
   // If the set of functions which can run script is not yet built, then build
   // it.
   if (!IsFuncSetBuilt) {
     buildFuncSet(Result.Context);
     IsFuncSetBuilt = true;
   }
 
-  const char* ErrorInvalidArg =
+  const char *ErrorInvalidArg =
       "arguments must all be strong refs or parent parameters when calling a "
       "function marked as MOZ_CAN_RUN_SCRIPT (including the implicit object "
       "argument)";
 
-  const char* ErrorNonCanRunScriptParent =
+  const char *ErrorNonCanRunScriptParent =
       "functions marked as MOZ_CAN_RUN_SCRIPT can only be called from "
       "functions also marked as MOZ_CAN_RUN_SCRIPT";
-  const char* NoteNonCanRunScriptParent =
-      "parent function declared here";
+  const char *NoteNonCanRunScriptParent = "parent function declared here";
 
-  const Expr* InvalidArg = Result.Nodes.getNodeAs<Expr>("invalidArg");
+  const Expr *InvalidArg = Result.Nodes.getNodeAs<Expr>("invalidArg");
 
-  const CallExpr* Call = Result.Nodes.getNodeAs<CallExpr>("callExpr");
+  const CallExpr *Call = Result.Nodes.getNodeAs<CallExpr>("callExpr");
   // If we don't find the FunctionDecl linked to this call or if it's not marked
   // as can-run-script, consider that we didn't find a match.
   if (Call && (!Call->getDirectCallee() ||
-      !CanRunScriptFuncs.count(Call->getDirectCallee()))) {
+               !CanRunScriptFuncs.count(Call->getDirectCallee()))) {
     Call = nullptr;
   }
 
-  const CXXConstructExpr* Construct =
+  const CXXConstructExpr *Construct =
       Result.Nodes.getNodeAs<CXXConstructExpr>("constructExpr");
 
   // If we don't find the CXXConstructorDecl linked to this construct expression
   // or if it's not marked as can-run-script, consider that we didn't find a
   // match.
   if (Construct && (!Construct->getConstructor() ||
-      !CanRunScriptFuncs.count(Construct->getConstructor()))) {
+                    !CanRunScriptFuncs.count(Construct->getConstructor()))) {
     Construct = nullptr;
   }
 
-  const FunctionDecl* ParentFunction =
+  const FunctionDecl *ParentFunction =
       Result.Nodes.getNodeAs<FunctionDecl>("nonCanRunScriptParentFunction");
   // If the parent function can run script, consider that we didn't find a match
   // because we only care about parent functions which can't run script.
   if (ParentFunction && CanRunScriptFuncs.count(ParentFunction)) {
     ParentFunction = nullptr;
   }
 
-
   // Get the call range from either the CallExpr or the ConstructExpr.
   SourceRange CallRange;
   if (Call) {
     CallRange = Call->getSourceRange();
   } else if (Construct) {
     CallRange = Construct->getSourceRange();
   } else {
     // If we have neither a Call nor a Construct, we have nothing do to here.
--- a/build/clang-plugin/CanRunScriptChecker.h
+++ b/build/clang-plugin/CanRunScriptChecker.h
@@ -5,28 +5,27 @@
 #ifndef CanRunScriptChecker_h__
 #define CanRunScriptChecker_h__
 
 #include "plugin.h"
 #include <unordered_set>
 
 class CanRunScriptChecker : public BaseCheck {
 public:
-  CanRunScriptChecker(StringRef CheckName,
-                      ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  CanRunScriptChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 
   // Simply initialize the can-run-script function set at the beginning of each
   // translation unit.
   void onStartOfTranslationUnit() override;
 
 private:
   /// Runs the inner matcher on the AST to find all the can-run-script
   /// functions using custom rules (not only the annotation).
   void buildFuncSet(ASTContext *Context);
 
   bool IsFuncSetBuilt;
-  std::unordered_set<const FunctionDecl*> CanRunScriptFuncs;
+  std::unordered_set<const FunctionDecl *> CanRunScriptFuncs;
 };
 
 #endif
--- a/build/clang-plugin/CustomMatchers.h
+++ b/build/clang-plugin/CustomMatchers.h
@@ -34,17 +34,17 @@ AST_MATCHER(CXXMethodDecl, isLValueRefQu
   return Node.getRefQualifier() == RQ_LValue;
 }
 
 /// This matcher will match rvalue-ref-qualified methods.
 AST_MATCHER(CXXMethodDecl, isRValueRefQualified) {
   return Node.getRefQualifier() == RQ_RValue;
 }
 
-AST_POLYMORPHIC_MATCHER(isFirstParty,                                          \
+AST_POLYMORPHIC_MATCHER(isFirstParty,
                         AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt)) {
   return !inThirdPartyPath(&Node, &Finder->getASTContext()) &&
          !ASTIsInSystemHeader(Finder->getASTContext(), Node);
 }
 
 /// This matcher will match temporary expressions.
 /// We need this matcher for compatibility with clang 3.* (clang 4 and above
 /// insert a MaterializeTemporaryExpr everywhere).
@@ -299,33 +299,33 @@ AST_MATCHER(FunctionDecl, isMozMustRetur
 ///   matches 'return *this'
 ///   but does match 'return > 0'
 AST_MATCHER_P(Stmt, forFunction, internal::Matcher<FunctionDecl>,
               InnerMatcher) {
   const auto &Parents = Finder->getASTContext().getParents(Node);
 
   llvm::SmallVector<ast_type_traits::DynTypedNode, 8> Stack(Parents.begin(),
                                                             Parents.end());
-  while(!Stack.empty()) {
+  while (!Stack.empty()) {
     const auto &CurNode = Stack.back();
     Stack.pop_back();
-    if(const auto *FuncDeclNode = CurNode.get<FunctionDecl>()) {
-      if(InnerMatcher.matches(*FuncDeclNode, Finder, Builder)) {
+    if (const auto *FuncDeclNode = CurNode.get<FunctionDecl>()) {
+      if (InnerMatcher.matches(*FuncDeclNode, Finder, Builder)) {
         return true;
       }
-    } else if(const auto *LambdaExprNode = CurNode.get<LambdaExpr>()) {
-      if(InnerMatcher.matches(*LambdaExprNode->getCallOperator(),
-                              Finder, Builder)) {
+    } else if (const auto *LambdaExprNode = CurNode.get<LambdaExpr>()) {
+      if (InnerMatcher.matches(*LambdaExprNode->getCallOperator(), Finder,
+                               Builder)) {
         return true;
       }
     } else {
-      for(const auto &Parent: Finder->getASTContext().getParents(CurNode))
+      for (const auto &Parent : Finder->getASTContext().getParents(CurNode))
         Stack.push_back(Parent);
     }
   }
   return false;
 }
 #endif
 
-}
-}
+} // namespace ast_matchers
+} // namespace clang
 
 #endif
--- a/build/clang-plugin/CustomTypeAnnotation.cpp
+++ b/build/clang-plugin/CustomTypeAnnotation.cpp
@@ -6,67 +6,62 @@
 #include "Utils.h"
 
 CustomTypeAnnotation StackClass =
     CustomTypeAnnotation("moz_stack_class", "stack");
 CustomTypeAnnotation GlobalClass =
     CustomTypeAnnotation("moz_global_class", "global");
 CustomTypeAnnotation NonHeapClass =
     CustomTypeAnnotation("moz_nonheap_class", "non-heap");
-CustomTypeAnnotation HeapClass =
-    CustomTypeAnnotation("moz_heap_class", "heap");
+CustomTypeAnnotation HeapClass = CustomTypeAnnotation("moz_heap_class", "heap");
 CustomTypeAnnotation NonTemporaryClass =
     CustomTypeAnnotation("moz_non_temporary_class", "non-temporary");
 
-void CustomTypeAnnotation::dumpAnnotationReason(BaseCheck &Check,
-                                                QualType T,
+void CustomTypeAnnotation::dumpAnnotationReason(BaseCheck &Check, QualType T,
                                                 SourceLocation Loc) {
-  const char* Inherits =
+  const char *Inherits =
       "%1 is a %0 type because it inherits from a %0 type %2";
-  const char* Member =
-      "%1 is a %0 type because member %2 is a %0 type %3";
-  const char* Array =
-      "%1 is a %0 type because it is an array of %0 type %2";
-  const char* Templ =
+  const char *Member = "%1 is a %0 type because member %2 is a %0 type %3";
+  const char *Array = "%1 is a %0 type because it is an array of %0 type %2";
+  const char *Templ =
       "%1 is a %0 type because it has a template argument %0 type %2";
-  const char* Implicit =
-      "%1 is a %0 type because %2";
+  const char *Implicit = "%1 is a %0 type because %2";
 
   AnnotationReason Reason = directAnnotationReason(T);
   for (;;) {
     switch (Reason.Kind) {
     case RK_ArrayElement:
       Check.diag(Loc, Array, DiagnosticIDs::Note) << Pretty << T << Reason.Type;
       break;
     case RK_BaseClass: {
       const CXXRecordDecl *Declaration = T->getAsCXXRecordDecl();
       assert(Declaration && "This type should be a C++ class");
 
       Check.diag(Declaration->getLocation(), Inherits, DiagnosticIDs::Note)
-        << Pretty << T << Reason.Type;
+          << Pretty << T << Reason.Type;
       break;
     }
     case RK_Field:
       Check.diag(Reason.Field->getLocation(), Member, DiagnosticIDs::Note)
           << Pretty << T << Reason.Field << Reason.Type;
       break;
     case RK_TemplateInherited: {
       const CXXRecordDecl *Declaration = T->getAsCXXRecordDecl();
       assert(Declaration && "This type should be a C++ class");
 
       Check.diag(Declaration->getLocation(), Templ, DiagnosticIDs::Note)
-        << Pretty << T << Reason.Type;
+          << Pretty << T << Reason.Type;
       break;
     }
     case RK_Implicit: {
       const TagDecl *Declaration = T->getAsTagDecl();
       assert(Declaration && "This type should be a TagDecl");
 
       Check.diag(Declaration->getLocation(), Implicit, DiagnosticIDs::Note)
-        << Pretty << T << Reason.ImplicitReason;
+          << Pretty << T << Reason.ImplicitReason;
       return;
     }
     default:
       // FIXME (bug 1203263): note the original annotation.
       return;
     }
 
     T = Reason.Type;
--- a/build/clang-plugin/CustomTypeAnnotation.h
+++ b/build/clang-plugin/CustomTypeAnnotation.h
@@ -36,22 +36,20 @@ public:
       : Spelling(Spelling), Pretty(Pretty){};
 
   virtual ~CustomTypeAnnotation() {}
 
   // Checks if this custom annotation "effectively affects" the given type.
   bool hasEffectiveAnnotation(QualType T) {
     return directAnnotationReason(T).valid();
   }
-  void dumpAnnotationReason(BaseCheck &Check, QualType T,
-                            SourceLocation Loc);
+  void dumpAnnotationReason(BaseCheck &Check, QualType T, SourceLocation Loc);
 
-  void reportErrorIfPresent(BaseCheck &Check, QualType T,
-                            SourceLocation Loc, const char* Error,
-                            const char* Note) {
+  void reportErrorIfPresent(BaseCheck &Check, QualType T, SourceLocation Loc,
+                            const char *Error, const char *Note) {
     if (hasEffectiveAnnotation(T)) {
       Check.diag(Loc, Error, DiagnosticIDs::Error) << T;
       Check.diag(Loc, Note, DiagnosticIDs::Note);
       dumpAnnotationReason(Check, T, Loc);
     }
   }
 
 private:
--- a/build/clang-plugin/DanglingOnTemporaryChecker.cpp
+++ b/build/clang-plugin/DanglingOnTemporaryChecker.cpp
@@ -37,78 +37,73 @@ void DanglingOnTemporaryChecker::registe
 
           decl().bind("invalidMethodPointer")),
       this);
 
   //////////////////
   // Main checker //
   //////////////////
 
-  auto hasParentCall =
-      hasParent(expr(anyOf(
-          cxxOperatorCallExpr(
-              // If we're in a lamda, we may have an operator call expression
-              // ancestor in the AST, but the temporary we're matching
-              // against is not going to have the same lifetime as the
-              // constructor call.
-              unless(has(expr(ignoreTrivials(lambdaExpr())))),
-              expr().bind("parentOperatorCallExpr")),
-          callExpr(
-              // If we're in a lamda, we may have a call expression
-              // ancestor in the AST, but the temporary we're matching
-              // against is not going to have the same lifetime as the
-              // function call.
-              unless(has(expr(ignoreTrivials(lambdaExpr())))),
-              expr().bind("parentCallExpr")),
-          objcMessageExpr(
-              // If we're in a lamda, we may have an objc message expression
-              // ancestor in the AST, but the temporary we're matching
-              // against is not going to have the same lifetime as the
-              // function call.
-              unless(has(expr(ignoreTrivials(lambdaExpr())))),
-              expr().bind("parentObjCMessageExpr")),
-          cxxConstructExpr(
-              // If we're in a lamda, we may have a construct expression
-              // ancestor in the AST, but the temporary we're matching
-              // against is not going to have the same lifetime as the
-              // constructor call.
-              unless(has(expr(ignoreTrivials(lambdaExpr())))),
-              expr().bind("parentConstructExpr")))));
+  auto hasParentCall = hasParent(expr(
+      anyOf(cxxOperatorCallExpr(
+                // If we're in a lamda, we may have an operator call expression
+                // ancestor in the AST, but the temporary we're matching
+                // against is not going to have the same lifetime as the
+                // constructor call.
+                unless(has(expr(ignoreTrivials(lambdaExpr())))),
+                expr().bind("parentOperatorCallExpr")),
+            callExpr(
+                // If we're in a lamda, we may have a call expression
+                // ancestor in the AST, but the temporary we're matching
+                // against is not going to have the same lifetime as the
+                // function call.
+                unless(has(expr(ignoreTrivials(lambdaExpr())))),
+                expr().bind("parentCallExpr")),
+            objcMessageExpr(
+                // If we're in a lamda, we may have an objc message expression
+                // ancestor in the AST, but the temporary we're matching
+                // against is not going to have the same lifetime as the
+                // function call.
+                unless(has(expr(ignoreTrivials(lambdaExpr())))),
+                expr().bind("parentObjCMessageExpr")),
+            cxxConstructExpr(
+                // If we're in a lamda, we may have a construct expression
+                // ancestor in the AST, but the temporary we're matching
+                // against is not going to have the same lifetime as the
+                // constructor call.
+                unless(has(expr(ignoreTrivials(lambdaExpr())))),
+                expr().bind("parentConstructExpr")))));
 
   AstMatcher->addMatcher(
       // This is a matcher on a method call,
       cxxMemberCallExpr(
           // which is in first party code,
           isFirstParty(),
 
           // and which is performed on a temporary,
-          on(allOf(
-              unless(hasType(pointerType())),
-              isTemporary(),
-              // but which is not `this`.
-              unless(cxxThisExpr()))),
+          on(allOf(unless(hasType(pointerType())), isTemporary(),
+                   // but which is not `this`.
+                   unless(cxxThisExpr()))),
 
           // and which is marked as no dangling on temporaries.
           callee(cxxMethodDecl(noDanglingOnTemporaries())),
 
           expr().bind("memberCallExpr"),
 
           // We optionally match a parent call expression or a parent construct
           // expression because using a temporary inside a call is fine as long
           // as the pointer doesn't escape the function call.
           anyOf(
               // This is the case where the call is the direct parent, so we
               // know that the member call expression is the argument.
               allOf(hasParentCall, expr().bind("parentCallArg")),
 
               // This is the case where the call is not the direct parent, so we
               // get its child to know in which argument tree we are.
-              hasAncestor(expr(
-                  hasParentCall,
-                  expr().bind("parentCallArg"))),
+              hasAncestor(expr(hasParentCall, expr().bind("parentCallArg"))),
               // To make it optional.
               anything())),
       this);
 }
 
 void DanglingOnTemporaryChecker::check(const MatchFinder::MatchResult &Result) {
   ///////////////////////////////////////
   // Quick annotation conflict checker //
@@ -158,51 +153,50 @@ void DanglingOnTemporaryChecker::check(c
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("memberCallExpr");
 
   const CallExpr *ParentCallExpr =
       Result.Nodes.getNodeAs<CallExpr>("parentCallExpr");
   const CXXConstructExpr *ParentConstructExpr =
       Result.Nodes.getNodeAs<CXXConstructExpr>("parentConstructExpr");
   const CXXOperatorCallExpr *ParentOperatorCallExpr =
       Result.Nodes.getNodeAs<CXXOperatorCallExpr>("parentOperatorCallExpr");
-  const Expr *ParentCallArg =
-      Result.Nodes.getNodeAs<Expr>("parentCallArg");
+  const Expr *ParentCallArg = Result.Nodes.getNodeAs<Expr>("parentCallArg");
 
   // Just in case.
   if (!MemberCall) {
     return;
   }
 
   // If we have a parent call, we check whether or not we escape the function
   // being called.
   if (ParentOperatorCallExpr || ParentCallExpr || ParentConstructExpr) {
     // Just in case.
     if (!ParentCallArg) {
       return;
     }
 
     // No default constructor so we can't construct it using if/else.
-    auto FunctionEscapeData
-        = ParentOperatorCallExpr
+    auto FunctionEscapeData =
+        ParentOperatorCallExpr
             ? escapesFunction(ParentCallArg, ParentOperatorCallExpr)
-          : ParentCallExpr
-              ? escapesFunction(ParentCallArg, ParentCallExpr)
-          : escapesFunction(ParentCallArg, ParentConstructExpr);
+            : ParentCallExpr
+                  ? escapesFunction(ParentCallArg, ParentCallExpr)
+                  : escapesFunction(ParentCallArg, ParentConstructExpr);
 
     // If there was an error in the escapesFunction call.
     if (std::error_code ec = FunctionEscapeData.getError()) {
       // FIXME: For now we ignore the variadic case and just consider that the
       // argument doesn't escape the function. Same for the case where we can't
       // find the function declaration or if the function is builtin.
       if (static_cast<EscapesFunctionError>(ec.value()) ==
-          EscapesFunctionError::FunctionIsVariadic ||
+              EscapesFunctionError::FunctionIsVariadic ||
           static_cast<EscapesFunctionError>(ec.value()) ==
-          EscapesFunctionError::FunctionDeclNotFound ||
+              EscapesFunctionError::FunctionDeclNotFound ||
           static_cast<EscapesFunctionError>(ec.value()) ==
-          EscapesFunctionError::FunctionIsBuiltin) {
+              EscapesFunctionError::FunctionIsBuiltin) {
         return;
       }
 
       // We emit the internal checker error and return.
       diag(MemberCall->getExprLoc(),
            std::string(ec.category().name()) + " error: " + ec.message(),
            DiagnosticIDs::Error);
       return;
@@ -253,10 +247,10 @@ void DanglingOnTemporaryChecker::check(c
     diag(EscapeDecl->getLocation(), EscapeDeclNote, DiagnosticIDs::Note)
         << EscapeDeclRange;
   } else {
     // We emit the error diagnostic indicating that we are calling the method
     // temporary.
     diag(MemberCall->getExprLoc(), Error, DiagnosticIDs::Error)
         << MemberCall->getMethodDecl()->getName()
         << MemberCall->getSourceRange();
-    }
+  }
 }
--- a/build/clang-plugin/DiagnosticsMatcher.cpp
+++ b/build/clang-plugin/DiagnosticsMatcher.cpp
@@ -1,17 +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/. */
 
 #include "DiagnosticsMatcher.h"
 
-DiagnosticsMatcher::DiagnosticsMatcher(CompilerInstance& CI) :
-#define CHECK(cls, name) cls ## _(name),
+DiagnosticsMatcher::DiagnosticsMatcher(CompilerInstance &CI)
+    :
+#define CHECK(cls, name) cls##_(name),
 #include "Checks.inc"
 #undef CHECK
-  AstMatcher()
-{
-#define CHECK(cls, name) cls ## _.registerMatchers(&AstMatcher); \
-                         cls ## _.registerPPCallbacks(CI);
+      AstMatcher() {
+#define CHECK(cls, name)                                                       \
+  cls##_.registerMatchers(&AstMatcher);                                        \
+  cls##_.registerPPCallbacks(CI);
 #include "Checks.inc"
 #undef CHECK
 }
--- a/build/clang-plugin/DiagnosticsMatcher.h
+++ b/build/clang-plugin/DiagnosticsMatcher.h
@@ -4,20 +4,20 @@
 
 #ifndef DiagnosticsMatcher_h__
 #define DiagnosticsMatcher_h__
 
 #include "ChecksIncludes.inc"
 
 class DiagnosticsMatcher {
 public:
-  DiagnosticsMatcher(CompilerInstance& CI);
+  DiagnosticsMatcher(CompilerInstance &CI);
 
   ASTConsumerPtr makeASTConsumer() { return AstMatcher.newASTConsumer(); }
 
 private:
-#define CHECK(cls, name) cls cls ## _;
+#define CHECK(cls, name) cls cls##_;
 #include "Checks.inc"
 #undef CHECK
   MatchFinder AstMatcher;
 };
 
 #endif
--- a/build/clang-plugin/ExplicitImplicitChecker.cpp
+++ b/build/clang-plugin/ExplicitImplicitChecker.cpp
@@ -1,31 +1,33 @@
 /* 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/. */
 
 #include "ExplicitImplicitChecker.h"
 #include "CustomMatchers.h"
 
-void ExplicitImplicitChecker::registerMatchers(MatchFinder* AstMatcher) {
-  AstMatcher->addMatcher(cxxConstructorDecl(isInterestingImplicitCtor(),
-                                            ofClass(allOf(isConcreteClass(),
-                                                          decl().bind("class"))),
-                                            unless(isMarkedImplicit()))
-                            .bind("ctor"),
-                        this);
+void ExplicitImplicitChecker::registerMatchers(MatchFinder *AstMatcher) {
+  AstMatcher->addMatcher(
+      cxxConstructorDecl(
+          isInterestingImplicitCtor(),
+          ofClass(allOf(isConcreteClass(), decl().bind("class"))),
+          unless(isMarkedImplicit()))
+          .bind("ctor"),
+      this);
 }
 
-void ExplicitImplicitChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void ExplicitImplicitChecker::check(const MatchFinder::MatchResult &Result) {
   // We've already checked everything in the matcher, so we just have to report
   // the error.
 
   const CXXConstructorDecl *Ctor =
       Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
   const CXXRecordDecl *Declaration =
       Result.Nodes.getNodeAs<CXXRecordDecl>("class");
 
   diag(Ctor->getLocation(), "bad implicit conversion constructor for %0",
-       DiagnosticIDs::Error) << Declaration->getDeclName();
-  diag(Ctor->getLocation(), "consider adding the explicit keyword to the constructor",
+       DiagnosticIDs::Error)
+      << Declaration->getDeclName();
+  diag(Ctor->getLocation(),
+       "consider adding the explicit keyword to the constructor",
        DiagnosticIDs::Note);
 }
--- a/build/clang-plugin/ExplicitImplicitChecker.h
+++ b/build/clang-plugin/ExplicitImplicitChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef ExplicitImplicitChecker_h__
 #define ExplicitImplicitChecker_h__
 
 #include "plugin.h"
 
 class ExplicitImplicitChecker : public BaseCheck {
 public:
-  ExplicitImplicitChecker(StringRef CheckName,
-                          ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  ExplicitImplicitChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/ExplicitOperatorBoolChecker.cpp
+++ b/build/clang-plugin/ExplicitOperatorBoolChecker.cpp
@@ -1,16 +1,16 @@
 /* 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/. */
 
 #include "ExplicitOperatorBoolChecker.h"
 #include "CustomMatchers.h"
 
-void ExplicitOperatorBoolChecker::registerMatchers(MatchFinder* AstMatcher) {
+void ExplicitOperatorBoolChecker::registerMatchers(MatchFinder *AstMatcher) {
   // Older clang versions such as the ones used on the infra recognize these
   // conversions as 'operator _Bool', but newer clang versions recognize these
   // as 'operator bool'.
   AstMatcher->addMatcher(
       cxxMethodDecl(anyOf(hasName("operator bool"), hasName("operator _Bool")))
           .bind("node"),
       this);
 }
@@ -21,13 +21,15 @@ void ExplicitOperatorBoolChecker::check(
       Result.Nodes.getNodeAs<CXXConversionDecl>("node");
   const CXXRecordDecl *Clazz = Method->getParent();
 
   if (!Method->isExplicitSpecified() &&
       !hasCustomAnnotation(Method, "moz_implicit") &&
       !ASTIsInSystemHeader(Method->getASTContext(), *Method) &&
       isInterestingDeclForImplicitConversion(Method)) {
     diag(Method->getLocStart(), "bad implicit conversion operator for %0",
-         DiagnosticIDs::Error) << Clazz;
+         DiagnosticIDs::Error)
+        << Clazz;
     diag(Method->getLocStart(), "consider adding the explicit keyword to %0",
-         DiagnosticIDs::Note) << "'operator bool'";
+         DiagnosticIDs::Note)
+        << "'operator bool'";
   }
 }
--- a/build/clang-plugin/ExplicitOperatorBoolChecker.h
+++ b/build/clang-plugin/ExplicitOperatorBoolChecker.h
@@ -6,14 +6,14 @@
 #define ExplicitOperatorBoolChecker_h__
 
 #include "plugin.h"
 
 class ExplicitOperatorBoolChecker : public BaseCheck {
 public:
   ExplicitOperatorBoolChecker(StringRef CheckName,
                               ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/KungFuDeathGripChecker.cpp
+++ b/build/clang-plugin/KungFuDeathGripChecker.cpp
@@ -1,26 +1,24 @@
 /* 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/. */
 
 #include "KungFuDeathGripChecker.h"
 #include "CustomMatchers.h"
 
-void KungFuDeathGripChecker::registerMatchers(MatchFinder* AstMatcher) {
-  AstMatcher->addMatcher(varDecl(hasType(isRefPtr())).bind("decl"),
-                         this);
+void KungFuDeathGripChecker::registerMatchers(MatchFinder *AstMatcher) {
+  AstMatcher->addMatcher(varDecl(hasType(isRefPtr())).bind("decl"), this);
 }
 
-void KungFuDeathGripChecker::check(
-    const MatchFinder::MatchResult &Result) {
-  const char* Error =
-    "Unused \"kungFuDeathGrip\" %0 objects constructed from %1 are prohibited";
-  const char* Note =
-    "Please switch all accesses to this %0 to go through '%1', or explicitly pass '%1' to `mozilla::Unused`";
+void KungFuDeathGripChecker::check(const MatchFinder::MatchResult &Result) {
+  const char *Error = "Unused \"kungFuDeathGrip\" %0 objects constructed from "
+                      "%1 are prohibited";
+  const char *Note = "Please switch all accesses to this %0 to go through "
+                     "'%1', or explicitly pass '%1' to `mozilla::Unused`";
 
   const VarDecl *D = Result.Nodes.getNodeAs<VarDecl>("decl");
   if (D->isReferenced() || !D->hasLocalStorage() || !D->hasInit()) {
     return;
   }
 
   // Not interested in parameters.
   if (isa<ImplicitParamDecl>(D) || isa<ParmVarDecl>(D)) {
@@ -59,40 +57,43 @@ void KungFuDeathGripChecker::check(
   }
 
   // These types are assigned into nsCOMPtr and RefPtr for their side effects,
   // and not as a kungFuDeathGrip. We don't want to consider RefPtr and nsCOMPtr
   // types which are initialized with these types as errors.
   const TagDecl *TD = E->getType()->getAsTagDecl();
   if (TD && TD->getIdentifier()) {
     static const char *IgnoreTypes[] = {
-      "already_AddRefed",
-      "nsGetServiceByCID",
-      "nsGetServiceByCIDWithError",
-      "nsGetServiceByContractID",
-      "nsGetServiceByContractIDWithError",
-      "nsCreateInstanceByCID",
-      "nsCreateInstanceByContractID",
-      "nsCreateInstanceFromFactory",
+        "already_AddRefed",
+        "nsGetServiceByCID",
+        "nsGetServiceByCIDWithError",
+        "nsGetServiceByContractID",
+        "nsGetServiceByContractIDWithError",
+        "nsCreateInstanceByCID",
+        "nsCreateInstanceByContractID",
+        "nsCreateInstanceFromFactory",
     };
 
-    for (uint32_t i = 0; i < sizeof(IgnoreTypes) / sizeof(IgnoreTypes[0]); ++i) {
+    for (uint32_t i = 0; i < sizeof(IgnoreTypes) / sizeof(IgnoreTypes[0]);
+         ++i) {
       if (TD->getName() == IgnoreTypes[i]) {
         return;
       }
     }
   }
 
   // Report the error
   const char *ErrThing;
   const char *NoteThing;
   if (isa<MemberExpr>(E)) {
-    ErrThing  = "members";
+    ErrThing = "members";
     NoteThing = "member";
   } else {
     ErrThing = "temporary values";
     NoteThing = "value";
   }
 
   // We cannot provide the note if we don't have an initializer
-  diag(D->getLocStart(), Error, DiagnosticIDs::Error) << D->getType() << ErrThing;
-  diag(E->getLocStart(), Note, DiagnosticIDs::Note) << NoteThing << getNameChecked(D);
+  diag(D->getLocStart(), Error, DiagnosticIDs::Error)
+      << D->getType() << ErrThing;
+  diag(E->getLocStart(), Note, DiagnosticIDs::Note)
+      << NoteThing << getNameChecked(D);
 }
--- a/build/clang-plugin/KungFuDeathGripChecker.h
+++ b/build/clang-plugin/KungFuDeathGripChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef KungFuDeathGripChecker_h__
 #define KungFuDeathGripChecker_h__
 
 #include "plugin.h"
 
 class KungFuDeathGripChecker : public BaseCheck {
 public:
-  KungFuDeathGripChecker(StringRef CheckName,
-                         ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  KungFuDeathGripChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/MemMoveAnnotation.h
+++ b/build/clang-plugin/MemMoveAnnotation.h
@@ -1,17 +1,17 @@
 /* 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/. */
 
 #ifndef MemMoveAnnotation_h__
 #define MemMoveAnnotation_h__
 
+#include "CustomMatchers.h"
 #include "CustomTypeAnnotation.h"
-#include "CustomMatchers.h"
 #include "Utils.h"
 
 class MemMoveAnnotation final : public CustomTypeAnnotation {
 public:
   MemMoveAnnotation()
       : CustomTypeAnnotation("moz_non_memmovable", "non-memmove()able") {}
 
   virtual ~MemMoveAnnotation() {}
@@ -19,40 +19,29 @@ public:
 protected:
   std::string getImplicitReason(const TagDecl *D) const override {
     // Annotate everything in ::std, with a few exceptions; see bug
     // 1201314 for discussion.
     if (getDeclarationNamespace(D) == "std") {
       // This doesn't check that it's really ::std::pair and not
       // ::std::something_else::pair, but should be good enough.
       StringRef Name = getNameChecked(D);
-      if (Name == "pair" ||
-          Name == "atomic" ||
+      if (Name == "pair" || Name == "atomic" ||
           // libstdc++ specific names
-          Name == "__atomic_base" ||
-          Name == "atomic_bool" ||
+          Name == "__atomic_base" || Name == "atomic_bool" ||
           // MSVCRT specific names
-          Name == "_Atomic_impl" ||
-          Name == "_Atomic_base" ||
-          Name == "_Atomic_bool" ||
-          Name == "_Atomic_char" ||
-          Name == "_Atomic_schar" ||
-          Name == "_Atomic_uchar" ||
-          Name == "_Atomic_char16_t" ||
-          Name == "_Atomic_char32_t" ||
-          Name == "_Atomic_wchar_t" ||
-          Name == "_Atomic_short" ||
-          Name == "_Atomic_ushort" ||
-          Name == "_Atomic_int" ||
-          Name == "_Atomic_uint" ||
-          Name == "_Atomic_long" ||
-          Name == "_Atomic_ulong" ||
-          Name == "_Atomic_llong" ||
-          Name == "_Atomic_ullong" ||
-          Name == "_Atomic_address") {
+          Name == "_Atomic_impl" || Name == "_Atomic_base" ||
+          Name == "_Atomic_bool" || Name == "_Atomic_char" ||
+          Name == "_Atomic_schar" || Name == "_Atomic_uchar" ||
+          Name == "_Atomic_char16_t" || Name == "_Atomic_char32_t" ||
+          Name == "_Atomic_wchar_t" || Name == "_Atomic_short" ||
+          Name == "_Atomic_ushort" || Name == "_Atomic_int" ||
+          Name == "_Atomic_uint" || Name == "_Atomic_long" ||
+          Name == "_Atomic_ulong" || Name == "_Atomic_llong" ||
+          Name == "_Atomic_ullong" || Name == "_Atomic_address") {
         return "";
       }
       return "it is an stl-provided type not guaranteed to be memmove-able";
     }
     return "";
   }
 };
 
--- a/build/clang-plugin/MozCheckAction.cpp
+++ b/build/clang-plugin/MozCheckAction.cpp
@@ -1,22 +1,22 @@
 /* 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/. */
 
+#include "DiagnosticsMatcher.h"
 #include "plugin.h"
-#include "DiagnosticsMatcher.h"
 #include "clang/Frontend/FrontendPluginRegistry.h"
 
 class MozCheckAction : public PluginASTAction {
 public:
   ASTConsumerPtr CreateASTConsumer(CompilerInstance &CI,
                                    StringRef FileName) override {
-    void* Buffer = CI.getASTContext().Allocate<DiagnosticsMatcher>();
-    auto Matcher = new(Buffer) DiagnosticsMatcher(CI);
+    void *Buffer = CI.getASTContext().Allocate<DiagnosticsMatcher>();
+    auto Matcher = new (Buffer) DiagnosticsMatcher(CI);
     return Matcher->makeASTConsumer();
   }
 
   bool ParseArgs(const CompilerInstance &CI,
                  const std::vector<std::string> &Args) override {
     return true;
   }
 };
--- a/build/clang-plugin/MozillaTidyModule.cpp
+++ b/build/clang-plugin/MozillaTidyModule.cpp
@@ -19,18 +19,18 @@ public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
 #define CHECK(cls, name) CheckFactories.registerCheck<cls>("mozilla-" name);
 #include "Checks.inc"
 #undef CHECK
   }
 };
 
 // Register the MozillaTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<MozillaModule> X("mozilla-module",
-                                                     "Adds Mozilla lint checks.");
+static ClangTidyModuleRegistry::Add<MozillaModule>
+    X("mozilla-module", "Adds Mozilla lint checks.");
 
 } // namespace tidy
 } // namespace clang
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the MozillaModule.
 volatile int MozillaModuleAnchorSource = 0;
 
--- a/build/clang-plugin/MustOverrideChecker.cpp
+++ b/build/clang-plugin/MustOverrideChecker.cpp
@@ -1,62 +1,60 @@
 /* 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/. */
 
 #include "MustOverrideChecker.h"
 #include "CustomMatchers.h"
 
-void MustOverrideChecker::registerMatchers(MatchFinder* AstMatcher) {
+void MustOverrideChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(cxxRecordDecl(isDefinition()).bind("class"), this);
 }
 
-void MustOverrideChecker::registerPPCallbacks(CompilerInstance& CI) {
+void MustOverrideChecker::registerPPCallbacks(CompilerInstance &CI) {
   this->CI = &CI;
 }
 
-void MustOverrideChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void MustOverrideChecker::check(const MatchFinder::MatchResult &Result) {
   auto D = Result.Nodes.getNodeAs<CXXRecordDecl>("class");
 
   // Look through all of our immediate bases to find methods that need to be
   // overridden
   typedef std::vector<CXXMethodDecl *> OverridesVector;
   OverridesVector MustOverrides;
-  for (const auto& Base : D->bases()) {
+  for (const auto &Base : D->bases()) {
     // The base is either a class (CXXRecordDecl) or it's a templated class...
     CXXRecordDecl *Parent = Base.getType()
                                 .getDesugaredType(D->getASTContext())
                                 ->getAsCXXRecordDecl();
     // The parent might not be resolved to a type yet. In this case, we can't
     // do any checking here. For complete correctness, we should visit
     // template instantiations, but this case is likely to be rare, so we will
     // ignore it until it becomes important.
     if (!Parent) {
       continue;
     }
     Parent = Parent->getDefinition();
-    for (const auto& M : Parent->methods()) {
+    for (const auto &M : Parent->methods()) {
       if (hasCustomAnnotation(M, "moz_must_override"))
         MustOverrides.push_back(M);
     }
   }
 
-  for (auto& O : MustOverrides) {
+  for (auto &O : MustOverrides) {
     bool Overridden = false;
-    for (const auto& M : D->methods()) {
+    for (const auto &M : D->methods()) {
       // The way that Clang checks if a method M overrides its parent method
       // is if the method has the same name but would not overload.
       if (getNameChecked(M) == getNameChecked(O) &&
           !CI->getSema().IsOverload(M, O, false)) {
         Overridden = true;
         break;
       }
     }
     if (!Overridden) {
-      diag(D->getLocation(), "%0 must override %1",
-           DiagnosticIDs::Error) << D->getDeclName()
-                                 << O->getDeclName();
+      diag(D->getLocation(), "%0 must override %1", DiagnosticIDs::Error)
+          << D->getDeclName() << O->getDeclName();
       diag(O->getLocation(), "function to override is here",
            DiagnosticIDs::Note);
     }
   }
 }
--- a/build/clang-plugin/MustOverrideChecker.h
+++ b/build/clang-plugin/MustOverrideChecker.h
@@ -4,20 +4,19 @@
 
 #ifndef MustOverrideChecker_h__
 #define MustOverrideChecker_h__
 
 #include "plugin.h"
 
 class MustOverrideChecker : public BaseCheck {
 public:
-  MustOverrideChecker(StringRef CheckName,
-                      ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context), CI(nullptr) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
-  void registerPPCallbacks(CompilerInstance& CI) override;
+  MustOverrideChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context), CI(nullptr) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
+  void registerPPCallbacks(CompilerInstance &CI) override;
   void check(const MatchFinder::MatchResult &Result) override;
 
 private:
-  const CompilerInstance* CI;
+  const CompilerInstance *CI;
 };
 
 #endif
--- a/build/clang-plugin/MustReturnFromCallerChecker.cpp
+++ b/build/clang-plugin/MustReturnFromCallerChecker.cpp
@@ -1,45 +1,47 @@
 /* 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/. */
 
 #include "MustReturnFromCallerChecker.h"
 #include "CustomMatchers.h"
 
-void MustReturnFromCallerChecker::registerMatchers(MatchFinder* AstMatcher) {
+void MustReturnFromCallerChecker::registerMatchers(MatchFinder *AstMatcher) {
   // Look for a call to a MOZ_MUST_RETURN_FROM_CALLER function
-  AstMatcher->addMatcher(callExpr(callee(functionDecl(isMozMustReturnFromCaller())),
-                                  anyOf(hasAncestor(lambdaExpr().bind("containing-lambda")),
-                                        hasAncestor(functionDecl().bind("containing-func")))).bind("call"),
-                         this);
+  AstMatcher->addMatcher(
+      callExpr(callee(functionDecl(isMozMustReturnFromCaller())),
+               anyOf(hasAncestor(lambdaExpr().bind("containing-lambda")),
+                     hasAncestor(functionDecl().bind("containing-func"))))
+          .bind("call"),
+      this);
 }
 
 void MustReturnFromCallerChecker::check(
-    const MatchFinder::MatchResult& Result) {
+    const MatchFinder::MatchResult &Result) {
   const auto *ContainingLambda =
-    Result.Nodes.getNodeAs<LambdaExpr>("containing-lambda");
+      Result.Nodes.getNodeAs<LambdaExpr>("containing-lambda");
   const auto *ContainingFunc =
-    Result.Nodes.getNodeAs<FunctionDecl>("containing-func");
+      Result.Nodes.getNodeAs<FunctionDecl>("containing-func");
   const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
 
   Stmt *Body = nullptr;
   if (ContainingLambda) {
     Body = ContainingLambda->getBody();
   } else if (ContainingFunc) {
     Body = ContainingFunc->getBody();
   } else {
     return;
   }
   assert(Body && "Should have a body by this point");
 
   // Generate the CFG for the enclosing function or decl.
   CFG::BuildOptions Options;
   std::unique_ptr<CFG> TheCFG =
-    CFG::buildCFG(nullptr, Body, Result.Context, Options);
+      CFG::buildCFG(nullptr, Body, Result.Context, Options);
   if (!TheCFG) {
     return;
   }
 
   // Determine which block in the CFG we want to look at the successors of.
   StmtToBlockMap BlockMap(TheCFG.get(), Result.Context);
   size_t CallIndex;
   const auto *Block = BlockMap.blockContainingStmt(Call, &CallIndex);
@@ -47,20 +49,19 @@ void MustReturnFromCallerChecker::check(
 
   if (!immediatelyReturns(Block, Result.Context, CallIndex + 1)) {
     diag(Call->getLocStart(),
          "You must immediately return after calling this function",
          DiagnosticIDs::Error);
   }
 }
 
-bool
-MustReturnFromCallerChecker::immediatelyReturns(RecurseGuard<const CFGBlock *> Block,
-                                                ASTContext *TheContext,
-                                                size_t FromIdx) {
+bool MustReturnFromCallerChecker::immediatelyReturns(
+    RecurseGuard<const CFGBlock *> Block, ASTContext *TheContext,
+    size_t FromIdx) {
   if (Block.isRepeat()) {
     return false;
   }
 
   for (size_t I = FromIdx; I < Block->size(); ++I) {
     Optional<CFGStmt> S = (*Block)[I].getAs<CFGStmt>();
     if (!S) {
       continue;
@@ -68,27 +69,27 @@ MustReturnFromCallerChecker::immediately
 
     auto AfterTrivials = IgnoreTrivials(S->getStmt());
 
     // If we are looking at a ConstructExpr, a DeclRefExpr or a MemberExpr it's
     // OK to use them after a call to a MOZ_MUST_RETURN_FROM_CALLER function.
     // It is also, of course, OK to look at a ReturnStmt.
     if (isa<ReturnStmt>(AfterTrivials) ||
         isa<CXXConstructExpr>(AfterTrivials) ||
-        isa<DeclRefExpr>(AfterTrivials) ||
-        isa<MemberExpr>(AfterTrivials)) {
+        isa<DeclRefExpr>(AfterTrivials) || isa<MemberExpr>(AfterTrivials)) {
       continue;
     }
 
     // It's also OK to call any function or method which is annotated with
     // MOZ_MAY_CALL_AFTER_MUST_RETURN. We consider all CXXConversionDecls
     // to be MOZ_MAY_CALL_AFTER_MUST_RETURN (like operator T*()).
     if (auto CE = dyn_cast<CallExpr>(AfterTrivials)) {
       auto Callee = CE->getDirectCallee();
-      if (Callee && hasCustomAnnotation(Callee, "moz_may_call_after_must_return")) {
+      if (Callee &&
+          hasCustomAnnotation(Callee, "moz_may_call_after_must_return")) {
         continue;
       }
 
       if (Callee && isa<CXXConversionDecl>(Callee)) {
         continue;
       }
     }
 
--- a/build/clang-plugin/MustReturnFromCallerChecker.h
+++ b/build/clang-plugin/MustReturnFromCallerChecker.h
@@ -1,26 +1,26 @@
 /* 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/. */
 
 #ifndef MustReturnFromCallerChecker_h__
 #define MustReturnFromCallerChecker_h__
 
-#include "plugin.h"
-#include "Utils.h"
 #include "RecurseGuard.h"
 #include "StmtToBlockMap.h"
+#include "Utils.h"
+#include "plugin.h"
 
 class MustReturnFromCallerChecker : public BaseCheck {
 public:
   MustReturnFromCallerChecker(StringRef CheckName,
                               ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
+
 private:
   bool immediatelyReturns(RecurseGuard<const CFGBlock *> Block,
-                          ASTContext *TheContext,
-                          size_t FromIdx);
+                          ASTContext *TheContext, size_t FromIdx);
 };
 
 #endif
--- a/build/clang-plugin/MustUseChecker.cpp
+++ b/build/clang-plugin/MustUseChecker.cpp
@@ -4,33 +4,33 @@
 
 #include "MustUseChecker.h"
 #include "CustomMatchers.h"
 #include "CustomTypeAnnotation.h"
 
 CustomTypeAnnotation MustUse =
     CustomTypeAnnotation("moz_must_use_type", "must-use");
 
-void MustUseChecker::registerMatchers(MatchFinder* AstMatcher) {
+void MustUseChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(switchCase().bind("switchcase"), this);
   AstMatcher->addMatcher(compoundStmt().bind("compound"), this);
   AstMatcher->addMatcher(ifStmt().bind("if"), this);
   AstMatcher->addMatcher(whileStmt().bind("while"), this);
   AstMatcher->addMatcher(doStmt().bind("do"), this);
   AstMatcher->addMatcher(forStmt().bind("for"), this);
-  AstMatcher->addMatcher(binaryOperator(binaryCommaOperator()).bind("bin"), this);
+  AstMatcher->addMatcher(binaryOperator(binaryCommaOperator()).bind("bin"),
+                         this);
 }
 
-void MustUseChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void MustUseChecker::check(const MatchFinder::MatchResult &Result) {
   if (auto SC = Result.Nodes.getNodeAs<SwitchCase>("switchcase")) {
     handleUnusedExprResult(SC->getSubStmt());
   }
   if (auto C = Result.Nodes.getNodeAs<CompoundStmt>("compound")) {
-    for (const auto& S : C->body()) {
+    for (const auto &S : C->body()) {
       handleUnusedExprResult(S);
     }
   }
   if (auto IF = Result.Nodes.getNodeAs<IfStmt>("if")) {
     handleUnusedExprResult(IF->getThen());
     handleUnusedExprResult(IF->getElse());
   }
   if (auto W = Result.Nodes.getNodeAs<WhileStmt>("while")) {
@@ -51,13 +51,14 @@ void MustUseChecker::check(
 
 void MustUseChecker::handleUnusedExprResult(const Stmt *Statement) {
   const Expr *E = dyn_cast_or_null<Expr>(Statement);
   if (E) {
     E = E->IgnoreImplicit(); // Ignore ExprWithCleanup etc. implicit wrappers
     QualType T = E->getType();
     if (MustUse.hasEffectiveAnnotation(T) && !isIgnoredExprForMustUse(E)) {
       diag(E->getLocStart(), "Unused value of must-use type %0",
-           DiagnosticIDs::Error) << T;
+           DiagnosticIDs::Error)
+          << T;
       MustUse.dumpAnnotationReason(*this, T, E->getLocStart());
     }
   }
 }
--- a/build/clang-plugin/MustUseChecker.h
+++ b/build/clang-plugin/MustUseChecker.h
@@ -4,19 +4,18 @@
 
 #ifndef MustUseChecker_h__
 #define MustUseChecker_h__
 
 #include "plugin.h"
 
 class MustUseChecker : public BaseCheck {
 public:
-  MustUseChecker(StringRef CheckName,
-                 ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  MustUseChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 
 private:
   void handleUnusedExprResult(const Stmt *Statement);
 };
 
 #endif
--- a/build/clang-plugin/NaNExprChecker.cpp
+++ b/build/clang-plugin/NaNExprChecker.cpp
@@ -1,56 +1,56 @@
 /* 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/. */
 
 #include "NaNExprChecker.h"
 #include "CustomMatchers.h"
 
-void NaNExprChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NaNExprChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
       binaryOperator(
           allOf(binaryEqualityOperator(),
                 hasLHS(hasIgnoringParenImpCasts(
                     declRefExpr(hasType(qualType((isFloat())))).bind("lhs"))),
                 hasRHS(hasIgnoringParenImpCasts(
                     declRefExpr(hasType(qualType((isFloat())))).bind("rhs"))),
                 unless(anyOf(isInSystemHeader(), isInWhitelistForNaNExpr()))))
           .bind("node"),
       this);
 }
 
-void NaNExprChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void NaNExprChecker::check(const MatchFinder::MatchResult &Result) {
   if (!Result.Context->getLangOpts().CPlusPlus) {
     // mozilla::IsNaN is not usable in C, so there is no point in issuing these
     // warnings.
     return;
   }
 
-  const BinaryOperator *Expression = Result.Nodes.getNodeAs<BinaryOperator>(
-    "node");
+  const BinaryOperator *Expression =
+      Result.Nodes.getNodeAs<BinaryOperator>("node");
   const DeclRefExpr *LHS = Result.Nodes.getNodeAs<DeclRefExpr>("lhs");
   const DeclRefExpr *RHS = Result.Nodes.getNodeAs<DeclRefExpr>("rhs");
-  const ImplicitCastExpr *LHSExpr = dyn_cast<ImplicitCastExpr>(
-    Expression->getLHS());
-  const ImplicitCastExpr *RHSExpr = dyn_cast<ImplicitCastExpr>(
-    Expression->getRHS());
+  const ImplicitCastExpr *LHSExpr =
+      dyn_cast<ImplicitCastExpr>(Expression->getLHS());
+  const ImplicitCastExpr *RHSExpr =
+      dyn_cast<ImplicitCastExpr>(Expression->getRHS());
   // The AST subtree that we are looking for will look like this:
   // -BinaryOperator ==/!=
   //  |-ImplicitCastExpr LValueToRValue
   //  | |-DeclRefExpr
   //  |-ImplicitCastExpr LValueToRValue
   //    |-DeclRefExpr
   // The check below ensures that we are dealing with the correct AST subtree
   // shape, and
   // also that both of the found DeclRefExpr's point to the same declaration.
   if (LHS->getFoundDecl() == RHS->getFoundDecl() && LHSExpr && RHSExpr &&
       std::distance(LHSExpr->child_begin(), LHSExpr->child_end()) == 1 &&
       std::distance(RHSExpr->child_begin(), RHSExpr->child_end()) == 1 &&
       *LHSExpr->child_begin() == LHS && *RHSExpr->child_begin() == RHS) {
-    diag(Expression->getLocStart(), "comparing a floating point value to itself for "
-                                    "NaN checking can lead to incorrect results",
+    diag(Expression->getLocStart(),
+         "comparing a floating point value to itself for "
+         "NaN checking can lead to incorrect results",
          DiagnosticIDs::Error);
     diag(Expression->getLocStart(), "consider using mozilla::IsNaN instead",
          DiagnosticIDs::Note);
   }
 }
--- a/build/clang-plugin/NaNExprChecker.h
+++ b/build/clang-plugin/NaNExprChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef NaNExprChecker_h__
 #define NaNExprChecker_h__
 
 #include "plugin.h"
 
 class NaNExprChecker : public BaseCheck {
 public:
-  NaNExprChecker(StringRef CheckName,
-                 ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  NaNExprChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/NeedsNoVTableTypeChecker.cpp
+++ b/build/clang-plugin/NeedsNoVTableTypeChecker.cpp
@@ -1,40 +1,39 @@
 /* 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/. */
 
 #include "NeedsNoVTableTypeChecker.h"
 #include "CustomMatchers.h"
 
-void NeedsNoVTableTypeChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NeedsNoVTableTypeChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
       classTemplateSpecializationDecl(
           allOf(hasAnyTemplateArgument(refersToType(hasVTable())),
                 hasNeedsNoVTableTypeAttr()))
           .bind("node"),
       this);
 }
 
-void NeedsNoVTableTypeChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void NeedsNoVTableTypeChecker::check(const MatchFinder::MatchResult &Result) {
   const ClassTemplateSpecializationDecl *Specialization =
       Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("node");
 
   // Get the offending template argument
   QualType Offender;
   const TemplateArgumentList &Args =
       Specialization->getTemplateInstantiationArgs();
   for (unsigned i = 0; i < Args.size(); ++i) {
     Offender = Args[i].getAsType();
     if (typeHasVTable(Offender)) {
       break;
     }
   }
 
   diag(Specialization->getLocStart(),
        "%0 cannot be instantiated because %1 has a VTable",
-       DiagnosticIDs::Error) << Specialization
-                             << Offender;
+       DiagnosticIDs::Error)
+      << Specialization << Offender;
   diag(Specialization->getPointOfInstantiation(),
-       "bad instantiation of %0 requested here",
-       DiagnosticIDs::Note)  << Specialization;
+       "bad instantiation of %0 requested here", DiagnosticIDs::Note)
+      << Specialization;
 }
--- a/build/clang-plugin/NeedsNoVTableTypeChecker.h
+++ b/build/clang-plugin/NeedsNoVTableTypeChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef NeedsNoVTableTypeChecker_h__
 #define NeedsNoVTableTypeChecker_h__
 
 #include "plugin.h"
 
 class NeedsNoVTableTypeChecker : public BaseCheck {
 public:
-  NeedsNoVTableTypeChecker(StringRef CheckName,
-                           ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  NeedsNoVTableTypeChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/NoAddRefReleaseOnReturnChecker.cpp
+++ b/build/clang-plugin/NoAddRefReleaseOnReturnChecker.cpp
@@ -1,32 +1,32 @@
 /* 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/. */
 
 #include "NoAddRefReleaseOnReturnChecker.h"
 #include "CustomMatchers.h"
 
-void NoAddRefReleaseOnReturnChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NoAddRefReleaseOnReturnChecker::registerMatchers(MatchFinder *AstMatcher) {
   // Look for all of the calls to AddRef() or Release()
-  AstMatcher->addMatcher(memberExpr(isAddRefOrRelease(), hasParent(callExpr())).bind("member"),
-                         this);
+  AstMatcher->addMatcher(
+      memberExpr(isAddRefOrRelease(), hasParent(callExpr())).bind("member"),
+      this);
 }
 
 void NoAddRefReleaseOnReturnChecker::check(
     const MatchFinder::MatchResult &Result) {
   const MemberExpr *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
   const Expr *Base = IgnoreTrivials(Member->getBase());
 
   // Check if the call to AddRef() or Release() was made on the result of a call
   // to a MOZ_NO_ADDREF_RELEASE_ON_RETURN function or method.
   if (auto *Call = dyn_cast<CallExpr>(Base)) {
     if (auto *Callee = Call->getDirectCallee()) {
       if (hasCustomAnnotation(Callee, "moz_no_addref_release_on_return")) {
         diag(Call->getLocStart(),
              "%1 cannot be called on the return value of %0",
              DiagnosticIDs::Error)
-          << Callee
-          << dyn_cast<CXXMethodDecl>(Member->getMemberDecl());
+            << Callee << dyn_cast<CXXMethodDecl>(Member->getMemberDecl());
       }
     }
   }
 }
--- a/build/clang-plugin/NoAddRefReleaseOnReturnChecker.h
+++ b/build/clang-plugin/NoAddRefReleaseOnReturnChecker.h
@@ -6,14 +6,14 @@
 #define NoAddRefReleaseOnReturnChecker_h__
 
 #include "plugin.h"
 
 class NoAddRefReleaseOnReturnChecker : public BaseCheck {
 public:
   NoAddRefReleaseOnReturnChecker(StringRef CheckName,
                                  ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/NoAutoTypeChecker.cpp
+++ b/build/clang-plugin/NoAutoTypeChecker.cpp
@@ -1,23 +1,21 @@
 /* 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/. */
 
 #include "NoAutoTypeChecker.h"
 #include "CustomMatchers.h"
 
-void NoAutoTypeChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NoAutoTypeChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(varDecl(hasType(autoNonAutoableType())).bind("node"),
                          this);
 }
 
-void NoAutoTypeChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void NoAutoTypeChecker::check(const MatchFinder::MatchResult &Result) {
   const VarDecl *D = Result.Nodes.getNodeAs<VarDecl>("node");
 
-  diag(D->getLocation(),
-       "Cannot use auto to declare a variable of type %0",
-       DiagnosticIDs::Error) << D->getType();
-  diag(D->getLocation(),
-       "Please write out this type explicitly",
+  diag(D->getLocation(), "Cannot use auto to declare a variable of type %0",
+       DiagnosticIDs::Error)
+      << D->getType();
+  diag(D->getLocation(), "Please write out this type explicitly",
        DiagnosticIDs::Note);
 }
--- a/build/clang-plugin/NoAutoTypeChecker.h
+++ b/build/clang-plugin/NoAutoTypeChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef NoAutoTypeChecker_h__
 #define NoAutoTypeChecker_h__
 
 #include "plugin.h"
 
 class NoAutoTypeChecker : public BaseCheck {
 public:
-  NoAutoTypeChecker(StringRef CheckName,
-                    ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  NoAutoTypeChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/NoDuplicateRefCntMemberChecker.cpp
+++ b/build/clang-plugin/NoDuplicateRefCntMemberChecker.cpp
@@ -1,16 +1,16 @@
 /* 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/. */
 
 #include "NoDuplicateRefCntMemberChecker.h"
 #include "CustomMatchers.h"
 
-void NoDuplicateRefCntMemberChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NoDuplicateRefCntMemberChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(cxxRecordDecl().bind("decl"), this);
 }
 
 void NoDuplicateRefCntMemberChecker::check(
     const MatchFinder::MatchResult &Result) {
   const CXXRecordDecl *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl");
   const FieldDecl *RefCntMember = getClassRefCntMember(D);
   const FieldDecl *FoundRefCntBase = nullptr;
@@ -29,40 +29,37 @@ void NoDuplicateRefCntMemberChecker::che
   // warn for those which do
   for (auto &Base : D->bases()) {
     // Determine if this base class has an mRefCnt member
     const FieldDecl *BaseRefCntMember = getBaseRefCntMember(Base.getType());
 
     if (BaseRefCntMember) {
       if (RefCntMember) {
         // We have an mRefCnt, and superclass has an mRefCnt
-        const char* Error =
-            "Refcounted record %0 has multiple mRefCnt members";
-        const char* Note1 =
-            "Superclass %0 also has an mRefCnt member";
-        const char* Note2 =
+        const char *Error = "Refcounted record %0 has multiple mRefCnt members";
+        const char *Note1 = "Superclass %0 also has an mRefCnt member";
+        const char *Note2 =
             "Consider using the _INHERITED macros for AddRef and Release here";
 
         diag(D->getLocStart(), Error, DiagnosticIDs::Error) << D;
         diag(BaseRefCntMember->getLocStart(), Note1, DiagnosticIDs::Note)
-          << BaseRefCntMember->getParent();
+            << BaseRefCntMember->getParent();
         diag(RefCntMember->getLocStart(), Note2, DiagnosticIDs::Note);
       }
 
       if (FoundRefCntBase) {
-        const char* Error =
-            "Refcounted record %0 has multiple superclasses with mRefCnt members";
-        const char* Note =
-            "Superclass %0 has an mRefCnt member";
+        const char *Error = "Refcounted record %0 has multiple superclasses "
+                            "with mRefCnt members";
+        const char *Note = "Superclass %0 has an mRefCnt member";
 
         // superclass has mRefCnt, and another superclass also has an mRefCnt
         diag(D->getLocStart(), Error, DiagnosticIDs::Error) << D;
         diag(BaseRefCntMember->getLocStart(), Note, DiagnosticIDs::Note)
-          << BaseRefCntMember->getParent();
+            << BaseRefCntMember->getParent();
         diag(FoundRefCntBase->getLocStart(), Note, DiagnosticIDs::Note)
-          << FoundRefCntBase->getParent();
+            << FoundRefCntBase->getParent();
       }
 
       // Record that we've found a base with a mRefCnt member
       FoundRefCntBase = BaseRefCntMember;
     }
   }
 }
--- a/build/clang-plugin/NoDuplicateRefCntMemberChecker.h
+++ b/build/clang-plugin/NoDuplicateRefCntMemberChecker.h
@@ -6,14 +6,14 @@
 #define NoDuplicateRefCntMemberChecker_h__
 
 #include "plugin.h"
 
 class NoDuplicateRefCntMemberChecker : public BaseCheck {
 public:
   NoDuplicateRefCntMemberChecker(StringRef CheckName,
                                  ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/NoExplicitMoveConstructorChecker.cpp
+++ b/build/clang-plugin/NoExplicitMoveConstructorChecker.cpp
@@ -1,19 +1,19 @@
 /* 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/. */
 
 #include "NoExplicitMoveConstructorChecker.h"
 #include "CustomMatchers.h"
 
-void NoExplicitMoveConstructorChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NoExplicitMoveConstructorChecker::registerMatchers(
+    MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
-      cxxConstructorDecl(isExplicitMoveConstructor()).bind("node"),
-      this);
+      cxxConstructorDecl(isExplicitMoveConstructor()).bind("node"), this);
 }
 
 void NoExplicitMoveConstructorChecker::check(
     const MatchFinder::MatchResult &Result) {
   // Everything we needed to know was checked in the matcher - we just report
   // the error here
   const CXXConstructorDecl *D =
       Result.Nodes.getNodeAs<CXXConstructorDecl>("node");
--- a/build/clang-plugin/NoExplicitMoveConstructorChecker.h
+++ b/build/clang-plugin/NoExplicitMoveConstructorChecker.h
@@ -6,14 +6,14 @@
 #define NoExplicitMoveConstructorChecker_h__
 
 #include "plugin.h"
 
 class NoExplicitMoveConstructorChecker : public BaseCheck {
 public:
   NoExplicitMoveConstructorChecker(StringRef CheckName,
                                    ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/NonMemMovableMemberChecker.cpp
+++ b/build/clang-plugin/NonMemMovableMemberChecker.cpp
@@ -2,37 +2,33 @@
  * 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/. */
 
 #include "NonMemMovableMemberChecker.h"
 #include "CustomMatchers.h"
 
 MemMoveAnnotation NonMemMovable = MemMoveAnnotation();
 
-void NonMemMovableMemberChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NonMemMovableMemberChecker::registerMatchers(MatchFinder *AstMatcher) {
   // Handle non-mem-movable members
-  AstMatcher->addMatcher(
-      cxxRecordDecl(needsMemMovableMembers())
-          .bind("decl"),
-      this);
+  AstMatcher->addMatcher(cxxRecordDecl(needsMemMovableMembers()).bind("decl"),
+                         this);
 }
 
-void NonMemMovableMemberChecker::check(
-    const MatchFinder::MatchResult &Result) {
-  const char* Error =
+void NonMemMovableMemberChecker::check(const MatchFinder::MatchResult &Result) {
+  const char *Error =
       "class %0 cannot have non-memmovable member %1 of type %2";
 
   // Get the specialization
-  const CXXRecordDecl* Declaration =
+  const CXXRecordDecl *Declaration =
       Result.Nodes.getNodeAs<CXXRecordDecl>("decl");
 
   // Report an error for every member which is non-memmovable
   for (const FieldDecl *Field : Declaration->fields()) {
     QualType Type = Field->getType();
     if (NonMemMovable.hasEffectiveAnnotation(Type)) {
       diag(Field->getLocation(), Error, DiagnosticIDs::Error)
-        << Declaration
-        << Field
-        << Type;
-      NonMemMovable.dumpAnnotationReason(*this, Type, Declaration->getLocation());
+          << Declaration << Field << Type;
+      NonMemMovable.dumpAnnotationReason(*this, Type,
+                                         Declaration->getLocation());
     }
   }
 }
--- a/build/clang-plugin/NonMemMovableMemberChecker.h
+++ b/build/clang-plugin/NonMemMovableMemberChecker.h
@@ -6,14 +6,14 @@
 #define NonMemMovableMemberChecker_h__
 
 #include "plugin.h"
 
 class NonMemMovableMemberChecker : public BaseCheck {
 public:
   NonMemMovableMemberChecker(StringRef CheckName,
                              ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/NonMemMovableTemplateArgChecker.cpp
+++ b/build/clang-plugin/NonMemMovableTemplateArgChecker.cpp
@@ -1,46 +1,45 @@
 /* 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/. */
 
 #include "NonMemMovableTemplateArgChecker.h"
 #include "CustomMatchers.h"
 
-void NonMemMovableTemplateArgChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NonMemMovableTemplateArgChecker::registerMatchers(
+    MatchFinder *AstMatcher) {
   // Handle non-mem-movable template specializations
   AstMatcher->addMatcher(
       classTemplateSpecializationDecl(
           allOf(needsMemMovableTemplateArg(),
                 hasAnyTemplateArgument(refersToType(isNonMemMovable()))))
           .bind("specialization"),
       this);
 }
 
 void NonMemMovableTemplateArgChecker::check(
     const MatchFinder::MatchResult &Result) {
-  const char* Error =
+  const char *Error =
       "Cannot instantiate %0 with non-memmovable template argument %1";
-  const char* Note =
-      "instantiation of %0 requested here";
+  const char *Note = "instantiation of %0 requested here";
 
   // Get the specialization
   const ClassTemplateSpecializationDecl *Specialization =
       Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("specialization");
   SourceLocation RequestLoc = Specialization->getPointOfInstantiation();
 
   // Report an error for every template argument which is non-memmovable
   const TemplateArgumentList &Args =
       Specialization->getTemplateInstantiationArgs();
   for (unsigned i = 0; i < Args.size(); ++i) {
     QualType ArgType = Args[i].getAsType();
     if (NonMemMovable.hasEffectiveAnnotation(ArgType)) {
-      diag(Specialization->getLocation(), Error,
-           DiagnosticIDs::Error) << Specialization
-                                 << ArgType;
+      diag(Specialization->getLocation(), Error, DiagnosticIDs::Error)
+          << Specialization << ArgType;
       // XXX It would be really nice if we could get the instantiation stack
       // information
       // from Sema such that we could print a full template instantiation stack,
       // however,
       // it seems as though that information is thrown out by the time we get
       // here so we
       // can only report one level of template specialization (which in many
       // cases won't
--- a/build/clang-plugin/NonMemMovableTemplateArgChecker.h
+++ b/build/clang-plugin/NonMemMovableTemplateArgChecker.h
@@ -6,14 +6,14 @@
 #define NonMemMovableTemplateArgChecker_h__
 
 #include "plugin.h"
 
 class NonMemMovableTemplateArgChecker : public BaseCheck {
 public:
   NonMemMovableTemplateArgChecker(StringRef CheckName,
                                   ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/NonParamInsideFunctionDeclChecker.cpp
+++ b/build/clang-plugin/NonParamInsideFunctionDeclChecker.cpp
@@ -1,19 +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/. */
 
 #include "NonParamInsideFunctionDeclChecker.h"
 #include "CustomMatchers.h"
 
-class NonParamAnnotation : public CustomTypeAnnotation
-{
+class NonParamAnnotation : public CustomTypeAnnotation {
 public:
-  NonParamAnnotation() : CustomTypeAnnotation("moz_non_param", "non-param") {};
+  NonParamAnnotation() : CustomTypeAnnotation("moz_non_param", "non-param"){};
 
 protected:
   // Adding alignas(_) on a struct implicitly marks it as MOZ_NON_PARAM, due to
   // MSVC limitations which prevent passing explcitly aligned types by value as
   // parameters. This overload of hasFakeAnnotation injects fake MOZ_NON_PARAM
   // annotations onto these types.
   std::string getImplicitReason(const TagDecl *D) const override {
     // Check if the decl itself has an AlignedAttr on it.
@@ -23,45 +22,47 @@ protected:
       }
     }
 
     // Check if any of the decl's fields have an AlignedAttr on them.
     if (auto RD = dyn_cast<RecordDecl>(D)) {
       for (auto F : RD->fields()) {
         for (auto A : F->attrs()) {
           if (isa<AlignedAttr>(A)) {
-            return ("member '" + F->getName() + "' has an alignas(_) annotation").str();
+            return ("member '" + F->getName() +
+                    "' has an alignas(_) annotation")
+                .str();
           }
         }
       }
     }
 
     // We don't need to check the types of fields, as the CustomTypeAnnotation
     // infrastructure will handle that for us.
     return "";
   }
 };
 NonParamAnnotation NonParam;
 
-void NonParamInsideFunctionDeclChecker::registerMatchers(MatchFinder* AstMatcher) {
+void NonParamInsideFunctionDeclChecker::registerMatchers(
+    MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
-      functionDecl(anyOf(allOf(isDefinition(),
-                               hasAncestor(classTemplateSpecializationDecl()
-                                               .bind("spec"))),
-                         isDefinition()))
+      functionDecl(
+          anyOf(allOf(isDefinition(),
+                      hasAncestor(
+                          classTemplateSpecializationDecl().bind("spec"))),
+                isDefinition()))
           .bind("func"),
       this);
-  AstMatcher->addMatcher(
-      lambdaExpr().bind("lambda"),
-      this);
+  AstMatcher->addMatcher(lambdaExpr().bind("lambda"), this);
 }
 
 void NonParamInsideFunctionDeclChecker::check(
     const MatchFinder::MatchResult &Result) {
-  static DenseSet<const FunctionDecl*> CheckedFunctionDecls;
+  static DenseSet<const FunctionDecl *> CheckedFunctionDecls;
 
   const FunctionDecl *func = Result.Nodes.getNodeAs<FunctionDecl>("func");
   if (!func) {
     const LambdaExpr *lambda = Result.Nodes.getNodeAs<LambdaExpr>("lambda");
     if (lambda) {
       func = lambda->getCallOperator();
     }
   }
@@ -93,23 +94,24 @@ void NonParamInsideFunctionDeclChecker::
 
   const ClassTemplateSpecializationDecl *Spec =
       Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("spec");
 
   for (ParmVarDecl *p : func->parameters()) {
     QualType T = p->getType().withoutLocalFastQualifiers();
     if (NonParam.hasEffectiveAnnotation(T)) {
       diag(p->getLocation(), "Type %0 must not be used as parameter",
-           DiagnosticIDs::Error) << T;
-      diag(p->getLocation(), "Please consider passing a const reference instead",
+           DiagnosticIDs::Error)
+          << T;
+      diag(p->getLocation(),
+           "Please consider passing a const reference instead",
            DiagnosticIDs::Note);
 
       if (Spec) {
         diag(Spec->getPointOfInstantiation(),
-             "The bad argument was passed to %0 here",
-             DiagnosticIDs::Note)
-          << Spec->getSpecializedTemplate();
+             "The bad argument was passed to %0 here", DiagnosticIDs::Note)
+            << Spec->getSpecializedTemplate();
       }
 
       NonParam.dumpAnnotationReason(*this, T, p->getLocation());
     }
   }
 }
--- a/build/clang-plugin/NonParamInsideFunctionDeclChecker.h
+++ b/build/clang-plugin/NonParamInsideFunctionDeclChecker.h
@@ -6,14 +6,14 @@
 #define NonParamInsideFunctionDeclChecker_h__
 
 #include "plugin.h"
 
 class NonParamInsideFunctionDeclChecker : public BaseCheck {
 public:
   NonParamInsideFunctionDeclChecker(StringRef CheckName,
                                     ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/OverrideBaseCallChecker.cpp
+++ b/build/clang-plugin/OverrideBaseCallChecker.cpp
@@ -1,95 +1,93 @@
 /* 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/. */
 
 #include "OverrideBaseCallChecker.h"
 #include "CustomMatchers.h"
 
-void OverrideBaseCallChecker::registerMatchers(MatchFinder* AstMatcher) {
-  AstMatcher->addMatcher(cxxRecordDecl(hasBaseClasses()).bind("class"),
-      this);
+void OverrideBaseCallChecker::registerMatchers(MatchFinder *AstMatcher) {
+  AstMatcher->addMatcher(cxxRecordDecl(hasBaseClasses()).bind("class"), this);
 }
 
 bool OverrideBaseCallChecker::isRequiredBaseMethod(
     const CXXMethodDecl *Method) {
   return hasCustomAnnotation(Method, "moz_required_base_method");
 }
 
 void OverrideBaseCallChecker::evaluateExpression(
-    const Stmt *StmtExpr, std::list<const CXXMethodDecl*> &MethodList) {
+    const Stmt *StmtExpr, std::list<const CXXMethodDecl *> &MethodList) {
   // Continue while we have methods in our list
   if (!MethodList.size()) {
     return;
   }
 
   if (auto MemberFuncCall = dyn_cast<CXXMemberCallExpr>(StmtExpr)) {
-    if (auto Method = dyn_cast<CXXMethodDecl>(
-        MemberFuncCall->getDirectCallee())) {
+    if (auto Method =
+            dyn_cast<CXXMethodDecl>(MemberFuncCall->getDirectCallee())) {
       findBaseMethodCall(Method, MethodList);
     }
   }
 
   for (auto S : StmtExpr->children()) {
     if (S) {
       evaluateExpression(S, MethodList);
     }
   }
 }
 
 void OverrideBaseCallChecker::getRequiredBaseMethod(
     const CXXMethodDecl *Method,
-    std::list<const CXXMethodDecl*>& MethodsList) {
+    std::list<const CXXMethodDecl *> &MethodsList) {
 
   if (isRequiredBaseMethod(Method)) {
     MethodsList.push_back(Method);
   } else {
     // Loop through all it's base methods.
     for (auto BaseMethod = Method->begin_overridden_methods();
-        BaseMethod != Method->end_overridden_methods(); BaseMethod++) {
+         BaseMethod != Method->end_overridden_methods(); BaseMethod++) {
       getRequiredBaseMethod(*BaseMethod, MethodsList);
     }
   }
 }
 
 void OverrideBaseCallChecker::findBaseMethodCall(
-    const CXXMethodDecl* Method,
-    std::list<const CXXMethodDecl*>& MethodsList) {
+    const CXXMethodDecl *Method,
+    std::list<const CXXMethodDecl *> &MethodsList) {
 
   MethodsList.remove(Method);
   // Loop also through all it's base methods;
   for (auto BaseMethod = Method->begin_overridden_methods();
-      BaseMethod != Method->end_overridden_methods(); BaseMethod++) {
+       BaseMethod != Method->end_overridden_methods(); BaseMethod++) {
     findBaseMethodCall(*BaseMethod, MethodsList);
   }
 }
 
-void OverrideBaseCallChecker::check(
-    const MatchFinder::MatchResult &Result) {
-  const char* Error =
+void OverrideBaseCallChecker::check(const MatchFinder::MatchResult &Result) {
+  const char *Error =
       "Method %0 must be called in all overrides, but is not called in "
       "this override defined for class %1";
   const CXXRecordDecl *Decl = Result.Nodes.getNodeAs<CXXRecordDecl>("class");
 
   // Loop through the methods and look for the ones that are overridden.
   for (auto Method : Decl->methods()) {
     // If this method doesn't override other methods or it doesn't have a body,
     // continue to the next declaration.
     if (!Method->size_overridden_methods() || !Method->hasBody()) {
       continue;
     }
 
     // Preferred the usage of list instead of vector in order to avoid
     // calling erase-remove when deleting items
-    std::list<const CXXMethodDecl*> MethodsList;
+    std::list<const CXXMethodDecl *> MethodsList;
     // For each overridden method push it to a list if it meets our
     // criteria
     for (auto BaseMethod = Method->begin_overridden_methods();
-        BaseMethod != Method->end_overridden_methods(); BaseMethod++) {
+         BaseMethod != Method->end_overridden_methods(); BaseMethod++) {
       getRequiredBaseMethod(*BaseMethod, MethodsList);
     }
 
     // If no method has been found then no annotation was used
     // so checking is not needed
     if (!MethodsList.size()) {
       continue;
     }
@@ -100,13 +98,12 @@ void OverrideBaseCallChecker::check(
 
     // If list is not empty pop up errors
     for (auto BaseMethod : MethodsList) {
       std::string QualName;
       raw_string_ostream OS(QualName);
       BaseMethod->printQualifiedName(OS);
 
       diag(Method->getLocation(), Error, DiagnosticIDs::Error)
-          << OS.str()
-          << Decl->getName();
+          << OS.str() << Decl->getName();
     }
   }
 }
--- a/build/clang-plugin/OverrideBaseCallChecker.h
+++ b/build/clang-plugin/OverrideBaseCallChecker.h
@@ -4,24 +4,24 @@
 
 #ifndef OverrideBaseCallChecker_h__
 #define OverrideBaseCallChecker_h__
 
 #include "plugin.h"
 
 class OverrideBaseCallChecker : public BaseCheck {
 public:
-  OverrideBaseCallChecker(StringRef CheckName,
-                          ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  OverrideBaseCallChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
+
 private:
   void evaluateExpression(const Stmt *StmtExpr,
-      std::list<const CXXMethodDecl*> &MethodList);
-  void getRequiredBaseMethod(const CXXMethodDecl* Method,
-      std::list<const CXXMethodDecl*>& MethodsList);
-  void findBaseMethodCall(const CXXMethodDecl* Method,
-      std::list<const CXXMethodDecl*>& MethodsList);
+                          std::list<const CXXMethodDecl *> &MethodList);
+  void getRequiredBaseMethod(const CXXMethodDecl *Method,
+                             std::list<const CXXMethodDecl *> &MethodsList);
+  void findBaseMethodCall(const CXXMethodDecl *Method,
+                          std::list<const CXXMethodDecl *> &MethodsList);
   bool isRequiredBaseMethod(const CXXMethodDecl *Method);
 };
 
 #endif
--- a/build/clang-plugin/OverrideBaseCallUsageChecker.cpp
+++ b/build/clang-plugin/OverrideBaseCallUsageChecker.cpp
@@ -1,21 +1,21 @@
 /* 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/. */
 
 #include "OverrideBaseCallUsageChecker.h"
 #include "CustomMatchers.h"
 
-void OverrideBaseCallUsageChecker::registerMatchers(MatchFinder* AstMatcher) {
+void OverrideBaseCallUsageChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
       cxxMethodDecl(isNonVirtual(), isRequiredBaseMethod()).bind("method"),
       this);
 }
 
 void OverrideBaseCallUsageChecker::check(
     const MatchFinder::MatchResult &Result) {
-  const char* Error =
+  const char *Error =
       "MOZ_REQUIRED_BASE_METHOD can be used only on virtual methods";
   const CXXMethodDecl *Method = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
 
   diag(Method->getLocation(), Error, DiagnosticIDs::Error);
 }
--- a/build/clang-plugin/OverrideBaseCallUsageChecker.h
+++ b/build/clang-plugin/OverrideBaseCallUsageChecker.h
@@ -10,14 +10,14 @@
 /*
  *  This is a companion checker for OverrideBaseCallChecker that rejects
  *  the usage of MOZ_REQUIRED_BASE_METHOD on non-virtual base methods.
  */
 class OverrideBaseCallUsageChecker : public BaseCheck {
 public:
   OverrideBaseCallUsageChecker(StringRef CheckName = "override-base-call-usage",
                                ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/RecurseGuard.h
+++ b/build/clang-plugin/RecurseGuard.h
@@ -12,52 +12,45 @@
 //
 // Constructing a RecurseGuard sets up a shared backing store which tracks the
 // currently observed objects. Whenever recursing, use RecurseGuard.recurse(T)
 // to construct another RecurseGuard with the same backing store.
 //
 // The RecurseGuard object will unregister its object when it is destroyed, and
 // has a method `isRepeat()` which will return `true` if the item was already
 // seen.
-template<typename T>
-class RecurseGuard {
+template <typename T> class RecurseGuard {
 public:
   RecurseGuard(T Thing) : Thing(Thing), Set(new DenseSet<T>()), Repeat(false) {
     Set->insert(Thing);
   }
-  RecurseGuard(T Thing, std::shared_ptr<DenseSet<T>>& Set)
-    : Thing(Thing), Set(Set), Repeat(false) {
+  RecurseGuard(T Thing, std::shared_ptr<DenseSet<T>> &Set)
+      : Thing(Thing), Set(Set), Repeat(false) {
     Repeat = !Set->insert(Thing).second;
   }
   RecurseGuard(const RecurseGuard &) = delete;
-  RecurseGuard(RecurseGuard && Other)
-    : Thing(Other.Thing), Set(Other.Set), Repeat(Other.Repeat) {
+  RecurseGuard(RecurseGuard &&Other)
+      : Thing(Other.Thing), Set(Other.Set), Repeat(Other.Repeat) {
     Other.Repeat = true;
   }
   ~RecurseGuard() {
     if (!Repeat) {
       Set->erase(Thing);
     }
   }
 
   bool isRepeat() { return Repeat; }
 
   T get() { return Thing; }
 
-  operator T() {
-    return Thing;
-  }
+  operator T() { return Thing; }
 
-  T operator ->() {
-    return Thing;
-  }
+  T operator->() { return Thing; }
 
-  RecurseGuard recurse(T NewThing) {
-    return RecurseGuard(NewThing, Set);
-  }
+  RecurseGuard recurse(T NewThing) { return RecurseGuard(NewThing, Set); }
 
 private:
   T Thing;
   std::shared_ptr<DenseSet<T>> Set;
   bool Repeat;
 };
 
 #endif // RecurseGuard_h__
--- a/build/clang-plugin/RefCountedCopyConstructorChecker.cpp
+++ b/build/clang-plugin/RefCountedCopyConstructorChecker.cpp
@@ -1,34 +1,34 @@
 /* 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/. */
 
 #include "RefCountedCopyConstructorChecker.h"
 #include "CustomMatchers.h"
 
-void RefCountedCopyConstructorChecker::registerMatchers(MatchFinder* AstMatcher) {
+void RefCountedCopyConstructorChecker::registerMatchers(
+    MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
       cxxConstructExpr(
           hasDeclaration(cxxConstructorDecl(isCompilerProvidedCopyConstructor(),
                                             ofClass(hasRefCntMember()))))
           .bind("node"),
       this);
 }
 
 void RefCountedCopyConstructorChecker::check(
     const MatchFinder::MatchResult &Result) {
-  const char* Error =
+  const char *Error =
       "Invalid use of compiler-provided copy constructor on refcounted type";
-  const char* 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";
+  const char *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";
 
   // Everything we needed to know was checked in the matcher - we just report
   // the error here
   const CXXConstructExpr *E = Result.Nodes.getNodeAs<CXXConstructExpr>("node");
 
   diag(E->getLocation(), Error, DiagnosticIDs::Error);
   diag(E->getLocation(), Note, DiagnosticIDs::Note);
 }
--- a/build/clang-plugin/RefCountedCopyConstructorChecker.h
+++ b/build/clang-plugin/RefCountedCopyConstructorChecker.h
@@ -6,14 +6,14 @@
 #define RefCountedCopyConstructorChecker_h__
 
 #include "plugin.h"
 
 class RefCountedCopyConstructorChecker : public BaseCheck {
 public:
   RefCountedCopyConstructorChecker(StringRef CheckName,
                                    ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/RefCountedInsideLambdaChecker.cpp
+++ b/build/clang-plugin/RefCountedInsideLambdaChecker.cpp
@@ -2,54 +2,53 @@
  * 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/. */
 
 #include "RefCountedInsideLambdaChecker.h"
 #include "CustomMatchers.h"
 
 RefCountedMap RefCountedClasses;
 
-void RefCountedInsideLambdaChecker::registerMatchers(MatchFinder* AstMatcher) {
+void RefCountedInsideLambdaChecker::registerMatchers(MatchFinder *AstMatcher) {
   // We want to reject any code which captures a pointer to an object of a
   // refcounted type, and then lets that value escape. As a primitive analysis,
   // we reject any occurances of the lambda as a template parameter to a class
   // (which could allow it to escape), as well as any presence of such a lambda
   // in a return value (either from lambdas, or in c++14, auto functions).
   //
   // We check these lambdas' capture lists for raw pointers to refcounted types.
+  AstMatcher->addMatcher(functionDecl(returns(recordType(hasDeclaration(
+                             cxxRecordDecl(isLambdaDecl()).bind("decl"))))),
+                         this);
+  AstMatcher->addMatcher(lambdaExpr().bind("lambdaExpr"), this);
   AstMatcher->addMatcher(
-      functionDecl(returns(recordType(hasDeclaration(cxxRecordDecl(
-        isLambdaDecl()).bind("decl"))))),
-      this);
-  AstMatcher->addMatcher(lambdaExpr().bind("lambdaExpr"),
-      this);
-  AstMatcher->addMatcher(
-      classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
-        recordType(hasDeclaration(cxxRecordDecl(
-          isLambdaDecl()).bind("decl")))))),
+      classTemplateSpecializationDecl(
+          hasAnyTemplateArgument(refersToType(recordType(
+              hasDeclaration(cxxRecordDecl(isLambdaDecl()).bind("decl")))))),
       this);
 }
 
 void RefCountedInsideLambdaChecker::emitDiagnostics(SourceLocation Loc,
                                                     StringRef Name,
                                                     QualType Type) {
-  diag(Loc, "Refcounted variable '%0' of type %1 cannot be captured by a lambda",
-       DiagnosticIDs::Error) << Name << Type;
-  diag(Loc, "Please consider using a smart pointer",
-       DiagnosticIDs::Note);
+  diag(Loc,
+       "Refcounted variable '%0' of type %1 cannot be captured by a lambda",
+       DiagnosticIDs::Error)
+      << Name << Type;
+  diag(Loc, "Please consider using a smart pointer", DiagnosticIDs::Note);
 }
 
 void RefCountedInsideLambdaChecker::check(
     const MatchFinder::MatchResult &Result) {
-  static DenseSet<const CXXRecordDecl*> CheckedDecls;
+  static DenseSet<const CXXRecordDecl *> CheckedDecls;
 
   const CXXRecordDecl *Lambda = Result.Nodes.getNodeAs<CXXRecordDecl>("decl");
 
   if (const LambdaExpr *OuterLambda =
-    Result.Nodes.getNodeAs<LambdaExpr>("lambdaExpr")) {
+          Result.Nodes.getNodeAs<LambdaExpr>("lambdaExpr")) {
     const CXXMethodDecl *OpCall = OuterLambda->getCallOperator();
     QualType ReturnTy = OpCall->getReturnType();
     if (const CXXRecordDecl *Record = ReturnTy->getAsCXXRecordDecl()) {
       Lambda = Record;
     }
   }
 
   if (!Lambda || !Lambda->isLambda()) {
@@ -59,29 +58,30 @@ void RefCountedInsideLambdaChecker::chec
   // Don't report errors on the same declarations more than once.
   if (CheckedDecls.count(Lambda)) {
     return;
   }
   CheckedDecls.insert(Lambda);
 
   bool StrongRefToThisCaptured = false;
 
-  for (const LambdaCapture& Capture : Lambda->captures()) {
+  for (const LambdaCapture &Capture : Lambda->captures()) {
     // Check if any of the captures are ByRef. If they are, we have nothing to
-    // report, as it's OK to capture raw pointers to refcounted objects so long as
-    // the Lambda doesn't escape the current scope, which is required by ByRef
-    // captures already.
+    // report, as it's OK to capture raw pointers to refcounted objects so long
+    // as the Lambda doesn't escape the current scope, which is required by
+    // ByRef captures already.
     if (Capture.getCaptureKind() == LCK_ByRef) {
       return;
     }
 
-    // Check if this capture is byvalue, and captures a strong reference to this.
-    // XXX: Do we want to make sure that this type which we are capturing is a "Smart Pointer" somehow?
-    if (!StrongRefToThisCaptured &&
-        Capture.capturesVariable() &&
+    // Check if this capture is byvalue, and captures a strong reference to
+    // this.
+    // XXX: Do we want to make sure that this type which we are capturing is a
+    // "Smart Pointer" somehow?
+    if (!StrongRefToThisCaptured && Capture.capturesVariable() &&
         Capture.getCaptureKind() == LCK_ByCopy) {
       const VarDecl *Var = Capture.getCapturedVar();
       if (Var->hasInit()) {
         const Stmt *Init = Var->getInit();
 
         // Ignore single argument constructors, and trivial nodes.
         while (true) {
           auto NewInit = IgnoreTrivials(Init);
@@ -98,52 +98,55 @@ void RefCountedInsideLambdaChecker::chec
 
         if (isa<CXXThisExpr>(Init)) {
           StrongRefToThisCaptured = true;
         }
       }
     }
   }
 
-  // Now we can go through and produce errors for any captured variables or this pointers.
-  for (const LambdaCapture& Capture : Lambda->captures()) {
+  // Now we can go through and produce errors for any captured variables or this
+  // pointers.
+  for (const LambdaCapture &Capture : Lambda->captures()) {
     if (Capture.capturesVariable()) {
       QualType Pointee = Capture.getCapturedVar()->getType()->getPointeeType();
 
       if (!Pointee.isNull() && isClassRefCounted(Pointee)) {
-        emitDiagnostics(Capture.getLocation(), Capture.getCapturedVar()->getName(), Pointee);
+        emitDiagnostics(Capture.getLocation(),
+                        Capture.getCapturedVar()->getName(), Pointee);
         return;
       }
     }
 
     // The situation with captures of `this` is more complex. All captures of
     // `this` look the same-ish (they are LCK_This). We want to complain about
     // captures of `this` where `this` is a refcounted type, and the capture is
     // actually used in the body of the lambda (if the capture isn't used, then
     // we don't care, because it's only being captured in order to give access
     // to private methods).
     //
     // In addition, we don't complain about this, even if it is used, if it was
     // captured implicitly when the LambdaCaptureDefault was LCD_ByRef, as that
     // expresses the intent that the lambda won't leave the enclosing scope.
     bool ImplicitByRefDefaultedCapture =
-      Capture.isImplicit() && Lambda->getLambdaCaptureDefault() == LCD_ByRef;
-    if (Capture.capturesThis() &&
-        !ImplicitByRefDefaultedCapture &&
+        Capture.isImplicit() && Lambda->getLambdaCaptureDefault() == LCD_ByRef;
+    if (Capture.capturesThis() && !ImplicitByRefDefaultedCapture &&
         !StrongRefToThisCaptured) {
       ThisVisitor V(*this);
-      bool NotAborted = V.TraverseDecl(const_cast<CXXMethodDecl *>(Lambda->getLambdaCallOperator()));
+      bool NotAborted = V.TraverseDecl(
+          const_cast<CXXMethodDecl *>(Lambda->getLambdaCallOperator()));
       if (!NotAborted) {
         return;
       }
     }
   }
 }
 
-bool RefCountedInsideLambdaChecker::ThisVisitor::VisitCXXThisExpr(CXXThisExpr *This) {
+bool RefCountedInsideLambdaChecker::ThisVisitor::VisitCXXThisExpr(
+    CXXThisExpr *This) {
   QualType Pointee = This->getType()->getPointeeType();
   if (!Pointee.isNull() && isClassRefCounted(Pointee)) {
     Checker.emitDiagnostics(This->getLocStart(), "this", Pointee);
     return false;
   }
 
   return true;
 }
--- a/build/clang-plugin/RefCountedInsideLambdaChecker.h
+++ b/build/clang-plugin/RefCountedInsideLambdaChecker.h
@@ -6,27 +6,28 @@
 #define RefCountedInsideLambdaChecker_h__
 
 #include "plugin.h"
 
 class RefCountedInsideLambdaChecker : public BaseCheck {
 public:
   RefCountedInsideLambdaChecker(StringRef CheckName,
                                 ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 
   void emitDiagnostics(SourceLocation Loc, StringRef Name, QualType Type);
 
 private:
   class ThisVisitor : public RecursiveASTVisitor<ThisVisitor> {
   public:
-    explicit ThisVisitor(RefCountedInsideLambdaChecker& Checker)
-      : Checker(Checker) {}
+    explicit ThisVisitor(RefCountedInsideLambdaChecker &Checker)
+        : Checker(Checker) {}
 
     bool VisitCXXThisExpr(CXXThisExpr *This);
+
   private:
-    RefCountedInsideLambdaChecker& Checker;
+    RefCountedInsideLambdaChecker &Checker;
   };
 };
 
 #endif
--- a/build/clang-plugin/ScopeChecker.cpp
+++ b/build/clang-plugin/ScopeChecker.cpp
@@ -1,22 +1,21 @@
 /* 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/. */
 
 #include "ScopeChecker.h"
 #include "CustomMatchers.h"
 
-void ScopeChecker::registerMatchers(MatchFinder* AstMatcher) {
+void ScopeChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(varDecl().bind("node"), this);
   AstMatcher->addMatcher(cxxNewExpr().bind("node"), this);
   AstMatcher->addMatcher(materializeTemporaryExpr().bind("node"), this);
   AstMatcher->addMatcher(
-      callExpr(callee(functionDecl(heapAllocator()))).bind("node"),
-      this);
+      callExpr(callee(functionDecl(heapAllocator()))).bind("node"), this);
   AstMatcher->addMatcher(parmVarDecl().bind("parm_vardecl"), this);
 }
 
 // These enum variants determine whether an allocation has occured in the code.
 enum AllocationVariety {
   AV_None,
   AV_Global,
   AV_Automatic,
@@ -26,18 +25,17 @@ enum AllocationVariety {
 
 // XXX Currently the Decl* in the AutomaticTemporaryMap is unused, but it
 // probably will be used at some point in the future, in order to produce better
 // error messages.
 typedef DenseMap<const MaterializeTemporaryExpr *, const Decl *>
     AutomaticTemporaryMap;
 AutomaticTemporaryMap AutomaticTemporaries;
 
-void ScopeChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void ScopeChecker::check(const MatchFinder::MatchResult &Result) {
   // There are a variety of different reasons why something could be allocated
   AllocationVariety Variety = AV_None;
   SourceLocation Loc;
   QualType T;
 
   if (const ParmVarDecl *D =
           Result.Nodes.getNodeAs<ParmVarDecl>("parm_vardecl")) {
     if (D->hasUnparsedDefaultArg() || D->hasUninstantiatedDefaultArg()) {
@@ -115,35 +113,27 @@ void ScopeChecker::check(
       // This will always allocate on the heap, as the heapAllocator() check
       // was made in the matcher
       Variety = AV_Heap;
       Loc = E->getLocStart();
     }
   }
 
   // Error messages for incorrect allocations.
-  const char* Stack =
-      "variable of type %0 only valid on the stack";
-  const char* Global =
-      "variable of type %0 only valid as global";
-  const char* Heap =
-      "variable of type %0 only valid on the heap";
-  const char* NonHeap =
-      "variable of type %0 is not valid on the heap";
-  const char* NonTemporary =
-      "variable of type %0 is not valid in a temporary";
+  const char *Stack = "variable of type %0 only valid on the stack";
+  const char *Global = "variable of type %0 only valid as global";
+  const char *Heap = "variable of type %0 only valid on the heap";
+  const char *NonHeap = "variable of type %0 is not valid on the heap";
+  const char *NonTemporary = "variable of type %0 is not valid in a temporary";
 
-  const char* StackNote =
+  const char *StackNote =
       "value incorrectly allocated in an automatic variable";
-  const char* GlobalNote =
-      "value incorrectly allocated in a global variable";
-  const char* HeapNote =
-      "value incorrectly allocated on the heap";
-  const char* TemporaryNote =
-      "value incorrectly allocated in a temporary";
+  const char *GlobalNote = "value incorrectly allocated in a global variable";
+  const char *HeapNote = "value incorrectly allocated on the heap";
+  const char *TemporaryNote = "value incorrectly allocated in a temporary";
 
   // Report errors depending on the annotations on the input types.
   switch (Variety) {
   case AV_None:
     return;
 
   case AV_Global:
     StackClass.reportErrorIfPresent(*this, T, Loc, Stack, GlobalNote);
--- a/build/clang-plugin/ScopeChecker.h
+++ b/build/clang-plugin/ScopeChecker.h
@@ -5,14 +5,14 @@
 #ifndef ScopeChecker_h__
 #define ScopeChecker_h__
 
 #include "plugin.h"
 
 class ScopeChecker : public BaseCheck {
 public:
   ScopeChecker(StringRef CheckName, ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/SprintfLiteralChecker.cpp
+++ b/build/clang-plugin/SprintfLiteralChecker.cpp
@@ -1,40 +1,43 @@
 /* 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/. */
 
 #include "SprintfLiteralChecker.h"
 #include "CustomMatchers.h"
 
-void SprintfLiteralChecker::registerMatchers(MatchFinder* AstMatcher) {
+void SprintfLiteralChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(
-      callExpr(isSnprintfLikeFunc(),
-        allOf(hasArgument(0, ignoringParenImpCasts(declRefExpr().bind("buffer"))),
-                             anyOf(hasArgument(1, sizeOfExpr(hasIgnoringParenImpCasts(declRefExpr().bind("size")))),
-                                   hasArgument(1, integerLiteral().bind("immediate")),
-                                   hasArgument(1, declRefExpr(to(varDecl(hasType(isConstQualified()),
-                                                                         hasInitializer(integerLiteral().bind("constant")))))))))
-        .bind("funcCall"),
-      this
-  );
+      callExpr(
+          isSnprintfLikeFunc(),
+          allOf(hasArgument(
+                    0, ignoringParenImpCasts(declRefExpr().bind("buffer"))),
+                anyOf(hasArgument(1, sizeOfExpr(hasIgnoringParenImpCasts(
+                                         declRefExpr().bind("size")))),
+                      hasArgument(1, integerLiteral().bind("immediate")),
+                      hasArgument(1, declRefExpr(to(varDecl(
+                                         hasType(isConstQualified()),
+                                         hasInitializer(integerLiteral().bind(
+                                             "constant")))))))))
+          .bind("funcCall"),
+      this);
 }
 
-void SprintfLiteralChecker::check(
-    const MatchFinder::MatchResult &Result) {
+void SprintfLiteralChecker::check(const MatchFinder::MatchResult &Result) {
   if (!Result.Context->getLangOpts().CPlusPlus) {
     // SprintfLiteral is not usable in C, so there is no point in issuing these
     // warnings.
     return;
   }
 
-  const char* Error =
-    "Use %1 instead of %0 when writing into a character array.";
-  const char* Note =
-    "This will prevent passing in the wrong size to %0 accidentally.";
+  const char *Error =
+      "Use %1 instead of %0 when writing into a character array.";
+  const char *Note =
+      "This will prevent passing in the wrong size to %0 accidentally.";
 
   const CallExpr *D = Result.Nodes.getNodeAs<CallExpr>("funcCall");
 
   StringRef Name = D->getDirectCallee()->getName();
   const char *Replacement;
   if (Name == "snprintf") {
     Replacement = "SprintfLiteral";
   } else {
@@ -51,27 +54,31 @@ void SprintfLiteralChecker::check(
     }
 
     diag(D->getLocStart(), Error, DiagnosticIDs::Error) << Name << Replacement;
     diag(D->getLocStart(), Note, DiagnosticIDs::Note) << Name;
     return;
   }
 
   const QualType QType = Buffer->getType();
-  const ConstantArrayType *Type = dyn_cast<ConstantArrayType>(QType.getTypePtrOrNull());
+  const ConstantArrayType *Type =
+      dyn_cast<ConstantArrayType>(QType.getTypePtrOrNull());
   if (Type) {
     // Match calls like snprintf(x, 100, ...), where x is int[100];
-    const IntegerLiteral *Literal = Result.Nodes.getNodeAs<IntegerLiteral>("immediate");
+    const IntegerLiteral *Literal =
+        Result.Nodes.getNodeAs<IntegerLiteral>("immediate");
     if (!Literal) {
       // Match calls like: const int y = 100; snprintf(x, y, ...);
       Literal = Result.Nodes.getNodeAs<IntegerLiteral>("constant");
     }
 
-    // We're going to assume here that the bitwidth of both of these values fits within 64 bits.
-    // and zero-extend both values to 64-bits before comparing them.
+    // We're going to assume here that the bitwidth of both of these values fits
+    // within 64 bits. and zero-extend both values to 64-bits before comparing
+    // them.
     uint64_t Size = Type->getSize().getZExtValue();
     uint64_t Lit = Literal->getValue().getZExtValue();
     if (Size <= Lit) {
-      diag(D->getLocStart(), Error, DiagnosticIDs::Error) << Name << Replacement;
+      diag(D->getLocStart(), Error, DiagnosticIDs::Error)
+          << Name << Replacement;
       diag(D->getLocStart(), Note, DiagnosticIDs::Note) << Name;
     }
   }
 }
--- a/build/clang-plugin/SprintfLiteralChecker.h
+++ b/build/clang-plugin/SprintfLiteralChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef SprintfLiteralChecker_h__
 #define SprintfLiteralChecker_h__
 
 #include "plugin.h"
 
 class SprintfLiteralChecker : public BaseCheck {
 public:
-  SprintfLiteralChecker(StringRef CheckName,
-                        ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  SprintfLiteralChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/StmtToBlockMap.h
+++ b/build/clang-plugin/StmtToBlockMap.h
@@ -33,52 +33,56 @@ inline SmallVector<const Stmt *, 1> getP
       Parents = Context->getParents(Node);
       NodesToProcess.append(Parents.begin(), Parents.end());
     }
   }
 
   return Result;
 }
 
-// This class is a modified version of the class from clang-tidy's ExprSequence.cpp
+// This class is a modified version of the class from clang-tidy's
+// ExprSequence.cpp
 //
 // Maps `Stmt`s to the `CFGBlock` that contains them. Some `Stmt`s may be
 // contained in more than one `CFGBlock`; in this case, they are mapped to the
 // innermost block (i.e. the one that is furthest from the root of the tree).
 // An optional outparameter provides the index into the block where the `Stmt`
 // was found.
 class StmtToBlockMap {
 public:
   // Initializes the map for the given `CFG`.
-  StmtToBlockMap(const CFG *TheCFG, ASTContext *TheContext) : Context(TheContext) {
+  StmtToBlockMap(const CFG *TheCFG, ASTContext *TheContext)
+      : Context(TheContext) {
     for (const auto *B : *TheCFG) {
       for (size_t I = 0; I < B->size(); ++I) {
         if (Optional<CFGStmt> S = (*B)[I].getAs<CFGStmt>()) {
           Map[S->getStmt()] = std::make_pair(B, I);
         }
       }
     }
   }
 
   // Returns the block that S is contained in. Some `Stmt`s may be contained
   // in more than one `CFGBlock`; in this case, this function returns the
   // innermost block (i.e. the one that is furthest from the root of the tree).
   //
   // The optional outparameter `Index` is set to the index into the block where
   // the `Stmt` was found.
-  const CFGBlock *blockContainingStmt(const Stmt *S, size_t *Index = nullptr) const {
+  const CFGBlock *blockContainingStmt(const Stmt *S,
+                                      size_t *Index = nullptr) const {
     while (!Map.count(S)) {
       SmallVector<const Stmt *, 1> Parents = getParentStmts(S, Context);
       if (Parents.empty())
         return nullptr;
       S = Parents[0];
     }
 
     const auto &E = Map.lookup(S);
-    if (Index) *Index = E.second;
+    if (Index)
+      *Index = E.second;
     return E.first;
   }
 
 private:
   ASTContext *Context;
 
   llvm::DenseMap<const Stmt *, std::pair<const CFGBlock *, size_t>> Map;
 };
--- a/build/clang-plugin/ThirdPartyPaths.h
+++ b/build/clang-plugin/ThirdPartyPaths.h
@@ -1,13 +1,13 @@
 #ifndef ThirdPartyPaths_h__
 #define ThirdPartyPaths_h__
 
 #include <stdint.h>
 
 // These two values are defined in ThirdPartyPaths.cpp, which is a file
 // generated by ThirdPartyPaths.py.
 
-extern const char* MOZ_THIRD_PARTY_PATHS[];
+extern const char *MOZ_THIRD_PARTY_PATHS[];
 
 extern const uint32_t MOZ_THIRD_PARTY_PATHS_COUNT;
 
 #endif
--- a/build/clang-plugin/TrivialCtorDtorChecker.cpp
+++ b/build/clang-plugin/TrivialCtorDtorChecker.cpp
@@ -1,24 +1,22 @@
 /* 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/. */
 
 #include "TrivialCtorDtorChecker.h"
 #include "CustomMatchers.h"
 
-void TrivialCtorDtorChecker::registerMatchers(MatchFinder* AstMatcher) {
+void TrivialCtorDtorChecker::registerMatchers(MatchFinder *AstMatcher) {
   AstMatcher->addMatcher(cxxRecordDecl(hasTrivialCtorDtor()).bind("node"),
                          this);
 }
 
-void TrivialCtorDtorChecker::check(
-    const MatchFinder::MatchResult &Result) {
-  const char* Error =
-      "class %0 must have trivial constructors and destructors";
+void TrivialCtorDtorChecker::check(const MatchFinder::MatchResult &Result) {
+  const char *Error = "class %0 must have trivial constructors and destructors";
   const CXXRecordDecl *Node = Result.Nodes.getNodeAs<CXXRecordDecl>("node");
 
   if (!Node->hasDefinition()) {
     return;
   }
 
   // We need to accept non-constexpr trivial constructors as well. This occurs
   // when a struct contains pod members, which will not be initialized. As
--- a/build/clang-plugin/TrivialCtorDtorChecker.h
+++ b/build/clang-plugin/TrivialCtorDtorChecker.h
@@ -4,16 +4,15 @@
 
 #ifndef TrivialCtorDtorChecker_h__
 #define TrivialCtorDtorChecker_h__
 
 #include "plugin.h"
 
 class TrivialCtorDtorChecker : public BaseCheck {
 public:
-  TrivialCtorDtorChecker(StringRef CheckName,
-                         ContextType *Context = nullptr)
-    : BaseCheck(CheckName, Context) {}
-  void registerMatchers(MatchFinder* AstMatcher) override;
+  TrivialCtorDtorChecker(StringRef CheckName, ContextType *Context = nullptr)
+      : BaseCheck(CheckName, Context) {}
+  void registerMatchers(MatchFinder *AstMatcher) override;
   void check(const MatchFinder::MatchResult &Result) override;
 };
 
 #endif
--- a/build/clang-plugin/Utils.h
+++ b/build/clang-plugin/Utils.h
@@ -423,17 +423,17 @@ inline bool inThirdPartyPath(SourceLocat
 inline bool inThirdPartyPath(const Decl *D, ASTContext *context) {
   D = D->getCanonicalDecl();
   SourceLocation Loc = D->getLocation();
   const SourceManager &SM = context->getSourceManager();
 
   return inThirdPartyPath(Loc, SM);
 }
 
-inline CXXRecordDecl* getNonTemplateSpecializedCXXRecordDecl(QualType Q) {
+inline CXXRecordDecl *getNonTemplateSpecializedCXXRecordDecl(QualType Q) {
   auto *D = Q->getAsCXXRecordDecl();
 
   if (!D) {
     auto TemplateQ = Q->getAs<TemplateSpecializationType>();
     if (!TemplateQ) {
       return nullptr;
     }
 
@@ -458,27 +458,27 @@ inline bool inThirdPartyPath(const Decl 
 inline bool inThirdPartyPath(const Stmt *S, ASTContext *context) {
   SourceLocation Loc = S->getLocStart();
   const SourceManager &SM = context->getSourceManager();
 
   return inThirdPartyPath(Loc, SM);
 }
 
 /// Polyfill for CXXOperatorCallExpr::isInfixBinaryOp()
-inline bool isInfixBinaryOp(const CXXOperatorCallExpr* OpCall) {
+inline bool isInfixBinaryOp(const CXXOperatorCallExpr *OpCall) {
 #if CLANG_VERSION_FULL >= 400
   return OpCall->isInfixBinaryOp();
 #else
   // Taken from clang source.
   if (OpCall->getNumArgs() != 2)
-     return false;
+    return false;
 
   switch (OpCall->getOperator()) {
-   case OO_Call: case OO_Subscript:
-     return false;
-   default:
-     return true;
+  case OO_Call:
+  case OO_Subscript:
+    return false;
+  default:
+    return true;
   }
 #endif
 }
 
-
 #endif
--- a/build/clang-plugin/VariableUsageHelpers.cpp
+++ b/build/clang-plugin/VariableUsageHelpers.cpp
@@ -1,33 +1,31 @@
 #include "VariableUsageHelpers.h"
 #include "Utils.h"
 
-std::vector<const Stmt*>
-getUsageAsRvalue(const ValueDecl* ValueDeclaration,
-                 const FunctionDecl* FuncDecl) {
-  std::vector<const Stmt*> UsageStatements;
+std::vector<const Stmt *> getUsageAsRvalue(const ValueDecl *ValueDeclaration,
+                                           const FunctionDecl *FuncDecl) {
+  std::vector<const Stmt *> UsageStatements;
 
   // We check the function declaration has a body.
   auto Body = FuncDecl->getBody();
   if (!Body) {
-    return std::vector<const Stmt*>();
+    return std::vector<const Stmt *>();
   }
 
   // We build a Control Flow Graph (CFG) fron the body of the function
   // declaration.
-  std::unique_ptr<CFG> StatementCFG
-      = CFG::buildCFG(FuncDecl, Body, &FuncDecl->getASTContext(),
-                      CFG::BuildOptions());
+  std::unique_ptr<CFG> StatementCFG = CFG::buildCFG(
+      FuncDecl, Body, &FuncDecl->getASTContext(), CFG::BuildOptions());
 
   // We iterate through all the CFGBlocks, which basically means that we go over
   // all the possible branches of the code and therefore cover all statements.
-  for (auto& Block : *StatementCFG) {
+  for (auto &Block : *StatementCFG) {
     // We iterate through all the statements of the block.
-    for (auto& BlockItem : *Block) {
+    for (auto &BlockItem : *Block) {
       Optional<CFGStmt> CFGStatement = BlockItem.getAs<CFGStmt>();
       if (!CFGStatement) {
         continue;
       }
 
       // FIXME: Right now this function/if chain is very basic and only covers
       // the cases we need for escapesFunction()
       if (auto BinOp = dyn_cast<BinaryOperator>(CFGStatement->getStmt())) {
@@ -45,17 +43,17 @@ getUsageAsRvalue(const ValueDecl* ValueD
 
         if (DeclRef->getDecl() != ValueDeclaration) {
           continue;
         }
       } else if (auto Return = dyn_cast<ReturnStmt>(CFGStatement->getStmt())) {
         // We want our declaration to be used as the expression of the return
         // statement.
         auto DeclRef = dyn_cast_or_null<DeclRefExpr>(
-                            IgnoreTrivials(Return->getRetValue()));
+            IgnoreTrivials(Return->getRetValue()));
         if (!DeclRef) {
           continue;
         }
 
         if (DeclRef->getDecl() != ValueDeclaration) {
           continue;
         }
       } else {
@@ -66,96 +64,89 @@ getUsageAsRvalue(const ValueDecl* ValueD
       UsageStatements.push_back(CFGStatement->getStmt());
     }
   }
 
   return UsageStatements;
 }
 
 // We declare our EscapesFunctionError enum to be an error code enum.
-namespace std
-{
-  template <>
-    struct is_error_code_enum<EscapesFunctionError> : true_type {};
-}
+namespace std {
+template <> struct is_error_code_enum<EscapesFunctionError> : true_type {};
+} // namespace std
 
 // We define the EscapesFunctionErrorCategory which contains the error messages
 // corresponding to each enum variant.
 namespace {
-  struct EscapesFunctionErrorCategory : std::error_category
-  {
-    const char* name() const noexcept override;
-    std::string message(int ev) const override;
-  };
-
-  const char* EscapesFunctionErrorCategory::name() const noexcept
-  {
-    return "escapes function";
-  }
-
-  std::string EscapesFunctionErrorCategory::message(int ev) const
-  {
-    switch (static_cast<EscapesFunctionError>(ev))
-    {
-    case EscapesFunctionError::ConstructorDeclNotFound:
-      return "constructor declaration not found";
+struct EscapesFunctionErrorCategory : std::error_category {
+  const char *name() const noexcept override;
+  std::string message(int ev) const override;
+};
 
-    case EscapesFunctionError::FunctionDeclNotFound:
-      return "function declaration not found";
-
-    case EscapesFunctionError::FunctionIsBuiltin:
-      return "function is builtin";
-
-    case EscapesFunctionError::FunctionIsVariadic:
-      return "function is variadic";
-
-    case EscapesFunctionError::ExprNotInCall:
-      return "expression is not in call";
-
-    case EscapesFunctionError::NoParamForArg:
-      return "no parameter for argument";
-
-    case EscapesFunctionError::ArgAndParamNotPointers:
-      return "argument and parameter are not pointers";
-    }
-  }
-
-  const EscapesFunctionErrorCategory TheEscapesFunctionErrorCategory {};
+const char *EscapesFunctionErrorCategory::name() const noexcept {
+  return "escapes function";
 }
 
-std::error_code make_error_code(EscapesFunctionError e)
-{
+std::string EscapesFunctionErrorCategory::message(int ev) const {
+  switch (static_cast<EscapesFunctionError>(ev)) {
+  case EscapesFunctionError::ConstructorDeclNotFound:
+    return "constructor declaration not found";
+
+  case EscapesFunctionError::FunctionDeclNotFound:
+    return "function declaration not found";
+
+  case EscapesFunctionError::FunctionIsBuiltin:
+    return "function is builtin";
+
+  case EscapesFunctionError::FunctionIsVariadic:
+    return "function is variadic";
+
+  case EscapesFunctionError::ExprNotInCall:
+    return "expression is not in call";
+
+  case EscapesFunctionError::NoParamForArg:
+    return "no parameter for argument";
+
+  case EscapesFunctionError::ArgAndParamNotPointers:
+    return "argument and parameter are not pointers";
+  }
+}
+
+const EscapesFunctionErrorCategory TheEscapesFunctionErrorCategory{};
+} // namespace
+
+std::error_code make_error_code(EscapesFunctionError e) {
   return {static_cast<int>(e), TheEscapesFunctionErrorCategory};
 }
 
-ErrorOr<std::tuple<const Stmt*, const Decl*>>
-escapesFunction(const Expr* Arg, const CXXConstructExpr* Construct) {
+ErrorOr<std::tuple<const Stmt *, const Decl *>>
+escapesFunction(const Expr *Arg, const CXXConstructExpr *Construct) {
   // We get the function declaration corresponding to the call.
   auto CtorDecl = Construct->getConstructor();
   if (!CtorDecl) {
     return EscapesFunctionError::ConstructorDeclNotFound;
   }
 
   return escapesFunction(Arg, CtorDecl, Construct->getArgs(),
                          Construct->getNumArgs());
 }
 
-ErrorOr<std::tuple<const Stmt*, const Decl*>>
-escapesFunction(const Expr* Arg, const CallExpr* Call) {
+ErrorOr<std::tuple<const Stmt *, const Decl *>>
+escapesFunction(const Expr *Arg, const CallExpr *Call) {
   // We get the function declaration corresponding to the call.
   auto FuncDecl = Call->getDirectCallee();
   if (!FuncDecl) {
     return EscapesFunctionError::FunctionDeclNotFound;
   }
 
   return escapesFunction(Arg, FuncDecl, Call->getArgs(), Call->getNumArgs());
 }
 
-ErrorOr<std::tuple<const Stmt*, const Decl*>>
-escapesFunction(const Expr* Arg, const CXXOperatorCallExpr* OpCall) {
+ErrorOr<std::tuple<const Stmt *, const Decl *>>
+escapesFunction(const Expr *Arg, const CXXOperatorCallExpr *OpCall) {
   // We get the function declaration corresponding to the operator call.
   auto FuncDecl = OpCall->getDirectCallee();
   if (!FuncDecl) {
     return EscapesFunctionError::FunctionDeclNotFound;
   }
 
   auto Args = OpCall->getArgs();
   auto NumArgs = OpCall->getNumArgs();
@@ -165,21 +156,21 @@ escapesFunction(const Expr* Arg, const C
   if (isInfixBinaryOp(OpCall) && FuncDecl->getNumParams() == 1) {
     Args++;
     NumArgs--;
   }
 
   return escapesFunction(Arg, FuncDecl, Args, NumArgs);
 }
 
-ErrorOr<std::tuple<const Stmt*, const Decl*>>
-escapesFunction(const Expr* Arg, const FunctionDecl *FuncDecl,
-                const Expr* const* Arguments, unsigned NumArgs) {
+ErrorOr<std::tuple<const Stmt *, const Decl *>>
+escapesFunction(const Expr *Arg, const FunctionDecl *FuncDecl,
+                const Expr *const *Arguments, unsigned NumArgs) {
   if (!NumArgs) {
-    return std::make_tuple((const Stmt*)nullptr, (const Decl*)nullptr);
+    return std::make_tuple((const Stmt *)nullptr, (const Decl *)nullptr);
   }
 
   if (FuncDecl->getBuiltinID() != 0 ||
       ASTIsInSystemHeader(FuncDecl->getASTContext(), *FuncDecl)) {
     return EscapesFunctionError::FunctionIsBuiltin;
   }
 
   // FIXME: should probably be handled at some point, but it's too annoying
@@ -242,38 +233,39 @@ escapesFunction(const Expr* Arg, const F
         //   *param2 = param1;
         // }
         // This should be fixed when we have better/more helper functions to
         // help deal with this kind of lvalue expressions.
         if (!ParamDeclaration->getType()->isReferenceType()) {
           continue;
         }
 
-        return std::make_tuple(Usage, (const Decl*)ParamDeclaration);
+        return std::make_tuple(Usage, (const Decl *)ParamDeclaration);
       } else if (auto VarDeclaration = dyn_cast<VarDecl>(DeclRef->getDecl())) {
         // This is the case where the parameter escapes through a global/static
         // variable.
         if (!VarDeclaration->hasGlobalStorage()) {
           continue;
         }
 
-        return std::make_tuple(Usage, (const Decl*)VarDeclaration);
-      } else if (auto FieldDeclaration = dyn_cast<FieldDecl>(DeclRef->getDecl())) {
+        return std::make_tuple(Usage, (const Decl *)VarDeclaration);
+      } else if (auto FieldDeclaration =
+                     dyn_cast<FieldDecl>(DeclRef->getDecl())) {
         // This is the case where the parameter escapes through a field.
 
-        return std::make_tuple(Usage, (const Decl*)FieldDeclaration);
+        return std::make_tuple(Usage, (const Decl *)FieldDeclaration);
       }
     } else if (isa<ReturnStmt>(Usage)) {
       // This is the case where the parameter escapes through the return value
       // of the function.
-      if (!FuncDecl->getReturnType()->isPointerType()
-          && !FuncDecl->getReturnType()->isReferenceType()) {
+      if (!FuncDecl->getReturnType()->isPointerType() &&
+          !FuncDecl->getReturnType()->isReferenceType()) {
         continue;
       }
 
-      return std::make_tuple(Usage, (const Decl*)FuncDecl);
+      return std::make_tuple(Usage, (const Decl *)FuncDecl);
     }
   }
 
   // No early-return, this means that we haven't found any case of funciton
   // escaping and that therefore the parameter remains in the function scope.
-  return std::make_tuple((const Stmt*)nullptr, (const Decl*)nullptr);
+  return std::make_tuple((const Stmt *)nullptr, (const Decl *)nullptr);
 }
--- a/build/clang-plugin/VariableUsageHelpers.h
+++ b/build/clang-plugin/VariableUsageHelpers.h
@@ -1,27 +1,25 @@
 /* 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/. */
 
-
 #ifndef VariableUsageHelpers_h__
 #define VariableUsageHelpers_h__
 
 #include "plugin.h"
 
 /// Returns a list of the statements where the given declaration is used as an
 /// rvalue (within the provided function).
 ///
 /// WARNING: incomplete behaviour/implementation for general-purpose use outside
 /// of escapesFunction(). This only detects very basic usages (see
 /// implementation for more details).
-std::vector<const Stmt*>
-getUsageAsRvalue(const ValueDecl* ValueDeclaration,
-                 const FunctionDecl* FuncDecl);
+std::vector<const Stmt *> getUsageAsRvalue(const ValueDecl *ValueDeclaration,
+                                           const FunctionDecl *FuncDecl);
 
 /// This is the error enumeration for escapesFunction(), describing all the
 /// possible error cases.
 enum class EscapesFunctionError {
   ConstructorDeclNotFound = 1,
   FunctionDeclNotFound,
   FunctionIsBuiltin,
   FunctionIsVariadic,
@@ -41,25 +39,25 @@ std::error_code make_error_code(EscapesF
 /// function, the tuple will only contain nullptrs.
 /// If the analysis runs into an unexpected error or into an unimplemented
 /// configuration, it will return an error_code of type EscapesFunctionError
 /// representing the precise issue.
 ///
 /// WARNING: incomplete behaviour/implementation for general-purpose use outside
 /// of DanglingOnTemporaryChecker. This only covers a limited set of cases,
 /// mainly in terms of arguments and parameter types.
-ErrorOr<std::tuple<const Stmt*, const Decl*>>
-escapesFunction(const Expr* Arg, const FunctionDecl *FuncDecl,
-                const Expr* const* Arguments, unsigned NumArgs);
+ErrorOr<std::tuple<const Stmt *, const Decl *>>
+escapesFunction(const Expr *Arg, const FunctionDecl *FuncDecl,
+                const Expr *const *Arguments, unsigned NumArgs);
 
 /// Helper function taking a call expression.
-ErrorOr<std::tuple<const Stmt*, const Decl*>>
-escapesFunction(const Expr* Arg, const CallExpr* Call);
+ErrorOr<std::tuple<const Stmt *, const Decl *>>
+escapesFunction(const Expr *Arg, const CallExpr *Call);
 
 /// Helper function taking a construct expression.
-ErrorOr<std::tuple<const Stmt*, const Decl*>>
-escapesFunction(const Expr* Arg, const CXXConstructExpr* Construct);
+ErrorOr<std::tuple<const Stmt *, const Decl *>>
+escapesFunction(const Expr *Arg, const CXXConstructExpr *Construct);
 
 /// Helper function taking an operator call expression.
-ErrorOr<std::tuple<const Stmt*, const Decl*>>
-escapesFunction(const Expr* Arg, const CXXOperatorCallExpr* OpCall);
+ErrorOr<std::tuple<const Stmt *, const Decl *>>
+escapesFunction(const Expr *Arg, const CXXOperatorCallExpr *OpCall);
 
 #endif
--- a/build/clang-plugin/plugin.h
+++ b/build/clang-plugin/plugin.h
@@ -1,30 +1,30 @@
 /* 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/. */
 
 #ifndef plugin_h__
 #define plugin_h__
 
-#include "clang/Analysis/CFG.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Analysis/CFG.h"
 #include "clang/Basic/Version.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Sema/Sema.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
+#include <iterator>
 #include <memory>
-#include <iterator>
 
 #define CLANG_VERSION_FULL (CLANG_VERSION_MAJOR * 100 + CLANG_VERSION_MINOR)
 
 using namespace llvm;
 using namespace clang;
 using namespace clang::ast_matchers;
 
 #if CLANG_VERSION_FULL >= 306
@@ -49,18 +49,18 @@ typedef ASTConsumer *ASTConsumerPtr;
 #else
 // Before clang 3.9 "has" would behave like has(ignoringParenImpCasts(x)),
 // however doing that explicitly would not compile.
 #define hasIgnoringParenImpCasts(x) has(ignoringParenImpCasts(x))
 #endif
 
 #endif
 
-// In order to support running our checks using clang-tidy, we implement a source
-// compatible base check class called BaseCheck, and we use the preprocessor to
-// decide which base class to pick.
+// In order to support running our checks using clang-tidy, we implement a
+// source compatible base check class called BaseCheck, and we use the
+// preprocessor to decide which base class to pick.
 #ifdef CLANG_TIDY
 #include "../ClangTidy.h"
 typedef clang::tidy::ClangTidyCheck BaseCheck;
 typedef clang::tidy::ClangTidyContext ContextType;
 #else
 #include "BaseCheck.h"
 #endif