diff --git a/ClangTidy.cmake b/ClangTidy.cmake
index 40fdba1..154169e 100644
--- a/ClangTidy.cmake
+++ b/ClangTidy.cmake
@@ -13,296 +13,210 @@
 #
 # A module to create custom targets to lint source files using clang-tidy
 #
-# The function swift_setup_clang_tidy will create several targets which will
-# use clang-tidy to lint source files. 2 types of targets will be created, one
-# for linting all listed source files and the other for linting only those which
-# differ from the master branch. The list of file to lint can be created in 2
-# ways which are explained below.
+# Call swift_create_clang_tidy_targets at the end of the top level CMakeLists.txt to create targets for running clang-tidy
 #
-# The created targets have the names
+# clang-tidy version 6 must be available on the system for this module to work properly. If an appropriate clang-tidy can't be found no targets will be created and a warning will
+# be logged
 #
-# - clang-tidy-all-${PROJECT_NAME} - lints all files
-# - clang-tidy-diff-${PROJECT_NAME} - lints only changed files
+# swift_create_clang_tidy_targets will only have an effect for top level projects. If called within a subproject it will return without taking any action
 #
-# In addition if the current project is at the top level of the working tree 2 more
-# targets will be created
+# For every compilable target defined within the calling repository two targets will be created.
 #
-# - clang-tidy-all
-# - clang-tidy-diff
+# The first target 'clang-tidy-${target}' will invoke clang-tidy for all source files which make up the given target. It will export fixes to a file called 'fixes-${target}.yaml'
+# in the top level project source directory.
 #
-# which behave in exactly the same way as the namespaced targets.
+# The second target 'clang-tidy-${target}-check' will run clang-tidy as the target described above and then return an error code if any warning/errors were generated
 #
-# The parameter SCRIPT can be passed to specify a custom linting script. If given
-# the create targets will call this script directly. The script will be passed
-# a single argument of 'all' or 'diff' according to the target
+# In addition there are two other targets created which lint multiple targets at the same time
 #
-# clang-tidy-all - will run `<script> all`
-# clang-tidy-diff - will run `<script> diff`
+# clang-tidy-all runs clang-tidy on all "core" targets in the repository (targets which were added with swift_add_executable or swift_add_library)
 #
-# If a script is not explicitly passed this function will first search for a
-# custom linting script. The script must exist in ${CMAKE_CURRENT_SOURCE_DIR}/scripts
-# and be named either clang-tidy.sh or clang-tidy.bash. It will be called with
-# the same arguments as described above.
+# clang-tidy-world runs clang-tidy on all compilable targets in the repository including all test suites
 #
-# If no custom script is available this function will generate some default linting
-# commands. clang-tidy will be called and passed a list of files to lint.
+# clang-tidy-all and clang-tidy-world each have a "check" variant which returns an error code should any warning/errors be generated
 #
-# The file list can be constructed in one of two ways, either by GLOB patterns or
-# a list of targets
-#
-# GLOB
-#   Pass the parameter 'PATTERNS' with 1 or more GLOB patterns as arguments. These
-#   patterns will be passed to git directly which will generate a list of files to
-#   lint.
-#
-#   swift_setup_clang_tidy(PATTERNS 'src/*.c' 'src/*.cc' 'src/*.cpp')
-#
-# TARGETS
-#   Pass the parameter 'TARGETS" with 1 or more cmake targets as arguments. These
-#   target must already have been created. The list of source files will be extracted
-#   from these targets and passed first to git so it can correctly filter them, then
-#   to clang-tidy.
-#
-# This function must be called with one of the above options, or it must be able to
-# find a custom script in the file system otherwise it will throw an error.
-#
-# The option EXTRA_ARGS may be used to pass command line options directly to the
-# clang-tidy command. This can be useful or even required when a compiler other
-# than clang is used to configure the project. clang-tidy will use the compile_commands.json
-# database to work out how to analyse files, but some GNU options are not understood.
-#
-# swift_setup_clang_tidy(EXTRA_ARGS '-extra-arg=-Wno-unknown-warning-option')
-#
-# will disable a clang-tidy error when it encounters a compiler warning switch it
-# doesn't support, such as -Wno-psabi (GNU does understand this one)
-#
-# All commands are run from ${CMAKE_CURRENT_SOURCE_DIR}. It is highly recommended
-# that this module only be included from the top level CMakeLists.txt of a project,
-# using it from a subdirectory may not work as expected.
-#
-# In addition this function sets up a cmake option which can be used to control
-# whether the targets are created either on the command line or by a super project.
-# The option has the name
-#
-# ${PROJECT_NAME}_ENABLE_CLANG_TIDY
-#
-# The default value is ON for top level projects, and OFF for any others.
-#
-# Running
-#
-# cmake -D<project>_ENABLE_CLANG_TIDY=OFF ..
-#
-# will explicitly disable these targets from the command line at configure time
+# swift_create_clang_tidy_targets will generate a .clang-tidy file in the project source directory which contains the Swift master config for clang-tidy. There is no need for
+# repositories to maintain their own version of .clang-tidy, it should be added to .gitignore in each repository to prevent being checked in. Pass the option
+# DONT_GENERATE_CLANG_TIDY_CONFIG to disable the autogenerated config
 #
 
 # Helper function to actually create the targets, not to be used outside this file
-function(create_clang_tidy_targets)
-  set(argOption "")
-  set(argSingle "TOP_LEVEL")
-  set(argMulti "ALL_COMMAND" "DIFF_COMMAND")
-
-  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
-
+function(create_clang_tidy_targets key fixes)
   add_custom_target(
-      clang-tidy-all-${PROJECT_NAME}
-      COMMAND ${x_ALL_COMMAND}
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-  )
+    clang-tidy-${key}
+    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/cmake/common/scripts/run-clang-tidy.py -clang-tidy-binary ${CLANG_TIDY} -p ${CMAKE_BINARY_DIR} -export-fixes=${CMAKE_SOURCE_DIR}/${fixes}
+            ${ARGN}
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
   add_custom_target(
-      clang-tidy-diff-${PROJECT_NAME}
-      COMMAND ${x_DIFF_COMMAND}
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-  )
+    clang-tidy-${key}-check
+    COMMAND test ! -f ${CMAKE_SOURCE_DIR}/${fixes}
+    DEPENDS clang-tidy-${key}
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+endfunction()
 
-  # Top level projects will create the targets clang-tidy-all and
-  # clang-tidy-diff with the same commands as the namespaced targets
-  # above. However, cmake doesn't support aliases for non-library targets
-  # so we have to create them fully.
-  if(x_TOP_LEVEL)
-    add_custom_target(
-        clang-tidy-all
-        COMMAND ${x_ALL_COMMAND}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    )
-    add_custom_target(
-        clang-tidy-diff
-        COMMAND ${x_DIFF_COMMAND}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    )
-    add_custom_target(clang-tidy-all-check
-        COMMAND test ! -f fixes.yaml
-        DEPENDS clang-tidy-all
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    )
-    add_custom_target(clang-tidy-diff-check
-        COMMAND test ! -f fixes.yaml
-        DEPENDS clang-tidy-diff
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    )
+function(swift_create_clang_tidy_targets)
+  if(NOT ${CMAKE_PROJECT_NAME} STREQUAL ${PROJECT_NAME})
+    return()
   endif()
-endfunction()
 
-# Scan a list of targets and build up a list of source files
-function(generate_file_list_from_targets)
-  set(argOption "")
+  set(argOption "DONT_GENERATE_CLANG_TIDY_CONFIG")
   set(argSingle "")
-  set(argMulti "TARGETS")
+  set(argMulti "")
 
   cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
-
-  foreach(target ${x_TARGETS})
-    if(NOT TARGET ${target})
-      message(FATAL_ERROR "Trying to enable clang-tidy for target ${target} which doesn't exist")
-    endif()
-
-    # Extract the list of source files from the target and convert to absolute paths
-    set(target_srcs "")
-    set(abs_target_srcs "")
-    get_target_property(target_srcs ${target} SOURCES)
-    foreach(file ${target_srcs})
-      if(${file} MATCHES ".*\\.h$")
-        list(REMOVE_ITEM target_srcs ${file})
-      endif()
-    endforeach()
-
-    list(REMOVE_DUPLICATES target_srcs)
-
-    get_target_property(target_dir ${target} SOURCE_DIR)
-    foreach(file ${target_srcs})
-      get_filename_component(abs_file ${file} ABSOLUTE BASE_DIR ${target_dir})
-      list(APPEND abs_target_srcs ${abs_file})
-    endforeach()
-
-    if(abs_target_srcs)
-      list(APPEND srcs ${abs_target_srcs})
-      set(srcs ${srcs} PARENT_SCOPE)
-    else()
-      message(WARNING "Target ${target} does not have any lintable sources")
-    endif()
-  endforeach()
-endfunction()
-
-macro(early_exit level msg)
-  message(${level} "${msg}")
-  if(x_REQUIRED)
-    message(FATAL_ERROR "clang-tidy support is REQUIRED for ${PROJECT_NAME}")
+  if(x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unparsed arguments to swift_create_clang_tidy_targets ${ARGN}")
   endif()
-  return()
-endmacro()
 
-# External function to create clang-tidy-* targets, Call according to the
-# documentation in the file header.
-function(swift_setup_clang_tidy)
-  set(argOption "REQUIRED")
-  set(argSingle "SCRIPT")
-  set(argMulti "CLANG_TIDY_NAMES" "TARGETS" "PATTERNS" "EXTRA_ARGS")
+  # This is required so that clang-tidy can work out what compiler options to use for each file
+  set(CMAKE_EXPORT_COMPILE_COMMANDS
+      ON
+      CACHE BOOL "Export compile commands" FORCE)
 
-  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
-
-  if(x_UNPARSED_ARGUMENTS)
-    message(FATAL_ERROR "Unparsed arguments ${x_UNPARSED_ARGUMENTS}")
-  endif()
+  find_program(CLANG_TIDY NAMES clang-tidy-6.0 clang-tidy)
 
-  # Global clang-tidy enable option, influences the default project specific enable option
-  option(ENABLE_CLANG_TIDY "Enable auto-linting of code using clang-tidy globally" ON)
-  if(NOT ENABLE_CLANG_TIDY)
-    early_exit(STATUS "auto-linting is disabled globally")
+  if("${CLANG_TIDY}" STREQUAL "CLANG_TIDY-NOTFOUND")
+    message(WARNING "Could not find clang-tidy, link targets will not be created")
+    return()
   endif()
 
-  if(${PROJECT_NAME} STREQUAL ${CMAKE_PROJECT_NAME})
-    set(top_level_project ON)
-  else()
-    set(top_level_project OFF)
+  if(NOT x_DONT_GENERATE_CLANG_TIDY_CONFIG)
+    # By default all clang-tidy are disabled. The following set of suites will be enabled in their entirety
+    set(enabled_categories
+        # bugprone could probably do with being turned on
+        # bugprone*
+        cert*
+        clang-analyzer*
+        cppcoreguidelines*
+        google*
+        misc*
+        modernize*
+        performance*
+        readability*)
+
+    # The set of specific tests which will be disabled. All checks in this list should have a reason for being disabled placed in a comment along side. Use wildcards with care, in
+    # general try to disabled the minimum set of checks required and provide a reason for doing so.
+    set(disabled_checks
+        # Don't need OSX checks
+        -clang-analyzer-osx*
+        -clang-analyzer-optin.osx.*
+        # Test suites aren't linted
+        -clang-analyzer-apiModeling.google.GTest
+        # Don't care about LLVM conventions
+        -clang-analyzer-llvm.Conventions
+        # Function size is not enforced through clang-tidy, sonar cloud has its own check
+        -readability-function-size
+        # No using MPI
+        -clang-analyzer-optin.mpi*
+        # No ObjC code anywhere
+        -google-objc*
+        # clang-format takes care of indentation
+        -readability-misleading-indentation
+        # Doesn't appear to be functional, even if it were appropriate
+        -readability-identifier-naming
+        # Caught by compiler, -Wunused-parameter
+        -misc-unused-parameters
+        # We have a external function blacklist which is much faster, don't need clang to do it
+        -clang-analyzer-security.insecureAPI*
+        # All the following checks were disabled when the CI project started. They are left like this to avoid having to make too many code changes. This should not be taken as an
+        # endorsement of anything.
+        -cert-dcl03-c
+        -cert-dcl21-cpp
+        -cert-err34-c
+        -cert-err58-cpp
+        -clang-analyzer-alpha*
+        -clang-analyzer-core.CallAndMessage
+        -clang-analyzer-core.UndefinedBinaryOperatorResult
+        -clang-analyzer-core.uninitialized.Assign
+        -clang-analyzer-core.uninitialized.UndefReturn
+        -clang-analyzer-optin.cplusplus.VirtualCall
+        -clang-analyzer-optin.performance.Padding
+        -cppcoreguidelines-owning-memory
+        -cppcoreguidelines-pro-bounds-array-to-pointer-decay
+        -cppcoreguidelines-pro-bounds-constant-array-index
+        -cppcoreguidelines-pro-bounds-pointer-arithmetic
+        -cppcoreguidelines-pro-type-member-init
+        -cppcoreguidelines-pro-type-static-cast-downcast
+        -cppcoreguidelines-pro-type-union-access
+        -cppcoreguidelines-pro-type-vararg
+        -cppcoreguidelines-special-member-functions
+        -google-runtime-references
+        -misc-static-assert
+        -modernize-deprecated-headers
+        -modernize-pass-by-value
+        -modernize-redundant-void-arg
+        -modernize-return-braced-init-list
+        -modernize-use-auto
+        -modernize-use-bool-literals
+        -modernize-use-default-member-init
+        -modernize-use-emplace
+        -modernize-use-equals-default
+        -modernize-use-equals-delete
+        -modernize-use-using
+        -performance-unnecessary-value-param
+        -readability-avoid-const-params-in-decls
+        -readability-non-const-parameter
+        -readability-redundant-declaration
+        -readability-redundant-member-init)
+
+    # Final list of checks to enable/disable
+    set(all_checks -* ${enabled_categories} ${disabled_checks})
+
+    # .clang-tidy needs a comma separated list of checks but cmake uses a semicolon as the list separator
+    string(REPLACE ";" "," comma_checks "${all_checks}")
+
+    # Generate .clang-tidy in project root dir
+    file(WRITE ${CMAKE_SOURCE_DIR}/.clang-tidy "\
+# Automatically generated, do not edit
+# Enabled checks are generated from SwiftClangTidy.cmake
+Checks: \"${comma_checks}\"
+HeaderFilterRegex: '.*'
+AnalyzeTemporaryDtors: true
+")
   endif()
 
-  # Create a cmake option to enable linting of this specific project
-  option(${PROJECT_NAME}_ENABLE_CLANG_TIDY "Enable auto-linting of code using clang-tidy for project ${PROJECT_NAME}" ${top_level_project})
+  # These two lists will ultimately contain the complete set of source files to pass to the clang-tidy-all and clang-tidy-world targets
+  unset(all_abs_srcs)
+  unset(world_abs_srcs)
 
-  if(NOT ${PROJECT_NAME}_ENABLE_CLANG_TIDY)
-    early_exit(STATUS "${PROJECT_NAME} clang-tidy support is DISABLED")
-  endif()
+  # Only lint targets created in this repository. Later on we will create 2 targets: clang-tidy-all will lint all "core" targets, executables and libraries clang-tidy-world will
+  # lint everything including test suites
+  swift_list_compilable_targets(all_targets ONLY_THIS_REPO SWIFT_TYPES "executable" "library")
+  swift_list_compilable_targets(world_targets ONLY_THIS_REPO)
 
-  # This is required so that clang-tidy can work out what compiler options to use
-  # for each file
-  set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Export compile commands" FORCE)
+  foreach(target IN LISTS world_targets)
+    # Build up a list of source files to pass to clang-tidy
+    get_target_property(target_srcs ${target} SOURCES)
+    get_target_property(target_dir ${target} SOURCE_DIR)
+    unset(abs_srcs)
+    foreach(file ${target_srcs})
+      get_filename_component(abs_file ${file} ABSOLUTE BASE_DIR ${target_dir})
+      list(APPEND abs_srcs ${abs_file})
+    endforeach()
 
-  # Use a custom script if explicitly passed
-  if(x_SCRIPT)
-    if(EXISTS ${x_SCRIPT})
-      message(STATUS "Initialising clang tidy targets for ${PROJECT_NAME} using existing script in ${x_SCRIPT}")
-      create_clang_tidy_targets(
-          TOP_LEVEL ${top_level_project}
-          ALL_COMMAND ${x_SCRIPT} all
-          DIFF_COMMAND ${x_SCRIPT} diff
-      )
-      return()
-    endif()
-    message(FATAL_ERROR "Specified clang-tidy script ${x_SCRIPT} doesn't exist")
-  endif()
+    create_clang_tidy_targets(${target} fixes-${target}.yaml ${abs_srcs})
 
-  # Search some default locations for a custom tidy script
-  set(custom_scripts "${CMAKE_CURRENT_SOURCE_DIR}/scripts/clang-tidy.sh" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/clang-tidy.bash")
+    # All targets are included in the world target
+    list(APPEND world_abs_srcs ${abs_srcs})
 
-  foreach(script ${custom_scripts})
-    if(EXISTS ${script})
-      message(STATUS "Initialising clang tidy target for ${PROJECT_NAME} using existing script in ${script}")
-      create_clang_tidy_targets(
-          TOP_LEVEL ${top_level_project}
-          ALL_COMMAND ${script} all
-          DIFF_COMMAND ${script} diff
-      )
-      return()
+    if(${target} IN_LIST all_targets)
+      # Only "core" executables and libraries are included in the all target
+      list(APPEND all_abs_srcs ${abs_srcs})
     endif()
   endforeach()
 
-  # Didn't find a custom script. Generate some default commands
-
-  # First search for an appropriate clang-tidy
-  if(NOT x_CLANG_TIDY_NAMES)
-    set(x_CLANG_TIDY_NAMES
-        clang-tidy60 clang-tidy-6.0
-        clang-tidy40 clang-tidy-4.0
-        clang-tidy39 clang-tidy-3.9
-        clang-tidy38 clang-tidy-3.8
-        clang-tidy37 clang-tidy-3.7
-        clang-tidy36 clang-tidy-3.6
-        clang-tidy35 clang-tidy-3.5
-        clang-tidy34 clang-tidy-3.4
-        clang-tidy
-    )
-  endif()
-  find_program(CLANG_TIDY NAMES ${x_CLANG_TIDY_NAMES})
-
-  if("${CLANG_TIDY}" STREQUAL "CLANG_TIDY-NOTFOUND")
-    early_exit(WARNING "Could not find appropriate clang-tidy, targets disabled")
-  endif()
-
-  message(STATUS "Using ${CLANG_TIDY}")
-  set(${PROJECT_NAME}_CLANG_TIDY ${CLANG_TIDY} CACHE STRING "Absolute path to clang-tidy for ${PROJECT_NAME}")
-
-  set(srcs "")
-  if(x_TARGETS)
-    # Extract a list of source files from each of the specified targets
-    generate_file_list_from_targets(TARGETS ${x_TARGETS})
-  elseif(x_PATTERNS)
-    # Just use the provided pattern as the file list
-    set(srcs ${x_PATTERNS})
+  if(NOT all_abs_srcs)
+    message(WARNING "No sources to lint for clang-tidy-all, that doesn't sound right")
   else()
-    message(FATAL_ERROR "ClangTidy modules must be set up to use either a custom script, a list of targets, or file patterns")
+    list(REMOVE_DUPLICATES all_abs_srcs)
+    create_clang_tidy_targets(all fixes.yaml ${all_abs_srcs})
+    create_clang_tidy_targets(diff fixes.yaml `git diff --diff-filter=ACMRTUXB --name-only master -- ${all_abs_srcs}`)
   endif()
 
-  if(NOT srcs)
-    early_exit(WARNING "Couldn't find any source/header files to tidy in ${PROJECT_NAME}")
+  if(NOT world_abs_srcs)
+    message(WARNING "No sources to lint for clang-tidy-world, that doesn't sound right")
   else()
-    create_clang_tidy_targets(
-        TOP_LEVEL ${top_level_project}
-        ALL_COMMAND
-        ${${PROJECT_NAME}_CLANG_TIDY} ${x_EXTRA_ARGS} -p ${CMAKE_BINARY_DIR} --export-fixes=${CMAKE_CURRENT_SOURCE_DIR}/fixes.yaml
-          `git ls-files ${srcs}`
-        DIFF_COMMAND
-        git diff --diff-filter=ACMRTUXB --quiet --name-only master -- ${srcs} ||
-        ${${PROJECT_NAME}_CLANG_TIDY} ${x_EXTRA_ARGS} -p ${CMAKE_BINARY_DIR} --export-fixes=${CMAKE_CURRENT_SOURCE_DIR}/fixes.yaml
-          `git diff --diff-filter=ACMRTUXB --name-only master -- ${srcs}`
-    )
+    list(REMOVE_DUPLICATES world_abs_srcs)
+    create_clang_tidy_targets(world fixes.yaml ${world_abs_srcs})
   endif()
 endfunction()
diff --git a/ListTargets.cmake b/ListTargets.cmake
new file mode 100644
index 0000000..17bf517
--- /dev/null
+++ b/ListTargets.cmake
@@ -0,0 +1,117 @@
+#
+# Copyright (C) 2021 Swift Navigation Inc. Contact: Swift Navigation <dev@swift-nav.com>
+#
+# This source is subject to the license found in the file 'LICENSE' which must be be distributed together with this source. All other rights reserved.
+#
+# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND/OR FITNESS FOR A PARTICULAR PURPOSE.
+#
+
+#
+# A helper module to enumerate all targets created in a source tree
+#
+# Calling swift_list_targets will populate the given variable with the list of targets which meet the given criteria. It will report all targets created in the current source dir
+# and all of its subdirectories
+#
+# Use the ONLY_THIS_REPO option to exclude targets which were created in submodules, returns a list of targets which were created in the caller's repository. This is fairly dumb
+# test which simply looks for 'third_party' anywhere in the path of the candidate target and excludes it
+#
+# Use the TYPES option to filter the returned list of targets based on the cmake target type (EXECUTABLE, DYNAMIC_LIBRARY and so on). Only targets which match one of the entries
+# in this list will be returned
+#
+# Use the SWIFT_TYPES option to filter the returned list of targets based on the Swift target type. This should be a list of target types which match one of the 'swift_add_*'
+# functions from SwiftTargets.cmake and TestTargets.cmake (ie, "executable", "library", "test", and so on)
+#
+# Example usage:
+#
+# Populate 'interfaces' with the set of interface library targets created within this repository
+#
+# swift_list_targets(interfaces ONLY_THIS_REPO TYPES "INTERFACE")
+#
+# Populate 'all_tests' with the set of tests defined anywhere within the source tree under the calling function's directory
+#
+# swift_list_targets(all_tests SWIFT_TYPE "test")
+#
+# A helper function swift_list_compilable_targets is provided which is equivalent to calling swift_list_targets with the option "TYPES EXECUTABLE DYNAMIC_LIBRARY STATIC_LIBRARY
+# OBJECT_LIBRARY", ie the set of all targets which can be compiled (not interface libraries). Other options can be passed in to this function (ONLY_THIS_REPO, SWIFT_TYPES) as for
+# swift_list_targets
+#
+
+cmake_minimum_required(VERSION 3.7)
+
+function(get_all_targets result dir)
+  get_property(
+    subdirs
+    DIRECTORY "${dir}"
+    PROPERTY SUBDIRECTORIES)
+  foreach(subdir IN LISTS subdirs)
+    get_all_targets(${result} "${subdir}")
+  endforeach()
+
+  get_directory_property(sub_targets DIRECTORY "${dir}" BUILDSYSTEM_TARGETS)
+  set(${result}
+      ${${result}} ${sub_targets}
+      PARENT_SCOPE)
+endfunction()
+
+function(swift_list_targets out_var)
+  set(argOption "ONLY_THIS_REPO")
+  set(argSingle "")
+  set(argMulti "TYPES" "SWIFT_TYPES")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+  if(x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unparsed arguments to swift_list_targets ${x_UNPARSED_ARGUMENTS}")
+  endif()
+
+  set(x_all_targets)
+  get_all_targets(x_all_targets ${CMAKE_CURRENT_SOURCE_DIR})
+
+  set(all_targets)
+
+  foreach(target IN LISTS x_all_targets)
+    if(x_TYPES)
+      get_target_property(type ${target} TYPE)
+      if(NOT ${type} IN_LIST x_TYPES)
+        continue()
+      endif()
+    endif()
+
+    if(x_SWIFT_TYPES)
+      get_target_property(type ${target} SWIFT_TYPE)
+      if(NOT ${type} IN_LIST x_SWIFT_TYPES)
+        continue()
+      endif()
+    endif()
+
+    if(x_ONLY_THIS_REPO)
+      get_target_property(target_dir ${target} SOURCE_DIR)
+      # This replacement makes sure that we only filter out third_party subdirectories which actually exist in the root project source dir - ie, a git repo cloned in to a path
+      # which just so happens to contain third_party should not break this function
+      string(REPLACE ${CMAKE_SOURCE_DIR} "" target_dir ${target_dir})
+      if(${target_dir} MATCHES ".*third_party.*")
+        continue()
+      endif()
+    endif()
+
+    set(all_targets ${all_targets} ${target})
+  endforeach()
+
+  set(${out_var}
+      ${all_targets}
+      PARENT_SCOPE)
+endfunction()
+
+function(swift_list_compilable_targets out_var)
+  swift_list_targets(
+    ${out_var}
+    TYPES
+    "EXECUTABLE"
+    "DYNAMIC_LIBRARY"
+    "STATIC_LIBRARY"
+    "OBJECT_LIBRARY"
+    ${ARGN})
+  set(${out_var}
+      ${${out_var}}
+      PARENT_SCOPE)
+endfunction()
diff --git a/OldClangTidy.cmake b/OldClangTidy.cmake
new file mode 100644
index 0000000..40fdba1
--- /dev/null
+++ b/OldClangTidy.cmake
@@ -0,0 +1,308 @@
+#
+# Copyright (C) 2021 Swift Navigation Inc.
+# Contact: Swift Navigation <dev@swift-nav.com>
+#
+# This source is subject to the license found in the file 'LICENSE' which must
+# be be distributed together with this source. All other rights reserved.
+#
+# THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
+# EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
+#
+
+#
+# A module to create custom targets to lint source files using clang-tidy
+#
+# The function swift_setup_clang_tidy will create several targets which will
+# use clang-tidy to lint source files. 2 types of targets will be created, one
+# for linting all listed source files and the other for linting only those which
+# differ from the master branch. The list of file to lint can be created in 2
+# ways which are explained below.
+#
+# The created targets have the names
+#
+# - clang-tidy-all-${PROJECT_NAME} - lints all files
+# - clang-tidy-diff-${PROJECT_NAME} - lints only changed files
+#
+# In addition if the current project is at the top level of the working tree 2 more
+# targets will be created
+#
+# - clang-tidy-all
+# - clang-tidy-diff
+#
+# which behave in exactly the same way as the namespaced targets.
+#
+# The parameter SCRIPT can be passed to specify a custom linting script. If given
+# the create targets will call this script directly. The script will be passed
+# a single argument of 'all' or 'diff' according to the target
+#
+# clang-tidy-all - will run `<script> all`
+# clang-tidy-diff - will run `<script> diff`
+#
+# If a script is not explicitly passed this function will first search for a
+# custom linting script. The script must exist in ${CMAKE_CURRENT_SOURCE_DIR}/scripts
+# and be named either clang-tidy.sh or clang-tidy.bash. It will be called with
+# the same arguments as described above.
+#
+# If no custom script is available this function will generate some default linting
+# commands. clang-tidy will be called and passed a list of files to lint.
+#
+# The file list can be constructed in one of two ways, either by GLOB patterns or
+# a list of targets
+#
+# GLOB
+#   Pass the parameter 'PATTERNS' with 1 or more GLOB patterns as arguments. These
+#   patterns will be passed to git directly which will generate a list of files to
+#   lint.
+#
+#   swift_setup_clang_tidy(PATTERNS 'src/*.c' 'src/*.cc' 'src/*.cpp')
+#
+# TARGETS
+#   Pass the parameter 'TARGETS" with 1 or more cmake targets as arguments. These
+#   target must already have been created. The list of source files will be extracted
+#   from these targets and passed first to git so it can correctly filter them, then
+#   to clang-tidy.
+#
+# This function must be called with one of the above options, or it must be able to
+# find a custom script in the file system otherwise it will throw an error.
+#
+# The option EXTRA_ARGS may be used to pass command line options directly to the
+# clang-tidy command. This can be useful or even required when a compiler other
+# than clang is used to configure the project. clang-tidy will use the compile_commands.json
+# database to work out how to analyse files, but some GNU options are not understood.
+#
+# swift_setup_clang_tidy(EXTRA_ARGS '-extra-arg=-Wno-unknown-warning-option')
+#
+# will disable a clang-tidy error when it encounters a compiler warning switch it
+# doesn't support, such as -Wno-psabi (GNU does understand this one)
+#
+# All commands are run from ${CMAKE_CURRENT_SOURCE_DIR}. It is highly recommended
+# that this module only be included from the top level CMakeLists.txt of a project,
+# using it from a subdirectory may not work as expected.
+#
+# In addition this function sets up a cmake option which can be used to control
+# whether the targets are created either on the command line or by a super project.
+# The option has the name
+#
+# ${PROJECT_NAME}_ENABLE_CLANG_TIDY
+#
+# The default value is ON for top level projects, and OFF for any others.
+#
+# Running
+#
+# cmake -D<project>_ENABLE_CLANG_TIDY=OFF ..
+#
+# will explicitly disable these targets from the command line at configure time
+#
+
+# Helper function to actually create the targets, not to be used outside this file
+function(create_clang_tidy_targets)
+  set(argOption "")
+  set(argSingle "TOP_LEVEL")
+  set(argMulti "ALL_COMMAND" "DIFF_COMMAND")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+
+  add_custom_target(
+      clang-tidy-all-${PROJECT_NAME}
+      COMMAND ${x_ALL_COMMAND}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  )
+  add_custom_target(
+      clang-tidy-diff-${PROJECT_NAME}
+      COMMAND ${x_DIFF_COMMAND}
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+  )
+
+  # Top level projects will create the targets clang-tidy-all and
+  # clang-tidy-diff with the same commands as the namespaced targets
+  # above. However, cmake doesn't support aliases for non-library targets
+  # so we have to create them fully.
+  if(x_TOP_LEVEL)
+    add_custom_target(
+        clang-tidy-all
+        COMMAND ${x_ALL_COMMAND}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+    add_custom_target(
+        clang-tidy-diff
+        COMMAND ${x_DIFF_COMMAND}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+    add_custom_target(clang-tidy-all-check
+        COMMAND test ! -f fixes.yaml
+        DEPENDS clang-tidy-all
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+    add_custom_target(clang-tidy-diff-check
+        COMMAND test ! -f fixes.yaml
+        DEPENDS clang-tidy-diff
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+  endif()
+endfunction()
+
+# Scan a list of targets and build up a list of source files
+function(generate_file_list_from_targets)
+  set(argOption "")
+  set(argSingle "")
+  set(argMulti "TARGETS")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+
+  foreach(target ${x_TARGETS})
+    if(NOT TARGET ${target})
+      message(FATAL_ERROR "Trying to enable clang-tidy for target ${target} which doesn't exist")
+    endif()
+
+    # Extract the list of source files from the target and convert to absolute paths
+    set(target_srcs "")
+    set(abs_target_srcs "")
+    get_target_property(target_srcs ${target} SOURCES)
+    foreach(file ${target_srcs})
+      if(${file} MATCHES ".*\\.h$")
+        list(REMOVE_ITEM target_srcs ${file})
+      endif()
+    endforeach()
+
+    list(REMOVE_DUPLICATES target_srcs)
+
+    get_target_property(target_dir ${target} SOURCE_DIR)
+    foreach(file ${target_srcs})
+      get_filename_component(abs_file ${file} ABSOLUTE BASE_DIR ${target_dir})
+      list(APPEND abs_target_srcs ${abs_file})
+    endforeach()
+
+    if(abs_target_srcs)
+      list(APPEND srcs ${abs_target_srcs})
+      set(srcs ${srcs} PARENT_SCOPE)
+    else()
+      message(WARNING "Target ${target} does not have any lintable sources")
+    endif()
+  endforeach()
+endfunction()
+
+macro(early_exit level msg)
+  message(${level} "${msg}")
+  if(x_REQUIRED)
+    message(FATAL_ERROR "clang-tidy support is REQUIRED for ${PROJECT_NAME}")
+  endif()
+  return()
+endmacro()
+
+# External function to create clang-tidy-* targets, Call according to the
+# documentation in the file header.
+function(swift_setup_clang_tidy)
+  set(argOption "REQUIRED")
+  set(argSingle "SCRIPT")
+  set(argMulti "CLANG_TIDY_NAMES" "TARGETS" "PATTERNS" "EXTRA_ARGS")
+
+  cmake_parse_arguments(x "${argOption}" "${argSingle}" "${argMulti}" ${ARGN})
+
+  if(x_UNPARSED_ARGUMENTS)
+    message(FATAL_ERROR "Unparsed arguments ${x_UNPARSED_ARGUMENTS}")
+  endif()
+
+  # Global clang-tidy enable option, influences the default project specific enable option
+  option(ENABLE_CLANG_TIDY "Enable auto-linting of code using clang-tidy globally" ON)
+  if(NOT ENABLE_CLANG_TIDY)
+    early_exit(STATUS "auto-linting is disabled globally")
+  endif()
+
+  if(${PROJECT_NAME} STREQUAL ${CMAKE_PROJECT_NAME})
+    set(top_level_project ON)
+  else()
+    set(top_level_project OFF)
+  endif()
+
+  # Create a cmake option to enable linting of this specific project
+  option(${PROJECT_NAME}_ENABLE_CLANG_TIDY "Enable auto-linting of code using clang-tidy for project ${PROJECT_NAME}" ${top_level_project})
+
+  if(NOT ${PROJECT_NAME}_ENABLE_CLANG_TIDY)
+    early_exit(STATUS "${PROJECT_NAME} clang-tidy support is DISABLED")
+  endif()
+
+  # This is required so that clang-tidy can work out what compiler options to use
+  # for each file
+  set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Export compile commands" FORCE)
+
+  # Use a custom script if explicitly passed
+  if(x_SCRIPT)
+    if(EXISTS ${x_SCRIPT})
+      message(STATUS "Initialising clang tidy targets for ${PROJECT_NAME} using existing script in ${x_SCRIPT}")
+      create_clang_tidy_targets(
+          TOP_LEVEL ${top_level_project}
+          ALL_COMMAND ${x_SCRIPT} all
+          DIFF_COMMAND ${x_SCRIPT} diff
+      )
+      return()
+    endif()
+    message(FATAL_ERROR "Specified clang-tidy script ${x_SCRIPT} doesn't exist")
+  endif()
+
+  # Search some default locations for a custom tidy script
+  set(custom_scripts "${CMAKE_CURRENT_SOURCE_DIR}/scripts/clang-tidy.sh" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/clang-tidy.bash")
+
+  foreach(script ${custom_scripts})
+    if(EXISTS ${script})
+      message(STATUS "Initialising clang tidy target for ${PROJECT_NAME} using existing script in ${script}")
+      create_clang_tidy_targets(
+          TOP_LEVEL ${top_level_project}
+          ALL_COMMAND ${script} all
+          DIFF_COMMAND ${script} diff
+      )
+      return()
+    endif()
+  endforeach()
+
+  # Didn't find a custom script. Generate some default commands
+
+  # First search for an appropriate clang-tidy
+  if(NOT x_CLANG_TIDY_NAMES)
+    set(x_CLANG_TIDY_NAMES
+        clang-tidy60 clang-tidy-6.0
+        clang-tidy40 clang-tidy-4.0
+        clang-tidy39 clang-tidy-3.9
+        clang-tidy38 clang-tidy-3.8
+        clang-tidy37 clang-tidy-3.7
+        clang-tidy36 clang-tidy-3.6
+        clang-tidy35 clang-tidy-3.5
+        clang-tidy34 clang-tidy-3.4
+        clang-tidy
+    )
+  endif()
+  find_program(CLANG_TIDY NAMES ${x_CLANG_TIDY_NAMES})
+
+  if("${CLANG_TIDY}" STREQUAL "CLANG_TIDY-NOTFOUND")
+    early_exit(WARNING "Could not find appropriate clang-tidy, targets disabled")
+  endif()
+
+  message(STATUS "Using ${CLANG_TIDY}")
+  set(${PROJECT_NAME}_CLANG_TIDY ${CLANG_TIDY} CACHE STRING "Absolute path to clang-tidy for ${PROJECT_NAME}")
+
+  set(srcs "")
+  if(x_TARGETS)
+    # Extract a list of source files from each of the specified targets
+    generate_file_list_from_targets(TARGETS ${x_TARGETS})
+  elseif(x_PATTERNS)
+    # Just use the provided pattern as the file list
+    set(srcs ${x_PATTERNS})
+  else()
+    message(FATAL_ERROR "ClangTidy modules must be set up to use either a custom script, a list of targets, or file patterns")
+  endif()
+
+  if(NOT srcs)
+    early_exit(WARNING "Couldn't find any source/header files to tidy in ${PROJECT_NAME}")
+  else()
+    create_clang_tidy_targets(
+        TOP_LEVEL ${top_level_project}
+        ALL_COMMAND
+        ${${PROJECT_NAME}_CLANG_TIDY} ${x_EXTRA_ARGS} -p ${CMAKE_BINARY_DIR} --export-fixes=${CMAKE_CURRENT_SOURCE_DIR}/fixes.yaml
+          `git ls-files ${srcs}`
+        DIFF_COMMAND
+        git diff --diff-filter=ACMRTUXB --quiet --name-only master -- ${srcs} ||
+        ${${PROJECT_NAME}_CLANG_TIDY} ${x_EXTRA_ARGS} -p ${CMAKE_BINARY_DIR} --export-fixes=${CMAKE_CURRENT_SOURCE_DIR}/fixes.yaml
+          `git diff --diff-filter=ACMRTUXB --name-only master -- ${srcs}`
+    )
+  endif()
+endfunction()
diff --git a/SwiftTargets.cmake b/SwiftTargets.cmake
index b6f7082..f6c325d 100644
--- a/SwiftTargets.cmake
+++ b/SwiftTargets.cmake
@@ -136,14 +136,26 @@
 #  that are enabled by "swift_set_compile_options" (see "CompileOptions.cmake"
 #  for details).
 #
+# At the end of the top level CMakeLists.txt for a repository call
+# swift_validate_targets. The function performs validation on all defined targets
+# to make sure they have been defined according to Swift policies. Currently
+# this only checks to make sure that all compilable targets were created with a
+# swift_add_* function (instead of built in add_* functions).
+#
 
 include(CodeCoverage)
 include(CompileOptions)
 include(LanguageStandards)
 include(TestTargets)
+include(ListTargets)
 
 cmake_policy(SET CMP0007 NEW)  # new behaviour list command no longer ignores empty elements
 
+define_property(TARGET
+  PROPERTY SWIFT_TYPE
+  BRIEF_DOCS "Swift target type"
+  FULL_DOCS "For use by other modules in this repository which need to know the classification of target. One of executable, library, tool, tool_library, test, test_library")
+
 macro(swift_collate_arguments prefix name)
   set(exclusion_list ${ARGN})
   set(${name}_args "")
@@ -277,6 +289,7 @@ function(swift_add_target target type)
   endif()
 
   if (NOT x_INTERFACE)
+    set_target_properties(${target} PROPERTIES SWIFT_TYPE ${type})
     swift_set_compile_options(${target} ${compile_options_args} EXTRA_FLAGS ${extra_flags})
     swift_set_language_standards(${target} ${language_standards_args})
     target_code_coverage(${target} NO_RUN)
@@ -302,3 +315,14 @@ endfunction()
 function(swift_add_test_library target)
   swift_add_target("${target}" test_library ${ARGN})
 endfunction()
+
+function(swift_validate_targets)
+  swift_list_compilable_targets(all_targets ONLY_THIS_REPO SWIFT_TYPES "executable" "library")
+
+  foreach(target ${all_targets})
+    get_target_property(swift_type ${target} SWIFT_TYPE)
+    if(NOT swift_type)
+      message(FATAL_ERROR "Can't identify type of target ${target}, was it added with the correct Swift function (swift_add_*)?")
+    endif()
+  endforeach()
+endfunction()
diff --git a/TestTargets.cmake b/TestTargets.cmake
index 64b11a4..1821268 100644
--- a/TestTargets.cmake
+++ b/TestTargets.cmake
@@ -268,6 +268,7 @@ function(swift_add_test target)
   endif()
 
   add_executable(${target} EXCLUDE_FROM_ALL ${x_SRCS})
+  set_target_properties(${target} PROPERTIES SWIFT_TYPE "test")
   swift_set_language_standards(${target} C_EXTENSIONS_ON)
   if(x_INCLUDE)
     target_include_directories(${target} PRIVATE ${x_INCLUDE})
diff --git a/scripts/run-clang-tidy.py b/scripts/run-clang-tidy.py
new file mode 100755
index 0000000..37f3850
--- /dev/null
+++ b/scripts/run-clang-tidy.py
@@ -0,0 +1,344 @@
+#!/usr/bin/env python
+#
+#===- run-clang-tidy.py - Parallel clang-tidy runner --------*- python -*--===#
+#
+# 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
+#
+#===-----------------------------------------------------------------------===#
+# FIXME: Integrate with clang-tidy-diff.py
+
+
+"""
+Parallel clang-tidy runner
+==========================
+
+Runs clang-tidy over all files in a compilation database. Requires clang-tidy
+and clang-apply-replacements in $PATH.
+
+Example invocations.
+- Run clang-tidy on all files in the current working directory with a default
+ set of checks and show warnings in the cpp files and all project headers.
+   run-clang-tidy.py $PWD
+
+- Fix all header guards.
+   run-clang-tidy.py -fix -checks=-*,llvm-header-guard
+
+- Fix all header guards included from clang-tidy and header guards
+ for clang-tidy headers.
+   run-clang-tidy.py -fix -checks=-*,llvm-header-guard extra/clang-tidy \
+                     -header-filter=extra/clang-tidy
+
+Compilation database setup:
+http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
+"""
+
+from __future__ import print_function
+
+import argparse
+import glob
+import json
+import multiprocessing
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+import traceback
+
+try:
+ import yaml
+except ImportError:
+ yaml = None
+
+is_py2 = sys.version[0] == '2'
+
+if is_py2:
+   import Queue as queue
+else:
+   import queue as queue
+
+
+def find_compilation_database(path):
+ """Adjusts the directory until a compilation database is found."""
+ result = './'
+ while not os.path.isfile(os.path.join(result, path)):
+   if os.path.realpath(result) == '/':
+     print('Error: could not find compilation database.')
+     sys.exit(1)
+   result += '../'
+ return os.path.realpath(result)
+
+
+def make_absolute(f, directory):
+ if os.path.isabs(f):
+   return f
+ return os.path.normpath(os.path.join(directory, f))
+
+
+def get_tidy_invocation(f, clang_tidy_binary, checks, tmpdir, build_path,
+                       header_filter, allow_enabling_alpha_checkers,
+                       extra_arg, extra_arg_before, quiet, config,
+                       line_filter):
+ """Gets a command line for clang-tidy."""
+ start = [clang_tidy_binary]
+ if allow_enabling_alpha_checkers:
+   start.append('-allow-enabling-analyzer-alpha-checkers')
+ if header_filter is not None:
+   start.append('-header-filter=' + header_filter)
+ if line_filter is not None:
+   start.append('-line-filter=' + line_filter)
+ if checks:
+   start.append('-checks=' + checks)
+ if tmpdir is not None:
+   start.append('-export-fixes')
+   # Get a temporary file. We immediately close the handle so clang-tidy can
+   # overwrite it.
+   (handle, name) = tempfile.mkstemp(suffix='.yaml', dir=tmpdir)
+   os.close(handle)
+   start.append(name)
+ for arg in extra_arg:
+     start.append('-extra-arg=%s' % arg)
+ for arg in extra_arg_before:
+     start.append('-extra-arg-before=%s' % arg)
+ start.append('-p=' + build_path)
+ if quiet:
+     start.append('-quiet')
+ if config:
+     start.append('-config=' + config)
+ start.append(f)
+ return start
+
+
+def merge_replacement_files(tmpdir, mergefile):
+ """Merge all replacement files in a directory into a single file"""
+ # The fixes suggested by clang-tidy >= 4.0.0 are given under
+ # the top level key 'Diagnostics' in the output yaml files
+ mergekey = "Diagnostics"
+ merged=[]
+ for replacefile in glob.iglob(os.path.join(tmpdir, '*.yaml')):
+   content = yaml.safe_load(open(replacefile, 'r'))
+   if not content:
+     continue # Skip empty files.
+   merged.extend(content.get(mergekey, []))
+
+ if merged:
+   # MainSourceFile: The key is required by the definition inside
+   # include/clang/Tooling/ReplacementsYaml.h, but the value
+   # is actually never used inside clang-apply-replacements,
+   # so we set it to '' here.
+   output = {'MainSourceFile': '', mergekey: merged}
+   with open(mergefile, 'w') as out:
+     yaml.safe_dump(output, out)
+
+
+def check_clang_apply_replacements_binary(args):
+ """Checks if invoking supplied clang-apply-replacements binary works."""
+ try:
+   subprocess.check_call([args.clang_apply_replacements_binary, '--version'])
+ except:
+   print('Unable to run clang-apply-replacements. Is clang-apply-replacements '
+         'binary correctly specified?', file=sys.stderr)
+   traceback.print_exc()
+   sys.exit(1)
+
+
+def apply_fixes(args, tmpdir):
+ """Calls clang-apply-fixes on a given directory."""
+ invocation = [args.clang_apply_replacements_binary]
+ if args.format:
+   invocation.append('-format')
+ if args.style:
+   invocation.append('-style=' + args.style)
+ invocation.append(tmpdir)
+ subprocess.call(invocation)
+
+
+def run_tidy(args, tmpdir, build_path, queue, lock, failed_files):
+ """Takes filenames out of queue and runs clang-tidy on them."""
+ while True:
+   name = queue.get()
+   invocation = get_tidy_invocation(name, args.clang_tidy_binary, args.checks,
+                                    tmpdir, build_path, args.header_filter,
+                                    args.allow_enabling_alpha_checkers,
+                                    args.extra_arg, args.extra_arg_before,
+                                    args.quiet, args.config, args.line_filter)
+
+   proc = subprocess.Popen(invocation, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+   output, err = proc.communicate()
+   if proc.returncode != 0:
+     if proc.returncode < 0:
+       msg = "%s: terminated by signal %d\n" % (name, -proc.returncode)
+       err += msg.encode('utf-8')
+     failed_files.append(name)
+   with lock:
+     sys.stdout.write(' '.join(invocation) + '\n' + output.decode('utf-8'))
+     if len(err) > 0:
+       sys.stdout.flush()
+       sys.stderr.write(err.decode('utf-8'))
+   queue.task_done()
+
+
+def main():
+ parser = argparse.ArgumentParser(description='Runs clang-tidy over all files '
+                                  'in a compilation database. Requires '
+                                  'clang-tidy and clang-apply-replacements in '
+                                  '$PATH.')
+ parser.add_argument('-allow-enabling-alpha-checkers',
+                     action='store_true', help='allow alpha checkers from '
+                                               'clang-analyzer.')
+ parser.add_argument('-clang-tidy-binary', metavar='PATH',
+                     default='clang-tidy',
+                     help='path to clang-tidy binary')
+ parser.add_argument('-clang-apply-replacements-binary', metavar='PATH',
+                     default='clang-apply-replacements',
+                     help='path to clang-apply-replacements binary')
+ parser.add_argument('-checks', default=None,
+                     help='checks filter, when not specified, use clang-tidy '
+                     'default')
+ parser.add_argument('-config', default=None,
+                     help='Specifies a configuration in YAML/JSON format: '
+                     '  -config="{Checks: \'*\', '
+                     '                       CheckOptions: [{key: x, '
+                     '                                       value: y}]}" '
+                     'When the value is empty, clang-tidy will '
+                     'attempt to find a file named .clang-tidy for '
+                     'each source file in its parent directories.')
+ parser.add_argument('-header-filter', default=None,
+                     help='regular expression matching the names of the '
+                     'headers to output diagnostics from. Diagnostics from '
+                     'the main file of each translation unit are always '
+                     'displayed.')
+ parser.add_argument('-line-filter', default=None,
+                     help='List of files with line ranges to filter the'
+                     'warnings.')
+ if yaml:
+   parser.add_argument('-export-fixes', metavar='filename', dest='export_fixes',
+                       help='Create a yaml file to store suggested fixes in, '
+                       'which can be applied with clang-apply-replacements.')
+ parser.add_argument('-j', type=int, default=0,
+                     help='number of tidy instances to be run in parallel.')
+ parser.add_argument('files', nargs='*', default=['.*'],
+                     help='files to be processed (regex on path)')
+ parser.add_argument('-fix', action='store_true', help='apply fix-its')
+ parser.add_argument('-format', action='store_true', help='Reformat code '
+                     'after applying fixes')
+ parser.add_argument('-style', default='file', help='The style of reformat '
+                     'code after applying fixes')
+ parser.add_argument('-p', dest='build_path',
+                     help='Path used to read a compile command database.')
+ parser.add_argument('-extra-arg', dest='extra_arg',
+                     action='append', default=[],
+                     help='Additional argument to append to the compiler '
+                     'command line.')
+ parser.add_argument('-extra-arg-before', dest='extra_arg_before',
+                     action='append', default=[],
+                     help='Additional argument to prepend to the compiler '
+                     'command line.')
+ parser.add_argument('-quiet', action='store_true',
+                     help='Run clang-tidy in quiet mode')
+ args = parser.parse_args()
+
+ db_path = 'compile_commands.json'
+
+ if args.build_path is not None:
+   build_path = args.build_path
+ else:
+   # Find our database
+   build_path = find_compilation_database(db_path)
+
+ try:
+   invocation = [args.clang_tidy_binary, '-list-checks']
+   if args.allow_enabling_alpha_checkers:
+     invocation.append('-allow-enabling-analyzer-alpha-checkers')
+   invocation.append('-p=' + build_path)
+   if args.checks:
+     invocation.append('-checks=' + args.checks)
+   invocation.append('-')
+   if args.quiet:
+     # Even with -quiet we still want to check if we can call clang-tidy.
+     with open(os.devnull, 'w') as dev_null:
+       subprocess.check_call(invocation, stdout=dev_null)
+   else:
+     subprocess.check_call(invocation)
+ except:
+   print("Unable to run clang-tidy.", file=sys.stderr)
+   sys.exit(1)
+
+ # Load the database and extract all files.
+ database = json.load(open(os.path.join(build_path, db_path)))
+ files = [make_absolute(entry['file'], entry['directory'])
+          for entry in database]
+
+ max_task = args.j
+ if max_task == 0:
+   max_task = multiprocessing.cpu_count()
+
+ tmpdir = None
+ if args.fix or (yaml and args.export_fixes):
+   check_clang_apply_replacements_binary(args)
+   tmpdir = tempfile.mkdtemp()
+
+ # Build up a big regexy filter from all command line arguments.
+ sanitised_files = re.sub('\\+', '\\+', '|'.join(args.files))
+ file_name_re = re.compile(sanitised_files)
+
+ return_code = 0
+ try:
+   # Spin up a bunch of tidy-launching threads.
+   task_queue = queue.Queue(max_task)
+   # List of files with a non-zero return code.
+   failed_files = []
+   lock = threading.Lock()
+   for _ in range(max_task):
+     t = threading.Thread(target=run_tidy,
+                          args=(args, tmpdir, build_path, task_queue, lock, failed_files))
+     t.daemon = True
+     t.start()
+
+   # Fill the queue with files.
+   for name in files:
+     if file_name_re.search(name):
+       task_queue.put(name)
+
+   # Wait for all threads to be done.
+   task_queue.join()
+   if len(failed_files):
+     return_code = 1
+
+ except KeyboardInterrupt:
+   # This is a sad hack. Unfortunately subprocess goes
+   # bonkers with ctrl-c and we start forking merrily.
+   print('\nCtrl-C detected, goodbye.')
+   if tmpdir:
+     shutil.rmtree(tmpdir)
+   os.kill(0, 9)
+
+ if yaml and args.export_fixes:
+   print('Writing fixes to ' + args.export_fixes + ' ...')
+   try:
+     merge_replacement_files(tmpdir, args.export_fixes)
+   except:
+     print('Error exporting fixes.\n', file=sys.stderr)
+     traceback.print_exc()
+     return_code=1
+
+ if args.fix:
+   print('Applying fixes ...')
+   try:
+     apply_fixes(args, tmpdir)
+   except:
+     print('Error applying fixes.\n', file=sys.stderr)
+     traceback.print_exc()
+     return_code = 1
+
+ if tmpdir:
+   shutil.rmtree(tmpdir)
+ sys.exit(return_code)
+
+
+if __name__ == '__main__':
+ main()