[clang-tidy] Introduce fuchsia-global-variables check

[Caslyn]

Summary

Introduce a clang-tidy check to the fuchsia module to warn of any static
or global variables that do not have trivial destructors.

The implementation is a pared down version of the Google3
check with configurable options to add types for the check to ignore
(e.g. LazyRE2).

[Caslyn]

Fixes, cleanups.

[Caslyn]

Include exception for variables declared in macros; cleanups.

[Caslyn]

Add constinit exception, remove G3 exceptions

[PiotrZSL]

This check overlap with fuchsia-statically-constructed-objects.
In fact only new warnings are in lines 118, 111, 99.

Provided link is dead.
Fuchsia codding standard does not forbid global objects with non-trivial destructors: https://fuchsia.dev/fuchsia-src/development/languages/c-cpp/cxx?hl=en

Looks like what you trying to implement is an google style rule: "https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables" -> "Objects with static storage duration are forbidden unless they are trivially destructible. "
Therefor this check should be in google namespace, not fuchsia.
Please also look into: https://github.com/llvm/llvm-project/issues/62334

Personally I would see this as some generic misc-non-trivial-global-variable that could handle both initialization & destruction, and simply some standards could alias it.

clang-tools-extra/clang-tidy/fuchsia/GlobalVariablesCheck.cpp

31

may not work with typedefs to reference

32–33

there can be some implicitCasts here, and it wont match, also CXXBindTemporaryExpr can show up, this isn't a good way...

39

what about typedefs ?

47

TK_AsIs is default.

87–88

do not use unless, because other checks make set other rules, and we could run into conflict between them

97

if you put non trivial type into std::array, then std::array instance will become non-trivial itself, no need to look into arguments.

clang-tools-extra/docs/clang-tidy/checks/fuchsia/global-variables.rst

29

wrong example, using = default will make it trivial, put something into destructor.

40

would be nice to point out to a rule, that it implements.

[Caslyn]

Fixes from review.

[Caslyn]

Thanks for the review @PiotrZSL, I’m new to this space and appreciate the comments. I have a few questions around some of them and would greatly appreciate any guidance you can give.

The intent of this patch is to upstream a generic version of the google style check (apologies for the private link) for use on Fuchsia and other projects. I’m happy to make this check a misc check that handles initialization and destruction if you wouldn’t mind advising a little bit. To handle the initialization aspect, would you suggest I combine logic from the existing fuchsia-statically-constructed-objects check?

Please also look into: https://github.com/llvm/llvm-project/issues/62334

I see there’s some potential clean up for the fuchsia module. I can take a stab at that ticket after this patch.

clang-tools-extra/clang-tidy/fuchsia/GlobalVariablesCheck.cpp

32–33

Is there a better way to implement this intent while handling those corner cases?

39

There is the typedef scenario tested on L#90 the global-variables.cpp test and I've added an additional test for typedef to references - are there any other test cases I can add to make sure this check handles them correctly?

97

Done - removed special handling for std::array.

[PiotrZSL]

clang-tools-extra/clang-tidy/fuchsia/GlobalVariablesCheck.cpp

27

Check LLVM codding standard, use CammelCase, and put it into matcher bellow anyway.

31

you can easily use here hasType(qualType(hasCanonicalType(references, it would work with typedefs to references.

32–33

in fact only thing that you need to check is if lifetime of materializeTemporaryExpr is extended by this varDecl, probably using getExtendingDecl () or getStroageDuration would be sufficient.

35

i would expect that this check would utilize CXXRecordDecl::hasNonTrivialDestructor().

36

only classes can be non trivial to destroy, so we should exclude on this level all types that are not CXXRecordDecl.

37

could be better, like in other checks.

37

39

typedef for const reference of non trivial type that is used to exend lfietime of variable (calling function that returns object with non trivial destructor).

clang-tools-extra/docs/clang-tidy/checks/fuchsia/global-variables.rst

4

I would name this check as: misc-no-static-variable-non-trivial-dtor or something similar, and then google check would just alias it as google-global-variables or something, and then fuchsia check could be named misc-no-static-variable-non-trivial-ctor, and current check could alias it. My main reason for that is very often awkward to use google check in project for something common, like for example explicit constructors. Those 2 rules I consider +- common, not all project need them but some project that code for DSP for example could find them useful.

You can do renaming at the end, there is script for that in repository.

38–39

obsolete

clang-tools-extra/test/clang-tidy/checkers/fuchsia/global-variables.cpp

8

Note: Remove all constructors from those classes here, we should teat this check on classes that are trivial to construct, but non trival to destroy.

36

104

that will act just like alias
``NonTriviallyDestructibleClass XYZ;
typedef_ref_ntdc = XYZ;``
this `new` here is confusing... both examples should be made simpler.

164

what about global object in a template function:
``
template<typename T> const T& fun() {

static T value;
return value;

}
``
and then calling this function with both non trivial and trivial to destroy type.

[Caslyn]

Changes per review.

[Caslyn]

Hi Piotr - I'm sorry for the delay in getting back to you. Thank you again for your review comments. I did my best trying to get the right combination of matchers that limit the candidates and allow the exceptions that we want. I wasn't successful in figuring out a way to exempt static references to non-trivial destructor classes that don't have the lifetime extension (see comment).

clang-tools-extra/clang-tidy/fuchsia/GlobalVariablesCheck.cpp

36

In the latest revision I narrowed the matching candidates to:

anyOf(hasType(hasCanonicalType(references(qualType()))),
               hasType(arrayType()),
               hasType(cxxRecordDecl(hasNonTrivialDestructor()))),

I found I needed to capture arrays and references in the tests and included those in the limited candidates.

However, after a lot of testing and experimenting with materializeTemporaryExpr and your suggestions, I still couldn't figure out a way to allow references without lifetime extensions. For ex, this test gives a false positive with the latest patch:

// Static references with function scope are allowed if they don't have
// lifetime-extension.
static const NonTriviallyDestructibleClass &ConstRefFuncNtdc = *new NonTriviallyDestructibleClass;

I've been starting to question if this is a general enough use case to include as an exception. Do you think it would be a mistake if this check does not allow static references to non-trivial destructors, regardless of a lifetime extension?

37

I went ahead and combined the two suggestions around the IgnoreVars matching .

clang-tools-extra/test/clang-tidy/checkers/fuchsia/global-variables.cpp

104

I got rid of these scenarios and tested typedef to a reference per your suggestion in the latest patch - hopefully I captured it correctly:

typedef for const reference of non trivial type that is used to exend lfietime of variable (calling function that returns object with non trivial destructor).

[Caslyn]

correct reference in test

clang-tools-extra/clang-tidy/fuchsia/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   Support
   )
 
 add_clang_library(clangTidyFuchsiaModule
   DefaultArgumentsCallsCheck.cpp
   DefaultArgumentsDeclarationsCheck.cpp
   FuchsiaTidyModule.cpp
   MultipleInheritanceCheck.cpp
+  GlobalVariablesCheck.cpp
   OverloadedOperatorCheck.cpp
   StaticallyConstructedObjectsCheck.cpp
   TrailingReturnCheck.cpp
   VirtualInheritanceCheck.cpp
 
   LINK_LIBS
   clangTidy
   clangTidyGoogleModule

clang-tools-extra/clang-tidy/fuchsia/FuchsiaTidyModule.cpp

 //===--- FuchsiaTidyModule.cpp - clang-tidy -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../google/UnnamedNamespaceInHeaderCheck.h"
 #include "DefaultArgumentsCallsCheck.h"
 #include "DefaultArgumentsDeclarationsCheck.h"
+#include "GlobalVariablesCheck.h"
 #include "MultipleInheritanceCheck.h"
 #include "OverloadedOperatorCheck.h"
 #include "StaticallyConstructedObjectsCheck.h"
 #include "TrailingReturnCheck.h"
 #include "VirtualInheritanceCheck.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang::tidy {
 namespace fuchsia {
 
 /// This module is for Fuchsia-specific checks.
 class FuchsiaModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<DefaultArgumentsCallsCheck>(
         "fuchsia-default-arguments-calls");
     CheckFactories.registerCheck<DefaultArgumentsDeclarationsCheck>(
         "fuchsia-default-arguments-declarations");
+    CheckFactories.registerCheck<GlobalVariablesCheck>(
+        "fuchsia-global-variables");
     CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
         "fuchsia-header-anon-namespaces");
     CheckFactories.registerCheck<MultipleInheritanceCheck>(
         "fuchsia-multiple-inheritance");
     CheckFactories.registerCheck<OverloadedOperatorCheck>(
         "fuchsia-overloaded-operator");
     CheckFactories.registerCheck<StaticallyConstructedObjectsCheck>(
         "fuchsia-statically-constructed-objects");

clang-tools-extra/clang-tidy/fuchsia/GlobalVariablesCheck.h

+//===--- GlobalVariablesCheck.h - clang-tidy --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_GLOBAL_VARIABLES_CHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_GLOBAL_VARIABLES_CHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang::tidy::fuchsia {
+
+/// GlobalVariables with non-trivial destructors are disallowed
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/fuchsia/global-variables.html
+class GlobalVariablesCheck : public ClangTidyCheck {
+public:
+  GlobalVariablesCheck(StringRef Name, ClangTidyContext *Context);
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void checkType(const ast_matchers::MatchFinder::MatchResult &Result,
+                 const VarDecl *decl, const QualType type);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
+private:
+  const std::vector<StringRef> IgnoreVars;
+};
+
+} // namespace clang::tidy::fuchsia
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_GLOBAL_VARIABLES_CHECK_H

clang-tools-extra/clang-tidy/fuchsia/GlobalVariablesCheck.cpp

+//===--- GlobalVariablesCheck.cpp - clang-tidy ----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "GlobalVariablesCheck.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+
+using llvm::StringRef;
+using namespace clang::ast_matchers;
+
+namespace clang::tidy::fuchsia {
+namespace {
+AST_MATCHER(CXXRecordDecl, hasNonTrivialDestructor) {
+  return Node.hasNonTrivialDestructor();
+}
+} // namespace
+
+GlobalVariablesCheck::GlobalVariablesCheck(StringRef Name,
+                                           ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      IgnoreVars(utils::options::parseStringList(Options.get("Ignore", ""))) {}
+
+void GlobalVariablesCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(
+      varDecl(
+          allOf(hasGlobalStorage(), isDefinition()),
+          anyOf(hasType(hasCanonicalType(references(qualType()))),
+                hasType(arrayType()),
+                hasType(cxxRecordDecl(hasNonTrivialDestructor()))),
+          unless(isConstexpr()), unless(isConstinit()),
+          unless(hasAttr(clang::attr::NoDestroy)),
+          unless(hasType(qualType(hasCanonicalType(hasDeclaration(
+              cxxRecordDecl(matchers::matchesAnyListedName(IgnoreVars))))))))
+          .bind("non_trivial_dtor_var"),
+      this);
+}
+
+void GlobalVariablesCheck::checkType(const MatchFinder::MatchResult &Result,
+                                     const VarDecl *Decl, QualType Type) {
+
+  if (Type.getNonReferenceType().isDestructedType() == QualType::DK_none) {
+    return;
+  }
+
+  // Ignore variables which are declared in macros even if they are static or
+  // global variables with non-trivial-destructors.
+  if (Decl->getLocation().isMacroID()) {
+    return;
+  }
+
+  // 'thread_local' variables in functions are allowed without restrictions.
+  auto *DeclContext = Decl->getDeclContext();
+  if (!isa<NamespaceDecl>(DeclContext) &&
+      !isa<TranslationUnitDecl>(DeclContext)) {
+    if (Decl->getTLSKind() == VarDecl::TLS_Dynamic ||
+        Decl->getTLSKind() == VarDecl::TLS_Static) {
+      return;
+    }
+  }
+
+  // 'thread_local' variables with no dynamic initialization are allowed
+  // everywhere.
+  if (Decl->getTLSKind() == VarDecl::TLS_Static) {
+    return;
+  }
+
+  // Objective-C ARC-managed objects are allowed everywhere.
+  if (Type->isObjCLifetimeType()) {
+    return;
+  }
+
+  diag(Decl->getLocation(),
+       "non trivially destructible static and global variables are forbidden");
+}
+
+void GlobalVariablesCheck::check(const MatchFinder::MatchResult &Result) {
+  if (const auto *Decl =
+          Result.Nodes.getNodeAs<VarDecl>("non_trivial_dtor_var")) {
+    QualType Type = Decl->getType().getCanonicalType();
+    checkType(Result, Decl, Type);
+  }
+}
+
+void GlobalVariablesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "Ignore",
+                utils::options::serializeStringList(IgnoreVars));
+}
+} // namespace clang::tidy::fuchsia

clang-tools-extra/docs/ReleaseNotes.rst

- New :doc:`cppcoreguidelines-missing-std-forward
   function body.
 
 - New :doc:`cppcoreguidelines-rvalue-reference-param-not-moved
   <clang-tidy/checks/cppcoreguidelines/rvalue-reference-param-not-moved>` check.
 
   Warns when an rvalue reference function parameter is never moved within
   the function body.
 
+- New :doc:`fuchsia-global-variables
+  <clang-tidy/checks/fuchsia/global-variables>` check.
+
+  Checks static and global variables that are not trivially destructible.
+
 - New :doc:`llvmlibc-inline-function-decl
   <clang-tidy/checks/llvmlibc/inline-function-decl>` check.
 
   Checks that all implicit and explicit inline functions in header files are
   tagged with the ``LIBC_INLINE`` macro.
 
 - New :doc:`misc-header-include-cycle
   <clang-tidy/checks/misc/header-include-cycle>` check.

clang-tools-extra/docs/clang-tidy/checks/fuchsia/global-variables.rst

+.. title:: clang-tidy - fuchsia-global-variables
+
+fuchsia-global-variables
+=============================
+
+Warns of static and global variables with non-trivial destructors.
+
+For example:
+
+.. code-block:: c++
+
+  // No warning
+  class PODClass {
+  public:
+    int Var;
+    float F;
+    char C;
+    char Cs[10];
+  };
+
+  // No warning
+  PODClass pod_class;
+
+  class NonPODClass {
+  public:
+    NonPODClass() : Var(0) {}
+    NonPODClass(int Var) : Var(Var) {}
+    ~NonPODClass() {
+      cout << "Running destructor";
+    }
+    int Var;
+  };
+
+  // Warning
+  NonPODClass non_pod_class;
+
+`thread_local` variables in functions are permitted without restrictions.
+
+Options
+-------
+
+.. option:: Ignore
+
+   Semicolon-separated list of names of types for the check to ignore. Default
+   is empty.

clang-tools-extra/docs/clang-tidy/checks/list.rst

.. csv-table::
    `cppcoreguidelines-pro-type-union-access <cppcoreguidelines/pro-type-union-access.html>`_,
    `cppcoreguidelines-pro-type-vararg <cppcoreguidelines/pro-type-vararg.html>`_,
    `cppcoreguidelines-rvalue-reference-param-not-moved <cppcoreguidelines/rvalue-reference-param-not-moved.html>`_,
    `cppcoreguidelines-slicing <cppcoreguidelines/slicing.html>`_,
    `cppcoreguidelines-special-member-functions <cppcoreguidelines/special-member-functions.html>`_,
    `cppcoreguidelines-virtual-class-destructor <cppcoreguidelines/virtual-class-destructor.html>`_, "Yes"
    `darwin-avoid-spinlock <darwin/avoid-spinlock.html>`_,
    `darwin-dispatch-once-nonstatic <darwin/dispatch-once-nonstatic.html>`_, "Yes"
+   `fuchsia-global-variables<fuchsia/global-variables.html>`_,
    `fuchsia-default-arguments-calls <fuchsia/default-arguments-calls.html>`_,
    `fuchsia-default-arguments-declarations <fuchsia/default-arguments-declarations.html>`_, "Yes"
    `fuchsia-multiple-inheritance <fuchsia/multiple-inheritance.html>`_,
    `fuchsia-overloaded-operator <fuchsia/overloaded-operator.html>`_,
    `fuchsia-statically-constructed-objects <fuchsia/statically-constructed-objects.html>`_,
    `fuchsia-trailing-return <fuchsia/trailing-return.html>`_,
    `fuchsia-virtual-inheritance <fuchsia/virtual-inheritance.html>`_,
    `google-build-explicit-make-pair <google/build-explicit-make-pair.html>`_,

clang-tools-extra/test/clang-tidy/checkers/fuchsia/global-variables.cpp

+// RUN: %check_clang_tidy %s fuchsia-global-variables %t \
+// RUN: -config="{CheckOptions: \
+// RUN:           [{key: fuchsia-global-variables.Ignore, value: 'LazyRE2;ThreadLocal'}] \
+// RUN:          }"
+
+using size_t = decltype(sizeof(int));
+
+class TriviallyDestructibleClass {
+ public:
+  // This is a trivially destructible class.
+  int I;
+  float F;
+  char C;
+  char Cs[10];
+};
+
+class NonTriviallyDestructibleClass {
+ public:
+  // We need a destructor to make the class non trivially destructible.
+  ~NonTriviallyDestructibleClass() { Var = 0; }
+  int Var;
+};
+
+template <class T>
+class NonTriviallyDestructibleTemplateClass {
+ public:
+  // We need a destructor to make the class non trivially destructible.
+  ~NonTriviallyDestructibleTemplateClass() { Var = 0; }
+  int Var;
+  T Var2;
+};
+
+int GlobalI;
+_Atomic size_t GlobalAtomic;
+
+TriviallyDestructibleClass Tdc;
+
+NonTriviallyDestructibleClass Ntdc;
+// CHECK-MESSAGES: [[@LINE-1]]:31: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+[[clang::no_destroy]] NonTriviallyDestructibleClass NtdcNoDestory;
+
+TriviallyDestructibleClass TdcArray[2] = { TriviallyDestructibleClass(), TriviallyDestructibleClass()};
+
+NonTriviallyDestructibleClass NtdcArray[2] = {
+    NonTriviallyDestructibleClass(), NonTriviallyDestructibleClass()};
+// CHECK-MESSAGES: [[@LINE-2]]:31: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+const TriviallyDestructibleClass TdcConstArray[2] = {
+    TriviallyDestructibleClass(), TriviallyDestructibleClass()};
+
+const NonTriviallyDestructibleClass NtdcConstArray[2] = {
+    NonTriviallyDestructibleClass(), NonTriviallyDestructibleClass()};
+// CHECK-MESSAGES: [[@LINE-2]]:37: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+TriviallyDestructibleClass TdcMultiArray[2][2] = {
+    {TriviallyDestructibleClass(), TriviallyDestructibleClass()},
+    {TriviallyDestructibleClass(), TriviallyDestructibleClass()}};
+
+NonTriviallyDestructibleClass NtdcMultiArray[2][2] = {
+    {NonTriviallyDestructibleClass(), NonTriviallyDestructibleClass()},
+    {NonTriviallyDestructibleClass(), NonTriviallyDestructibleClass()}};
+// CHECK-MESSAGES: [[@LINE-3]]:31: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+const TriviallyDestructibleClass TdcMultiConstArray[2][2] = {
+    {TriviallyDestructibleClass(), TriviallyDestructibleClass()},
+    {TriviallyDestructibleClass(), TriviallyDestructibleClass()}};
+
+const NonTriviallyDestructibleClass NtdcMultiConstArray[2][2] = {
+    {NonTriviallyDestructibleClass(), NonTriviallyDestructibleClass()},
+    {NonTriviallyDestructibleClass(), NonTriviallyDestructibleClass()}};
+// CHECK-MESSAGES: [[@LINE-3]]:37: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+typedef TriviallyDestructibleClass TDCArray[1];
+TDCArray TdcTypedefArray[1];
+
+typedef NonTriviallyDestructibleClass NTDCArray[1];
+NTDCArray NTdcTypedefArray[1];
+// CHECK-MESSAGES: [[@LINE-1]]:11: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+const TriviallyDestructibleClass& getTdcRef() {
+  return *new TriviallyDestructibleClass;
+}
+
+const NonTriviallyDestructibleClass& getNtdcRef() {
+  return *new NonTriviallyDestructibleClass;
+}
+
+typedef const TriviallyDestructibleClass& TdcConstRef;
+typedef const NonTriviallyDestructibleClass& NtdcConstRef;
+
+void testLifetimeExtension() {
+  static const TriviallyDestructibleClass &Tdc = getTdcRef();
+  static TdcConstRef TdcTypedef = getTdcRef();
+
+  static const NonTriviallyDestructibleClass& Ntdc = getNtdcRef();
+  // CHECK-MESSAGES: [[@LINE-1]]:47: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+  static NtdcConstRef NtdcTypedef = getNtdcRef();
+  // CHECK-MESSAGES: [[@LINE-1]]:23: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+  static const NonTriviallyDestructibleClass &ExtendedLifetimeNtdc = {};
+  // CHECK-MESSAGES: [[@LINE-1]]:47: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+  /*
+  // TODO: fix false-positive match
+  // Static references with function scope are allowed if they don't have
+  // lifetime-extension.
+  static const NonTriviallyDestructibleClass &ConstRefFuncNtdc =
+      *new NonTriviallyDestructibleClass;
+  */
+}
+
+/*
+// TODO: fix false-positive match
+static const NonTriviallyDestructibleClass &ConstRefNtdc =
+    *new NonTriviallyDestructibleClass;
+*/
+
+template<typename T>
+const T& f() {
+static T Value;
+// CHECK-MESSAGES: [[@LINE-1]]:10: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+return Value;
+}
+
+void func() {
+  static TriviallyDestructibleClass FuncTdc = f<TriviallyDestructibleClass>();
+
+  static NonTriviallyDestructibleClass FuncNtdc = f<NonTriviallyDestructibleClass>();
+  // CHECK-MESSAGES: [[@LINE-1]]:40: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+  static NonTriviallyDestructibleClass Ntdc;
+  // CHECK-MESSAGES: [[@LINE-1]]:40: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+  static int FuncJ = 0;
+  static TriviallyDestructibleClass Tdc;
+
+  // 'thread_local' variables in functions are allowed without restrictions.
+  thread_local NonTriviallyDestructibleClass TlNtdc;
+}
+
+thread_local NonTriviallyDestructibleClass TlNtdc;
+// CHECK-MESSAGES: [[@LINE-1]]:44: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+class ContainsStaticVars {
+  static NonTriviallyDestructibleClass ClassNtdc;
+  static NonTriviallyDestructibleTemplateClass<int> ClassNtdt;
+  int LocalVar;
+  static int ClassCounter;
+  static TriviallyDestructibleClass ClassTriviallyDestructible;
+};
+
+NonTriviallyDestructibleClass ContainsStaticVars::ClassNtdc;
+// CHECK-MESSAGES: [[@LINE-1]]:51: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+NonTriviallyDestructibleTemplateClass<int> ContainsStaticVars::ClassNtdt;
+// CHECK-MESSAGES: [[@LINE-1]]:64: warning: non trivially destructible static and global variables are forbidden [fuchsia-global-variables]
+
+int ContainsStaticVars::ClassCounter = 42;
+TriviallyDestructibleClass ContainsStaticVars::ClassTriviallyDestructible;
+
+// Test exemptions configured through options
+
+class LazyRE2 {
+ public:
+  LazyRE2();
+};
+
+LazyRE2 Lre2;
+
+template <class Type>
+class ThreadLocal {
+ public:
+  // We need a destructor to make the class non trivially destructible.
+  ~ThreadLocal() {}
+};
+
+ThreadLocal<int> GlobalThreadLocal;
+
+void foo() {
+  static ThreadLocal<int> StaticThreadLocal;
+}

llvm/utils/gn/secondary/clang-tools-extra/clang-tidy/fuchsia/BUILD.gn

deps = [
     "//clang/lib/Lex",
     "//llvm/lib/Support",
   ]
   sources = [
     "DefaultArgumentsCallsCheck.cpp",
     "DefaultArgumentsDeclarationsCheck.cpp",
     "FuchsiaTidyModule.cpp",
     "MultipleInheritanceCheck.cpp",
+    "GlobalVariablesCheck.cpp",
     "OverloadedOperatorCheck.cpp",
     "StaticallyConstructedObjectsCheck.cpp",
     "TrailingReturnCheck.cpp",
     "VirtualInheritanceCheck.cpp",
   ]
 }