For a used declaration, mark any associated usings as referenced.

[CarlosAlbertoEnciso]

Summary

The following submission under review

https://reviews.llvm.org/D44826

introduced an option to warn on unused 'using declarations'.

But it can't detect cases like

namespace N {
  void foo();
  int var;
}

using N::foo;     <-- warning
using N::var;     <-- MISSING warning  

void A() {
  using N::foo;     <-- warning
  using N::var;     <-- warning
}

void B() {
  N::var = 1;
}

One of the reviewers (dblaikie) mentioned the possible cause for that limitation.

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?

This patch, set the 'Referenced' bit for any associated 'usings' for a referenced
declaration. The goal is to create additional information to help in the reduction
of the debug information size, which is affected by the extra generation of
'non-referenced' declarations.

Note:

To solve the debug information issue (size), there are 3 pieces of
work:

• Set the 'referenced' bit for 'usings'. This patch.
• Review the - Wunused-usings and -Wunused-local-typedefs implementation to take advantage of new 'Referenced' settings.
• Do not generate debug information for the non-referenced using.

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

[CarlosAlbertoEnciso]

Note:

The patch includes the entry points to set Objective-C and OpenMP declarations, but I do not
know anything about Objective-C or OpenMP. The functions just return without updating any
extra 'Used' bit.

Any suggestion on how to deal with those functions, is very much appreciated.

Thanks.

[rsmith]

No, absolutely not. This would be insanely expensive, and marks entirely unrelated things "used".

The right thing to do here is to consistently track both the named declaration (the one found by name lookup, which might be a using-declaration) and the ultimately selected declaration (which might be the target of the using-declaration, or if that declaration is a template, a specialization of that template), and pass both to MarkAnyDeclUsed. Then we should mark the named declaration as Referenced and the selected declaration as Used. (The "unused using-declaration" warning should be based on the Referenced bit, since it's not meaningful to odr-use a using-declaration.)

[rsmith]

In D46190#1081773, @rsmith wrote:

No, absolutely not. This would be insanely expensive, and marks entirely unrelated things "used".

My apologies, reading this again it comes off a lot harsher than I'd intended.

[CarlosAlbertoEnciso]

In D46190#1081836, @rsmith wrote:

In D46190#1081773, @rsmith wrote:

No, absolutely not. This would be insanely expensive, and marks entirely unrelated things "used".

My apologies, reading this again it comes off a lot harsher than I'd intended.

I appreciate your apology and I understand your concerns. I do not have much knowledge on this area.

My initial intention was to traverse just the associated type for an odr-used declaration and mark them as used, as an indication that those types are "really needed" for that odr-declaration. The type chain is traversed just once.

The approach was intended as a general solution, not only for the original 'using declaration' issue.

I will have a look at your suggested approach.

Thanks very much for your feedback.

[CarlosAlbertoEnciso]

My initial approach was based on the following test case:

void Bar() {
  typedef int I_Ref;
  I_Ref var_bar;
}

void Foo() {
  typedef int I_Used;
  I_Used var_foo;
  var_foo = 2;
}

void Test() {
  Foo();
}

and the generated AST looks like:

|-FunctionDecl Bar 'void ()'
|   |-DeclStmt
|   | `-TypedefDecl referenced I_Ref 'int'
|   |-DeclStmt
|     `-VarDecl var_bar 'I_Ref':'int'

|-FunctionDecl used Foo 'void ()'
|   |-DeclStmt
|   | `-TypedefDecl referenced I_Used 'int'
|   |-DeclStmt
|   | `-VarDecl used var_foo 'I_Used':'int'

The typedef 'I_Ref' is marked as 'referenced' due to its association with 'var_bar'.
The typedef 'I_Used' is marked as 'referenced' despite that its association with 'var_foo' which is 'used'
Both 'typedefs' are marked as 'referenced'.

With the intended patch, the AST looks like:

|-FunctionDecl Bar 'void ()'
|   |-DeclStmt
|   | `-TypedefDecl referenced I_Ref 'int'
|   `-DeclStmt
|     `-VarDecl var_bar 'I_Ref':'int'

|-FunctionDecl used Foo 'void ()'
|   |-DeclStmt
|   | `-TypedefDecl used I_Used 'int'
|   |-DeclStmt
|   | `-VarDecl used var_foo 'I_Used':'int'

The typedef 'I_Ref' is marked as 'referenced'.
The typedef 'I_Used' is marked as 'used'.

[rsmith]

In D46190#1082616, @CarlosAlbertoEnciso wrote:

My initial approach was based on the following test case:

void Bar() {
  typedef int I_Ref;
  I_Ref var_bar;
}

void Foo() {
  typedef int I_Used;
  I_Used var_foo;
  var_foo = 2;
}

void Test() {
  Foo();
}

[...]

The typedef 'I_Ref' is marked as 'referenced' due to its association with 'var_bar'.
The typedef 'I_Used' is marked as 'referenced' despite that its association with 'var_foo' which is 'used'
Both 'typedefs' are marked as 'referenced'.

This is already the correct outcome. Both typedefs are referenced; this is correct because they are named by the source code. Neither typedef is marked as "used"; this is correct because a typedef cannot be odr-used.

Let's look at your original example again (I've cleaned it up and extended it a bit, but hopefully this matches your intent):

namespace nsp {
  int var1, var2;
}

using nsp::var1;
using nsp::var2;

void bar() {
  nsp::var1 = 1;
  var2 = 1;
}

Now, what should happen here is:

• The use of nsp::var1 in bar marks nsp::var1 as referenced (because it was named), and marks nsp::var1 as used (because it was odr-used by the assignment). The UsingShadowDecl for ::var1 is not marked as referenced (nor used), so we emit an unused-using-declaration warning.
• The use of var2 in bar marks ::var2 as referenced (because it was named), and marks nsp::var2 as used (because it was odr-used by the assignment). The UsingShadowDecl for ::var2 is marked as referenced, so we do not warn on it.

[CarlosAlbertoEnciso]

In D46190#1083502, @rsmith wrote:

This is already the correct outcome. Both typedefs are referenced; this is correct because they are named by the source code. Neither typedef is marked as "used"; this is correct because a typedef cannot be odr-used.

I appreciate very much your explanations on the typedef case.

My misunderstanding comes from my experience with a commercial C/C++ front-end, which has the concept of 'needed' and 'really needed' and those concepts seems different to the 'referenced' and 'used' in Clang. I was trying to match that concept:

needed -> referenced.
really needed -> used.

[CarlosAlbertoEnciso]

In D46190#1083502, @rsmith wrote:

Let's look at your original example again (I've cleaned it up and extended it a bit, but hopefully this matches your intent):

namespace nsp {
  int var1, var2;
}

using nsp::var1;
using nsp::var2;

void bar() {
  nsp::var1 = 1;
  var2 = 1;
}

Now, what should happen here is:

• The use of nsp::var1 in bar marks nsp::var1 as referenced (because it was named), and marks nsp::var1 as used (because it was odr-used by the assignment). The UsingShadowDecl for ::var1 is not marked as referenced (nor used), so we emit an unused-using-declaration warning.
• The use of var2 in bar marks ::var2 as referenced (because it was named), and marks nsp::var2 as used (because it was odr-used by the assignment). The UsingShadowDecl for ::var2 is marked as referenced, so we do not warn on it.

Your extended example matches my original intent. That is a good starting point. Now I am clear on the expected behavior.

Thanks very much for your comments.

[CarlosAlbertoEnciso]

Address the issues raised by the reviewer (rsmith).

[CarlosAlbertoEnciso]

Ping.

Thanks

[CarlosAlbertoEnciso]

Ping.

Thanks

[CarlosAlbertoEnciso]

Ping.

The review

https://reviews.llvm.org/D44826

is already approved and it is dependent on this patch being reviewed.

Is there anything I can add to this patch?

Thanks very much.

[probinson]

@rsmith anything else needed here?

[CarlosAlbertoEnciso]

Ping.

The review

https://reviews.llvm.org/D44826

is already approved and it is dependent on this patch being reviewed.

@rsmith Is there anything I can add to this patch?

Thanks

[probinson]

@dblaikie is @rsmith back from the standards meeting yet? I hate to be a pest but this is blocking other work Carlos has in progress.

[probinson]

Style comments.
The two new Sema methods (for namespaces and using references) are C++ specific, so SemaDeclCXX.cpp would seem like a more appropriate home for them.

lib/Sema/Sema.cpp

1876

You could do this as an early return and reduce indentation in the rest of the method.

if (!ND || ND->isReferenced())
  return;

1877

Initializing this to nullptr is redundant, as you set NA in the while-loop expression.

1888

\brief is unnecessary, as we have auto-brief turned on.

1900

This dyn_cast<> can be simply a cast<>.

1913

You could sink the declaration of USD like so:

for (auto *DR : S->decls())
  if (auto *USD = dyn_cast<UsingShadowDecl>(DR))
    if (!USD->isReferenced() && USD->getTargetDecl() == D) {

Also I would put braces around the 'for' loop body, even though it is technically one statement.

1924

You verified that his is a namespace earlier, so use cast<> not dyn_cast<>.

[rsmith]

The right way to handle this is to pass both the ultimately-selected declaration and the declaration found by name lookup into the calls to MarkAnyDeclReferenced and friends. We should mark the selected declaration as Used (when appropriate), and mark the found declaration as Referenced.

We should not be trying to reconstruct which using declarations are in scope after the fact. Only declarations actually found by name lookup and then selected by the context performing the lookup should be marked referenced. (There may be cases where name lookup discards equivalent lookup results that are not redeclarations of one another, though, and to handle such cases properly, you may need to teach name lookup to track a list of found declarations rather than only one.)

lib/Sema/Sema.cpp

1881–1882

The loop and recursion here -- and indeed this whole function -- seem unnecessary.

namespace A {} // #1 
namespace X {
  namespace B = A; // #2
}
namespace Y = X; // #3
namespace C = Y::B; // #4

Declaration #4 should mark #2 and #3 referenced. So the only 'unreferenced namespace alias' warning we should get here is for #4 -- and there is no need for marking #4 as referenced to affect #2 or #3.

1887–1888

Why is this ever appropriate? I would think we should just mark the named declaration from the relevant lookup as referenced in all cases.

[CarlosAlbertoEnciso]

@probinson Thanks very much for your review. I will address them.

[CarlosAlbertoEnciso]

rsmith Thanks very much for your review. I will address them.

[CarlosAlbertoEnciso]

In D46190#1135688, @rsmith wrote:

The right way to handle this is to pass both the ultimately-selected declaration and the declaration found by name lookup into the calls to MarkAnyDeclReferenced and friends. We should mark the selected declaration as Used (when appropriate), and mark the found declaration as Referenced.

We should not be trying to reconstruct which using declarations are in scope after the fact. Only declarations actually found by name lookup and then selected by the context performing the lookup should be marked referenced. (There may be cases where name lookup discards equivalent lookup results that are not redeclarations of one another, though, and to handle such cases properly, you may need to teach name lookup to track a list of found declarations rather than only one.)

Following your comments, I have replaced the scope traversal with LookupName in order to find the declarations.

But there are 2 specific cases:

• using-directives

The LookupName function does not record the using-directives. With this patch, there is an extra option to store those directives in the lookup results, to be processed during the setting of the 'Referenced' bit.

• namespace-alias

I am aware of your comment on the function that recursively traverse the namespace alias, but I can't see another way to do it. If you have a more specific idea, I am happy to explore it.

For both cases, may be LookupName function can have that functionality and store in the results any namespace-directives and namespace-alias associated with the given declaration.

lib/Sema/Sema.cpp

1876

Corrected to

if (!ND || ND->isReferenced())
  return;

1877

Removed the nullptr initialization.

1888

Removed the \brief format.

1900

Changed the dyn_cast<> to cast<>

1913

Not available in the new patch.

1924

Not available in the new patch.

[CarlosAlbertoEnciso]

In D46190#1135295, @probinson wrote:

Style comments.
The two new Sema methods (for namespaces and using references) are C++ specific, so SemaDeclCXX.cpp would seem like a more appropriate home for them.

Both functions have been moved to SemaDeclCXX.cpp.

[CarlosAlbertoEnciso]

Update the patch to address the comments from the reviewers.

[CarlosAlbertoEnciso]

lib/Sema/Sema.cpp

1881–1882

The function and recursion is to be able to handle cases like:

namespace N {
  int var;
}

void Foo() {
  namespace NA = N;
  namespace NB = NA;
  NB::var = 4;
}

'var' is referenced and N, NA and NB should be marked as 'referenced' as well.

1887–1888

My intention is to detect cases where the using statements do not affect other declarations.

namespace N {
  int var;
}

void Foo() {
  using N::var;    <- No Referenced
  N::var = 1;      <- Used
}

[CarlosAlbertoEnciso]

@rsmith Is there anything I can add to this patch?

The review

https://reviews.llvm.org/D44826

is already approved and it is dependent on this patch being reviewed.

Thanks very much

[CarlosAlbertoEnciso]

@rsmith and @probinson:

Is there anything I can add to this patch?

The review

https://reviews.llvm.org/D44826

is already approved and it is blocked by this patch being reviewed.

Thanks very much

[probinson]

A bunch of style comments. Maybe try clang-format-diff.

include/clang/Sema/SemaInternal.h

91

The comments on a nullptr parameter usually use the formal parameter name, not its type.

lib/Sema/SemaDeclCXX.cpp

15345

Space after the comma.

15350

Could this be a range-based for loop?

15362

else if

lib/Sema/SemaExpr.cpp

14139

Parameter comments usually use the formal parameter name, not its type.

15076

Parameter comments usually use the formal parameter name, not its type.

15097

Parameter comments usually use the formal parameter name, not its type.

lib/Sema/SemaLookup.cpp

196 ↗

(On Diff #154091)

Can this be a range-based for loop?

1064 ↗

(On Diff #154091)

Space after the comma.
UDirs has a different meaning elsewhere in this file, maybe UsingDirs instead?

1236 ↗

(On Diff #154091)

Space after the comma.

1277 ↗

(On Diff #154091)

Space after the comma.

[CarlosAlbertoEnciso]

Address review comments from @probinson

[CarlosAlbertoEnciso]

include/clang/Sema/SemaInternal.h

91

Replaced the type name with the formal parameter name.

lib/Sema/SemaDeclCXX.cpp

15350

Replaced by a range-based for loop.

lib/Sema/SemaExpr.cpp

14139

Replaced the type name with the formal parameter name.

15076

Replaced the type name with the formal parameter name.

15097

Replaced the type name with the formal parameter name.

lib/Sema/SemaLookup.cpp

98 ↗

(On Diff #154091)

As UDirs is used to reference an instance of UnqualUsingDirectiveSet, I have changed UDirs to UsingDirs.

196 ↗

(On Diff #154091)

Replaced with a range-based for loop.

1064 ↗

(On Diff #154091)

Preserved 'UDirs' in this function, but changed the 'UDirs' typedef into 'UsingDirs'.

[CarlosAlbertoEnciso]

In D46190#1166775, @probinson wrote:

A bunch of style comments. Maybe try clang-format-diff.

@probinson:

Thanks very much for your review.

[CarlosAlbertoEnciso]

@probinson: I tried clang-format-diff and the main format issues are with the test cases.

Do you want the test cases to follow the clang format?

[probinson]

@rsmith any further thoughts? We would really like to get this in before the LLVM 7.0 branch, currently scheduled for 1 August.

In D46190#1168027, @CarlosAlbertoEnciso wrote:

@probinson: I tried clang-format-diff and the main format issues are with the test cases.

Do you want the test cases to follow the clang format?

The lib and include files absolutely need to follow clang format. Tests should also, if doing so doesn't disturb their readability. If clang-format-diff is doing things like rearranging comments in the test files, it depends on whether it improves or reduces clarity. Up to you.

lib/Sema/SemaDeclCXX.cpp

15296

This should use /// to be picked up by doxygen.

[CarlosAlbertoEnciso]

Used clang-format-diff as indicated by @probinson:

• The lib and include files follow the clang format.
• The tests mostly follow the clang format. I removed some extra formatting which was introduced and disturb their readability.

[CarlosAlbertoEnciso]

A minor modification to allow the comments for MarkNamespaceAliasReferenced to be picked up by doxygen.

[CarlosAlbertoEnciso]

@rsmith & @probinson,

Is there anything I can add to this patch in order to submit it?
This patch is blocking the review https://reviews.llvm.org/D44826 which is already approved.

Thanks very much.

lib/Sema/SemaDeclCXX.cpp

15296

Uploaded a new patch that contains that change.

[probinson]

Although I am far from expert in how Clang manages declarations, AFAICT this does what @rsmith requested, so LGTM.

[rsmith]

include/clang/Sema/Sema.h

4010–4012

Pass in the FoundDecl instead of a scope specifier and an expression.

lib/Sema/SemaDeclCXX.cpp

15301–15306

This is not the right approach. You should not iteratively mark namespaces as referenced here. Instead, when we parse the first namespace alias declaration in the chain, *it* should mark the subsequent one referenced immediately. So:

namespace A { int n; }
namespace B = A; // this declaration marks A referenced
namespace C = B; // this declaration marks B referenced
int k = C::n; // parsing the nested-name-specifier of this expression marks C referenced

15312–15367

You should not do any of this. You should keep track of how each name was actually originally found, and mark the FoundDecl as referenced. Do not attempt to redo the lookup like you do here. You will get it wrong, and in any case, redoing the lookup is wasteful.

include/clang/Sema/Sema.h

public:
   // needs to be delayed for some constant variables when we build one of the
   // named expressions.
   //
   // MightBeOdrUse indicates whether the use could possibly be an odr-use, and
   // should usually be true. This only needs to be set to false if the lack of
   // odr-use cannot be determined from the current context (for instance,
   // because the name denotes a virtual function and was written without an
   // explicit nested-name-specifier).
-  void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);
+  void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse,
+                             Expr *RefExpr = nullptr);
   void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
-                              bool MightBeOdrUse = true);
+                              bool MightBeOdrUse = true,
+                              Expr *RefExpr = nullptr);
   void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
   void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);
   void MarkMemberReferenced(MemberExpr *E);
 
   void UpdateMarkingForLValueToRValue(Expr *E);
   void CleanupVarDeclMarking();
 
   enum TryCaptureKind {
private:
   /// due to the packed attribute.
   SmallVector<MisalignedMember, 4> MisalignedMembers;
 
   /// \brief Adds an expression to the set of gathered misaligned members.
   void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
                                      CharUnits Alignment);
 
 public:
+  /// \brief Mark the declaration used, in the sense of odr-use.
+  ///
+  /// This notifies any mutation listeners in addition to setting a bit
+  /// indicating the declaration is used. It traverse its associated types
+  /// and mark them as used. Intended mainly for debug information.
+  void markAllUsed(Decl *D, ASTContext &C, Expr *RefExpr = nullptr);
+
+public:
   /// \brief Diagnoses the current set of gathered accesses. This typically
   /// happens at full expression level. The set is cleared after emitting the
   /// diagnostics.
   void DiagnoseMisalignedMembers();
 
   /// \brief This function checks if the expression is in the sef of potentially
   /// misaligned members and it is converted to some pointer type T with lower
   /// or equal alignment requirements. If so it removes it. This is used when

include/clang/Sema/SemaInternal.h

 // 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,
     SourceLocation Loc, Sema &SemaRef,
-    const unsigned *const FunctionScopeIndexToStopAt) {
+    const unsigned *const FunctionScopeIndexToStopAt, Expr *RefExpr = nullptr) {
   // Keep track of used but undefined variables.
   // FIXME: We shouldn't suppress this warning for static data members.
   if (Var->hasDefinition(SemaRef.Context) == VarDecl::DeclarationOnly &&
       (!Var->isExternallyVisible() || Var->isInline() ||
        SemaRef.isExternalWithNoLinkageType(Var)) &&
       !(Var->isStaticDataMember() && Var->hasInit())) {
     SourceLocation &old = SemaRef.UndefinedButUsed[Var->getCanonicalDecl()];
     if (old.isInvalid())
       old = Loc;
   }
   QualType CaptureType, DeclRefType;
   SemaRef.tryCaptureVariable(Var, Loc, Sema::TryCapture_Implicit, 
     /*EllipsisLoc*/ SourceLocation(),
     /*BuildAndDiagnose*/ true, 
     CaptureType, DeclRefType, 
     FunctionScopeIndexToStopAt);
 
-  Var->markUsed(SemaRef.Context);
+  SemaRef.markAllUsed(Var, SemaRef.Context, RefExpr);
 }
 
 /// Return a DLL attribute from the declaration.
 inline InheritableAttr *getDLLAttr(Decl *D) {
   assert(!(D->hasAttr<DLLImportAttr>() && D->hasAttr<DLLExportAttr>()) &&
          "A declaration cannot be both dllimport and dllexport.");
   if (auto *Import = D->getAttr<DLLImportAttr>())
     return Import;
   if (auto *Export = D->getAttr<DLLExportAttr>())

lib/AST/ASTDumper.cpp

for (ArrayRef<const Attr *>::iterator I = Node->getAttrs().begin(),
                                         E = Node->getAttrs().end();
        I != E; ++I)
     dumpAttr(*I);
 }
 
 void ASTDumper::VisitLabelStmt(const LabelStmt *Node) {
   VisitStmt(Node);
   OS << " '" << Node->getName() << "'";
+  dumpDecl(Node->getDecl());
 }
 
 void ASTDumper::VisitGotoStmt(const GotoStmt *Node) {
   VisitStmt(Node);
   OS << " '" << Node->getLabel()->getName() << "'";
   dumpPointer(Node->getLabel());
 }
 

lib/AST/DeclBase.cpp

if (CheckUsedAttr && getMostRecentDecl()->hasAttr<UsedAttr>())
     return true;
 
   // The information may have not been deserialized yet. Force deserialization
   // to complete the needed information.
   return getMostRecentDecl()->getCanonicalDecl()->Used;
 }
 
 void Decl::markUsed(ASTContext &C) {
-  if (isUsed(false))
-    return;
-
+  // The 'markAllUsed' does the check for an already used declaration. 
   if (C.getASTMutationListener())
     C.getASTMutationListener()->DeclarationMarkedUsed(this);
 
   setIsUsed();
 }
 
 bool Decl::isReferenced() const { 
   if (Referenced)

lib/Sema/Sema.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/PrettyDeclStackTrace.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/CXXFieldCollector.h"
 #include "clang/Sema/DelayedDiagnostic.h"
return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
                                        QT, OpenCLTypeExtMap);
 }
 
 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
   IdentifierInfo *FnName = D.getIdentifier();
   return checkOpenCLDisabledTypeOrDecl(&D, E.getLocStart(), FnName,
                                        OpenCLDeclExtMap, 1, D.getSourceRange());
 }
+
+// Visitor to set the 'used' bit.
+class UsedSetter : public RecursiveASTVisitor<UsedSetter> {
+using VisitorBase = RecursiveASTVisitor<UsedSetter>;
+public:
+  UsedSetter(Sema *S, ASTContext &C, Expr *RefExpr) :
+     S(S), C(C), CurContext(S->CurContext), RefExpr(RefExpr) {}
+
+public:
+  // C Types.
+  bool VisitArrayType(const ArrayType *T);
+  bool VisitAtomicType(const AtomicType *T);
+  bool VisitBlockPointerType(const BlockPointerType *T);
+  bool VisitEnumType(const EnumType *T);
+  bool VisitIncompleteArrayType(const IncompleteArrayType *T);
+  bool VisitParenType(const ParenType *T);
+  bool VisitPointerType(const PointerType *T);
+  bool VisitTypedefType(const TypedefType *T);
+  bool VisitVariableArrayType(const VariableArrayType *T);
+
+  // C++ Types.
+  bool VisitAttributedType(const AttributedType *T);
+  bool VisitComplexType(const ComplexType *T);
+  bool VisitConstantArrayType(const ConstantArrayType *T);
+  bool VisitDecayedType(const DecayedType *T);
+  bool VisitDecltypeType(const DecltypeType *T);
+  bool VisitDependentSizedArrayType(const DependentSizedArrayType *T);
+  bool VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T);
+  bool VisitElaboratedType(const ElaboratedType *T);
+  bool VisitExtVectorType(const ExtVectorType *T);
+  bool VisitLValueReferenceType(const LValueReferenceType *T);
+  bool VisitMemberPointerType(const MemberPointerType *T);
+  bool VisitRecordType(const RecordType *T);
+  bool VisitReferenceType(const ReferenceType *T);
+  bool VisitRValueReferenceType(const RValueReferenceType *T);
+  bool VisitTypeOfType(const TypeOfType *T);
+  bool VisitUnaryTransformType(const UnaryTransformType *T);
+  bool VisitUnresolvedUsingType(const UnresolvedUsingType *T);
+  bool VisitVectorType(const VectorType *T);
+
+  // ObjC Types.
+  bool VisitObjCInterfaceType(const ObjCInterfaceType *T);
+  bool VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
+  bool VisitObjCObjectType(const ObjCObjectType *T);
+
+  // C Decls.
+  bool VisitBlockDecl(const BlockDecl *D);
+  bool VisitDeclContext(DeclContext *DC);
+  bool VisitEnumConstantDecl(EnumConstantDecl *D);
+  bool VisitEnumDecl(EnumDecl *D);
+  bool VisitFieldDecl(FieldDecl *D);
+  bool VisitFunctionDecl(FunctionDecl *D);
+  bool VisitLabelDecl(LabelDecl *D);
+  bool VisitParmVarDecl(ParmVarDecl *D);
+  bool VisitRecordDecl(RecordDecl *D);
+  bool VisitTypedefDecl(TypedefNameDecl *D);
+  bool VisitVarDecl(VarDecl *D);
+
+  // C++ Decls.
+  bool VisitCXXConstructorDecl(CXXConstructorDecl *D);
+  bool VisitCXXConversionDecl(CXXConversionDecl *D);
+  bool VisitCXXDestructorDecl(CXXDestructorDecl *D);
+  bool VisitCXXMethodDecl(CXXMethodDecl *D);
+  bool VisitCXXRecordDecl(CXXRecordDecl *D);
+  bool VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
+  bool VisitNamespaceDecl(NamespaceDecl *D);
+  bool VisitTypeAliasDecl(TypeAliasDecl *D);
+  bool VisitUsingDecl(UsingDecl *D);
+  bool VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
+  bool VisitUsingShadowDecl(UsingShadowDecl *D);
+
+  // OpenMP Decls.
+  bool VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
+  bool VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
+  bool VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
+
+  // ObjC Decls.
+  bool VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
+  bool VisitObjCCategoryDecl(ObjCCategoryDecl *D);
+  bool VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
+  bool VisitObjCImplementationDecl(ObjCImplementationDecl *D);
+  bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
+  bool VisitObjCMethodDecl(ObjCMethodDecl *D);
+  bool VisitObjCPropertyDecl(ObjCPropertyDecl *D);
+  bool VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
+  bool VisitObjCProtocolDecl(ObjCProtocolDecl *D);
+
+public:
+  bool VisitDecl(Decl *D);
+
+private:
+  // Mark usings dependencies.
+  void markSymbolFromNamespace(NamedDecl *D);
+  void markUsings(Decl *D, QualType T);
+  bool markUsings(DeclContext *LookupContext, NamedDecl *TargetDecl,
+                  NamespaceDecl *TargetNamespace);
+
+  // Mark parent context for given declaration.
+  void markParentContext(Decl *D);
+
+private:
+  Sema *S;
+  ASTContext &C;
+  DeclContext *CurContext;
+  Expr *RefExpr;
+};
+
+//===---------------------------------------------------------------------===//
+// C Types.
+//===---------------------------------------------------------------------===//
+bool UsedSetter::VisitArrayType(const ArrayType *T) {
+  return TraverseType(T->getElementType());
+}
+bool UsedSetter::VisitAtomicType(const AtomicType *T) {
+  return TraverseType(T->getValueType());
+}
+bool UsedSetter::VisitBlockPointerType(const BlockPointerType *T) {
+  return TraverseType(T->getPointeeType());
+}
+bool UsedSetter::VisitEnumType(const EnumType *T) {
+  return VisitEnumDecl(T->getDecl());
+}
+bool UsedSetter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
+  return VisitArrayType(T);
+}
+bool UsedSetter::VisitParenType(const ParenType *T) {
+  return TraverseType(T->getInnerType());
+}
+bool UsedSetter::VisitPointerType(const PointerType *T) {
+  return TraverseType(T->getPointeeType());
+}
+bool UsedSetter::VisitTypedefType(const TypedefType *T) {
+  return VisitTypedefDecl(T->getDecl());
+}
+bool UsedSetter::VisitVariableArrayType(const VariableArrayType *T) {
+  return VisitArrayType(T);
+}
+
+//===---------------------------------------------------------------------===//
+// C++ Types.
+//===---------------------------------------------------------------------===//
+bool UsedSetter::VisitAttributedType(const AttributedType *T) {
+  return TraverseType(T->getModifiedType());
+}
+bool UsedSetter::VisitComplexType(const ComplexType *T) {
+  return TraverseType(T->getElementType());
+}
+bool UsedSetter::VisitConstantArrayType(const ConstantArrayType *T) {
+  return VisitArrayType(T);
+}
+bool UsedSetter::VisitDecayedType(const DecayedType *T) {
+  return TraverseType(T->getPointeeType());
+}
+bool UsedSetter::VisitDecltypeType(const DecltypeType *T) {
+  return TraverseType(T->getUnderlyingType());
+}
+bool UsedSetter::VisitDependentSizedArrayType(
+                                           const DependentSizedArrayType *T) {
+  return VisitArrayType(T);
+}
+bool UsedSetter::VisitDependentSizedExtVectorType(
+                                       const DependentSizedExtVectorType *T) {
+  return TraverseType(T->getElementType());
+}
+bool UsedSetter::VisitElaboratedType(const ElaboratedType *T) {
+  return TraverseType(T->getNamedType());
+}
+bool UsedSetter::VisitExtVectorType(const ExtVectorType *T) {
+  return VisitVectorType(T);
+}
+bool UsedSetter::VisitLValueReferenceType(const LValueReferenceType *T) {
+  return VisitReferenceType(T);
+}
+bool UsedSetter::VisitMemberPointerType(const MemberPointerType *T) {
+  return TraverseType(T->getPointeeType());
+}
+bool UsedSetter::VisitRecordType(const RecordType *T) {
+  return VisitRecordDecl(T->getDecl());
+}
+bool UsedSetter::VisitReferenceType(const ReferenceType *T) {
+  return TraverseType(T->getPointeeType());
+}
+bool UsedSetter::VisitRValueReferenceType(const RValueReferenceType *T) {
+  return VisitReferenceType(T);
+}
+bool UsedSetter::VisitTypeOfType(const TypeOfType *T) {
+  return TraverseType(T->getUnderlyingType());
+}
+bool UsedSetter::VisitUnaryTransformType(const UnaryTransformType *T) {
+  return TraverseType(T->getUnderlyingType());
+}
+bool UsedSetter::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
+  return VisitUnresolvedUsingTypenameDecl(T->getDecl());
+}
+bool UsedSetter::VisitVectorType(const VectorType *T) {
+  return TraverseType(T->getElementType());
+}
+
+//===---------------------------------------------------------------------===//
+// ObjC Types.
+//===---------------------------------------------------------------------===//
+bool UsedSetter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
+  return true;
+}
+bool UsedSetter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
+  return true;
+}
+bool UsedSetter::VisitObjCObjectType(const ObjCObjectType *T) {
+  return true;
+}
+
+//===---------------------------------------------------------------------===//
+// C Decls.
+//===---------------------------------------------------------------------===//
+bool UsedSetter::VisitBlockDecl(const BlockDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitDeclContext(DeclContext *DC) {
+  // Base: CXXMethodDecl
+  if (auto *CD = dyn_cast<CXXConstructorDecl>(DC))
+    return VisitCXXConstructorDecl(CD);
+
+  // Base: CXXMethodDecl
+  if (auto *DD = dyn_cast<CXXDestructorDecl>(DC))
+    return VisitCXXDestructorDecl(DD);
+
+  // Base: CXXMethodDecl
+  if (auto *CD = dyn_cast<CXXConversionDecl>(DC))
+    return VisitCXXConversionDecl(CD);
+
+  // Base: FunctionDecl
+  if (auto *MD = dyn_cast<CXXMethodDecl>(DC))
+    return VisitCXXMethodDecl(MD);
+
+  // Base: DeclaratorDecl
+  if (auto *FD = dyn_cast<FunctionDecl>(DC))
+    return VisitFunctionDecl(FD);
+
+  // Base: NamedDecl
+  if (auto *ND = dyn_cast<NamespaceDecl>(DC))
+    return VisitNamespaceDecl(ND);
+
+  // Base: TagDecl
+  if (auto *RD = dyn_cast<RecordDecl>(DC))
+    return VisitRecordDecl(RD);
+
+  // Base: Decl
+  if (auto *BD = dyn_cast<BlockDecl>(DC))
+    return VisitBlockDecl(BD);
+
+  return true;
+}
+bool UsedSetter::VisitEnumConstantDecl(EnumConstantDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  return TraverseType(D->getType());
+}
+bool UsedSetter::VisitEnumDecl(EnumDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  return TraverseType(D->getPromotionType());
+}
+bool UsedSetter::VisitFieldDecl(FieldDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  // Mark the field type.
+  auto T = D->getType();
+  markUsings(D, T);
+  return TraverseType(T);
+}
+bool UsedSetter::VisitFunctionDecl(FunctionDecl *D) {
+  if (D->isUsed(false) && !RefExpr)
+    return true;
+  D->markUsed(C);
+
+  markParentContext(D);
+
+  // Mark parameters.
+  if (D->getNumParams())
+    for (auto *PD : D->parameters())
+      VisitParmVarDecl(PD);
+
+  // Mark return type.
+  auto T = D->getReturnType();
+  markUsings(D, T);
+
+  // Check if the symbols referenced by a 'using' statement.
+  markSymbolFromNamespace(D);
+
+  return TraverseType(T);
+}
+bool UsedSetter::VisitLabelDecl(LabelDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  return VisitDeclContext(D->getDeclContext());
+}
+bool UsedSetter::VisitParmVarDecl(ParmVarDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  // Mark the parameter type.
+  auto T = D->getType();
+  markUsings(D, T);
+  return TraverseType(T);
+}
+bool UsedSetter::VisitRecordDecl(RecordDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  // Mark non-static fields.
+  for (auto *FD : D->fields())
+    VisitFieldDecl(FD);
+
+  markParentContext(D);
+  return true;
+}
+bool UsedSetter::VisitTypedefDecl(TypedefNameDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  markParentContext(D);
+  return TraverseType(D->getUnderlyingType());
+}
+bool UsedSetter::VisitVarDecl(VarDecl *D) {
+  if (D->isUsed(false) && !RefExpr)
+    return true;
+  D->markUsed(C);
+
+  markParentContext(D);
+
+  // Mark the variable type.
+  auto T = D->getType();
+  markUsings(D, T);
+
+  // Check if the symbols referenced by a 'using' statement.
+  markSymbolFromNamespace(D);
+
+  return TraverseType(T);
+}
+
+//===---------------------------------------------------------------------===//
+// C++ Decls.
+//===---------------------------------------------------------------------===//
+bool UsedSetter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
+  return VisitCXXMethodDecl(D);
+}
+bool UsedSetter::VisitCXXConversionDecl(CXXConversionDecl *D) {
+  return VisitCXXMethodDecl(D);
+}
+bool UsedSetter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
+  return VisitCXXMethodDecl(D);
+}
+bool UsedSetter::VisitCXXMethodDecl(CXXMethodDecl *D) {
+  return VisitFunctionDecl(D);
+}
+bool UsedSetter::VisitCXXRecordDecl(CXXRecordDecl *D) {
+  return VisitRecordDecl(D);
+}
+bool UsedSetter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  return VisitNamespaceDecl(D->getNamespace());
+}
+bool UsedSetter::VisitNamespaceDecl(NamespaceDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  markParentContext(D);
+  return true;
+}
+bool UsedSetter::VisitTypeAliasDecl(TypeAliasDecl *D) {
+  if (D->isUsed(false))
+    return true;
+
+  return TraverseType(D->getUnderlyingType());
+}
+bool UsedSetter::VisitUsingDecl(UsingDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  return true;
+}
+bool UsedSetter::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  return VisitNamespaceDecl(D->getNominatedNamespace());
+}
+bool UsedSetter::VisitUsingShadowDecl(UsingShadowDecl *D) {
+  if (D->isUsed(false))
+    return true;
+  D->markUsed(C);
+
+  // Mark the associated using declaration.
+  return VisitUsingDecl(D->getUsingDecl());
+}
+
+//===---------------------------------------------------------------------===//
+// OpenMP Decls.
+//===---------------------------------------------------------------------===//
+bool UsedSetter::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
+  return true;
+}
+
+//===---------------------------------------------------------------------===//
+// ObjC Decls.
+//===---------------------------------------------------------------------===//
+bool UsedSetter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
+  return true;
+}
+bool UsedSetter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
+  return true;
+}
+
+/// \brief For the given declaration, mark all its parent context as used.
+void UsedSetter::markParentContext(Decl *D) {
+  // For the given declaration, mark its parent context.
+  for (auto *DC = D->getDeclContext();
+    !isa<TranslationUnitDecl>(DC) && 
+    !isa<LinkageSpecDecl>(DC) && D->isUsed(false); DC = DC->getParent())
+      VisitDeclContext(DC);
+}
+
+/// \brief For the given declaration (variable or function), mark as used
+/// any associated 'using' statement.
+void UsedSetter::markSymbolFromNamespace(NamedDecl *D) {
+  // For a function or variable declared in a namespace, check for 'using'
+  // statement. Use the context passed by Sema, as it corresponds to the
+  // context where the variable or function is being referenced.
+  auto *DC = D->getDeclContext();
+  if (DC->isNamespace()) {
+    // Check if the referenced variable or function contains any named
+    // qualifiers. As this function can be called recursively, ignore
+    // the calls that do not refer to the original referenced variable
+    // or function.
+    DeclRefExpr *DRE;
+    if (RefExpr && (DRE = dyn_cast<DeclRefExpr>(RefExpr))) {
+      auto *VD = cast<ValueDecl>(DRE->getDecl());
+      if (VD == D && !DRE->hasQualifier())
+        if (markUsings(CurContext, D, dyn_cast<NamespaceDecl>(DC)))
+          return;
+    }
+    // Consider namespace aliases.
+    auto *TargetNamespace = dyn_cast<NamespaceDecl>(DC);
+    for (DC = CurContext; DC; DC = DC->getParent()) {
+      for (auto *DR : DC->decls())
+        if (auto *NA = dyn_cast<NamespaceAliasDecl>(DR)) {
+          if (NA->getNamespace() == TargetNamespace) {
+            VisitNamespaceAliasDecl(NA);
+            return;
+          }
+        }
+    }
+  }
+}
+
+/// \brief If the given type was introduced by a 'using' statement, mark its
+// associated 'using' as used.
+void UsedSetter::markUsings(Decl *D, QualType QT) {
+  // In the case of name qualified type, do not look for any reference to
+  // a 'using' declaration.
+  //   namespace N {
+  //     typedef int INT;
+  //   }
+  //   void foo {
+  //     N::INT var;
+  //   }
+  if (isa<ElaboratedType>(QT))
+    return;
+
+  NamedDecl *TargetDecl = nullptr;
+  auto *T = QT.getTypePtr();
+  if (auto *TT = dyn_cast<TypedefType>(T))
+    TargetDecl = TT->getDecl();
+  else if (auto *RT = dyn_cast<RecordType>(T))
+    TargetDecl = RT->getDecl();
+
+  if (TargetDecl) {
+    // To have a proper search on 'using' statements, we need to determine
+    // the correct lookup context, based on the symbol being marked as used.
+    // In the case of parameters, the lookup context is the enclosing scope.
+    auto *LookupContext = D->getDeclContext();
+    if (D->getKind() == Decl::ParmVar)
+      LookupContext = LookupContext->getParent();
+
+    auto *DC = TargetDecl->getDeclContext();
+    if (DC->isNamespace())
+      markUsings(LookupContext, TargetDecl, dyn_cast<NamespaceDecl>(DC));
+  }
+}
+
+/// \brief If the given declaration was introduced by a 'using' statement,
+// mark its associated 'using' as used.
+bool UsedSetter::markUsings(DeclContext *LookupContext, NamedDecl *TargetDecl,
+                            NamespaceDecl *TargetNamespace) {
+  // Look for an introduced declaration via a 'using' statement.
+  // Do not perform lookups into transparent contexts.
+  for (auto *DC = LookupContext;
+       DC && !isa<LinkageSpecDecl>(DC) && !isa<ExportDecl>(DC);
+       DC = DC->getParent()) {
+    // The using-declaration are contained in the returned 'decls()'.
+    for (auto *DR : DC->decls())
+      if (auto *USD = dyn_cast<UsingShadowDecl>(DR)) {
+        if (USD->getTargetDecl() == TargetDecl) {
+          VisitUsingShadowDecl(USD);
+          return true;
+        }
+      }
+    // Check for using-directives.
+    for (auto *UD : DC->using_directives())
+      if (UD->getNominatedNamespace() == TargetNamespace) {
+        VisitUsingDirectiveDecl(UD);
+        return true;
+      }
+  }
+
+  // Do not perform lookups into transparent contexts.
+  if (LookupContext->getDeclKind() == Decl::LinkageSpec ||
+      LookupContext->getDeclKind() == Decl::Export)
+    return false;
+
+  if (auto *scope = S->getScopeForContext(LookupContext))
+    for (auto *UD : scope->using_directives())
+      if (UD->getNominatedNamespace() == TargetNamespace) {
+        VisitUsingDirectiveDecl(UD);
+        return true;
+      }
+
+  return false;
+}
+
+bool UsedSetter::VisitDecl(Decl *D) {
+  // This is the main entry point to mark the given declaration as used.
+  // We deal only with functions and variables.
+
+  // Base: CXXMethodDecl
+  if (auto *CD = dyn_cast<CXXConstructorDecl>(D))
+    return VisitCXXConstructorDecl(CD);
+
+  // Base: CXXMethodDecl
+  if (auto *DD = dyn_cast<CXXDestructorDecl>(D))
+    return VisitCXXDestructorDecl(DD);
+
+  // Base: CXXMethodDecl
+  if (auto *CD = dyn_cast<CXXConversionDecl>(D))
+    return VisitCXXConversionDecl(CD);
+
+  // Base: FunctionDecl
+  if (auto *MD = dyn_cast<CXXMethodDecl>(D))
+    return VisitCXXMethodDecl(MD);
+
+  // Base: DeclaratorDecl
+  if (auto *FD = dyn_cast<FunctionDecl>(D))
+    return VisitFunctionDecl(FD);
+
+  // Base: VarDecl
+  if (auto *PD = dyn_cast<ParmVarDecl>(D))
+    return VisitParmVarDecl(PD);
+
+  // Base: DeclaratorDecl
+  if (auto *VD = dyn_cast<VarDecl>(D))
+    return VisitVarDecl(VD);
+
+  // Base: NamedDecl
+  if (auto *LD = dyn_cast<LabelDecl>(D))
+    return VisitLabelDecl(LD);
+
+  // For unsupported ObjC or OpenMP declarations.
+  D->markUsed(C);
+  return true;
+}
+
+void Sema::markAllUsed(Decl *D, ASTContext &C, Expr *RefExpr) {
+  // When setting the 'used' bit for referenced variables or functions, the
+  // 'RefExpr' is the expression associated with that reference. Within the
+  // same context, the variable or function can be referenced more than once:
+  //   namespace M { void Foo(); }
+  //   namespace N { int a; }
+  //   void Bar() {
+  //     M::Foo();        <-- Marked as used. RefExpr1;
+  //     using M::Foo;
+  //     Foo();           <-- Already marked as used. RefExpr2;
+  //                      <-- We have to mark the 'using' statement.
+  //
+  //     N::a = 1;        <-- Marked as used. RefExpr3;
+  //     using N::a;
+  //     a = 2;           <-- Already marked as used. RefExpr4;
+  //                      <-- We have to mark the 'using' statement.
+  //   }
+  if (D->isUsed(false) && !RefExpr)
+    return;
+
+  UsedSetter Setter(this, C, RefExpr);
+  Setter.VisitDecl(D);
+}

lib/Sema/SemaDeclCXX.cpp

if (SetCtorInitializers(Constructor, /*AnyErrors=*/false)) {
     Constructor->setInvalidDecl();
     return;
   }
 
   SourceLocation Loc = Constructor->getLocEnd().isValid()
                            ? Constructor->getLocEnd()
                            : Constructor->getLocation();
   Constructor->setBody(new (Context) CompoundStmt(Loc));
-  Constructor->markUsed(Context);
+  markAllUsed(Constructor, Context);
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(Constructor);
   }
 
   DiagnoseUninitializedFields(*this, Constructor);
 }
 
void Sema::DefineInheritingConstructor(SourceLocation CurrentLocation,
   // initializers replaced.
 
   if (SetCtorInitializers(Constructor, /*AnyErrors*/false, Inits)) {
     Constructor->setInvalidDecl();
     return;
   }
 
   Constructor->setBody(new (Context) CompoundStmt(InitLoc));
-  Constructor->markUsed(Context);
+  markAllUsed(Constructor, Context);
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(Constructor);
   }
 
   DiagnoseUninitializedFields(*this, Constructor);
 }
 
if (CheckDestructor(Destructor)) {
     Destructor->setInvalidDecl();
     return;
   }
 
   SourceLocation Loc = Destructor->getLocEnd().isValid()
                            ? Destructor->getLocEnd()
                            : Destructor->getLocation();
   Destructor->setBody(new (Context) CompoundStmt(Loc));
-  Destructor->markUsed(Context);
+  markAllUsed(Destructor, Context);
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(Destructor);
   }
 }
 
 /// \brief Perform any semantic analysis which needs to be delayed until all
 /// pending class member declarations have been parsed.
void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
   StmtResult Body;
   {
     CompoundScopeRAII CompoundScope(*this);
     Body = ActOnCompoundStmt(Loc, Loc, Statements,
                              /*isStmtExpr=*/false);
     assert(!Body.isInvalid() && "Compound statement creation cannot fail");
   }
   CopyAssignOperator->setBody(Body.getAs<Stmt>());
-  CopyAssignOperator->markUsed(Context);
+  markAllUsed(CopyAssignOperator, Context);
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(CopyAssignOperator);
   }
 }
 
 CXXMethodDecl *Sema::DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl) {
   assert(ClassDecl->needsImplicitMoveAssignment());
void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
   StmtResult Body;
   {
     CompoundScopeRAII CompoundScope(*this);
     Body = ActOnCompoundStmt(Loc, Loc, Statements,
                              /*isStmtExpr=*/false);
     assert(!Body.isInvalid() && "Compound statement creation cannot fail");
   }
   MoveAssignOperator->setBody(Body.getAs<Stmt>());
-  MoveAssignOperator->markUsed(Context);
+  markAllUsed(MoveAssignOperator, Context);
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(MoveAssignOperator);
   }
 }
 
 CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
                                                     CXXRecordDecl *ClassDecl) {
if (SetCtorInitializers(CopyConstructor, /*AnyErrors=*/false)) {
     CopyConstructor->setInvalidDecl();
   }  else {
     SourceLocation Loc = CopyConstructor->getLocEnd().isValid()
                              ? CopyConstructor->getLocEnd()
                              : CopyConstructor->getLocation();
     Sema::CompoundScopeRAII CompoundScope(*this);
     CopyConstructor->setBody(
         ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
-    CopyConstructor->markUsed(Context);
+    markAllUsed(CopyConstructor, Context);
   }
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(CopyConstructor);
   }
 }
 
 CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
if (SetCtorInitializers(MoveConstructor, /*AnyErrors=*/false)) {
     MoveConstructor->setInvalidDecl();
   } else {
     SourceLocation Loc = MoveConstructor->getLocEnd().isValid()
                              ? MoveConstructor->getLocEnd()
                              : MoveConstructor->getLocation();
     Sema::CompoundScopeRAII CompoundScope(*this);
     MoveConstructor->setBody(ActOnCompoundStmt(
         Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
-    MoveConstructor->markUsed(Context);
+    markAllUsed(MoveConstructor, Context);
   }
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(MoveConstructor);
   }
 }
 
 bool Sema::isImplicitlyDeleted(FunctionDecl *FD) {
void Sema::DefineImplicitLambdaToFunctionPointerConversion(
   // For both the conversion and static-invoker template specializations
   // we construct their body's in this function, so no need to add them
   // to the PendingInstantiations.
   MarkFunctionReferenced(CurrentLocation, CallOp);
 
   // Fill in the __invoke function with a dummy implementation. IR generation
   // will fill in the actual details. Update its type in case it contained
   // an 'auto'.
-  Invoker->markUsed(Context);
+  markAllUsed(Invoker, Context);
   Invoker->setReferenced();
   Invoker->setType(Conv->getReturnType()->getPointeeType());
   Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
 
   // Construct the body of the conversion function { return __invoke; }.
   Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
                                        VK_LValue, Conv->getLocation()).get();
   assert(FunctionRef && "Can't refer to __invoke function?");
   Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
   Conv->setBody(CompoundStmt::Create(Context, Return, Conv->getLocation(),
                                      Conv->getLocation()));
-  Conv->markUsed(Context);
+  markAllUsed(Conv, Context);
   Conv->setReferenced();
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(Conv);
     L->CompletedImplicitDefinition(Invoker);
   }
 }
 
if (Return.isInvalid()) {
     Conv->setInvalidDecl();
     return;
   }
 
   // Set the body of the conversion function.
   Stmt *ReturnS = Return.get();
   Conv->setBody(CompoundStmt::Create(Context, ReturnS, Conv->getLocation(),
                                      Conv->getLocation()));
-  Conv->markUsed(Context);
+  markAllUsed(Conv, Context);
 
   // We're done; notify the mutation listener, if any.
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(Conv);
   }
 }
 
 /// \brief Determine whether the given list arguments contains exactly one
if (NewPD->isInvalidDecl() && PrevDecl) {
     // Don't introduce NewFD into scope; there's already something
     // with the same name in the same scope.
   } else if (II) {
     PushOnScopeChains(NewPD, S);
   } else
     Record->addDecl(NewPD);
 
   return NewPD;
 }

lib/Sema/SemaExpr.cpp

 ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
                               tok::TokenKind Op, Expr *Input) {
   return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input);
 }
 
 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
 ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
                                 LabelDecl *TheDecl) {
-  TheDecl->markUsed(Context);
+  markAllUsed(TheDecl, Context);
   // Create the AST node.  The address of a label always has type 'void*'.
   return new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl,
                                      Context.getPointerType(Context.VoidTy));
 }
 
 /// Given the last statement in a statement-expression, check whether
 /// the result is a producing expression (like a call to an
 /// ns_returns_retained function) and, if so, rebuild it to hoist the
static bool isImplicitlyDefinableConstexprFunction(FunctionDecl *Func) {
   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Func);
   return Func->isConstexpr() &&
          (Func->isImplicitlyInstantiable() || (MD && !MD->isUserProvided()));
 }
 
 /// \brief Mark a function referenced, and check whether it is odr-used
 /// (C++ [basic.def.odr]p2, C99 6.9p3)
 void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
-                                  bool MightBeOdrUse) {
+                                  bool MightBeOdrUse, Expr *RefExpr) {
   assert(Func && "No function?");
 
   Func->setReferenced();
 
   // C++11 [basic.def.odr]p3:
   //   A function whose name appears as a potentially-evaluated expression is
   //   odr-used if it is the unique lookup result or the selected member of a
   //   set of overloaded functions [...].
if (!Func->isDefined()) {
     else if (Func->getMostRecentDecl()->isInlined() &&
              !LangOpts.GNUInline &&
              !Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
       UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
     else if (isExternalWithNoLinkageType(Func))
       UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
   }
 
-  Func->markUsed(Context);
+  markAllUsed(Func, Context, RefExpr);
 }
 
 static void
 diagnoseUncapturableValueReference(Sema &S, SourceLocation loc,
                                    ValueDecl *var, DeclContext *DC) {
   DeclContext *VarDC = var->getDeclContext();
 
   //  If the parameter still belongs to the translation unit, then
   //  we're actually just using one parameter in the declaration of
if (BuildAndDiagnose) {
     Field->setAccess(AS_private);
     RD->addDecl(Field);
     if (S.getLangOpts().OpenMP && RSI->CapRegionKind == CR_OpenMP)
       S.setOpenMPCaptureKind(Field, Var, RSI->OpenMPLevel);
  
     CopyExpr = new (S.Context) DeclRefExpr(Var, RefersToCapturedVariable,
                                             DeclRefType, VK_LValue, Loc);
     Var->setReferenced(true);
-    Var->markUsed(S.Context);
+    S.markAllUsed(Var, S.Context);
   }
 
   // Actually capture the variable.
   if (BuildAndDiagnose)
     RSI->addCapture(Var, /*isBlock*/false, ByRef, RefersToCapturedVariable, Loc,
                     SourceLocation(), CaptureType, CopyExpr);
   
   
if (OdrUseContext && E &&
       IsVariableAConstantExpression(Var, SemaRef.Context)) {
     // A reference initialized by a constant expression can never be
     // odr-used, so simply ignore it.
     if (!Var->getType()->isReferenceType() ||
         (SemaRef.LangOpts.OpenMP && SemaRef.isOpenMPCapturedDecl(Var)))
       SemaRef.MaybeODRUseExprs.insert(E);
   } else if (OdrUseContext) {
     MarkVarDeclODRUsed(Var, Loc, SemaRef,
-                       /*MaxFunctionScopeIndex ptr*/ nullptr);
+                       /*MaxFunctionScopeIndex ptr*/ nullptr, E);
   } else if (isOdrUseContext(SemaRef, /*SkipDependentUses*/false)) {
     // If this is a dependent context, we don't need to mark variables as
     // odr-used, but we may still need to track them for lambda capture.
     // FIXME: Do we also need to do this inside dependent typeid expressions
     // (which are modeled as unevaluated at this point)?
     const bool RefersToEnclosingScope =
         (SemaRef.CurContext != Var->getDeclContext() &&
          Var->getDeclContext()->isFunctionOrMethod() && Var->hasLocalStorage());
static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc,
   if (SemaRef.isInOpenMPDeclareTargetContext())
     SemaRef.checkDeclIsAllowedInOpenMPTarget(E, D);
 
   if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
     DoMarkVarDeclReferenced(SemaRef, Loc, Var, E);
     return;
   }
 
-  SemaRef.MarkAnyDeclReferenced(Loc, D, MightBeOdrUse);
+  SemaRef.MarkAnyDeclReferenced(Loc, D, MightBeOdrUse, E);
 
   // If this is a call to a method via a cast, also mark the method in the
   // derived class used in case codegen can devirtualize the call.
   const MemberExpr *ME = dyn_cast<MemberExpr>(E);
   if (!ME)
     return;
   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ME->getMemberDecl());
   if (!MD)
     return;
   // Only attempt to devirtualize if this is truly a virtual call.
   bool IsVirtualCall = MD->isVirtual() &&
                           ME->performsVirtualDispatch(SemaRef.getLangOpts());
   if (!IsVirtualCall)
     return;
 
   // If it's possible to devirtualize the call, mark the called function
   // referenced.
   CXXMethodDecl *DM = MD->getDevirtualizedMethod(
       ME->getBase(), SemaRef.getLangOpts().AppleKext);
   if (DM)
-    SemaRef.MarkAnyDeclReferenced(Loc, DM, MightBeOdrUse);
+    SemaRef.MarkAnyDeclReferenced(Loc, DM, MightBeOdrUse, E);
 }
 
 /// \brief Perform reference-marking and odr-use handling for a DeclRefExpr.
 void Sema::MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base) {
   // TODO: update this with DR# once a defect report is filed.
   // C++11 defect. The address of a pure member should not be an ODR use, even
   // if it's a qualified reference.
   bool OdrUse = true;
   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getDecl()))
void Sema::MarkMemberReferenced(MemberExpr *E) {
   MarkExprReferenced(*this, Loc, E->getMemberDecl(), E, MightBeOdrUse);
 }
 
 /// \brief Perform marking for a reference to an arbitrary declaration.  It
 /// marks the declaration referenced, and performs odr-use checking for
 /// functions and variables. This method should not be used when building a
 /// normal expression which refers to a variable.
 void Sema::MarkAnyDeclReferenced(SourceLocation Loc, Decl *D,
-                                 bool MightBeOdrUse) {
+                                 bool MightBeOdrUse, Expr *RefExpr) {
   if (MightBeOdrUse) {
     if (auto *VD = dyn_cast<VarDecl>(D)) {
       MarkVariableReferenced(Loc, VD);
       return;
     }
   }
   if (auto *FD = dyn_cast<FunctionDecl>(D)) {
-    MarkFunctionReferenced(Loc, FD, MightBeOdrUse);
+    MarkFunctionReferenced(Loc, FD, MightBeOdrUse, RefExpr);
     return;
   }
   D->setReferenced();
 }
 
 namespace {
   // Mark all of the declarations used by a type as referenced.
   // FIXME: Not fully implemented yet! We need to have a better understanding

lib/Sema/SemaLambda.cpp

VarDecl *Sema::createLambdaInitCaptureVarDecl(SourceLocation Loc,
   // init-capture.
   // FIXME: Pass in separate source locations for '&' and identifier.
   VarDecl *NewVD = VarDecl::Create(Context, CurContext, Loc,
                                    Loc, Id, InitCaptureType, TSI, SC_Auto);
   NewVD->setInitCapture(true);
   NewVD->setReferenced(true);
   // FIXME: Pass in a VarDecl::InitializationStyle.
   NewVD->setInitStyle(static_cast<VarDecl::InitializationStyle>(InitStyle));
-  NewVD->markUsed(Context);
+  markAllUsed(NewVD, Context);
   NewVD->setInit(Init);
   return NewVD;
 }
 
 FieldDecl *Sema::buildInitCaptureField(LambdaScopeInfo *LSI, VarDecl *Var) {
   FieldDecl *Field = FieldDecl::Create(
       Context, LSI->Lambda, Var->getLocation(), Var->getLocation(),
       nullptr, Var->getType(), Var->getTypeSourceInfo(), nullptr, false,
ExprResult Sema::BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
                                                Expr *Src) {
   // Make sure that the lambda call operator is marked used.
   CXXRecordDecl *Lambda = Conv->getParent();
   CXXMethodDecl *CallOperator 
     = cast<CXXMethodDecl>(
         Lambda->lookup(
           Context.DeclarationNames.getCXXOperatorName(OO_Call)).front());
   CallOperator->setReferenced();
-  CallOperator->markUsed(Context);
+  markAllUsed(CallOperator, Context);
 
   ExprResult Init = PerformCopyInitialization(
       InitializedEntity::InitializeLambdaToBlock(ConvLocation, Src->getType(),
                                                  /*NRVO=*/false),
       CurrentLocation, Src);
   if (!Init.isInvalid())
     Init = ActOnFinishFullExpr(Init.get());
   

lib/Sema/SemaOpenMP.cpp

static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
   }
   return Decl;
 }
 
 static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
                                      SourceLocation Loc,
                                      bool RefersToCapture = false) {
   D->setReferenced();
-  D->markUsed(S.Context);
+  S.markAllUsed(D, S.Context);
   return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
                              SourceLocation(), D, RefersToCapture, Loc, Ty,
                              VK_LValue);
 }
 
 void DSAStackTy::addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
                                            BinaryOperatorKind BOK) {
   D = getCanonicalDecl(D);
Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
   SmallVector<Expr *, 8> Vars;
   for (Expr *RefExpr : VarList) {
     auto *DE = cast<DeclRefExpr>(RefExpr);
     auto *VD = cast<VarDecl>(DE->getDecl());
     SourceLocation ILoc = DE->getExprLoc();
 
     // Mark variable as used.
     VD->setReferenced();
-    VD->markUsed(Context);
+    markAllUsed(VD, Context);
 
     QualType QType = VD->getType();
     if (QType->isDependentType() || QType->isInstantiationDependentType()) {
       // It will be analyzed later.
       Vars.push_back(DE);
       continue;
     }
 

lib/Sema/SemaStmt.cpp

InvalidateOnErrorScope Invalidate(*this, LoopVar,
                                     LoopVar->getType()->isUndeducedType());
 
   StmtResult BeginDeclStmt = Begin;
   StmtResult EndDeclStmt = End;
   ExprResult NotEqExpr = Cond, IncrExpr = Inc;
 
   if (RangeVarType->isDependentType()) {
     // The range is implicitly used as a placeholder when it is dependent.
-    RangeVar->markUsed(Context);
+    markAllUsed(RangeVar, Context);
 
     // Deduce any 'auto's in the loop variable as 'DependentTy'. We'll fill
     // them in properly when we instantiate the loop.
     if (!LoopVar->isInvalidDecl() && Kind != BFRK_Check) {
       if (auto *DD = dyn_cast<DecompositionDecl>(LoopVar))
         for (auto *Binding : DD->bindings())
           Binding->setType(Context.DependentTy);
       LoopVar->setType(SubstAutoType(LoopVar->getType(), Context.DependentTy));
StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
 
   return S;
 }
 
 StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
                                SourceLocation LabelLoc,
                                LabelDecl *TheDecl) {
   setFunctionHasBranchIntoScope();
-  TheDecl->markUsed(Context);
+  markAllUsed(TheDecl, Context);
   return new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc);
 }
 
 StmtResult
 Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
                             Expr *E) {
   // Convert operand to void*
   if (!E->isTypeDependent()) {

lib/Sema/SemaStmtAsm.cpp

 LabelDecl *Sema::GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
                                        SourceLocation Location,
                                        bool AlwaysCreate) {
   LabelDecl* Label = LookupOrCreateLabel(PP.getIdentifierInfo(ExternalLabelName),
                                          Location);
 
   if (Label->isMSAsmLabel()) {
     // If we have previously created this label implicitly, mark it as used.
-    Label->markUsed(Context);
+    markAllUsed(Label, Context);
   } else {
     // Otherwise, insert it, but only resolve it if we have seen the label itself.
     std::string InternalName;
     llvm::raw_string_ostream OS(InternalName);
     // Create an internal name for the label.  The name should not be a valid
     // mangled name, and should be unique.  We use a dot to make the name an
     // invalid mangled name. We use LLVM's inline asm ${:uid} escape so that a
     // unique label is generated each time this blob is emitted, even after

test/Frontend/float16.cpp

public:
   _Float16 func1c(_Float16 arg ) {
     return f1c + arg;
   }
   static _Float16 func2c(_Float16 arg) {
     return arg * C1::f2c;
   }
 };
 
-//CHECK:      |-CXXRecordDecl {{.*}} referenced class C1 definition
+//CHECK:      |-CXXRecordDecl {{.*}} used class C1 definition
 //CHECK:      | |-CXXRecordDecl {{.*}} implicit referenced class C1
-//CHECK-NEXT: | |-FieldDecl {{.*}} referenced f1c '_Float16'
+//CHECK-NEXT: | |-FieldDecl {{.*}} used f1c '_Float16'
 //CHECK-NEXT: | |-VarDecl {{.*}} used f2c 'const _Float16' static
 //CHECK-NEXT: | |-FieldDecl {{.*}} f3c 'volatile _Float16'
 //CHECK-NEXT: | |-AccessSpecDecl
 //CHECK-NEXT: | |-CXXConstructorDecl {{.*}} used C1 'void (_Float16)
 //CHECK-NEXT: | | |-ParmVarDecl {{.*}} used arg '_Float16'
 //CHECK-NEXT: | | |-CXXCtorInitializer Field {{.*}} 'f1c' '_Float16'
 //CHECK-NEXT: | | | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
 //CHECK-NEXT: | | |   `-DeclRefExpr {{.*}} '_Float16' lvalue ParmVar 0x{{.*}} 'arg' '_Float16'

test/Misc/ast-dump-attr.cpp

 
 void TestLabel() {
 L: __attribute__((unused)) int i;
 // CHECK: LabelStmt{{.*}}'L'
 // CHECK: VarDecl{{.*}}i 'int'
 // CHECK-NEXT: UnusedAttr{{.*}}
 
 M: __attribute(()) int j;
-// CHECK: LabelStmt {{.*}} 'M'
+// CHECK: LabelStmt {{.*}} 'M'
+// CHECK-NEXT: LabelDecl
 // CHECK-NEXT: DeclStmt
 // CHECK-NEXT: VarDecl {{.*}} j 'int'
 
 N: __attribute(()) ;
 // CHECK: LabelStmt {{.*}} 'N'
+// CHECK-NEXT: LabelDecl
 // CHECK-NEXT: NullStmt
 }
 
 namespace Test {
 extern "C" int printf(const char *format, ...);
 // CHECK: FunctionDecl{{.*}}printf
 // CHECK-NEXT: ParmVarDecl{{.*}}format{{.*}}'const char *'
 // CHECK-NEXT: FormatAttr{{.*}}Implicit printf 1 2

test/Misc/ast-dump-color.cpp

 //CHECK: {{^}}[[Blue]]| |     |   `-[[RESET]][[MAGENTA]]NullStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:27[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     `-[[RESET]][[MAGENTA]]CaseStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:13:3[[RESET]], [[Yellow]]line:14:5[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |       |-[[RESET]][[MAGENTA]]IntegerLiteral[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:13:8[[RESET]]> [[Green]]'int'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]][[CYAN]] 2[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |       |-[[RESET]][[Blue]]<<<NULL>>>[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| |       `-[[RESET]][[MAGENTA]]NullStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:14:5[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| `-[[RESET]][[Blue]]FullComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:8:4[[RESET]], [[Yellow]]col:11[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]|   `-[[RESET]][[Blue]]ParagraphComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:4[[RESET]], [[Yellow]]col:11[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]|     `-[[RESET]][[Blue]]TextComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:4[[RESET]], [[Yellow]]col:11[[RESET]]> Text=" Comment"{{$}}
-//CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:18:1[[RESET]], [[Yellow]]line:25:1[[RESET]]> [[Yellow]]line:18:33[[RESET]] class[[CYAN]] Mutex[[RESET]] definition{{$}}
+//CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:18:1[[RESET]], [[Yellow]]line:25:1[[RESET]]> [[Yellow]]line:18:33[[RESET]] used class[[CYAN]] Mutex[[RESET]] definition{{$}}
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[BLUE]]CapabilityAttr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:22[[RESET]]> capability "mutex"{{$}}
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit class[[CYAN]] Mutex[[RESET]]{{$}}
-//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]FieldDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:20:3[[RESET]], [[Yellow]]col:7[[RESET]]> [[Yellow]]col:7[[RESET]][[CYAN]] var1[[RESET]] [[Green]]'int'[[RESET]]{{$}}
+//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]FieldDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:20:3[[RESET]], [[Yellow]]col:7[[RESET]]> [[Yellow]]col:7[[RESET]] used[[CYAN]] var1[[RESET]] [[Green]]'int'[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[Blue]]FullComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:19:6[[RESET]], [[Yellow]]col:16[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |   `-[[RESET]][[Blue]]ParagraphComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:6[[RESET]], [[Yellow]]col:16[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     `-[[RESET]][[Blue]]TextComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:6[[RESET]], [[Yellow]]col:16[[RESET]]> Text=" A variable"{{$}}
-//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]FieldDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:24:3[[RESET]], [[Yellow]]col:7[[RESET]]> [[Yellow]]col:7[[RESET]][[CYAN]] var2[[RESET]] [[Green]]'int'[[RESET]]{{$}}
+//CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]FieldDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:24:3[[RESET]], [[Yellow]]col:7[[RESET]]> [[Yellow]]col:7[[RESET]] used[[CYAN]] var2[[RESET]] [[Green]]'int'[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[Blue]]FullComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:21:6[[RESET]], [[Yellow]]line:23:44[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |   |-[[RESET]][[Blue]]ParagraphComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:21:6[[RESET]], [[Yellow]]col:22[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |   | `-[[RESET]][[Blue]]TextComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:6[[RESET]], [[Yellow]]col:22[[RESET]]> Text=" Another variable"{{$}}
 //CHECK: {{^}}[[Blue]]| |   `-[[RESET]][[Blue]]ParagraphComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:23:6[[RESET]], [[Yellow]]col:44[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |     `-[[RESET]][[Blue]]TextComment[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:6[[RESET]], [[Yellow]]col:44[[RESET]]> Text=" Like the other variable, but different"{{$}}
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:18:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit used[[CYAN]] Mutex[[RESET]] [[Green]]'void () noexcept'[[RESET]] inline{{.*$}}
 //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[MAGENTA]]CompoundStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit constexpr[[CYAN]] Mutex[[RESET]] [[Green]]'void (const Mutex &)'[[RESET]] inline{{ .*$}}
 //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] [[Green]]'const Mutex &'[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]| `-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] implicit constexpr[[CYAN]] Mutex[[RESET]] [[Green]]'void (Mutex &&)'[[RESET]] inline{{ .*$}}
 //CHECK: {{^}}[[Blue]]|   `-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:33[[RESET]]> [[Yellow]]col:33[[RESET]] [[Green]]'Mutex &&'[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]line:25:3[[RESET]]> [[Yellow]]col:3[[RESET]] referenced[[CYAN]] mu1[[RESET]] [[Green]]'class Mutex':'Mutex'[[RESET]]
 //CHECK: {{^}}[[Blue]]| `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:3[[RESET]]> [[Green]]'class Mutex':'Mutex'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void () noexcept'[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:18:1[[RESET]], [[Yellow]]line:25:8[[RESET]]> [[Yellow]]col:8[[RESET]][[CYAN]] mu2[[RESET]] [[Green]]'class Mutex':'Mutex'[[RESET]]
 //CHECK: {{^}}[[Blue]]| `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Green]]'class Mutex':'Mutex'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void () noexcept'[[RESET]]{{$}}
 //CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:26:1[[RESET]], [[Yellow]]col:5[[RESET]]> [[Yellow]]col:5[[RESET]][[CYAN]] TestExpr[[RESET]] [[Green]]'int'[[RESET]]
 //CHECK: {{^}}[[Blue]]| `-[[RESET]][[BLUE]]GuardedByAttr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:29[[RESET]], [[Yellow]]col:43[[RESET]]>{{$}}
 //CHECK: {{^}}[[Blue]]|   `-[[RESET]][[MAGENTA]]DeclRefExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:40[[RESET]]> [[Green]]'class Mutex':'Mutex'[[RESET]][[Cyan]] lvalue[[RESET]][[Cyan]][[RESET]] [[GREEN]]Var[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]][[CYAN]] 'mu1'[[RESET]] [[Green]]'class Mutex':'Mutex'[[RESET]]{{$}}
-//CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:28:1[[RESET]], [[Yellow]]line:30:1[[RESET]]> [[Yellow]]line:28:8[[RESET]] struct[[CYAN]] Invalid[[RESET]] definition
+//CHECK: {{^}}[[Blue]]|-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:28:1[[RESET]], [[Yellow]]line:30:1[[RESET]]> [[Yellow]]line:28:8[[RESET]] used struct[[CYAN]] Invalid[[RESET]] definition
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXRecordDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit referenced struct[[CYAN]] Invalid[[RESET]]
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:29:3[[RESET]], [[Yellow]]col:42[[RESET]]> [[Yellow]]col:29[[RESET]] invalid[[CYAN]] Invalid[[RESET]] [[Green]]'void (int)'[[RESET]]
 //CHECK: {{^}}[[Blue]]| | |-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:37[[RESET]], [[Yellow]]<invalid sloc>[[RESET]]> [[Yellow]]col:42[[RESET]] invalid [[Green]]'int'[[RESET]]
 //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[BLUE]]NoInlineAttr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:18[[RESET]]>
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]line:28:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit used constexpr[[CYAN]] Invalid[[RESET]] [[Green]]'void () noexcept'[[RESET]] inline
 //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[MAGENTA]]CompoundStmt[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]>
 //CHECK: {{^}}[[Blue]]| |-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit constexpr[[CYAN]] Invalid[[RESET]] [[Green]]'void (const Invalid &)'[[RESET]] inline default trivial noexcept-unevaluated 0x{{[0-9a-fA-F]*}}
 //CHECK: {{^}}[[Blue]]| | `-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] [[Green]]'const Invalid &'[[RESET]]
 //CHECK: {{^}}[[Blue]]| `-[[RESET]][[GREEN]]CXXConstructorDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] implicit constexpr[[CYAN]] Invalid[[RESET]] [[Green]]'void (Invalid &&)'[[RESET]] inline default trivial noexcept-unevaluated 0x{{[0-9a-fA-F]*}}
 //CHECK: {{^}}[[Blue]]|   `-[[RESET]][[GREEN]]ParmVarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:8[[RESET]]> [[Yellow]]col:8[[RESET]] [[Green]]'Invalid &&'[[RESET]]
 //CHECK: {{^}}[[Blue]]`-[[RESET]][[GREEN]]VarDecl[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:1[[RESET]], [[Yellow]]line:30:3[[RESET]]> [[Yellow]]col:3[[RESET]][[CYAN]] Invalid[[RESET]] [[Green]]'struct Invalid':'Invalid'[[RESET]]
 //CHECK: {{^}}[[Blue]]  `-[[RESET]][[MAGENTA]]CXXConstructExpr[[RESET]][[Yellow]] 0x{{[0-9a-fA-F]*}}[[RESET]] <[[Yellow]]col:3[[RESET]]> [[Green]]'struct Invalid':'Invalid'[[RESET]][[Cyan]][[RESET]][[Cyan]][[RESET]] [[Green]]'void () noexcept'[[RESET]]

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
 
 struct A {
   typedef int type;
   static void my_f();
   template <typename T>
   static T my_templf(T x) { return x; }
 };
 
 void test(const int (&a6)[17]) {
-  int x = templ_f<int, 5>(3);
+  int x = templ_f<int, 5>(3);;
   
   S<char, float>::templ();
   S<int, char>::partial();
   S<int, float>::explicit_special();
   
   Dep<A>::Ty ty;
   Dep<A> a;
   a.f();

test/SemaCXX/used_class_struct_union.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+struct S {
+  void SF(int param) {
+    int var;
+    var = 1;
+  }
+};
+
+//CHECK:      |-CXXRecordDecl {{.*}} used struct S definition
+//CHECK-NEXT: | |-DefinitionData {{.*}}
+//CHECK-NEXT: | | |-DefaultConstructor {{.*}}
+//CHECK-NEXT: | | |-CopyConstructor {{.*}}
+//CHECK-NEXT: | | |-MoveConstructor {{.*}}
+//CHECK-NEXT: | | |-CopyAssignment {{.*}}
+//CHECK-NEXT: | | |-MoveAssignment {{.*}}
+//CHECK-NEXT: | | `-Destructor {{.*}}
+//CHECK-NEXT: | |-CXXRecordDecl {{.*}} implicit struct S
+//CHECK-NEXT: | |-CXXMethodDecl {{.*}} used SF 'void (int)'
+//CHECK-NEXT: | | |-ParmVarDecl {{.*}} used param 'int'
+//CHECK-NEXT: | | `-CompoundStmt {{.*}}
+//CHECK-NEXT: | |   |-DeclStmt {{.*}}
+//CHECK-NEXT: | |   | `-VarDecl {{.*}} used var 'int'
+//CHECK-NEXT: | |   `-BinaryOperator {{.*}}
+//CHECK-NEXT: | |     |-DeclRefExpr {{.*}} 'var' 'int'
+//CHECK-NEXT: | |     `-IntegerLiteral {{.*}}
+//CHECK-NEXT: | |-CXXConstructorDecl {{.*}}
+//CHECK-NEXT: | | `-CompoundStmt {{.*}}
+//CHECK-NEXT: | |-CXXConstructorDecl {{.*}}
+//CHECK-NEXT: | | `-ParmVarDecl {{.*}} 'const S &'
+//CHECK-NEXT: | `-CXXConstructorDecl {{.*}}
+//CHECK-NEXT: |   `-ParmVarDecl {{.*}} 'S &&'
+
+typedef int INTEGER;
+typedef float FLOAT;
+
+//CHECK:      |-TypedefDecl {{.*}} used INTEGER 'int'
+//CHECK-NEXT: | `-BuiltinType {{.*}}
+//CHECK-NEXT: |-TypedefDecl {{.*}} FLOAT 'float'
+//CHECK-NEXT: | `-BuiltinType {{.*}}
+
+class C {
+  typedef float FLOAT;
+  typedef int INTEGER;
+  ::INTEGER i;
+  FLOAT f;
+public:
+  C() : i(0), f(0.0) {}
+  C(::INTEGER pi) : i(pi), f(0.0) {}
+  C(::INTEGER pi,FLOAT pf) : i(pi), f(pf) {}
+  void CF() {}
+};
+
+//CHECK:      |-CXXRecordDecl {{.*}} used class C definition
+//CHECK-NEXT: |-DefinitionData {{.*}}
+//CHECK-NEXT: | |-DefaultConstructor {{.*}}
+//CHECK-NEXT: | |-CopyConstructor {{.*}}
+//CHECK-NEXT: | |-MoveConstructor {{.*}}
+//CHECK-NEXT: | |-CopyAssignment {{.*}}
+//CHECK-NEXT: | |-MoveAssignment {{.*}}
+//CHECK-NEXT: | `-Destructor {{.*}}
+//CHECK-NEXT: |-CXXRecordDecl {{.*}} implicit referenced class C
+//CHECK-NEXT: |-TypedefDecl {{.*}} used FLOAT 'float'
+//CHECK-NEXT: | `-BuiltinType {{.*}}
+//CHECK-NEXT: |-TypedefDecl {{.*}} INTEGER 'int'
+//CHECK-NEXT: | `-BuiltinType {{.*}}
+//CHECK-NEXT: |-FieldDecl {{.*}} used i '::INTEGER':'int'
+//CHECK-NEXT: |-FieldDecl {{.*}} used f 'C::FLOAT':'float'
+//CHECK-NEXT: |-AccessSpecDecl {{.*}} public
+//CHECK-NEXT: |-CXXConstructorDecl {{.*}} used C 'void ()'
+//CHECK-NEXT: | |-CXXCtorInitializer {{.*}}
+//CHECK-NEXT: | | `-IntegerLiteral {{.*}}
+//CHECK-NEXT: | |-CXXCtorInitializer {{.*}}
+//CHECK-NEXT: | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: | |   `-FloatingLiteral {{.*}}
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |-CXXConstructorDecl {{.*}} used C 'void (::INTEGER)'
+//CHECK-NEXT: | |-ParmVarDecl {{.*}} used pi '::INTEGER':'int'
+//CHECK-NEXT: | |-CXXCtorInitializer {{.*}}
+//CHECK-NEXT: | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: | |   `-DeclRefExpr {{.*}} 'pi' '::INTEGER':'int'
+//CHECK-NEXT: | |-CXXCtorInitializer {{.*}}
+//CHECK-NEXT: | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: | |   `-FloatingLiteral {{.*}}
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |-CXXConstructorDecl {{.*}} used C 'void (::INTEGER, C::FLOAT)'
+//CHECK-NEXT: | |-ParmVarDecl {{.*}} used pi '::INTEGER':'int'
+//CHECK-NEXT: | |-ParmVarDecl {{.*}} used pf 'C::FLOAT':'float'
+//CHECK-NEXT: | |-CXXCtorInitializer {{.*}}
+//CHECK-NEXT: | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: | |   `-DeclRefExpr {{.*}} 'pi' '::INTEGER':'int'
+//CHECK-NEXT: | |-CXXCtorInitializer {{.*}}
+//CHECK-NEXT: | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: | |   `-DeclRefExpr {{.*}} 'pf' 'C::FLOAT':'float'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |-CXXMethodDecl {{.*}} CF 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |-CXXConstructorDecl {{.*}}
+//CHECK-NEXT: | `-ParmVarDecl {{.*}} 'const C &'
+//CHECK-NEXT: `-CXXConstructorDecl {{.*}}
+//CHECK-NEXT:   `-ParmVarDecl {{.*}} 'C &&'
+
+void Foo() {
+  S r;
+  r.SF(1);
+
+  C c1;
+  C c2(1);
+  C c3(1,1.1);
+}
+
+//CHECK:      `-FunctionDecl {{.*}} used Foo 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used r 'S' callinit
+//CHECK-NEXT:     |   `-CXXConstructExpr {{.*}} 'S' 'void () noexcept'
+//CHECK-NEXT:     |-CXXMemberCallExpr {{.*}}
+//CHECK-NEXT:     | |-MemberExpr {{.*}}
+//CHECK-NEXT:     | | `-DeclRefExpr {{.*}} 'r' 'S'
+//CHECK-NEXT:     | `-IntegerLiteral{{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} 'C' callinit
+//CHECK-NEXT:     |   `-CXXConstructExpr {{.*}} 'C' 'void ()'
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} 'C' callinit
+//CHECK-NEXT:     |   `-CXXConstructExpr {{.*}} 'C' 'void (::INTEGER)'
+//CHECK-NEXT:     |     `-IntegerLiteral{{.*}}
+//CHECK-NEXT:     `-DeclStmt {{.*}}
+//CHECK-NEXT:       `-VarDecl {{.*}} 'C' callinit
+//CHECK-NEXT:         `-CXXConstructExpr {{.*}} 'C' 'void (::INTEGER, C::FLOAT)'
+//CHECK-NEXT:           |-IntegerLiteral {{.*}}
+//CHECK-NEXT:           `-ImplicitCastExpr {{.*}} 'C::FLOAT':'float' <FloatingCast>
+//CHECK-NEXT:             `-FloatingLiteral {{.*}}

test/SemaCXX/used_enum.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+enum NUMBER {
+  ONE = 1,
+  TWO = 2
+};
+
+//CHECK:      |-EnumDecl {{.*}} used NUMBER
+//CHECK-NEXT: | |-EnumConstantDecl {{.*}} ONE 'NUMBER'
+//CHECK-NEXT: | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: | |   `-IntegerLiteral {{.*}}
+//CHECK-NEXT: | `-EnumConstantDecl {{.*}} referenced TWO 'NUMBER'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}}
+
+enum LETTER {
+  A = 'a',
+  B = 'b',
+  C = 'c'
+};
+
+//CHECK:      |-EnumDecl {{.*}} referenced LETTER
+//CHECK-NEXT: | |-EnumConstantDecl {{.*}} A 'LETTER'
+//CHECK-NEXT: | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: | |   `-CharacterLiteral {{.*}}
+//CHECK-NEXT: | |-EnumConstantDecl {{.*}} 'LETTER'
+//CHECK-NEXT: | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: | |   `-CharacterLiteral {{.*}}
+//CHECK-NEXT: | `-EnumConstantDecl {{.*}} C 'LETTER'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |     `-CharacterLiteral {{.*}}
+
+void Foo() {
+  NUMBER n;
+  n = TWO;
+  LETTER l;
+}
+
+//CHECK:      `-FunctionDecl {{.*}} used Foo 'void ()'
+//CHECK-NEXT:  `-CompoundStmt {{.*}}
+//CHECK-NEXT:    |-DeclStmt {{.*}}
+//CHECK-NEXT:    | `-VarDecl {{.*}} used n 'NUMBER'
+//CHECK-NEXT:    |-BinaryOperator {{.*}}
+//CHECK-NEXT:    | |-DeclRefExpr {{.*}} 'n' 'NUMBER'
+//CHECK-NEXT:    | `-DeclRefExpr {{.*}} 'TWO' 'NUMBER'
+//CHECK-NEXT:    `-DeclStmt {{.*}}
+//CHECK-NEXT:      `-VarDecl {{.*}} l 'LETTER'

test/SemaCXX/used_goto.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+void Foo(int p) {
+start:
+  int a;
+  typedef int INT;
+  if (p) {
+    goto end;
+    do {
+    } while (--p);
+  }
+
+end:
+  return;
+}
+
+void Bar() {
+  Foo(2);
+}
+
+//CHECK:      |-FunctionDecl {{.*}} used Foo 'void (int)'
+//CHECK-NEXT: | |-ParmVarDecl {{.*}} used p 'int'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-LabelStmt {{.*}} 'start'
+//CHECK-NEXT: |   | |-LabelDecl {{.*}} start
+//CHECK-NEXT: |   | `-DeclStmt {{.*}}
+//CHECK-NEXT: |   |   `-VarDecl {{.*}} a 'int'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-TypedefDecl {{.*}} INT 'int'
+//CHECK-NEXT: |   |   `-BuiltinType {{.*}}
+//CHECK-NEXT: |   |-IfStmt {{.*}}
+//CHECK-NEXT: |   | |-<<<NULL>>>
+//CHECK-NEXT: |   | |-<<<NULL>>>
+//CHECK-NEXT: |   | |-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |   | | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |   | |   `-DeclRefExpr {{.*}} 'p' 'int'
+//CHECK-NEXT: |   | |-CompoundStmt {{.*}}
+//CHECK-NEXT: |   | | |-GotoStmt {{.*}} 'end' {{.*}}
+//CHECK-NEXT: |   | | `-DoStmt {{.*}}
+//CHECK-NEXT: |   | |   |-CompoundStmt {{.*}}
+//CHECK-NEXT: |   | |   `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |   | |     `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |   | |       `-UnaryOperator {{.*}}
+//CHECK-NEXT: |   | |         `-DeclRefExpr {{.*}} 'p' 'int'
+//CHECK-NEXT: |   | `-<<<NULL>>>
+//CHECK-NEXT: |   `-LabelStmt {{.*}} 'end'
+//CHECK-NEXT: |     |-LabelDecl {{.*}} used end
+//CHECK-NEXT: |     `-ReturnStmt {{.*}}
+//CHECK:      `-FunctionDecl {{.*}} Bar 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     `-CallExpr {{.*}}
+//CHECK-NEXT:       |-ImplicitCastExpr {{.*}}
+//CHECK-NEXT:       | `-DeclRefExpr {{.*}} 'Foo' 'void (int)'
+//CHECK-NEXT:       `-IntegerLiteral {{.*}}

test/SemaCXX/used_pointer.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+typedef int INTEGER;
+typedef INTEGER INT;
+
+//CHECK:      |-TypedefDecl {{.*}} used INTEGER 'int'
+//CHECK-NEXT: | `-BuiltinType {{.*}}
+//CHECK-NEXT: |-TypedefDecl {{.*}} used INT 'INTEGER':'int'
+//CHECK-NEXT: | `-TypedefType {{.*}}
+//CHECK-NEXT: |   |-Typedef {{.*}}
+//CHECK-NEXT: |   `-BuiltinType {{.*}}
+
+struct S {
+  static int si;
+  INT fi;
+  void F() {}
+};
+
+//CHECK:      |-CXXRecordDecl {{.*}} used struct S definition
+//CHECK-NEXT: | |-DefinitionData {{.*}}
+//CHECK-NEXT: | | |-DefaultConstructor {{.*}}
+//CHECK-NEXT: | | |-CopyConstructor {{.*}}
+//CHECK-NEXT: | | |-MoveConstructor {{.*}}
+//CHECK-NEXT: | | |-CopyAssignment {{.*}}
+//CHECK-NEXT: | | |-MoveAssignment {{.*}}
+//CHECK-NEXT: | | `-Destructor {{.*}}
+//CHECK-NEXT: | |-CXXRecordDecl {{.*}} implicit struct S
+//CHECK-NEXT: | |-VarDecl {{.*}} used si 'int' static
+//CHECK-NEXT: | |-FieldDecl {{.*}} used fi 'INT':'int'
+//CHECK-NEXT: | |-CXXMethodDecl {{.*}} F 'void ()'
+//CHECK-NEXT: | | `-CompoundStmt {{.*}}
+//CHECK-NEXT: | |-CXXConstructorDecl {{.*}}
+//CHECK-NEXT: | | `-CompoundStmt {{.*}}
+//CHECK-NEXT: | |-CXXConstructorDecl {{.*}}
+//CHECK-NEXT: | | `-ParmVarDecl {{.*}} 'const S &'
+//CHECK-NEXT: | `-CXXConstructorDecl {{.*}}
+//CHECK-NEXT: |   `-ParmVarDecl {{.*}} 'S &&'
+
+void Bar(S *ps) {
+  ps->fi = 0;
+}
+
+//CHECK:      |-FunctionDecl {{.*}} used Bar 'void (S *)'
+//CHECK-NEXT: | |-ParmVarDecl {{.*}} used ps 'S *'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   `-BinaryOperator {{.*}}
+//CHECK-NEXT: |     |-MemberExpr {{.*}}
+//CHECK-NEXT: |     | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |     |   `-DeclRefExpr {{.*}} 'ps' 'S *'
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}}
+
+void Foo() {
+  S s;
+  Bar(&s);
+  S::si = 2;
+}
+
+//CHECK:      `-FunctionDecl {{.*}} used Foo 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used s 'S' callinit
+//CHECK-NEXT:     |   `-CXXConstructExpr {{.*}}
+//CHECK-NEXT:     |-CallExpr {{.*}}
+//CHECK-NEXT:     | |-ImplicitCastExpr {{.*}}
+//CHECK-NEXT:     | | `-DeclRefExpr {{.*}} 'Bar' 'void (S *)'
+//CHECK-NEXT:     | `-UnaryOperator {{.*}}
+//CHECK-NEXT:     |   `-DeclRefExpr {{.*}} 's' 'S'
+//CHECK-NEXT:     `-BinaryOperator {{.*}}
+//CHECK-NEXT:       |-DeclRefExpr {{.*}} 'si' 'int'
+//CHECK-NEXT:       `-IntegerLiteral {{.*}}

test/SemaCXX/used_template.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+template <class T>
+T B(T param) {
+  typedef T TYPE;
+  typedef int I;
+  TYPE var;
+  var = 1;
+  return ++param;
+}
+
+//CHECK:      | `-FunctionDecl {{.*}} used B 'int (int)'
+//CHECK-NEXT: |   |-TemplateArgument type 'int'
+//CHECK-NEXT: |   |-ParmVarDecl {{.*}} used param 'int':'int'
+//CHECK-NEXT: |   `-CompoundStmt {{.*}}
+//CHECK-NEXT: |     |-DeclStmt {{.*}}
+//CHECK-NEXT: |     | `-TypedefDecl {{.*}} used TYPE 'int':'int'
+//CHECK-NEXT: |     |   `-SubstTemplateTypeParmType {{.*}}
+//CHECK-NEXT: |     |     |-TemplateTypeParmType {{.*}}
+//CHECK-NEXT: |     |     | `-TemplateTypeParm {{.*}}
+//CHECK-NEXT: |     |     `-BuiltinType {{.*}}
+//CHECK-NEXT: |     |-DeclStmt {{.*}}
+//CHECK-NEXT: |     | `-TypedefDecl {{.*}} I 'int'
+//CHECK-NEXT: |     |   `-BuiltinType {{.*}}
+//CHECK-NEXT: |     |-DeclStmt {{.*}}
+//CHECK-NEXT: |     | `-VarDecl {{.*}} used var 'TYPE':'int'
+//CHECK-NEXT: |     |-BinaryOperator {{.*}} 'TYPE':'int' lvalue '='
+//CHECK-NEXT: |     | |-DeclRefExpr {{.*}}
+//CHECK-NEXT: |     | `-IntegerLiteral {{.*}}
+//CHECK-NEXT: |     `-ReturnStmt {{.*}}
+//CHECK-NEXT: |       `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |         `-UnaryOperator {{.*}}
+//CHECK-NEXT: |           `-DeclRefExpr {{.*}}
+
+void Bar() {
+  B<int>(1);
+}
+
+//CHECK:      `-FunctionDecl {{.*}} Bar 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     `-CallExpr {{.*}}
+//CHECK-NEXT:       |-ImplicitCastExpr {{.*}}
+//CHECK-NEXT:       | `-DeclRefExpr {{.*}}
+//CHECK-NEXT:       `-IntegerLiteral {{.*}}

test/SemaCXX/used_typedef.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+namespace A {
+  typedef int INTEGER;
+  typedef char CHAR;
+  namespace B {
+    typedef int INTEGER;
+    typedef char CHAR;
+    struct S {
+      typedef int INTEGER;
+      typedef char CHAR;
+    };
+  }
+}
+
+//CHECK:      |-NamespaceDecl {{.*}} used A
+//CHECK-NEXT: | |-TypedefDecl {{.*}} used INTEGER 'int'
+//CHECK-NEXT: | | `-BuiltinType {{.*}}
+//CHECK-NEXT: | |-TypedefDecl {{.*}} CHAR 'char'
+//CHECK-NEXT: | | `-BuiltinType {{.*}}
+//CHECK-NEXT: | `-NamespaceDecl {{.*}} used B
+//CHECK-NEXT: |   |-TypedefDecl {{.*}} used INTEGER 'int'
+//CHECK-NEXT: |   | `-BuiltinType {{.*}}
+//CHECK-NEXT: |   |-TypedefDecl {{.*}} CHAR 'char'
+//CHECK-NEXT: |   | `-BuiltinType {{.*}}
+//CHECK-NEXT: |   `-CXXRecordDecl {{.*}} used struct S definition
+//CHECK-NEXT: |     |-DefinitionData {{.*}} 
+//CHECK-NEXT: |     | |-DefaultConstructor {{.*}} 
+//CHECK-NEXT: |     | |-CopyConstructor {{.*}} 
+//CHECK-NEXT: |     | |-MoveConstructor {{.*}} 
+//CHECK-NEXT: |     | |-CopyAssignment {{.*}} 
+//CHECK-NEXT: |     | |-MoveAssignment {{.*}} 
+//CHECK-NEXT: |     | `-Destructor {{.*}} 
+//CHECK-NEXT: |     |-CXXRecordDecl {{.*}} implicit struct S
+//CHECK-NEXT: |     |-TypedefDecl {{.*}} used INTEGER 'int'
+//CHECK-NEXT: |     | `-BuiltinType {{.*}}
+//CHECK-NEXT: |     `-TypedefDecl {{.*}} CHAR 'char'
+//CHECK-NEXT: |       `-BuiltinType {{.*}}
+
+typedef int INTEGER;
+typedef char CHAR;
+
+//CHECK:      |-TypedefDecl {{.*}} used INTEGER 'int'
+//CHECK-NEXT: | `-BuiltinType {{.*}}
+//CHECK-NEXT: |-TypedefDecl {{.*}} CHAR 'char'
+//CHECK-NEXT: | `-BuiltinType {{.*}}
+
+void Foo() {
+  typedef char CHAR;
+
+  typedef int INTEGER;
+  INTEGER L_I;
+  L_I = 1;
+
+  ::INTEGER G_I;
+  G_I = 1;
+
+  A::B::S::INTEGER M_N_S_I;
+  M_N_S_I = 1;
+
+  A::B::INTEGER M_N_I;
+  M_N_I = 1;
+
+  A::INTEGER M_I;
+  M_I = 1;
+}
+
+//CHECK:      `-FunctionDecl {{.*}} used Foo 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-TypedefDecl {{.*}} CHAR 'char'
+//CHECK-NEXT:     |   `-BuiltinType {{.*}} 'char'
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-TypedefDecl {{.*}} used INTEGER 'int'
+//CHECK-NEXT:     |   `-BuiltinType {{.*}} 'int'
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used L_I 'INTEGER':'int'
+//CHECK-NEXT:     |-BinaryOperator {{.*}} 'INTEGER':'int' lvalue '='
+//CHECK-NEXT:     | |-DeclRefExpr {{.*}} 'INTEGER':'int' lvalue Var {{.*}} 'L_I' 'INTEGER':'int'
+//CHECK-NEXT:     | `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used G_I '::INTEGER':'int'
+//CHECK-NEXT:     |-BinaryOperator {{.*}} '::INTEGER':'int' lvalue '='
+//CHECK-NEXT:     | |-DeclRefExpr {{.*}} '::INTEGER':'int' lvalue Var {{.*}} 'G_I' '::INTEGER':'int'
+//CHECK-NEXT:     | `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used M_N_S_I 'A::B::S::INTEGER':'int'
+//CHECK-NEXT:     |-BinaryOperator {{.*}} 'A::B::S::INTEGER':'int' lvalue '='
+//CHECK-NEXT:     | |-DeclRefExpr {{.*}} 'A::B::S::INTEGER':'int' lvalue Var {{.*}} 'M_N_S_I' 'A::B::S::INTEGER':'int'
+//CHECK-NEXT:     | `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used M_N_I 'A::B::INTEGER':'int'
+//CHECK-NEXT:     |-BinaryOperator {{.*}} 'A::B::INTEGER':'int' lvalue '='
+//CHECK-NEXT:     | |-DeclRefExpr {{.*}} 'A::B::INTEGER':'int' lvalue Var {{.*}} 'M_N_I' 'A::B::INTEGER':'int'
+//CHECK-NEXT:     | `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used M_I 'A::INTEGER':'int'
+//CHECK-NEXT:     `-BinaryOperator {{.*}} 'A::INTEGER':'int' lvalue '='
+//CHECK-NEXT:       |-DeclRefExpr {{.*}} 'A::INTEGER':'int' lvalue Var {{.*}} 'M_I' 'A::INTEGER':'int'
+//CHECK-NEXT:       `-IntegerLiteral {{.*}} 'int' 1

test/SemaCXX/used_using.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+namespace A {
+  typedef char CHAR;
+}
+
+//CHECK:      |-NamespaceDecl {{.*}} used A
+//CHECK-NEXT: | `-TypedefDecl {{.*}} used CHAR 'char'
+//CHECK-NEXT: |   `-BuiltinType {{.*}}
+
+namespace B {
+  typedef char CHAR;
+}
+
+//CHECK:      |-NamespaceDecl {{.*}} used B
+//CHECK-NEXT: | `-TypedefDecl {{.*}} used CHAR 'char'
+//CHECK-NEXT: |   `-BuiltinType {{.*}}
+
+namespace C {
+  typedef char CHAR;
+  typedef int INTEGER;
+  typedef unsigned UNSIGNED;
+
+  void FA();
+  void FB();
+
+  int Var1;
+  int Var2;
+}
+
+//CHECK:      |-NamespaceDecl {{.*}} used C
+//CHECK-NEXT: | |-TypedefDecl {{.*}} CHAR 'char'
+//CHECK-NEXT: | | `-BuiltinType {{.*}}
+//CHECK-NEXT: | |-TypedefDecl {{.*}} INTEGER 'int'
+//CHECK-NEXT: | | `-BuiltinType {{.*}}
+//CHECK-NEXT: | |-TypedefDecl {{.*}} UNSIGNED 'unsigned int'
+//CHECK-NEXT: | | `-BuiltinType {{.*}}
+//CHECK-NEXT: | |-FunctionDecl {{.*}} used FA 'void ()'
+//CHECK-NEXT: | |-FunctionDecl {{.*}} used FB 'void ()'
+//CHECK-NEXT: | |-VarDecl {{.*}} used Var1 'int'
+//CHECK-NEXT: | `-VarDecl {{.*}} used Var2 'int'
+
+using A::CHAR;
+using B::CHAR;
+
+//CHECK:      |-UsingDecl {{.*}} A::CHAR
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} 'CHAR'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'A::CHAR' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}}
+//CHECK-NEXT: |   `-BuiltinType {{.*}}
+//CHECK-NEXT: |-UsingDecl {{.*}} B::CHAR
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} 'CHAR'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'B::CHAR' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'CHAR'
+//CHECK-NEXT: |   `-BuiltinType {{.*}}
+
+void F1() {
+  using A::CHAR;
+  CHAR ca;
+  ca = '1';
+
+  using B::CHAR;
+  B::CHAR cb;
+  cb = '1';
+}
+
+//CHECK:      |-FunctionDecl {{.*}} used F1 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDecl {{.*}} used A::CHAR
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-VarDecl {{.*}} used ca 'A::CHAR':'char'
+//CHECK-NEXT: |   |-BinaryOperator {{.*}}
+//CHECK-NEXT: |   | |-DeclRefExpr {{.*}} 'ca' 'A::CHAR':'char'
+//CHECK-NEXT: |   | `-CharacterLiteral {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDecl {{.*}} B::CHAR
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-VarDecl {{.*}} used cb 'B::CHAR':'char'
+//CHECK-NEXT: |   `-BinaryOperator {{.*}}
+//CHECK-NEXT: |     |-DeclRefExpr {{.*}} 'cb' 'B::CHAR':'char'
+//CHECK-NEXT: |     `-CharacterLiteral {{.*}}
+
+void F2() {
+  using C::FA;
+  FA();
+
+  using C::Var1;
+  Var1 = 2;
+
+  using C::FB;
+  C::FB();
+
+  using C::Var2;
+  C::Var2 = 2;
+}
+
+//CHECK:      |-FunctionDecl {{.*}} used F2 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDecl {{.*}} used C::FA
+//CHECK-NEXT: |   |-CallExpr {{.*}}
+//CHECK-NEXT: |   | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |   |   `-DeclRefExpr {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDecl {{.*}} used C::Var1
+//CHECK-NEXT: |   |-BinaryOperator {{.*}}
+//CHECK-NEXT: |   | |-DeclRefExpr {{.*}}
+//CHECK-NEXT: |   | `-IntegerLiteral {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDecl {{.*}} C::FB
+//CHECK-NEXT: |   |-CallExpr {{.*}}
+//CHECK-NEXT: |   | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |   |   `-DeclRefExpr {{.*}} 'FB' 'void ()'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDecl {{.*}} C::Var2
+//CHECK-NEXT: |   `-BinaryOperator {{.*}}
+//CHECK-NEXT: |     |-DeclRefExpr {{.*}} 'Var2' 'int'
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}}
+
+void F3() {
+  using namespace C;
+  C::FA();
+
+  namespace CC = C;
+  using namespace CC;
+  CC::FA();
+}
+
+//CHECK:      |-FunctionDecl {{.*}} used F3 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDirectiveDecl {{.*}} Namespace {{.*}} 'C'
+//CHECK-NEXT: |   |-CallExpr {{.*}}
+//CHECK-NEXT: |   | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |   |   `-DeclRefExpr {{.*}} 'FA' 'void ()'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-NamespaceAliasDecl {{.*}} used CC
+//CHECK-NEXT: |   |   `-Namespace {{.*}} 'C'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDirectiveDecl {{.*}} Namespace {{.*}} 'C'
+//CHECK-NEXT: |   `-CallExpr {{.*}}
+//CHECK-NEXT: |     `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT: |       `-DeclRefExpr {{.*}} 'FA' 'void ()'
+
+void Bar() {
+  F1();
+  F2();
+  F3();
+}
+
+//CHECK:      `-FunctionDecl {{.*}} Bar 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-CallExpr {{.*}}
+//CHECK-NEXT:     | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT:     |   `-DeclRefExpr {{.*}} 'F1' 'void ()'
+//CHECK-NEXT:     |-CallExpr {{.*}}
+//CHECK-NEXT:     | `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT:     |   `-DeclRefExpr {{.*}} 'F2' 'void ()'
+//CHECK-NEXT:     `-CallExpr {{.*}}
+//CHECK-NEXT:       `-ImplicitCastExpr {{.*}}
+//CHECK-NEXT:         `-DeclRefExpr {{.*}} 'F3' 'void ()'