Add -Wunused-using, a warning that finds unused using declarations.

[CarlosAlbertoEnciso]

Summary

Add -Wunused-using, a warning that finds unused using declarations.
Also added an alias -Wunused-usings.

This patch uses a similar approach as the work done for the typedefs
as discussed in:

https://reviews.llvm.org/rC217298

It uses the 'referenced' available bit for the declarations.

For the below test:

namespace nsp {
  void foo();
}

using foo;

A debug information entries are generated for the namespace
and for the using declaration.

In order to reduce the debug information for those specific cases,
the work is divided in 2 parts:

• Emit a warning for the unused using
• Do not generate debug information for the unused using

The current patch deals with the first part and it covers global
and local detection of unused using declarations.

Thanks for your view on this issue and on the general approach.

Note: This patch is dependent on

https://reviews.llvm.org/D46190

which is under review.

[erichkeane]

My opinion matters less than @rsmith or @dblaikie on the review, but it seems to me that Typedef and Using are SO similar that the implementations should just be combined. You'd likely have to change a couple of types along the way to be more generic, but the implementations are essentially a copy/paste of eachother.

[CarlosAlbertoEnciso]

In D44826#1046671, @erichkeane wrote:

My opinion matters less than @rsmith or @dblaikie on the review, but it seems to me that Typedef and Using are SO similar that the implementations should just be combined. You'd likely have to change a couple of types along the way to be more generic, but the implementations are essentially a copy/paste of eachother.

That is a very valid point and it simplifies quite a lot the patch.

If the other reviewers do not have any objection, I will combine both implementations and update the uploaded patch.

Thanks,
Carlos

[dblaikie]

While implementing the warning is great (wonder if there's any codebase
that isn't -Wunused-using clean, that we could use to compare Clang and
GCC's behavior broadly - make sure it's catching the same cases (or
justify/investigate differences)) - and using it to motivate the debug info
is an improvement to the debug info - it won't quite address all the wasted
debug info, unfortunately :/

Consider this:

namespace a {

struct b;

};
namespace x {

using a::b;
inline void f(b*) {
}

}

Now the using declaration is used, but if 'f' is never called in this
translation unit, it's a bit weird to produce debug info for the using decl
and could still substantially bloat debug info. (indeed most of the bloat
that the using decl/directive debug info is producing is probably from
directives that are used, but not in a way that's relevant to a certain
translation unit)

I've not looked at the change yet, but if it's particularly
expensive/complicated to wire up the debug info side, it might not be worth
it given it's probably not a significant savings & somewhat of a dead-end
compared to what would be needed for a more complete fix. But I guess it's
probably not expensive/complicated, so probably some fine low hanging fruit
to pick until a more complete fix/improvement is implemented.

[Eugene.Zelenko]

This duplicates Clang-tidy misc-unused-using-decls. If Clang will provide same or better functionality, it should be removed.

[Eugene.Zelenko]

Please also mention new warning in Release Notes and documentation.

Will this warning be part of -Wall or -Wextra?

[CarlosAlbertoEnciso]

In D44826#1046910, @Eugene.Zelenko wrote:

This duplicates Clang-tidy misc-unused-using-decls. If Clang will provide same or better functionality, it should be removed.

Thanks for bringing this up.

[CarlosAlbertoEnciso]

In D44826#1046913, @Eugene.Zelenko wrote:

Please also mention new warning in Release Notes and documentation.

I will do it.

Will this warning be part of -Wall or -Wextra?

The warning is part of -Wall

Thanks for your feedback.

[CarlosAlbertoEnciso]

In D44826#1046906, @dblaikie wrote:

First of all, thanks very much for your feedback.

While implementing the warning is great (wonder if there's any codebase
that isn't -Wunused-using clean, that we could use to compare Clang and
GCC's behavior broadly - make sure it's catching the same cases (or
justify/investigate differences)) - and using it to motivate the debug info
is an improvement to the debug info - it won't quite address all the wasted
debug info, unfortunately :/

You are making a very good point. The -Wunused-using is just addressing
one of the factors affecting the debug info size.

Consider this:

namespace a {

struct b;

};
namespace x {

using a::b;
inline void f(b*) {
}

}

Now the using declaration is used, but if 'f' is never called in this
translation unit, it's a bit weird to produce debug info for the using decl
and could still substantially bloat debug info. (indeed most of the bloat
that the using decl/directive debug info is producing is probably from
directives that are used, but not in a way that's relevant to a certain
translation unit)

The modified patch catches that 'referenced' but 'unused' using declaration.

I've not looked at the change yet, but if it's particularly
expensive/complicated to wire up the debug info side, it might not be worth
it given it's probably not a significant savings & somewhat of a dead-end
compared to what would be needed for a more complete fix. But I guess it's
probably not expensive/complicated, so probably some fine low hanging fruit
to pick until a more complete fix/improvement is implemented.

The warning generation check is done at the point where a lexical scope
is closed and it does not 'see' further changes on the same using after that
point.

The second part (do not generate debug info) uses a similar approach, with
the only difference that the checks and debug info generation is done at
the end of the compilation unit, when more information is available.

[dblaikie]

You mention a missed case in the description - where the target of a using decl is used and that causes the unused-using not to warn about the using decl? That seems like a big limitation. Does that mean the 'used' bit is being tracked in the wrong place, on the target of the using decl instead of on the using decl itself?

lib/Sema/MultiplexExternalSemaSource.cpp

278–279

Could you use a range-based-for here?

lib/Serialization/ASTReader.cpp

8104–8106

roll the declaration into the condition, perhaps:

if (auto *D = dyn_cast_or_null...)
  Decls.insert(D);

test/Modules/warn-unused-using.cpp

6

This would only warn for the unused local using, but wouldn't fire for an namespace-scoped unused using? Perhaps there should be a test for that?

test/SemaCXX/warn-unused-using.cpp

6–8 ↗

(On Diff #139581)

Do these need to be different types? Maybe just name them t1/t2/t3/t4, etc - or name them after their use in test cases to indicate what makes each type interesting/different, if that's suitable.

11–12 ↗

(On Diff #139581)

What's the difference between these two cases?

15–20 ↗

(On Diff #139581)

And these 4? (I guess one in a nested scope is significant in some way? But not sure about the second scope, and the two (rather than one) using decls in there)

28 ↗

(On Diff #139581)

Probably don't need this use? (can turn off all the other warnings, rather than crafting warning-free code when testing only one warning)

35 ↗

(On Diff #139581)

This tests the fact that 'Foo' is overridden in B anyway, so this using decl doesn't bring anything in?

I'm assuming in the case where the using decl does bring at least one name in, this warning doesn't fire? (maybe test that?)

39–42 ↗

(On Diff #139581)

Does B need to be used at all, here? Oh, to demonstrate that 'Foo' is using one overload, but not using the using decl?

[CarlosAlbertoEnciso]

@dblaikie,

Thanks for your feedback and questions. I will address them.

Currently I am looking with more detail the tracking of the 'used' and 'referenced' bits.

[CarlosAlbertoEnciso]

This patch addresses the reviewers comments:

1. Merge the -Wunused-local-typedefs and -Wunused-usings implementations
2. Update the Release Notes
3. Review the test cases

[CarlosAlbertoEnciso]

lib/Serialization/ASTReader.cpp

8104–8106

Done.

test/Modules/warn-unused-using.cpp

6

I have added a namespace-scoped unused using.

[lebedev.ri]

Please improve test coverage a bit.
-Wunused-using is part of -Wunused.
And -Wunused is part of -Wall.
That needs to be tested.

Also, one small test to show that it is not on by default,
and -Wno-unused-using actually disables it is needed.

docs/ReleaseNotes.rst

117

``-Wall``

117

``-Wunused-using``

include/clang/Basic/DiagnosticGroups.td

830–831

Why? gcc compatibility?

include/clang/Basic/DiagnosticSemaKinds.td

282–284

http://en.cppreference.com/w/cpp/keyword/using says that there are multiple flavors.
It may be more friendlier to have more than one single message for all of them.

test/SemaCXX/referenced_alias_declaration_1.cpp

2

The svn attribute changes are likely unintentional.

test/SemaCXX/referenced_alias_declaration_2.cpp

2

The svn attribute changes are likely unintentional.

test/SemaCXX/referenced_using_all.cpp

2

The svn attribute changes are likely unintentional.

test/SemaCXX/referenced_using_declaration_1.cpp

2

The svn attribute changes are likely unintentional.

test/SemaCXX/referenced_using_declaration_2.cpp

2

The svn attribute changes are likely unintentional.

test/SemaCXX/referenced_using_directive.cpp

2

The svn attribute changes are likely unintentional.

[CarlosAlbertoEnciso]

@lebedev.ri,

Thanks very much for your review. I will address those issues and update the patch.

[CarlosAlbertoEnciso]

include/clang/Basic/DiagnosticGroups.td

830–831

No particular reason. I just follow the 'unused-local-typedefs' model.
If there is not objection from others reviewers, I will drop the gcc compatibility.

[CarlosAlbertoEnciso]

This patch addresses the reviewers comments:

• Additional test cases to cover: -Wunused, -Wall and -Wno-unused-using
• Formatting in ReleaseNotes
• Removed the '-Wunused-usings' alias (GCC compatibility).
• Added individual warning messages for using-declaration, using-directive and namespace-alias.
• Fixed SVN attribute changes.

[thakis]

Looks great.

docs/ReleaseNotes.rst

126

Maybe include an example with a using directive and a namespace alias as well.

139

nit: I'd omit this paragraph -- this is true for all warnings and not special for this warning.

include/clang/Basic/DiagnosticGroups.td

830–831

Does gcc have a -Wunused-usings? As far as I can tell it doesn't, so I agree not having the alias makes sense. -Wunused-local-typedefs is here because gcc has that flag.

[CarlosAlbertoEnciso]

Address feedback from @thakis in relation to the Release Notes.

docs/ReleaseNotes.rst

139

Removed that specific paragraph.

include/clang/Basic/DiagnosticGroups.td

830–831

As far as I can see, GCC does not have the `-Wunused-usings` alias.

[CarlosAlbertoEnciso]

Thanks to all reviewers for your comments and suggestions.

[lebedev.ri]

include/clang/Basic/DiagnosticSemaKinds.td

282–290

JFYI you can condense it down to just

def warn_unused_using_declaration : Warning<
  "unused %select{using declaration|using directive|namespace alias}0 %1">,
  InGroup<UnusedUsing>, DefaultIgnore;

if that simplifies the code that actually emits that warning.

[CarlosAlbertoEnciso]

include/clang/Basic/DiagnosticSemaKinds.td

282–290

Thanks for the suggestion.

I will have a look at it and see if that simplifies the code that emits the warning.

docs/ReleaseNotes.rst

- :option:`-fstrict-float-cast-overflow` and
   :option:`-fno-strict-float-cast-overflow`.
 
   When a floating-point value is not representable in a destination integer
   type, the code has undefined behavior according to the language standard. By
   default, Clang will not guarantee any particular result in that case. With the
   'no-strict' option, Clang attempts to match the overflowing behavior of the
   target's native float-to-int conversion instructions.
 
+- :option:`-Wunused-using`.
+
+  ``-Wall`` now includes the new warning flag ``-Wunused-using``, which emits a
+  warning on using statements that are not used. This may result in new
+  warnings in code that compiled cleanly with previous versions.
+
+  Example:
+
+  .. code-block:: c++
+
+    namespace n { class C; }
+
+    using n::C;
+
+    namespace a = n;
+
+    using namespace n;
+    using namespace a;
+
+  Gives the following warnings:
+
+  ::
+
+    ./test.cpp:3:10: warning: unused using declaration 'C' [-Wunused-using]
+    using n::C;
+             ^
+    ./test.cpp:5:11: warning: unused namespace alias 'a' [-Wunused-using]
+    namespace a = n;
+              ^
+    ./test.cpp:7:17: warning: unused using directive 'n' [-Wunused-using]
+    using namespace n;
+                    ^
+    ./test.cpp:8:17: warning: unused using directive 'a' [-Wunused-using]
+    using namespace a;
+                    ^
+    4 warnings generated.
+
+  To fix, simply remove the unused using statement or use ``-Wno-unused-using``.
+
 - ...
 
 Deprecated Compiler Flags
 -------------------------
 
 The following options are deprecated and ignored. They will be removed in
 future versions of Clang.
 

include/clang/Basic/DiagnosticGroups.td

 def UnevaluatedExpression : DiagGroup<"unevaluated-expression",
                                       [PotentiallyEvaluatedExpression]>;
 def UnusedValue : DiagGroup<"unused-value", [UnusedComparison, UnusedResult,
                                              UnevaluatedExpression]>;
 def UnusedConstVariable : DiagGroup<"unused-const-variable">;
 def UnusedVariable : DiagGroup<"unused-variable",
                                [UnusedConstVariable]>;
 def UnusedLocalTypedef : DiagGroup<"unused-local-typedef">;
+def UnusedUsing : DiagGroup<"unused-using">;
 def UnusedPropertyIvar :  DiagGroup<"unused-property-ivar">;
 def UnusedGetterReturnValue : DiagGroup<"unused-getter-return-value">;
 def UsedButMarkedUnused : DiagGroup<"used-but-marked-unused">;
 def UserDefinedLiterals : DiagGroup<"user-defined-literals">;
 def UserDefinedWarnings : DiagGroup<"user-defined-warnings">;
 def Reorder : DiagGroup<"reorder">;
 def UndeclaredSelector : DiagGroup<"undeclared-selector">;
 def ImplicitAtomic : DiagGroup<"implicit-atomic-properties">;

 
 def Unused : DiagGroup<"unused",
                        [UnusedArgument, UnusedFunction, UnusedLabel,
                         // UnusedParameter, (matches GCC's behavior)
                         // UnusedTemplate, (clean-up libc++ before enabling)
                         // UnusedMemberFunction, (clean-up llvm before enabling)
                         UnusedPrivateField, UnusedLambdaCapture,
                         UnusedLocalTypedef, UnusedValue, UnusedVariable,
+                        UnusedUsing,
                         UnusedPropertyIvar]>,
                         DiagCategory<"Unused Entity Issue">;
 
 // Format settings.
 def FormatInvalidSpecifier : DiagGroup<"format-invalid-specifier">;
 def FormatSecurity : DiagGroup<"format-security">;
 def FormatNonStandard : DiagGroup<"format-non-iso">;
 def FormatY2K : DiagGroup<"format-y2k">;

 def : DiagGroup<"bool-conversions",
                 [BoolConversion]>; // -Wbool-conversions  = -Wbool-conversion
 def : DiagGroup<"int-conversions",
                 [IntConversion]>; // -Wint-conversions = -Wint-conversion
 def : DiagGroup<"vector-conversions",
                 [VectorConversion]>; // -Wvector-conversions = -Wvector-conversion
 def : DiagGroup<"unused-local-typedefs", [UnusedLocalTypedef]>;
                 // -Wunused-local-typedefs = -Wunused-local-typedef
 
 // A warning group for warnings that we want to have on by default in clang,
 // but which aren't on by default in GCC.
 def NonGCC : DiagGroup<"non-gcc",
     [SignCompare, Conversion, LiteralRange]>;
 
 // A warning group for warnings about using C++11 features as extensions in
 // earlier C++ versions.
 def CXX11 : DiagGroup<"c++11-extensions", [CXX11ExtraSemi, CXX11InlineNamespace,
                                            CXX11LongLong]>;

include/clang/Basic/DiagnosticSemaKinds.td

def warn_mips_interrupt_attribute : Warning<
    InGroup<IgnoredAttributes>;
 def warn_unused_parameter : Warning<"unused parameter %0">,
   InGroup<UnusedParameter>, DefaultIgnore;
 def warn_unused_variable : Warning<"unused variable %0">,
   InGroup<UnusedVariable>, DefaultIgnore;
 def warn_unused_local_typedef : Warning<
   "unused %select{typedef|type alias}0 %1">,
   InGroup<UnusedLocalTypedef>, DefaultIgnore;
+def warn_unused_using_declaration : Warning<
+  "unused using declaration %0">,
+  InGroup<UnusedUsing>, DefaultIgnore;
+def warn_unused_using_directive : Warning<
+  "unused using directive %0">,
+  InGroup<UnusedUsing>, DefaultIgnore;
+def warn_unused_using_alias : Warning<
+  "unused namespace alias %0">,
+  InGroup<UnusedUsing>, DefaultIgnore;
 def warn_unused_property_backing_ivar : 
   Warning<"ivar %0 which backs the property is not "
   "referenced in this property's accessor">,
   InGroup<UnusedPropertyIvar>, DefaultIgnore;
 def warn_unused_const_variable : Warning<"unused variable %0">,
   InGroup<UnusedConstVariable>, DefaultIgnore;
 def warn_unused_exception_param : Warning<"unused exception parameter %0">,
   InGroup<UnusedExceptionParameter>, DefaultIgnore;

include/clang/Sema/ExternalSemaSource.h

public:
   /// external Sema source.
   ///
   /// The external source should append its own ext_vector type declarations to
   /// the given vector of declarations. Note that this routine may be
   /// invoked multiple times; the external source should take care not to
   /// introduce the same declarations repeatedly.
   virtual void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {}
 
-  /// Read the set of potentially unused typedefs known to the source.
+  /// Read the set of potentially unused typedefs and usings known to the
+  /// source.
   ///
   /// The external source should append its own potentially unused local
   /// typedefs to the given vector of declarations. Note that this routine may
   /// be invoked multiple times; the external source should take care not to
   /// introduce the same declarations repeatedly.
-  virtual void ReadUnusedLocalTypedefNameCandidates(
-      llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {}
+  virtual void ReadUnusedNamedDeclCandidates(
+      llvm::SmallSetVector<const NamedDecl *, 4> &Decls) {}
 
   /// Read the set of referenced selectors known to the
   /// external Sema source.
   ///
   /// The external source should append its own referenced selectors to the 
   /// given vector of selectors. Note that this routine 
   /// may be invoked multiple times; the external source should take care not 
   /// to introduce the same selectors repeatedly.

include/clang/Sema/MultiplexExternalSemaSource.h

public:
   /// external Sema source.
   ///
   /// The external source should append its own ext_vector type declarations to
   /// the given vector of declarations. Note that this routine may be
   /// invoked multiple times; the external source should take care not to
   /// introduce the same declarations repeatedly.
   void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl*> &Decls) override;
 
-  /// Read the set of potentially unused typedefs known to the source.
+  /// Read the set of potentially unused typedefs and usings known to the
+  /// source.
   ///
   /// The external source should append its own potentially unused local
   /// typedefs to the given vector of declarations. Note that this routine may
   /// be invoked multiple times; the external source should take care not to
   /// introduce the same declarations repeatedly.
-  void ReadUnusedLocalTypedefNameCandidates(
-      llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override;
+  void ReadUnusedNamedDeclCandidates(
+      llvm::SmallSetVector<const NamedDecl *, 4> &Decls) override;
 
   /// Read the set of referenced selectors known to the
   /// external Sema source.
   ///
   /// The external source should append its own referenced selectors to the 
   /// given vector of selectors. Note that this routine 
   /// may be invoked multiple times; the external source should take care not 
   /// to introduce the same selectors repeatedly.

include/clang/Sema/Sema.h

public:
   /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
   std::unique_ptr<CXXFieldCollector> FieldCollector;
 
   typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;
 
   /// Set containing all declared private fields that are not used.
   NamedDeclSetType UnusedPrivateFields;
 
-  /// Set containing all typedefs that are likely unused.
-  llvm::SmallSetVector<const TypedefNameDecl *, 4>
-      UnusedLocalTypedefNameCandidates;
+  /// Set containing all typedefs and usings that are likely unused.
+  llvm::SmallSetVector<const NamedDecl *, 4>
+      UnusedNamedDeclCandidates;
 
   /// Delete-expressions to be analyzed at the end of translation unit
   ///
   /// This list contains class members, and locations of delete-expressions
   /// that could not be proven as to whether they mismatch with new-expression
   /// used in initializer of the field.
   typedef std::pair<SourceLocation, bool> DeleteExprLoc;
   typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;
public:
   std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
 
   /// Calls \c Lexer::getLocForEndOfToken()
   SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
 
   /// Retrieve the module loader associated with the preprocessor.
   ModuleLoader &getModuleLoader() const;
 
-  void emitAndClearUnusedLocalTypedefWarnings();
+  void emitAndClearUnusedNamedDeclWarnings();
 
   void ActOnStartOfTranslationUnit();
   void ActOnEndOfTranslationUnit();
 
   void CheckDelegatingCtorCycles();
 
   Scope *getScopeForContext(DeclContext *Ctx);
 

include/clang/Sema/SemaInternal.h

inline bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D) {
   if (!LangOpts.CUDA || !D)
     return true;
   bool isDeviceSideDecl = D->hasAttr<CUDADeviceAttr>() ||
                           D->hasAttr<CUDASharedAttr>() ||
                           D->hasAttr<CUDAGlobalAttr>();
   return isDeviceSideDecl == LangOpts.CUDAIsDevice;
 }
 
+// Helper function to check whether D is associated with namespace via one of
+// the variations: using-declaration, using-directive, alias-declaration.
+inline bool DeclAccessNamespace(const Decl *D) {
+  return isa<UsingDecl>(D) ||
+         isa<UsingDirectiveDecl>(D) ||
+         isa<NamespaceAliasDecl>(D);
+}
+
 // Directly mark a variable odr-used. Given a choice, prefer to use 
 // MarkVariableReferenced since it does additional checks and then 
 // calls MarkVarDeclODRUsed.
 // If the variable must be captured:
 //  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
 //  - else capture it in the DeclContext that maps to the 
 //    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.  
 inline void MarkVarDeclODRUsed(VarDecl *Var,

include/clang/Serialization/ASTBitCodes.h

enum ASTRecordTypes {
       UNDEFINED_BUT_USED = 49,
 
       /// Record code for late parsed template functions.
       LATE_PARSED_TEMPLATE = 50,
 
       /// Record code for \#pragma optimize options.
       OPTIMIZE_PRAGMA_OPTIONS = 51,
 
-      /// Record code for potentially unused local typedef names.
-      UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES = 52,
+      /// Record code for potentially unused local typedef and using names.
+      UNUSED_NAMED_DECL_CANDIDATES = 52,
 
       // ID 53 used to be a table of constructor initializer records.
 
       /// Delete expressions that will be analyzed later.
       DELETE_EXPRS_TO_ANALYZE = 54,
 
       /// Record code for \#pragma ms_struct options.
       MSSTRUCT_PRAGMA_OPTIONS = 55,

include/clang/Serialization/ASTReader.h

private:
   SmallVector<uint64_t, 4> ExtVectorDecls;
 
   //@}
 
   /// \name Sema-relevant special data
   /// Fields containing data that is used for semantic analysis
   //@{
 
-  /// The IDs of all potentially unused typedef names in the chain.
+  /// The IDs of all potentially unused typedef and using names in the chain.
   ///
   /// Sema tracks these to emit warnings.
-  SmallVector<uint64_t, 16> UnusedLocalTypedefNameCandidates;
+  SmallVector<uint64_t, 16> UnusedNamedDeclCandidates;
 
   /// Our current depth in #pragma cuda force_host_device begin/end
   /// macros.
   unsigned ForceCUDAHostDeviceDepth = 0;
 
   /// The IDs of the declarations Sema stores directly.
   ///
   /// Sema tracks a few important decls, such as namespace std, directly.
public:
   void ReadUnusedFileScopedDecls(
                        SmallVectorImpl<const DeclaratorDecl *> &Decls) override;
 
   void ReadDelegatingConstructors(
                          SmallVectorImpl<CXXConstructorDecl *> &Decls) override;
 
   void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) override;
 
-  void ReadUnusedLocalTypedefNameCandidates(
-      llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) override;
+  void ReadUnusedNamedDeclCandidates(
+      llvm::SmallSetVector<const NamedDecl *, 4> &Decls) override;
 
   void ReadReferencedSelectors(
            SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) override;
 
   void ReadWeakUndeclaredIdentifiers(
            SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WI) override;
 
   void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) override;

lib/Sema/MultiplexExternalSemaSource.cpp

 }
 
 void MultiplexExternalSemaSource::ReadExtVectorDecls(
                                      SmallVectorImpl<TypedefNameDecl*> &Decls) {
   for(size_t i = 0; i < Sources.size(); ++i)
     Sources[i]->ReadExtVectorDecls(Decls);
 }
 
-void MultiplexExternalSemaSource::ReadUnusedLocalTypedefNameCandidates(
-    llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
+void MultiplexExternalSemaSource::ReadUnusedNamedDeclCandidates(
+    llvm::SmallSetVector<const NamedDecl *, 4> &Decls) {
   for(size_t i = 0; i < Sources.size(); ++i)
-    Sources[i]->ReadUnusedLocalTypedefNameCandidates(Decls);
+    Sources[i]->ReadUnusedNamedDeclCandidates(Decls);
 }
 
 void MultiplexExternalSemaSource::ReadReferencedSelectors(
                   SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
   for(size_t i = 0; i < Sources.size(); ++i)
     Sources[i]->ReadReferencedSelectors(Sels);
 }
 
 void MultiplexExternalSemaSource::ReadWeakUndeclaredIdentifiers(
                    SmallVectorImpl<std::pair<IdentifierInfo*, WeakInfo> > &WI) {
   for(size_t i = 0; i < Sources.size(); ++i)
     Sources[i]->ReadWeakUndeclaredIdentifiers(WI);
 }
 

lib/Sema/Sema.cpp

if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
         // This is a template friend, give up.
         Complete = false;
     }
   }
   RecordsComplete[RD] = Complete;
   return Complete;
 }
 
-void Sema::emitAndClearUnusedLocalTypedefWarnings() {
+void Sema::emitAndClearUnusedNamedDeclWarnings() {
   if (ExternalSource)
-    ExternalSource->ReadUnusedLocalTypedefNameCandidates(
-        UnusedLocalTypedefNameCandidates);
-  for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
-    if (TD->isReferenced())
+    ExternalSource->ReadUnusedNamedDeclCandidates(
+        UnusedNamedDeclCandidates);
+  for (const NamedDecl *ND : UnusedNamedDeclCandidates) {
+    if (ND->isReferenced())
       continue;
-    Diag(TD->getLocation(), diag::warn_unused_local_typedef)
-        << isa<TypeAliasDecl>(TD) << TD->getDeclName();
+    if (isa<TypedefNameDecl>(ND))
+      Diag(ND->getLocation(), diag::warn_unused_local_typedef)
+          << isa<TypeAliasDecl>(ND) << ND->getDeclName();
+    else if (isa<UsingDecl>(ND))
+      Diag(ND->getLocation(), diag::warn_unused_using_declaration)
+          << ND->getDeclName();
+    else if (isa<UsingDirectiveDecl>(ND)) {
+      auto *UD = dyn_cast<UsingDirectiveDecl>(ND);
+      Diag(ND->getLocation(), diag::warn_unused_using_directive)
+          << UD->getNominatedNamespaceAsWritten()->getDeclName();
+    } else
+      Diag(ND->getLocation(), diag::warn_unused_using_alias)
+          << ND->getDeclName();
   }
-  UnusedLocalTypedefNameCandidates.clear();
+  UnusedNamedDeclCandidates.clear();
 }
 
 /// This is called before the very first declaration in the translation unit
 /// is parsed. Note that the ASTContext may have already injected some
 /// declarations.
 void Sema::ActOnStartOfTranslationUnit() {
   if (getLangOpts().ModulesTS) {
     SourceLocation StartOfTU =
if (Module *CurrentModule = PP.getCurrentModule()) {
 
         // Queue the submodules, so their exports will also be resolved.
         Stack.append(Mod->submodule_begin(), Mod->submodule_end());
       }
     }
 
     // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
     // modules when they are built, not every time they are used.
-    emitAndClearUnusedLocalTypedefWarnings();
+    emitAndClearUnusedNamedDeclWarnings();
 
     // Modules don't need any of the checking below.
     if (!PP.isIncrementalProcessingEnabled())
       TUScope = nullptr;
     return;
   }
 
   // C99 6.9.2p2:
for (UnusedFileScopedDeclsType::iterator
               << /*variable*/1 << DiagD->getDeclName();
           else
             Diag(DiagD->getLocation(), diag::warn_unused_variable)
               << DiagD->getDeclName();
         }
       }
     }
 
-    emitAndClearUnusedLocalTypedefWarnings();
+    emitAndClearUnusedNamedDeclWarnings();
   }
 
   if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
     RecordCompleteMap RecordsComplete;
     RecordCompleteMap MNCComplete;
     for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
          E = UnusedPrivateFields.end(); I != E; ++I) {
       const NamedDecl *D = *I;

lib/Sema/SemaDecl.cpp

static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
   bool WithinFunction = D->getDeclContext()->isFunctionOrMethod();
   if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
     // For dependent types, the diagnostic is deferred.
     WithinFunction =
         WithinFunction || (R->isLocalClass() && !R->isDependentType());
   if (!WithinFunction)
     return false;
 
-  if (isa<TypedefNameDecl>(D))
+  if (isa<TypedefNameDecl>(D) || DeclAccessNamespace(D))
     return true;
 
   // White-list anything that isn't a local variable.
   if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
     return false;
 
   // Types of valid local variables should be complete, so this should succeed.
   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {

 }
 
 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
 /// unless they are marked attr(unused).
 void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
   if (!ShouldDiagnoseUnusedDecl(D))
     return;
 
-  if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
-    // typedefs can be referenced later on, so the diagnostics are emitted
-    // at end-of-translation-unit.
-    UnusedLocalTypedefNameCandidates.insert(TD);
+  if (isa<TypedefNameDecl>(D) || DeclAccessNamespace(D)) {
+    // typedefs and usings can be referenced later on, so the diagnostics are
+    // emitted at end-of-translation-unit.
+    UnusedNamedDeclCandidates.insert(D);
     return;
   }
 
   FixItHint Hint;
   GenerateFixForUnusedDecl(D, Context, Hint);
 
   unsigned DiagID;
   if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())

lib/Sema/SemaDeclCXX.cpp

if (IsUsingDirectiveInToplevelContext(CurContext) &&
       Diag(IdentLoc, diag::warn_using_directive_in_header);
     }
 
     PushUsingDirective(S, UDir);
   } else {
     Diag(IdentLoc, diag::err_expected_namespace_name) << SS.getRange();
   }
 
-  if (UDir)
+  if (UDir) {
     ProcessDeclAttributeList(S, UDir, AttrList);
+    UnusedNamedDeclCandidates.insert(UDir);
+  }
 
   return UDir;
 }
 
 void Sema::PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir) {
   // If the scope has an associated entity and the using directive is at
   // namespace or translation unit scope, add the UsingDirectiveDecl into
   // its lookup structure so qualified name lookup can find it.
if (!SS.getScopeRep()->containsUnexpandedParameterPack() &&
       EllipsisLoc = SourceLocation();
     }
   }
 
   NamedDecl *UD =
       BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
                             SS, TargetNameInfo, EllipsisLoc, AttrList,
                             /*IsInstantiation*/false);
-  if (UD)
+  if (UD) {
     PushOnScopeChains(UD, S, /*AddToContext*/ false);
+    if (isa<UsingDecl>(UD))
+      UnusedNamedDeclCandidates.insert(UD);
+  }
 
   return UD;
 }
 
 /// Determine whether a using declaration considers the given
 /// declarations as "equivalent", e.g., if they are redeclarations of
 /// the same entity or are both typedefs of the same type.
 static bool
Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc,
   NamespaceAliasDecl *AliasDecl =
     NamespaceAliasDecl::Create(Context, CurContext, NamespaceLoc, AliasLoc,
                                Alias, SS.getWithLocInContext(Context),
                                IdentLoc, ND);
   if (Prev)
     AliasDecl->setPreviousDecl(Prev);
 
   PushOnScopeChains(AliasDecl, S);
+
+  if (AliasDecl)
+    UnusedNamedDeclCandidates.insert(AliasDecl);
+
   return AliasDecl;
 }
 
 namespace {
 struct SpecialMemberExceptionSpecInfo
     : SpecialMemberVisitor<SpecialMemberExceptionSpecInfo> {
   SourceLocation Loc;
   Sema::ImplicitExceptionSpecification ExceptSpec;

lib/Serialization/ASTReader.cpp

case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
       if (Record.size() != 2) {
         Error("invalid pragma ms_struct record");
         return Failure;
       }
       PragmaMSPointersToMembersState = Record[0];
       PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
       break;
 
-    case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
+    case UNUSED_NAMED_DECL_CANDIDATES:
       for (unsigned I = 0, N = Record.size(); I != N; ++I)
-        UnusedLocalTypedefNameCandidates.push_back(
-            getGlobalDeclID(F, Record[I]));
+        UnusedNamedDeclCandidates.push_back(getGlobalDeclID(F, Record[I]));
       break;
 
     case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
       if (Record.size() != 1) {
         Error("invalid cuda pragma options record");
         return Failure;
       }
       ForceCUDAHostDeviceDepth = Record[0];
for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
     TypedefNameDecl *D
       = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
     if (D)
       Decls.push_back(D);
   }
   ExtVectorDecls.clear();
 }
 
-void ASTReader::ReadUnusedLocalTypedefNameCandidates(
-    llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
-  for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
+void ASTReader::ReadUnusedNamedDeclCandidates(
+    llvm::SmallSetVector<const NamedDecl *, 4> &Decls) {
+  for (unsigned I = 0, N = UnusedNamedDeclCandidates.size(); I != N;
        ++I) {
-    TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
-        GetDecl(UnusedLocalTypedefNameCandidates[I]));
-    if (D)
-      Decls.insert(D);
+    if (auto *ND = dyn_cast_or_null<NamedDecl>(
+        GetDecl(UnusedNamedDeclCandidates[I])))
+      Decls.insert(ND);
   }
-  UnusedLocalTypedefNameCandidates.clear();
+  UnusedNamedDeclCandidates.clear();
 }
 
 void ASTReader::ReadReferencedSelectors(
        SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
   if (ReferencedSelectorsData.empty())
     return;
 
   // If there are @selector references added them to its pool. This is for
   // implementation of -Wselector.
   unsigned int DataSize = ReferencedSelectorsData.size()-1;
   unsigned I = 0;
   while (I < DataSize) {
     Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
     SourceLocation SelLoc
       = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
     Sels.push_back(std::make_pair(Sel, SelLoc));

lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(OBJC_CATEGORIES);
   RECORD(MACRO_OFFSET);
   RECORD(INTERESTING_IDENTIFIERS);
   RECORD(UNDEFINED_BUT_USED);
   RECORD(LATE_PARSED_TEMPLATE);
   RECORD(OPTIMIZE_PRAGMA_OPTIONS);
   RECORD(MSSTRUCT_PRAGMA_OPTIONS);
   RECORD(POINTERS_TO_MEMBERS_PRAGMA_OPTIONS);
-  RECORD(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES);
+  RECORD(UNUSED_NAMED_DECL_CANDIDATES);
   RECORD(DELETE_EXPRS_TO_ANALYZE);
   RECORD(CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH);
   RECORD(PP_CONDITIONAL_STACK);
 
   // SourceManager Block.
   BLOCK(SOURCE_MANAGER_BLOCK);
   RECORD(SM_SLOC_FILE_ENTRY);
   RECORD(SM_SLOC_BUFFER_ENTRY);
ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot,
   if (!SemaRef.VTableUses.empty()) {
     for (unsigned I = 0, N = SemaRef.VTableUses.size(); I != N; ++I) {
       AddDeclRef(SemaRef.VTableUses[I].first, VTableUses);
       AddSourceLocation(SemaRef.VTableUses[I].second, VTableUses);
       VTableUses.push_back(SemaRef.VTablesUsed[SemaRef.VTableUses[I].first]);
     }
   }
 
-  // Build a record containing all of the UnusedLocalTypedefNameCandidates.
-  RecordData UnusedLocalTypedefNameCandidates;
-  for (const TypedefNameDecl *TD : SemaRef.UnusedLocalTypedefNameCandidates)
-    AddDeclRef(TD, UnusedLocalTypedefNameCandidates);
+  // Build a record containing all of the UnusedNameCandidates.
+  RecordData UnusedNamedDeclCandidates;
+  for (const NamedDecl *ND : SemaRef.UnusedNamedDeclCandidates)
+    AddDeclRef(ND, UnusedNamedDeclCandidates);
 
   // Build a record containing all of pending implicit instantiations.
   RecordData PendingInstantiations;
   for (const auto &I : SemaRef.PendingInstantiations) {
     AddDeclRef(I.first, PendingInstantiations);
     AddSourceLocation(I.second, PendingInstantiations);
   }
   assert(SemaRef.PendingLocalImplicitInstantiations.empty() &&
ASTFileSignature ASTWriter::WriteASTCore(Sema &SemaRef, StringRef isysroot,
   if (!ExtVectorDecls.empty())
     Stream.EmitRecord(EXT_VECTOR_DECLS, ExtVectorDecls);
 
   // Write the record containing VTable uses information.
   if (!VTableUses.empty())
     Stream.EmitRecord(VTABLE_USES, VTableUses);
 
   // Write the record containing potentially unused local typedefs.
-  if (!UnusedLocalTypedefNameCandidates.empty())
-    Stream.EmitRecord(UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES,
-                      UnusedLocalTypedefNameCandidates);
+  if (!UnusedNamedDeclCandidates.empty())
+    Stream.EmitRecord(UNUSED_NAMED_DECL_CANDIDATES,
+                      UnusedNamedDeclCandidates);
 
   // Write the record containing pending implicit instantiations.
   if (!PendingInstantiations.empty())
     Stream.EmitRecord(PENDING_IMPLICIT_INSTANTIATIONS, PendingInstantiations);
 
   // Write the record containing declaration references of Sema.
   if (!SemaDeclRefs.empty())
     Stream.EmitRecord(SEMA_DECL_REFS, SemaDeclRefs);

test/FixIt/fixit.cpp

-// RUN: %clang_cc1 -pedantic -Wall -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++98 %s
+// RUN: %clang_cc1 -pedantic -Wall -Wno-unused-using -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++98 %s
 // RUN: cp %s %t-98
-// RUN: not %clang_cc1 -pedantic -Wall -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++98 %t-98
-// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-comment -fcxx-exceptions -x c++ -std=c++98 %t-98
+// RUN: not %clang_cc1 -pedantic -Wall -Wno-unused-using -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++98 %t-98
+// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-unused-using -Wno-comment -fcxx-exceptions -x c++ -std=c++98 %t-98
 // RUN: not %clang_cc1 -fsyntax-only -fdiagnostics-parseable-fixits -x c++ -std=c++11 %s 2>&1 | FileCheck %s
-// RUN: %clang_cc1 -pedantic -Wall -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++11 %s
+// RUN: %clang_cc1 -pedantic -Wall -Wno-unused-using -Wno-comment -verify -fcxx-exceptions -x c++ -std=c++11 %s
 // RUN: cp %s %t-11
-// RUN: not %clang_cc1 -pedantic -Wall -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++11 %t-11
-// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-comment -fcxx-exceptions -x c++ -std=c++11 %t-11
+// RUN: not %clang_cc1 -pedantic -Wall -Wno-unused-using -Wno-comment -fcxx-exceptions -fixit -x c++ -std=c++11 %t-11
+// RUN: %clang_cc1 -fsyntax-only -pedantic -Wall -Werror -Wno-unused-using -Wno-comment -fcxx-exceptions -x c++ -std=c++11 %t-11
 
 /* This is a test of the various code modification hints that are
    provided as part of warning or extension diagnostics. All of the
    warnings will be fixed by -fixit, and the resulting file should
    compile cleanly with -Werror -pedantic. */
 
 struct C1 {
   virtual void f();

test/Modules/Inputs/module.map

 module warning {
   header "warning.h"
 }
 
 module warn_unused_local_typedef {
   header "warn-unused-local-typedef.h"
 }
 
+module warn_unused_using {
+  header "warn-unused-using.h"
+}
+
 module using_decl {
   module a { header "using-decl-a.h" export * }
   module b { header "using-decl-b.h" export * }
 }
 
 module recursive_visibility_a1 {
   module inner { header "recursive_visibility_a1_inner.h" }
 }

test/Modules/Inputs/warn-unused-using.h

+namespace A {
+  typedef char CHAR;
+}
+namespace B {
+  typedef int INT;
+  using A::CHAR;
+}
+inline void foo() {
+  using B::INT;
+}

test/Modules/warn-unused-using.cpp

+// RUN: rm -rf %t
+// RUN: %clang_cc1 -Wunused-using -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -fsyntax-only 2>&1 | FileCheck %s -check-prefix=CHECK_1
+// RUN: %clang_cc1 -Wunused-using -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -fsyntax-only 2>&1 | FileCheck %s -check-prefix=CHECK_2 --allow-empty
+
+// For modules, the warning should only fire the first time, when the module is
+// built.
+// CHECK_1: warning: unused using declaration 'CHAR'
+// CHECK_1: warning: unused using declaration 'INT'
+// CHECK_2-NOT: warning: unused using declaration 'CHAR'
+// CHECK_2-NOT: warning: unused using declaration 'INT'
+@import warn_unused_using;

test/PCH/cxx-templates.cpp

 // Test this without pch.
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include %S/cxx-templates.h -verify %s -ast-dump -o -
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include %S/cxx-templates.h %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
 
 // Test with pch.
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include-pch %t -verify %s -ast-dump  -o -
-// RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -include-pch %t %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
 
 // Test with modules.
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fmodules -x c++-header -emit-pch -o %t %S/cxx-templates.h
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fmodules -include-pch %t -verify %s -ast-dump  -o -
-// RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fmodules -include-pch %t %s -emit-llvm -o - -error-on-deserialized-decl doNotDeserialize -DNO_ERRORS -fmodules-ignore-macro=NO_ERRORS | FileCheck %s
+// RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fexceptions -fmodules -include-pch %t %s -emit-llvm -o - -DNO_ERRORS -fmodules-ignore-macro=NO_ERRORS | FileCheck %s
 
 // Test with pch and delayed template parsing.
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fdelayed-template-parsing -fexceptions -x c++-header -emit-pch -o %t %S/cxx-templates.h
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t -verify %s -ast-dump  -o -
 // RUN: %clang_cc1 -std=c++11 -triple %itanium_abi_triple -fcxx-exceptions -fdelayed-template-parsing -fexceptions -include-pch %t %s -emit-llvm -o - -DNO_ERRORS | FileCheck %s
 
 // CHECK: define weak_odr {{.*}}void @_ZN2S4IiE1mEv
 // CHECK: define linkonce_odr {{.*}}void @_ZN2S3IiE1mEv

test/SemaCXX/coreturn.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin9 %s -std=c++14 -fcoroutines-ts -fsyntax-only -Wignored-qualifiers -Wno-error=return-type -verify -fblocks -Wall -Wextra -Wno-error=unreachable-code
 #include "Inputs/std-coroutine.h"
 
 using std::experimental::suspend_always;
-using std::experimental::suspend_never;
+using std::experimental::suspend_never; // expected-warning {{unused using declaration 'suspend_never'}}
 
 struct awaitable {
   bool await_ready();
   void await_suspend(std::experimental::coroutine_handle<>); // FIXME: coroutine_handle
   void await_resume();
 } a;
 
 struct promise_void {

test/SemaCXX/referenced_alias_declaration_1.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused-using -verify %s
+
+namespace N {
+  int var;
+}
+
+void Fa() {
+  namespace NN = N;     // Referenced
+  using namespace NN;   // Referenced
+  var = 1;
+}
+
+void Fb() {
+  namespace NA = N;     // Referenced
+  namespace NB = NA;    // Referenced
+  namespace NC = NB;    // Referenced
+  using namespace NC;   // Referenced
+  var = 2;
+  namespace ND = NC;    // expected-warning {{unused namespace alias 'ND'}}
+}
+
+void Fc() {
+  namespace NA = N;     // expected-warning {{unused namespace alias 'NA'}}
+  using namespace NA;   // expected-warning {{unused using directive 'NA'}}
+  N::var = 3;
+}
+
+void Fd() {
+  namespace NA = N;     // Referenced
+  namespace NB = NA;    // Referenced
+  NB::var = 4;
+}
+

test/SemaCXX/referenced_alias_declaration_2.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused-using -verify %s
+
+namespace A {
+  namespace B {
+    namespace C {
+      typedef int Integer;
+    }
+  }
+}
+
+void foo() {
+  {
+    namespace N_A = A;                // Referenced
+    {
+      namespace N_AB = N_A::B;        // Referenced
+      {
+        namespace N_ABC = N_AB::C;    // Referenced
+        {
+          using N_ABC::Integer;       // Referenced
+          Integer var;
+        }
+      }
+    }
+  }
+  {
+    namespace N_A = A;                // expected-warning {{unused namespace alias 'N_A'}}
+    {
+      namespace N_AB = N_A::B;        // expected-warning {{unused namespace alias 'N_AB'}}
+      {
+        namespace N_ABC = N_AB::C;    // expected-warning {{unused namespace alias 'N_ABC'}}
+        {
+          A::B::C::Integer var;
+        }
+      }
+    }
+  }
+}
+

test/SemaCXX/referenced_using_all.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused-using -verify %s
+
+namespace A {
+  typedef char Char;
+  typedef int Integer;
+  typedef float Float;
+  int var;
+}
+
+using A::Char;                  // expected-warning {{unused using declaration 'Char'}}
+using A::Integer;               // Referenced
+using A::Float;                 // expected-warning {{unused using declaration 'Float'}}
+
+namespace B {
+  using A::Char;                // Referenced
+  template <class T>
+  T FuncTempl(T p1,Char p2) {
+    using A::Float;             // Referenced
+    typedef Float Type;
+    Integer I;
+    return p1;
+  }
+}
+
+using A::Char;                  // Referenced
+using A::Integer;               // expected-warning {{unused using declaration 'Integer'}}
+namespace ND1 = A;
+void foo() {
+  using A::Integer;             // Referenced
+  namespace ND2 = ND1;          // Referenced
+  {
+    Integer Ivar;
+    namespace ND3 = ND2;        // Referenced
+    {
+      namespace ND4 = ND3;      // Referenced
+      Char Cvar;
+      {
+        using ND4::var;         // Referenced
+        var = 1;
+      }
+    }
+  }
+  using A::Char;                // Referenced
+  using namespace::B;           // Referenced
+  FuncTempl<Char>(1,'a');
+}
+

test/SemaCXX/referenced_using_declaration_1.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused-using -verify %s
+
+namespace N {
+  // Types.
+  typedef int Integer;
+  struct Record {
+    int a;
+  };
+
+  // Variables.
+  int var1;
+  int var2;
+
+  // Functions.
+  void func1();
+  void func2();
+}
+
+using N::Integer;   // expected-warning {{unused using declaration 'Integer'}}
+using N::Record;    // expected-warning {{unused using declaration 'Record'}}
+using N::var1;      // expected-warning {{unused using declaration 'var1'}}
+using N::var2;      // expected-warning {{unused using declaration 'var2'}}
+using N::func1;     // expected-warning {{unused using declaration 'func1'}}
+using N::func2;     // expected-warning {{unused using declaration 'func2'}}
+
+void Foo() {
+  using N::Integer; // expected-warning {{unused using declaration 'Integer'}}
+  N::Integer int_var;
+  int_var = 1;
+
+  using N::Record;  // Referenced
+  Record rec_var;
+  rec_var.a = 2;
+
+  using N::var1;    // expected-warning {{unused using declaration 'var1'}}
+  N::var1 = 3;
+
+  using N::var2;    // Referenced
+  var2 = 4;
+
+  using N::func1;   // expected-warning {{unused using declaration 'func1'}}
+  N::func1();
+
+  using N::func2;   // Referenced
+  func2();
+}
+

test/SemaCXX/referenced_using_declaration_2.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused-using -verify %s
+
+namespace N {
+  typedef int Integer;
+  typedef char Char;
+}
+
+using N::Integer;   // expected-warning {{unused using declaration 'Integer'}}
+using N::Char;      // Referenced
+
+void Foo(int p1, N::Integer p2, Char p3) {
+  N::Integer var;
+  var = 0;
+}
+
+using N::Integer;   // Referenced
+Integer Bar() {
+  using N::Char;    // expected-warning {{unused using declaration 'Char'}}
+  return 0;
+}
+

test/SemaCXX/referenced_using_directive.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused-using -verify %s
+
+namespace N {
+  typedef int Integer;
+  int var;
+}
+
+void Fa() {
+  using namespace N;  // Referenced
+  var = 1;
+}
+
+void Fb() {
+  using namespace N;  // expected-warning {{unused using directive 'N'}}
+  N::var = 1;
+}
+
+void Fc() {
+  using namespace N;  // Referenced
+  Integer var = 1;
+}
+
+void Fd() {
+  using namespace N;  // expected-warning {{unused using directive 'N'}}
+  N::Integer var = 1;
+}
+

test/SemaCXX/referenced_using_options.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wall -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -Wunused-using -verify %s
+
+namespace N {
+  typedef int Integer;
+}
+
+using N::Integer;   // expected-warning {{unused using declaration 'Integer'}}
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-using"
+using N::Integer;   // no warning
+#pragma clang diagnostic pop
+
+using N::Integer;   // expected-warning {{unused using declaration 'Integer'}}
+