[clang-tidy] Adding Fuchsia checkers to clang-tidy

[juliehockett]

Summary

Adds a new Fuchsia module to clang-tidy to warn for features that are
disallowed in the Fuchsia and Zircon style guides.

Fuchsia is a modular, capability-based operating system. Fuchsia and its
Zircon kernel use a subset of the C++14 language, and so these checks
are designed to prompt the user to avoid disallowed behaviors.

Adds a check to the Fuchsia modules to warn when functions are declared
or called with default arguments.

See https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md for
reference.

[Eugene.Zelenko]

Please split this review with one check per review.

docs/ReleaseNotes.rst

83

Please fix double space

docs/clang-tidy/checks/fuchsia-default-arguments.rst

8

Please don't use abbreviations. Same in other places.

19

Please insert empty line above.

docs/clang-tidy/checks/fuchsia-statically-constructed-objects.rst

7

Please highlight constexpr with ``. Same in other places.

docs/clang-tidy/checks/fuchsia-thread-local.rst

6

Please highlight thread-local and extern with ``. Same in other places.

[Eugene.Zelenko]

clang-tidy/fuchsia/FuchsiaTidyModule.cpp

31

Please remove empty line.

clang-tidy/fuchsia/MultipleInheritanceCheck.cpp

100

Please remove empty line.

docs/ReleaseNotes.rst

63

Check to should be removed, just Prevent. Same in other places.

[Eugene.Zelenko]

Please mention new module in docs/clang-tidy/index.rst.

[aaron.ballman]

For background: what is Fuchsia and where do these requirements come from (are they documented publicly somewhere)?

We tend to prefer concise patches over code dumps, so I think it would make sense to split this review into multiple patches. The first one can be adding the module and a single check along with background information on why the module would be appropriate. The rest of the patches should be one check per patch.

[Eugene.Zelenko]

docs/ReleaseNotes.rst

60

Check name and link was accidentally removed.

docs/clang-tidy/checks/list.rst

58

List should be pruned.

[juliehockett]

Updated docs

[juliehockett]

We do need to figure out what the right prefix for these checks is (whether fuchsia-* since they'll be used under the Fuchsia umbrella, zircon-* since the follow the Zircon section of the style guide linked above, or the more generic google-*).

[Eugene.Zelenko]

Does Fuchsia coding conventions allows default parameters in class methods? If not, test should reflect this

docs/ReleaseNotes.rst

63

I think will be good idea to have description same as first sentence in documentation, i. e. Warns if a function is declared or called with default arguments.

test/clang-tidy/fuchsia-default-arguments.cpp

7

Please remove void (see modernize-redundant-void-arg). Same below.

[Eugene.Zelenko]

In D40108#928212, @juliehockett wrote:

We do need to figure out what the right prefix for these checks is (whether fuchsia-* since they'll be used under the Fuchsia umbrella, zircon-* since the follow the Zircon section of the style guide linked above, or the more generic google-*).

I think it should use project-specific prefix, since it's open source project. Google may have different coding guidelines for other projects.

[juliehockett]

Updated docs and added tests to check class methods.

[juliehockett]

In D40108#928224, @Eugene.Zelenko wrote:

I think it should use project-specific prefix, since it's open source project. Google may have different coding guidelines for other projects.

Reasonable. It makes sense to consider it on a check-by-check basis too, I'd think.

[Eugene.Zelenko]

docs/ReleaseNotes.rst

63

I think will be good idea to change to function to function or method. Same in documentation.

docs/clang-tidy/checks/fuchsia-default-arguments.rst

9

I briefly look on other checks documentation, so will be good idea to use just Example: or For example, the declaration: . But will be good idea to hear opinion of native English speaker.

[aaron.ballman]

Thank you for the explanation about what is driving this and the documentation. I don't think google-* is the correct module for this as it's too general of an umbrella. I have a slight preference for zircon-* because this appears to be specific to that particular project.

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

19

I think this should be put into ASTMatchers.h as a separate patch (feel free to list me as a reviewer). See D39940 for an example of how to do that, but the only non-obvious task is running clang\docs\tools\dump_ast_matchers.py to generate the HTML from ASTMatchers.h.

23

Isn't this case already covered by the other matcher? Or do you have system header files which have default arguments and those functions are disallowed by the style guide, but cannot be removed from the system header?

29

You can use const auto * here instead of spelling the type out twice.

37

Would it make sense to add a fix-it that removes the intializer for the default argument?

docs/clang-tidy/checks/fuchsia-default-arguments.rst

9

I'd go with: For example, the declaration:

docs/clang-tidy/index.rst

672 ↗

(On Diff #123446)

Spurious newline removal?

[juliehockett]

Moved AST matcher out to ASTMatchers.h (see D40261), fixing comments

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

23

The latter -- there's a bunch of third-party code and the like that could have default arguments, but shouldn't be used like that in the project.

[aaron.ballman]

Did you decide on fuchsia instead of zircon for the module name, or is that decision still up in the air?

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

23

Ah, that makes sense. Thanks!

30

I think the diagnostic should be in singular form. How about: calling a function that uses a default argument is disallowed?

36–39

Does getDefaultArgRange() not provide the correct range already (so you don't need to go back to the original source)? Or does that range miss the =?

You might want to disable the fix-it in the case getDefaultArgRange() returns an empty range, or in case the default arg expression comes from a macro (and add a test for the latter case). e.g.,

#define DERP(val)  = val

void f(int i DERP);

Additionally, a test where the identifier is elided would be good as well: void f(int = 12);

42

This diagnostic could be similarly tightened -- the function isn't the issue, the parameter with the default argument is. Perhaps: declaring a parameter with a default value is disallowed?

docs/clang-tidy/checks/fuchsia-default-arguments.rst

17–18

The wording here is a bit confusing; it's not that calling it with no arguments causes the warning, it's that calling it such that the default argument value is used that's the problem. Perhaps: A function call expression that uses a default argument will be diagnosed. or something along those lines.

[juliehockett]

Disabled the fix-it for getDefaultArgRange() that returns an empty range and for default args that come from a macro.

[juliehockett]

We're going to go with fuchsia-* for the module name, since the style applies to the broader project. Also, there may be zircon-specific checks at some point, so we want to leave the door open for that.

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

36–39

getDefaultArgRange() misses the = -- though if there's a better way to do it I'm all ears!

[aaron.ballman]

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

32

Drop "the" from the diagnostic to match wording in other places

36–39

In that case, this seems fine to me.

45

Drop "the" here as well.

49–53

This can be hoisted to the initialization: SourceLocation StartLocation = D->getName().empty() ? D->getLocStart() : D->getLocation();

test/clang-tidy/fuchsia-default-arguments.cpp

41

I think this diagnostic should be suppressed -- having it on the declaration where the default argument is defined should be sufficient, no?

58

Two more test cases that should be added:

void f(int i);
void f(int i = 12);

void f(int i) {
    
}

struct S {
  void f(int i);
};

void S::f(int i = 12) {}

int main() {
  S s;
  s.f();
  f();
}

[juliehockett]

Added new tests and updated wording in warning.

[Eugene.Zelenko]

docs/clang-tidy/checks/fuchsia-default-arguments.rst

7

Please synchronize with text in Release Notes.

[juliehockett]

Updating docs

[aaron.ballman]

LGTM aside from one small nit with the test file missing a trailing newline.

test/clang-tidy/fuchsia-default-arguments.cpp

20

Please add a newline at the end of the file.

[juliehockett]

Added missing newline

[aaron.ballman]

Thanks for the nit fix. If you'd like me to commit this on your behalf, just let me know.

[juliehockett]

If you could, that'd be great! Thank you!

[aaron.ballman]

I've commit in r319225.

[Eugene.Zelenko]

In D40108#938131, @juliehockett wrote:

If you could, that'd be great! Thank you!

It'll be good idea it you'll request commit rights, since you have more checks in development queue.

[alexfh]

A couple of late comments.

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

40

No else after return, please. http://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

57

This argument is not used in the message. Does it have any effect at all?

docs/clang-tidy/index.rst

64 ↗

(On Diff #124586)

How about adding a link to the coding style document? (We should do this for other entries here, but that's unrelated to your patch.)

clang-tidy/CMakeLists.txt

add_clang_library(clangTidy
   clangToolingCore
   )
 
 add_subdirectory(android)
 add_subdirectory(boost)
 add_subdirectory(bugprone)
 add_subdirectory(cert)
 add_subdirectory(cppcoreguidelines)
+add_subdirectory(fuchsia)
 add_subdirectory(google)
 add_subdirectory(hicpp)
 add_subdirectory(llvm)
 add_subdirectory(misc)
 add_subdirectory(modernize)
 add_subdirectory(mpi)
 add_subdirectory(objc)
 add_subdirectory(performance)
 add_subdirectory(plugin)
 add_subdirectory(readability)
 add_subdirectory(tool)
 add_subdirectory(utils)

clang-tidy/fuchsia/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS support)
+
+add_clang_library(clangTidyFuchsiaModule
+  DefaultArgumentsCheck.cpp
+  FuchsiaTidyModule.cpp
+  MultipleInheritanceCheck.cpp
+  OverloadedOperatorCheck.cpp
+  StaticallyConstructedObjectsCheck.cpp
+  ThreadLocalCheck.cpp
+  TrailingReturnCheck.cpp
+  VirtualInheritanceCheck.cpp
+
+  LINK_LIBS
+  clangAST
+  clangASTMatchers
+  clangBasic
+  clangLex
+  clangTidy
+  clangTidyUtils
+  )

clang-tidy/fuchsia/DefaultArgumentsCheck.h

+//===--- DefaultArgumentsCheck.h - clang-tidy--------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// Default arguments are not allowed in declared or called functions.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-arguments.html
+class DefaultArgumentsCheck : public ClangTidyCheck {
+public:
+  DefaultArgumentsCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_H

clang-tidy/fuchsia/DefaultArgumentsCheck.cpp

+//===--- DefaultArgumentsCheck.cpp - clang-tidy----------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DefaultArgumentsCheck.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+AST_MATCHER(ParmVarDecl, hasDefaultArgument) { return Node.hasDefaultArg(); }
+
+void DefaultArgumentsCheck::registerMatchers(MatchFinder *Finder) {
+  // Calling a function which uses default arguments is disallowed.
+  Finder->addMatcher(cxxDefaultArgExpr().bind("stmt"), this);
+  // Declaring default parameters is disallowed.
+  Finder->addMatcher(parmVarDecl(hasDefaultArgument()).bind("decl"), this);
+}
+
+void DefaultArgumentsCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const CXXDefaultArgExpr *S =
+          Result.Nodes.getNodeAs<CXXDefaultArgExpr>("stmt")) {
+    diag(S->getUsedLocation(),
+         "calling functions which use default arguments is disallowed");
+    diag(S->getParam()->getLocStart(), "the default parameter was declared here",
+         DiagnosticIDs::Note);
+  } else if (const ParmVarDecl *D = Result.Nodes.getNodeAs<ParmVarDecl>("decl")) {
+    diag(D->getLocStart(),
+         "declaring functions which use default arguments is disallowed");
+  }
+}
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang

clang-tidy/fuchsia/FuchsiaTidyModule.cpp

+//===--- FuchsiaTidyModule.cpp - clang-tidy--------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../ClangTidy.h"
+#include "../ClangTidyModule.h"
+#include "../ClangTidyModuleRegistry.h"
+#include "DefaultArgumentsCheck.h"
+#include "MultipleInheritanceCheck.h"
+#include "OverloadedOperatorCheck.h"
+#include "StaticallyConstructedObjectsCheck.h"
+#include "ThreadLocalCheck.h"
+#include "TrailingReturnCheck.h"
+#include "VirtualInheritanceCheck.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// This module is for Fuchsia specific checks.
+class FuchsiaModule : public ClangTidyModule {
+public:
+  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+
+    CheckFactories.registerCheck<DefaultArgumentsCheck>(
+        "fuchsia-default-arguments");
+    CheckFactories.registerCheck<MultipleInheritanceCheck>(
+        "fuchsia-multiple-inheritance");
+    CheckFactories.registerCheck<OverloadedOperatorCheck>(
+        "fuchsia-overloaded-operator");
+    CheckFactories.registerCheck<StaticallyConstructedObjectsCheck>(
+        "fuchsia-statically-constructed-objects");
+    CheckFactories.registerCheck<ThreadLocalCheck>(
+        "fuchsia-thread-local");
+    CheckFactories.registerCheck<TrailingReturnCheck>(
+        "fuchsia-trailing-return");
+    CheckFactories.registerCheck<VirtualInheritanceCheck>(
+        "fuchsia-virtual-inheritance");
+  }
+};
+// Register the FuchsiaTidyModule using this statically initialized variable.
+static ClangTidyModuleRegistry::Add<FuchsiaModule>
+    X("fuchsia-module", "Adds Fuchsia platform checks.");
+
+} // namespace fuchsia
+
+// This anchor is used to force the linker to link in the generated object file
+// and thus register the FuchsiaModule.
+volatile int FuchsiaModuleAnchorSource = 0;
+
+} // namespace tidy
+} // namespace clang

clang-tidy/fuchsia/MultipleInheritanceCheck.h

+//===--- MultipleInheritanceCheck.h - clang-tidy-----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_MULTIPLE_INHERITANCE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_MULTIPLE_INHERITANCE_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// Mulitple inheritance is disallowed.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-multiple-inheritance.html
+class MultipleInheritanceCheck : public ClangTidyCheck {
+public:
+  MultipleInheritanceCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+  void onStartOfTranslationUnit() override {
+   InterfaceMap = new llvm::StringMap<bool>;
+  }
+  void onEndOfTranslationUnit() override { delete InterfaceMap; }
+
+  void addNodeToInterfaceMap(const CXXRecordDecl *Node, bool isInterface);
+  bool getInterfaceStatus(const CXXRecordDecl *Node, bool *isInterface);
+  bool isCurrentClassInterface(const CXXRecordDecl *Node);
+  bool isInterface(const CXXRecordDecl *Node);
+
+private:
+  // Contains the identity of each named CXXRecord as an interface.  This is used
+  // to memoize lookup speeds and improve performance from O(N^2) to O(N), where N
+  // is the number of classes.
+  llvm::StringMap<bool> *InterfaceMap;
+};
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_MULTIPLE_INHERITANCE_H

clang-tidy/fuchsia/MultipleInheritanceCheck.cpp

+//===--- MultipleInheritanceCheck.cpp - clang-tidy-------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MultipleInheritanceCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang;
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+  AST_MATCHER(CXXRecordDecl, hasDefinition) {
+    if (!Node.hasDefinition())
+      return false;
+    return true;
+  }
+
+// Adds a node (by name) to the interface map, if it was not present in the map
+// previously.
+void MultipleInheritanceCheck::addNodeToInterfaceMap(const CXXRecordDecl *Node,
+                            bool isInterface) {
+  StringRef Name = Node->getIdentifier()->getName();
+  MultipleInheritanceCheck::InterfaceMap->insert(
+                            std::make_pair(Name, isInterface));
+}
+
+// Returns "true" if the boolean "isInterface" has been set to the
+// interface status of the current Node. Return "false" if the
+// interface status for the current node is not yet known.
+bool MultipleInheritanceCheck::getInterfaceStatus(const CXXRecordDecl *Node,
+                            bool *isInterface) {
+  StringRef Name = Node->getIdentifier()->getName();
+  if (MultipleInheritanceCheck::InterfaceMap->count(Name)) {
+    *isInterface = MultipleInheritanceCheck::InterfaceMap->lookup(Name);
+    return true;
+  }
+  return false;
+}
+
+// TODO(smklein): Make an exception for 'Dispatcher' -- consider it an
+// interface, even though it isn't.
+bool MultipleInheritanceCheck::isCurrentClassInterface(
+                            const CXXRecordDecl *Node) {
+  // Interfaces should have no fields.
+  if (!Node->field_empty()) {
+    return false;
+  }
+  // Interfaces should have exclusively pure methods.
+  for (auto method : Node->methods()) {
+    if (method->isUserProvided() && !method->isPure()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool MultipleInheritanceCheck::isInterface(const CXXRecordDecl *Node) {
+  // Short circuit the lookup if we have analyzed this record before.
+  bool PreviousIsInterfaceResult;
+  if (MultipleInheritanceCheck::getInterfaceStatus(Node,
+                              &PreviousIsInterfaceResult)) {
+    return PreviousIsInterfaceResult;
+  }
+
+  // To be an interface, all base classes must be interfaces as well.
+  for (const auto &I : Node->bases()) {
+    const RecordType *Ty = I.getType()->getAs<RecordType>();
+    assert(Ty && "RecordType of base class is unknown");
+    CXXRecordDecl *Base = cast<CXXRecordDecl>(Ty->getDecl()->getDefinition());
+    if (!MultipleInheritanceCheck::isInterface(Base)) {
+      MultipleInheritanceCheck::addNodeToInterfaceMap(Node, false);
+      return false;
+    }
+  }
+
+  bool CurrentClassIsInterface =
+          MultipleInheritanceCheck::isCurrentClassInterface(Node);
+  MultipleInheritanceCheck::addNodeToInterfaceMap(Node,
+          CurrentClassIsInterface);
+  return CurrentClassIsInterface;
+}
+
+void MultipleInheritanceCheck::registerMatchers(MatchFinder *Finder) {
+  // Match declarations which have definitions.
+  Finder->addMatcher(cxxRecordDecl(hasDefinition()).bind("decl"), this);
+}
+
+void MultipleInheritanceCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const CXXRecordDecl *D =
+            Result.Nodes.getNodeAs<CXXRecordDecl>("decl")) {
+
+    // Check against map to see if if the class inherits from multiple 
+    // concrete classes
+    int NumConcrete = 0;
+    for (const auto &I : D->bases()) {
+      const RecordType *Ty = I.getType()->getAs<RecordType>();
+      assert(Ty && "RecordType of base class is unknown");
+      CXXRecordDecl *Base = cast<CXXRecordDecl>(Ty->getDecl()->getDefinition());
+      if (!MultipleInheritanceCheck::isInterface(Base))
+        NumConcrete++;
+    }
+
+    if (NumConcrete > 1) {
+      diag(D->getLocStart(), "inheriting mulitple classes which aren't "
+                             "pure virtual is disallowed");
+    }
+  }
+}
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang

clang-tidy/fuchsia/OverloadedOperatorCheck.h

+//===--- OverloadedOperatorCheck.h - clang-tidy------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_OVERLOADED_OPERATOR_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_OVERLOADED_OPERATOR_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// Operator overloading is disallowed.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-overloaded-operator.html
+class OverloadedOperatorCheck : public ClangTidyCheck {
+public:
+  OverloadedOperatorCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_OVERLOADED_OPERATOR_H

clang-tidy/fuchsia/OverloadedOperatorCheck.cpp

+//===--- OverloadedOperatorCheck.cpp - clang-tidy--------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "OverloadedOperatorCheck.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+AST_MATCHER(CXXMethodDecl, hasOverloadedOperator) {
+  if (Node.isCopyAssignmentOperator() || Node.isMoveAssignmentOperator()) {
+    return false;
+  }
+  return Node.isOverloadedOperator();
+}
+
+void OverloadedOperatorCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(cxxMethodDecl(hasOverloadedOperator()).bind("decl"), this);
+}
+
+void OverloadedOperatorCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const CXXMethodDecl *D =
+            Result.Nodes.getNodeAs<CXXMethodDecl>("decl")) {
+      diag(D->getLocStart(),"operator overloading is disallowed");
+  }
+}
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang

clang-tidy/fuchsia/StaticallyConstructedObjectsCheck.h

+//===--- StaticallyConstructedObjectsCheck.h - clang-tidy--------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// Constructing objects which are statically stored is disallowed.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-statically-constructed-objects.html
+class StaticallyConstructedObjectsCheck : public ClangTidyCheck {
+public:
+  StaticallyConstructedObjectsCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H

clang-tidy/fuchsia/StaticallyConstructedObjectsCheck.cpp

+//===--- StaticallyConstructedObjectsCheck.cpp - clang-tidy----------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "StaticallyConstructedObjectsCheck.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+void StaticallyConstructedObjectsCheck::registerMatchers(MatchFinder *Finder) {
+  // Constructing objects which are stored statically is disallowed.
+  Finder->addMatcher(
+      varDecl(allOf(
+                  // Match statically stored objects...
+                  hasStaticStorageDuration(),
+                  // ... which have C++ constructors...
+                  hasDescendant(cxxConstructExpr(unless(
+                      // ... that are not constexpr.
+                      hasDeclaration(cxxConstructorDecl(isConstexpr())))))))
+          .bind("decl"),
+      this);
+}
+
+void StaticallyConstructedObjectsCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const VarDecl *D = Result.Nodes.getNodeAs<VarDecl>("decl")) {
+      diag(D->getLocStart(), "statically constructed objects are disallowed");
+      diag(D->getLocStart(), "if possible, use a constexpr constructor instead",
+          DiagnosticIDs::Note);
+  }
+}
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang

clang-tidy/fuchsia/ThreadLocalCheck.h

+//===--- ThreadLocalCheck.h - clang-tidy-------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_THREAD_LOCAL_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_THREAD_LOCAL_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// Thread-local storage is disallowed.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-thread-local.html
+class ThreadLocalCheck : public ClangTidyCheck {
+public:
+  ThreadLocalCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_THREAD_LOCAL_H

clang-tidy/fuchsia/ThreadLocalCheck.cpp

+//===--- ThreadLocalCheck.cpp - clang-tidy---------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ThreadLocalCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+void ThreadLocalCheck::registerMatchers(MatchFinder *Finder) {
+  // Using thread-local storage is disallowed.
+    Finder->addMatcher(varDecl(hasThreadStorageDuration()).bind("decl"), this);
+}
+
+void ThreadLocalCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const VarDecl *D = Result.Nodes.getNodeAs<VarDecl>("decl")) {
+    diag(D->getLocStart(), "thread local storage is disallowed");
+  }
+}
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang

clang-tidy/fuchsia/TrailingReturnCheck.h

+//===--- TrailingReturnCheck.h - clang-tidy----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// Functions with trailing returns are disallowed.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-trailing-return.html
+class TrailingReturnCheck : public ClangTidyCheck {
+public:
+  TrailingReturnCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H

clang-tidy/fuchsia/TrailingReturnCheck.cpp

+//===--- TrailingReturnCheck.cpp - clang-tidy------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TrailingReturnCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+AST_MATCHER(FunctionDecl, hasTrailingReturn) {
+  const Type *T = Node.getType().getTypePtr();
+  const FunctionProtoType *F = cast<FunctionProtoType>(T);
+  return F->hasTrailingReturn();
+}
+
+void TrailingReturnCheck::registerMatchers(MatchFinder *Finder) {
+  // Functions which have trailing returns are disallowed.
+  Finder->addMatcher(functionDecl(hasTrailingReturn()).bind("decl"), this);
+}
+
+void TrailingReturnCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const Decl *D = Result.Nodes.getNodeAs<Decl>("decl")) {
+    diag(D->getLocStart(), "trailing returns are disallowed");
+  }
+}
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang

clang-tidy/fuchsia/VirtualInheritanceCheck.h

+//===--- VirtualInheritanceCheck.h - clang-tidy------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_VIRTUAL_INHERITANCE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_VIRTUAL_INHERITANCE_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+/// Defining classes with virtual inheritance is disallowed.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-virtual-inheritance.html
+class VirtualInheritanceCheck : public ClangTidyCheck {
+public:
+  VirtualInheritanceCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_VIRTUAL_INHERITANCE_H

clang-tidy/fuchsia/VirtualInheritanceCheck.cpp

+//===--- VirtualInheritanceCheck.cpp - clang-tidy--------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "VirtualInheritanceCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace fuchsia {
+
+AST_MATCHER(CXXRecordDecl, hasVirtualBaseClass) {
+  return Node.hasDefinition() && (Node.getNumVBases() != 0);
+}
+
+void VirtualInheritanceCheck::registerMatchers(MatchFinder *Finder) {
+  // Defining classes using virtual inheritance is disallowed.
+  Finder->addMatcher(cxxRecordDecl(hasVirtualBaseClass()).bind("decl"), this);
+  // Calling constructors of classes using virtual inheritance is disallowed.
+  // To clarify, this matcher finds, in order:
+  //  1) Calls to Constructors,
+  //  2) The declarations of those constructors,
+  //  3) The classes those constructors belong to,
+  //  4) And matches the classes which have virtual base classes.
+  Finder->addMatcher(
+      cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
+                           ofClass(cxxRecordDecl(hasVirtualBaseClass())))))
+          .bind("stmt"),
+      this);
+}
+
+void VirtualInheritanceCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const CXXRecordDecl *D =
+            Result.Nodes.getNodeAs<CXXRecordDecl>("decl")) {
+    diag(D->getLocStart(), "[kernel-c++] virtual inheritance is disallowed");
+  } else if (const CXXConstructExpr *S =
+            Result.Nodes.getNodeAs<CXXConstructExpr>("stmt")) {
+    diag(S->getLocStart(),
+        "[kernel-c++] constructing a class which inherits "
+        "a virtual base class is disallowed");
+  }
+}
+
+} // namespace fuchsia
+} // namespace tidy
+} // namespace clang

clang-tidy/tool/CMakeLists.txt

target_link_libraries(clang-tidy
   clangASTMatchers
   clangBasic
   clangTidy
   clangTidyAndroidModule
   clangTidyBoostModule
   clangTidyBugproneModule
   clangTidyCERTModule
   clangTidyCppCoreGuidelinesModule
+  clangTidyFuchsiaModule
   clangTidyGoogleModule
   clangTidyHICPPModule
   clangTidyLLVMModule
   clangTidyMiscModule
   clangTidyModernizeModule
   clangTidyMPIModule
   clangTidyObjCModule
   clangTidyPerformanceModule

clang-tidy/tool/ClangTidyMain.cpp

static int LLVM_ATTRIBUTE_UNUSED LLVMModuleAnchorDestination =
     LLVMModuleAnchorSource;
 
 // This anchor is used to force the linker to link the CppCoreGuidelinesModule.
 extern volatile int CppCoreGuidelinesModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED CppCoreGuidelinesModuleAnchorDestination =
     CppCoreGuidelinesModuleAnchorSource;
 
 // This anchor is used to force the linker to link the GoogleModule.
+extern volatile int FuchsiaModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED FuchsiaModuleAnchorDestination =
+    FuchsiaModuleAnchorSource;
+
+// This anchor is used to force the linker to link the GoogleModule.
 extern volatile int GoogleModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED GoogleModuleAnchorDestination =
     GoogleModuleAnchorSource;
 
 // This anchor is used to force the linker to link the AndroidModule.
 extern volatile int AndroidModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED AndroidModuleAnchorDestination =
     AndroidModuleAnchorSource;

docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- New `fuchsia-multiple-inheritance
+  <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-multiple-inheritance.html>`_ check
+
+  Check to prevent multiple inheritance in Fuchsia.
+
+- New `fuchsia-virtual-inheritance
+  <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-virtual-inheritance.html>`_ check
+
+  Check to prevent the definition of classes with virtual inheritance.
+
+- New `fuchsia-trailing-return
+  <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-trailing-return.html>`_ check
+
+  Check to prevent functions with trailing returns in Fuchsia.
+
+- New `fuchsia-thread-local
+  <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-thread-local.html>`_ check
+
+  Check to prevent thread-local storage in Fuchsia.
+
+- New `fuchsia-statically-constructed-objects
+  <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-statically-constructed-objects.html>`_ check
+
+  Check to prevent creation of  statically-stored objects in Fuchsia.
+
+- New `fuchsia-overloaded-operator
+  <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-overloaded-operator.html>`_ check
+
+  Check to prevent operator overloading in Fuchsia.
+
+- New `fuchsia-default-arguments
+  <http://clang.llvm.org/extra/clang-tidy/checks/fuchsia-default-arguments.html>`_ check
+
+  Check to prevent use of default arguments in declared or called functions in Fuchsia.
+
 - New `objc-property-declaration
   <http://clang.llvm.org/extra/clang-tidy/checks/objc-property-declaration.html>`_ check
 
   Add new check for Objective-C code to ensure property
   names follow the naming convention of Apple's programming
   guide.
 
 - New `google-objc-global-variable-declaration
   <http://clang.llvm.org/extra/clang-tidy/checks/google-global-variable-declaration.html>`_ check
 
-  Add new check for Objective-C code to ensure global 
-  variables follow the naming convention of 'k[A-Z].*' (for constants) 
+  Add new check for Objective-C code to ensure global
+  variables follow the naming convention of 'k[A-Z].*' (for constants)
   or 'g[A-Z].*' (for variables).
 
 - New module `objc` for Objective-C style checks.
 
 - New `objc-forbidden-subclassing
   <http://clang.llvm.org/extra/clang-tidy/checks/objc-forbidden-subclassing.html>`_ check
 
   Ensures Objective-C classes do not subclass any classes which are
- New `android-cloexec-memfd_create
   of ``memfd_create()``.
 
 - New `bugprone-integer-division
   <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-integer-division.html>`_ check
 
   Finds cases where integer division in a floating point context is likely to
   cause unintended loss of precision.
 
-- New `cppcoreguidelines-owning-memory <http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-owning-memory.html>`_ check 
+- New `cppcoreguidelines-owning-memory <http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-owning-memory.html>`_ check
 
   This check implements the type-based semantic of ``gsl::owner<T*>``, but without
   flow analysis.
 
 - New `hicpp-exception-baseclass
   <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-exception-baseclass.html>`_ check
 
-  Ensures that all exception will be instances of ``std::exception`` and classes 
+  Ensures that all exception will be instances of ``std::exception`` and classes
   that are derived from it.
 
 - New `hicpp-signed-bitwise
   <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-signed-bitwise.html>`_ check
 
-  Finds uses of bitwise operations on signed integer types, which may lead to 
+  Finds uses of bitwise operations on signed integer types, which may lead to
   undefined or implementation defined behaviour.
 
 - New `android-cloexec-inotify-init1
   <http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-inotify-init1.html>`_ check
 
   Checks if the required file flag ``IN_CLOEXEC`` is present in the argument of
   ``inotify_init1()``.
 
 - New `readability-static-accessed-through-instance
   <http://clang.llvm.org/extra/clang-tidy/checks/readability-static-accessed-through-instance.html>`_ check
 
   Finds member expressions that access static members through instances and
   replaces them with uses of the appropriate qualified-id.
 
 - Added `modernize-use-emplace.IgnoreImplicitConstructors
   <http://clang.llvm.org/extra/clang-tidy/checks/modernize-use-emplace.html#cmdoption-arg-IgnoreImplicitConstructors>`_
   option.
 
-- Added aliases for the `High Integrity C++ Coding Standard <http://www.codingstandard.com/section/index/>`_ 
+- Added aliases for the `High Integrity C++ Coding Standard <http://www.codingstandard.com/section/index/>`_
   to already implemented checks in other modules.
 
   - `hicpp-deprecated-headers <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-deprecated-headers.html>`_
   - `hicpp-move-const-arg <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-move-const-arg.html>`_
   - `hicpp-no-array-decay <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-no-array-decay.html>`_
   - `hicpp-no-malloc <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-no-malloc.html>`_
   - `hicpp-static-assert <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-static-assert.html>`_
   - `hicpp-use-auto <http://clang.llvm.org/extra/clang-tidy/checks/hicpp-use-auto.html>`_

docs/clang-tidy/checks/fuchsia-default-arguments.rst

+.. title:: clang-tidy - fuchsia-default-arguments
+
+fuchsia-default-arguments
+=========================
+
+Warns if a function is declared or called with default arguments.
+
+Ex. The declaration:
+
+.. code-block:: c++
+
+  int foo(int value = 5) { return value; }
+
+will cause a warning.
+
+If a function with default arguments is already defined, calling it with no
+arguments will also cause a warning. Calling it without defaults will not cause
+a warning:
+.. code-block:: c++
+
+  foo();  // warning
+  foo(0); // no warning
+
+See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md

docs/clang-tidy/checks/fuchsia-multiple-inheritance.rst

+.. title:: clang-tidy - fuchsia-multiple-inheritance
+
+fuchsia-multiple-inheritance
+============================
+
+Warns if a function inherits from multiple classes that are not pure virtual.
+
+Ex: Declaring a class that inherits from multiple concrete classes is
+disallowed:
+
+.. code-block:: c++
+
+  class Base_A {
+  public:
+    virtual int foo() { return 0; }
+  };
+
+  class Base_B {
+  public:
+    virtual int bar() { return 0; }
+  };
+
+  // Warning
+  class Bad_Child1 : public Base_A, Base_B {};
+
+A class that inherits from a pure virtual is allowed:
+
+.. code-block:: c++
+
+  class Interface_A {
+  public:
+    virtual int foo() = 0;
+  };
+
+  class Interface_B {
+  public:
+    virtual int bar() = 0;
+  };
+
+  // No warning
+  class Good_Child1 : public Interface_A, Interface_B {
+    virtual int foo() override { return 0; }
+    virtual int bar() override { return 0; }
+  };
+
+See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md

docs/clang-tidy/checks/fuchsia-overloaded-operator.rst

+.. title:: clang-tidy - fuchsia-overloaded-operator
+
+fuchsia-overloaded-operator
+===========================
+
+Warns if an operator is overloaded, except for the copy and move operators.
+
+Ex.
+
+.. code-block:: c++
+
+  int operator+(int);     // Warning
+
+  B &operator=(B other);  // No warning
+  B &operator=(B &&other) // No warning
+
+See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md

docs/clang-tidy/checks/fuchsia-statically-constructed-objects.rst

+.. title:: clang-tidy - fuchsia-statically-constructed-objects
+
+fuchsia-statically-constructed-objects
+======================================
+
+Warns if statically-stored objects are created, unless constructed
+with constexpr.
+
+Ex. Creating static classes or structs is not allowed:
+
+.. code-block:: c++
+
+  class AdderClass {
+  public:
+    AdderClass(int value1, int value2) : val(value1 + value2) {}
+    constexpr AdderClass(int value) : val(value) {}
+
+  private:
+    int val;
+  };
+
+  // Will cause warning
+  static AdderClass a(1, 2);
+
+But creation of static objects using constexpr constructors is allowed:
+
+.. code-block:: c++
+
+  // No warning
+  static AdderClass b(0);
+
+See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md

docs/clang-tidy/checks/fuchsia-thread-local.rst

+.. title:: clang-tidy - fuchsia-thread-local
+
+fuchsia-thread-local
+====================
+
+Warns if thread-local storage is used.
+
+Ex. Using thread_local or extern thread_local is not allowed:
+
+.. code-block:: c++
+
+  thread_local int foo;           // Warning
+  extern thread_local int bar;    // Warning
+
+See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md

docs/clang-tidy/checks/fuchsia-trailing-return.rst

+.. title:: clang-tidy - fuchsia-trailing-return
+
+fuchsia-trailing-return
+=======================
+
+Warns if a function has a trailing return.
+
+Ex.
+
+.. code-block:: c++
+
+  // No warning
+  int add_one(const int arg) { return arg; }
+
+  // Warning
+  auto get_add_one() -> int (*)(const int) {
+    return add_one;
+  }
+
+See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md

docs/clang-tidy/checks/fuchsia-virtual-inheritance.rst

+.. title:: clang-tidy - fuchsia-virtual-inheritance
+
+fuchsia-virtual-inheritance
+===========================
+
+Warns if classes are defined or created with virtual inheritance.
+
+Ex. Classes should not be defined with virtual inheritance:
+
+.. code-block:: c++
+
+  class B : public virtual A {}   // warning
+
+Classes with virtual inheritance should not be created:
+
+.. code-block:: c++
+
+  B *b = new B();   // warning
+
+See the features disallowed in Fuchsia at https://fuchsia.googlesource.com/zircon/+/master/docs/cxx.md

docs/clang-tidy/checks/list.rst

.. toctree::
    cppcoreguidelines-pro-type-cstyle-cast
    cppcoreguidelines-pro-type-member-init
    cppcoreguidelines-pro-type-reinterpret-cast
    cppcoreguidelines-pro-type-static-cast-downcast
    cppcoreguidelines-pro-type-union-access
    cppcoreguidelines-pro-type-vararg
    cppcoreguidelines-slicing
    cppcoreguidelines-special-member-functions
+   fuchsia-default-arguments
+   fuchsia-multiple-inheritance
+   fuchsia-overloaded-operator
+   fuchsia-statically-constructed-objects
+   fuchsia-thread-local
+   fuchsia-trailing-return
+   fuchsia-virtual-inheritance
    google-build-explicit-make-pair
    google-build-namespaces
    google-build-using-namespace
    google-default-arguments
    google-explicit-constructor
    google-global-names-in-headers
    google-objc-global-variable-declaration
    google-readability-braces-around-statements (redirects to readability-braces-around-statements) <google-readability-braces-around-statements>

test/clang-tidy/fuchsia-default-arguments.cpp

+// RUN: %check_clang_tidy %s fuchsia-default-arguments %t
+
+int foo(int value = 5) { return value; }
+// CHECK-MESSAGES: [[@LINE-1]]:9: warning: declaring functions which use default arguments is disallowed [fuchsia-default-arguments]
+
+int f(void) {
+  foo();
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: calling functions which use default arguments is disallowed [fuchsia-default-arguments]
+  // CHECK-NEXT: note: the default parameter was declared here:
+  // CHECK-NEXT: int foo(int value = 5) { return value; }
+}
+
+// Negatives.
+int bar(int value) { return value; }
+
+int n(void) {
+  foo(0);
+  bar(0);
+}

test/clang-tidy/fuchsia-multiple-inheritance.cpp

+// RUN: %check_clang_tidy %s fuchsia-multiple-inheritance %t
+
+class Base_A {
+public:
+  virtual int foo() { return 0; }
+};
+
+class Base_B {
+public:
+  virtual int bar() { return 0; }
+};
+
+class Base_A_child : public Base_A {
+public:
+  virtual int baz() { return 0; }
+};
+
+class Interface_A {
+public:
+  virtual int foo() = 0;
+};
+
+class Interface_B {
+public:
+  virtual int bar() = 0;
+};
+
+class Interface_C {
+public:
+  virtual int blat() = 0;
+};
+
+class Interface_A_with_member {
+public:
+  virtual int foo() = 0;
+  int val = 0;
+};
+
+class Interface_with_A_Parent : public Base_A {
+public:
+  virtual int baz() = 0;
+};
+
+// Inherits from multiple concrete classes.
+// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting mulitple classes which aren't pure virtual is disallowed [fuchsia-multiple-inheritance]
+// CHECK-NEXT: class Bad_Child1 : public Base_A, Base_B {};
+class Bad_Child1 : public Base_A, Base_B {};
+
+// CHECK-MESSAGES: [[@LINE+1]]:1: warning: inheriting mulitple classes which aren't pure virtual is disallowed [fuchsia-multiple-inheritance]
+class Bad_Child2 : public Base_A, Interface_A_with_member {
+  virtual int foo() override { return 0; }
+};
+
+// CHECK-MESSAGES: [[@LINE+2]]:1: warning: inheriting mulitple classes which aren't pure virtual is disallowed [fuchsia-multiple-inheritance]
+// CHECK-NEXT: class Bad_Child3 : public Interface_with_A_Parent, Base_B {
+class Bad_Child3 : public Interface_with_A_Parent, Base_B {
+  virtual int baz() override { return 0; }
+};
+
+// Easy cases of single inheritance
+class Simple_Child1 : public Base_A {};
+class Simple_Child2 : public Interface_A {
+  virtual int foo() override { return 0; }
+};
+
+// Valid uses of multiple inheritance
+class Good_Child1 : public Interface_A, Interface_B {
+  virtual int foo() override { return 0; }
+  virtual int bar() override { return 0; }
+};
+
+class Good_Child2 : public Base_A, Interface_B {
+  virtual int bar() override { return 0; }
+};
+
+class Good_Child3 : public Base_A_child, Interface_C, Interface_B {
+  virtual int bar() override { return 0; }
+  virtual int blat() override { return 0; }
+};
+
+int main(void) {
+  Bad_Child1 a;
+  Bad_Child2 b;
+  Bad_Child3 c;
+  Simple_Child1 d;
+  Simple_Child2 e;
+  Good_Child1 f;
+  Good_Child2 g;
+  Good_Child3 h;
+  return 0;
+}

test/clang-tidy/fuchsia-overloaded-operator.cpp

+// RUN: %check_clang_tidy %s fuchsia-overloaded-operator %t
+
+class A {
+public:
+  int operator+(int);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: operator overloading is disallowed [fuchsia-overloaded-operator]
+};
+
+class B {
+public:
+  B &operator=(B other);
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:3: warning: operator overloading is disallowed [fuchsia-overloaded-operator]
+  B &operator=(B &&other);
+  // CHECK-MESSAGES-NOT: [[@LINE-1]]:3: warning: operator overloading is disallowed [fuchsia-overloaded-operator]
+};

test/clang-tidy/fuchsia-statically-constructed-objects.cpp

+// RUN: %check_clang_tidy %s fuchsia-statically-constructed-objects %t
+
+class AdderClass {
+public:
+  AdderClass(int value1, int value2) : val(value1 + value2) {}
+  constexpr AdderClass(int value) : val(value) {}
+
+private:
+  int val;
+};
+
+struct mystruct {
+  int a;
+};
+
+struct mystruct_with_method {
+  int a;
+  void b() { a++; }
+};
+
+struct static_mystruct_container {
+  int a;
+  static int b;
+  static struct mystruct c;
+};
+
+int main(void) {
+
+  static AdderClass a(1, 2);
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: statically constructed objects are disallowed
+  // CHECK-NEXT:  static AdderClass a(1, 2);
+
+  // Allowed (constexpr ctor)
+  static AdderClass b(0);
+
+  static struct mystruct c;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: statically constructed objects are disallowed
+  // CHECK-NEXT:  static struct mystruct c;
+
+  static struct mystruct_with_method d;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: statically constructed objects are disallowed
+  // CHECK-NEXT:  static struct mystruct_with_method d;
+
+  static int e;
+  struct static_mystruct_container f;
+}

test/clang-tidy/fuchsia-thread-local.cpp

+// RUN: %check_clang_tidy %s fuchsia-thread-local %t
+
+int main(void) {
+  thread_local int foo;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: thread local storage is disallowed
+  // CHECK-NEXT:  thread_local int foo;
+
+  extern thread_local int bar;
+  // CHECK-MESSAGES: [[@LINE-1]]:3: warning: thread local storage is disallowed
+  // CHECK-NEXT:  extern thread_local int bar;
+  int baz;
+  return 0;
+}

test/clang-tidy/fuchsia-trailing-return.cpp

+// RUN: %check_clang_tidy %s fuchsia-trailing-return %t
+
+int add_one(const int arg) { return arg; }
+
+auto get_add_one() -> int (*)(const int) {
+  // CHECK-MESSAGES: [[@LINE-1]]:1: warning: trailing returns are disallowed
+  // CHECK-NEXT: auto get_add_one() -> int (*)(const int) {
+  return add_one;
+}
+
+int main(void) {
+  get_add_one()(5);
+  return 0;
+}

test/clang-tidy/fuchsia-virtual-inheritance.cpp

+// RUN: %check_clang_tidy %s fuchsia-virtual-inheritance %t
+
+class A {
+public:
+  A(int value) : val(value) {}
+
+  int do_A() { return val; }
+
+private:
+  int val;
+};
+
+class B : public virtual A {
+  // CHECK-MESSAGES: [[@LINE-1]]:1: warning: [kernel-c++] virtual inheritance is disallowed [fuchsia-virtual-inheritance]
+  // CHECK-NEXT: class B : public virtual A {
+public:
+  B() : A(0) {}
+  int do_B() { return 1 + do_A(); }
+};
+
+class C : public virtual A {
+  // CHECK-MESSAGES: [[@LINE-1]]:1: warning: [kernel-c++] virtual inheritance is disallowed [fuchsia-virtual-inheritance]
+  // CHECK-NEXT: class C : public virtual A {
+public:
+  C() : A(0) {}
+  int do_C() { return 2 + do_A(); }
+};
+
+class D : public B, public C {
+  // CHECK-MESSAGES: [[@LINE-1]]:1: warning: [kernel-c++] virtual inheritance is disallowed [fuchsia-virtual-inheritance]
+  // CHECK-NEXT: class C : public B, public C {
+public:
+  D(int value) : A(value), B(), C() {}
+  // CHECK-MESSAGES: [[@LINE-1]]:28: warning: [kernel-c++] constructing a class which inherits a virtual base class is disallowed [fuchsia-virtual-inheritance]
+  // CHECK-NEXT:  D(int value) : A(value), B(), C() {}
+  // CHECK-MESSAGES: [[@LINE-3]]:33: warning: [kernel-c++] constructing a class which inherits a virtual base class is disallowed [fuchsia-virtual-inheritance]
+  // CHECK-NEXT:  D(int value) : A(value), B(), C() {}
+
+  int do_D() { return do_A() + do_B() + do_C(); }
+};
+
+int main(void) {
+  A *a = new A(0);
+  B *b = new B();
+  // CHECK-MESSAGES: [[@LINE-1]]:14: warning: [kernel-c++] constructing a class which inherits a virtual base class is disallowed [fuchsia-virtual-inheritance]
+  // CHECK-NEXT:  B *b = new B();
+  C *c = new C();
+  // CHECK-MESSAGES: [[@LINE-1]]:14: warning: [kernel-c++] constructing a class which inherits a virtual base class is disallowed [fuchsia-virtual-inheritance]
+  // CHECK-NEXT:  C *c = new C();
+  D *d = new D(0);
+  // CHECK-MESSAGES: [[@LINE-1]]:14: warning: [kernel-c++] constructing a class which inherits a virtual base class is disallowed [fuchsia-virtual-inheritance]
+  // CHECK-NEXT:  D *d = new D(0);
+  return 0;
+}