missing-namespace-std check for clang-tidy

[jbcoe]

Summary

Sanity check would be good along with suggestions for how to proceed.

missing-namespace-std works but only in very limited scope:

It can't handle references.
It can't handle pointers.
It can't handle nested template types like MyTemplateClass<std::string>.

I'd be grateful for input on how to do any of these. I presume there's a standard way to get the referenced type or ultimate pointee (so that std::string**** works). There's no need for the check to dig into typedefs as it's only the written type that it's concerned with. My best efforts resulted in odd hangs when parsing the <vector> header.

[klimek]

Why is this not something we want to directly match the TypeLocs via loc(type(..)).bind(...)? That would also help with the nested type problems (std::vector****)

[jbcoe]

Can you elaborate?

I've not written checks before and this was the first thing I could get to work (for a ver limited definition of 'work'), if there's a neater or smarter way to do it I'd be keen to learn.

[klimek]

clang-tidy/misc/MissingNamespaceStdCheck.cpp

21

I imagine you'll want to replace this matcher with something like:
loc(qualType(hasDeclaration(decl(hasAncestor(decl(namespaceDecl(hasName("std")))))), unless(elaboratedType(hasQualifier(anyOf(specifiesNamespace(hasName("std")), hasPrefix(specifiesNamespace(hasName("std")))))))))
(you can pull out duplicate submatchers with auto matcher = ... and reuse it)
The problem is that we don't have hasParent for typeLoc matches, so for
std::X
this will still match "X" (the inner typeloc).
For that you'll need to make sure to have a matcher like:
loc(elaboratedType(namesType(type().bind("root"))))
store the bound types as "visited",
and then make sure when you hit the callback for the first matcher that the type was not visited via an outer elaboratedType already.

[jbcoe]

This work is stalled but not abandoned. I plan to resume work mid-August.

[jbcoe]

This work needs such extensive revision that I'll submit a new version when I start work on it again.

clang-tidy/misc/CMakeLists.txt

   InaccurateEraseCheck.cpp
   InefficientAlgorithmCheck.cpp
   MiscTidyModule.cpp
+  MissingNamespaceStdCheck.cpp
   SwappedArgumentsCheck.cpp
   UndelegatedConstructor.cpp
   UnusedRAII.cpp

clang-tidy/misc/MiscTidyModule.cpp

 #include "ArgumentCommentCheck.h"
 #include "AssignOperatorSignatureCheck.h"
 #include "BoolPointerImplicitConversion.h"
+#include "MissingNamespaceStdCheck.h"
 #include "InaccurateEraseCheck.h"
 #include "InefficientAlgorithmCheck.h"
 #include "SwappedArgumentsCheck.h"

         "misc-uniqueptr-reset-release");
     CheckFactories.registerCheck<UnusedRAIICheck>("misc-unused-raii");
     CheckFactories.registerCheck<UseOverride>("misc-use-override");
+    CheckFactories.registerCheck<MissingNamespaceStdCheck>("misc-missing-namespace-std");
   }
 };
 

clang-tidy/misc/MissingNamespaceStdCheck.h

+//===--- MissingNamespaceStdCheck.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_MISC_ADD_NAMESPACE_STD_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ADD_NAMESPACE_STD_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+
+class MissingNamespaceStdCheck : public ClangTidyCheck {
+public:
+  MissingNamespaceStdCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ADD_NAMESPACE_STD_H
+

clang-tidy/misc/MissingNamespaceStdCheck.cpp

+//===--- MissingNamespaceStdCheck.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 "MissingNamespaceStdCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+
+void MissingNamespaceStdCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(decl(anyOf(fieldDecl(),varDecl())).bind("field_or_variable"), this);
+}
+
+StringRef getTypeNameSource(const DeclaratorDecl& decl, const SourceManager& SM, const ASTContext& Context)
+{
+  UnqualTypeLoc UnqualifiedTypeLocation = decl.getTypeSourceInfo()->getTypeLoc().getUnqualifiedLoc();
+  SourceRange TokRange(UnqualifiedTypeLocation.getLocStart(), UnqualifiedTypeLocation.getLocEnd());
+  return Lexer::getSourceText(CharSourceRange::getTokenRange(TokRange), SM, Context.getLangOpts());
+}
+
+void MissingNamespaceStdCheck::check(const MatchFinder::MatchResult &Result) {
+                                                           
+  const DeclaratorDecl *MatchedDecl = Result.Nodes.getNodeAs<DeclaratorDecl>("field_or_variable");
+
+  auto MatchedType = MatchedDecl->getType().getTypePtr();
+  if (!MatchedType->isStructureOrClassType())
+    return;
+
+  const RecordType* recordType = static_cast<const RecordType *>(MatchedType);
+  const RecordDecl* recordDecl = recordType->getAsCXXRecordDecl();
+  const DeclContext* recordContext = recordDecl->getDeclContext();
+  if (!recordContext->isStdNamespace())
+    return;
+
+  // Check to see that type actually is missing namespace std
+  StringRef typeNameSource = getTypeNameSource(*MatchedDecl, *Result.SourceManager, *Result.Context);
+  if (typeNameSource.startswith("::std") || typeNameSource.startswith("std"))
+    return;
+
+  auto FieldTypeName = MatchedDecl->getType().getUnqualifiedType().getAsString();
+  diag(MatchedDecl->getTypeSourceInfo()->getTypeLoc().getLocStart(),
+       "type '%0' is missing namespace std")
+      << FieldTypeName
+      << FixItHint::CreateInsertion(
+             MatchedDecl->getTypeSourceInfo()->getTypeLoc().getLocStart(),
+             "std::");
+}
+
+} // namespace tidy
+} // namespace clang
+

test/clang-tidy/misc-missing-namespace-std.cpp

+// RUN: $(dirname %s)/check_clang_tidy.sh %s misc-missing-namespace-std %t
+// REQUIRES: shell
+
+namespace std { struct Demo{}; }
+
+using namespace std;
+
+Demo global_demo_instance;
+// CHECK: warning: type 'Demo' is missing namespace std.
+// CHECK-FIXES:  std::Demo global_demo_instance;
+
+std::Demo global_demo_instance_with_std; // no-warning