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

1879 ↗

(On Diff #147050)

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

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

1880 ↗

(On Diff #147050)

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

1891 ↗

(On Diff #147050)

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

1903 ↗

(On Diff #147050)

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

1916 ↗

(On Diff #147050)

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.

1927 ↗

(On Diff #147050)

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

1884–1885 ↗

(On Diff #147050)

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.

1890–1891 ↗

(On Diff #147050)

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

1879 ↗

(On Diff #147050)

Corrected to

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

1880 ↗

(On Diff #147050)

Removed the nullptr initialization.

1891 ↗

(On Diff #147050)

Removed the \brief format.

1903 ↗

(On Diff #147050)

Changed the dyn_cast<> to cast<>

1916 ↗

(On Diff #147050)

Not available in the new patch.

1927 ↗

(On Diff #147050)

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

1884–1885 ↗

(On Diff #147050)

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.

1890–1891 ↗

(On Diff #147050)

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

15564

Space after the comma.

15569

Could this be a range-based for loop?

15581

else if

lib/Sema/SemaExpr.cpp

14460

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

15374

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

15395

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

lib/Sema/SemaLookup.cpp

196

Can this be a range-based for loop?

1064

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

1236

Space after the comma.

1277

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

15569

Replaced by a range-based for loop.

lib/Sema/SemaExpr.cpp

14460

Replaced the type name with the formal parameter name.

15374

Replaced the type name with the formal parameter name.

15395

Replaced the type name with the formal parameter name.

lib/Sema/SemaLookup.cpp

98

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

196

Replaced with a range-based for loop.

1064

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

15515

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

15515

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

4040–4041

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

lib/Sema/SemaDeclCXX.cpp

15520–15525

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

15531–15586

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/Lookup.h

LookupResult(LookupResult &&Other)
         Redecl(std::move(Other.Redecl)),
         ExternalRedecl(std::move(Other.ExternalRedecl)),
         HideTags(std::move(Other.HideTags)),
         Diagnose(std::move(Other.Diagnose)),
         AllowHidden(std::move(Other.AllowHidden)),
         Shadowed(std::move(Other.Shadowed)) {
     Other.Paths = nullptr;
     Other.Diagnose = false;
+    Other.AddUsingDirectives = false;
   }
 
   LookupResult &operator=(LookupResult &&Other) {
     ResultKind = std::move(Other.ResultKind);
     Ambiguity = std::move(Other.Ambiguity);
     Decls = std::move(Other.Decls);
     Paths = std::move(Other.Paths);
     NamingClass = std::move(Other.NamingClass);
     BaseObjectType = std::move(Other.BaseObjectType);
     SemaPtr = std::move(Other.SemaPtr);
     NameInfo = std::move(Other.NameInfo);
     NameContextRange = std::move(Other.NameContextRange);
     LookupKind = std::move(Other.LookupKind);
     IDNS = std::move(Other.IDNS);
     Redecl = std::move(Other.Redecl);
     ExternalRedecl = std::move(Other.ExternalRedecl);
     HideTags = std::move(Other.HideTags);
     Diagnose = std::move(Other.Diagnose);
     AllowHidden = std::move(Other.AllowHidden);
     Shadowed = std::move(Other.Shadowed);
     Other.Paths = nullptr;
     Other.Diagnose = false;
+    Other.AddUsingDirectives = false;
     return *this;
   }
 
   ~LookupResult() {
     if (Diagnose) diagnose();
     if (Paths) deletePaths(Paths);
   }
 
public:
   /// Determine whether the lookup result was shadowed by some other
   /// declaration that lookup ignored.
   bool isShadowed() const { return Shadowed; }
 
   /// Note that we found and ignored a declaration while performing
   /// lookup.
   void setShadowed() { Shadowed = true; }
 
+  /// Determine wheter the lookup result should store using directives.
+  bool isAddUsingDirectives() const { return AddUsingDirectives; }
+  void setAddUsingDirectives() { AddUsingDirectives = true; }
+
   /// Resolves the result kind of the lookup, possibly hiding
   /// decls.
   ///
   /// This should be called in any environment where lookup might
   /// generate multiple lookup results.
   void resolveKind();
 
   /// Re-resolves the result kind of the lookup after a set of
private:
 
   /// True if we should allow hidden declarations to be 'visible'.
   bool AllowHidden = false;
 
   /// True if the found declarations were shadowed by some other
   /// declaration that we skipped. This only happens when \c LookupKind
   /// is \c LookupRedeclarationWithLinkage.
   bool Shadowed = false;
+
+  /// True if the using directives should be added to the results.
+  bool AddUsingDirectives = false;
 };
 
 /// Consumes visible declarations found when searching for
 /// all visible names within a given scope or context.
 ///
 /// This abstract class is meant to be subclassed by clients of \c
 /// Sema::LookupVisibleDecls(), each of which should override the \c
 /// FoundDecl() function to process declarations as they are found.

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,
+                             CXXScopeSpec *SS = nullptr, Expr *E = nullptr);
   void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
-                              bool MightBeOdrUse = true);
+                              bool MightBeOdrUse = true, Expr *E = 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();
 
+  void MarkNamespaceAliasReferenced(NamedDecl *ND);
+  void MarkUsingReferenced(NamedDecl *ND, SourceLocation Loc,
+                           CXXScopeSpec *SS = nullptr, Expr *E = nullptr);
+
   enum TryCaptureKind {
     TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
   };
 
   /// Try to capture the given variable.
   ///
   /// \param Var The variable to capture.
   ///

include/clang/Sema/SemaInternal.h

 }
 
 // Directly mark a variable odr-used. Given a choice, prefer to use 
 // MarkVariableReferenced since it does additional checks and then 
 // calls MarkVarDeclODRUsed.
 // If the variable must be captured:
 //  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
 //  - else capture it in the DeclContext that maps to the 
-//    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.  
-inline void MarkVarDeclODRUsed(VarDecl *Var,
-    SourceLocation Loc, Sema &SemaRef,
-    const unsigned *const FunctionScopeIndexToStopAt) {
+//    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.
+inline void MarkVarDeclODRUsed(VarDecl *Var, SourceLocation Loc, Sema &SemaRef,
+                               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.MarkUsingReferenced(Var, Loc, /*SS=*/nullptr, 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;

lib/Sema/SemaCXXScopeSpec.cpp

if (!ObjectType.isNull() && !ObjectTypeSearchedInScope &&
          Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);
 
          // Fall through so that we'll pick the name we found in the object
          // type, since that's probably what the user wanted anyway.
        }
     }
 
     if (auto *TD = dyn_cast_or_null<TypedefNameDecl>(SD))
-      MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
+      MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false, &SS);
 
     // If we're just performing this lookup for error-recovery purposes,
     // don't extend the nested-name-specifier. Just return now.
     if (ErrorRecoveryLookup)
       return false;
 
     // The use of a nested name specifier may trigger deprecation warnings.
     DiagnoseUseOfDecl(SD, IdInfo.CCLoc);

lib/Sema/SemaDecl.cpp

if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
         FoundRD->isInjectedClassName() &&
         declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
       Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
           << &II << /*Type*/1;
 
     DiagnoseUseOfDecl(IIDecl, NameLoc);
 
     T = Context.getTypeDeclType(TD);
-    MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
+    MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false, SS);
   } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
     (void)DiagnoseUseOfDecl(IDecl, NameLoc);
     if (!HasTrailingDot)
       T = Context.getObjCInterfaceType(IDecl);
   } else if (AllowDeducedTemplate) {
     if (auto *TD = getAsTypeTemplateDecl(IIDecl))
       T = Context.getDeducedTemplateSpecializationType(TemplateName(TD),
                                                        QualType(), false);
if (!Result.empty()) {
       return IsVarTemplate ? NameClassification::VarTemplate(Template)
                            : NameClassification::TypeTemplate(Template);
     }
   }
 
   NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
   if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
     DiagnoseUseOfDecl(Type, NameLoc);
-    MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
+    MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false, &SS);
     QualType T = Context.getTypeDeclType(Type);
     if (SS.isNotEmpty())
       return buildNestedType(*this, SS, T, NameLoc);
     return ParsedType::make(T);
   }
 
   ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
   if (!Class) {

lib/Sema/SemaDeclCXX.cpp

if (!TyD) {
         Diag(IdLoc, diag::err_mem_init_not_member_or_class)
           << MemberOrBase << SourceRange(IdLoc,Init->getSourceRange().getEnd());
         return true;
       }
     }
 
     if (BaseType.isNull()) {
       BaseType = Context.getTypeDeclType(TyD);
-      MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false);
+      MarkAnyDeclReferenced(TyD->getLocation(), TyD, /*OdrUse=*/false, &SS);
       if (SS.isSet()) {
         BaseType = Context.getElaboratedType(ETK_None, SS.getScopeRep(),
                                              BaseType);
         TInfo = Context.CreateTypeSourceInfo(BaseType);
         ElaboratedTypeLoc TL = TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>();
         TL.getNamedTypeLoc().castAs<TypeSpecTypeLoc>().setNameLoc(IdLoc);
         TL.setElaboratedKeywordLoc(SourceLocation());
         TL.setQualifierLoc(SS.getWithLocInContext(Context));
if (NewPD->isInvalidDecl() && PrevDecl) {
     // with the same name in the same scope.
   } else if (II) {
     PushOnScopeChains(NewPD, S);
   } else
     Record->addDecl(NewPD);
 
   return NewPD;
 }
+
+/// Mark the alias declaration and any associated chain as referenced.
+void Sema::MarkNamespaceAliasReferenced(NamedDecl *ND) {
+  if (!ND || ND->isReferenced())
+    return;
+  NamespaceAliasDecl *NA;
+  while ((NA = dyn_cast<NamespaceAliasDecl>(ND)) && !NA->isReferenced()) {
+    NA->setReferenced();
+    ND = NA->getAliasedNamespace();
+    if (auto *NNS = NA->getQualifier())
+      MarkNamespaceAliasReferenced(NNS->getAsNamespaceAlias());
+  }
+}
+
+/// Mark as referenced any 'using' statement (using-declaration,
+/// using directive or namespace alias), that have introduced the
+/// given declaration into the current context.
+void Sema::MarkUsingReferenced(NamedDecl *ND, SourceLocation Loc,
+                               CXXScopeSpec *SS, Expr *E) {
+  // The declaration was not defined in a namespace.
+  auto *DC = ND->getDeclContext();
+  if (!DC->isNamespace())
+    return;
+
+  // If the declaration was accessed explicitly using a namespace context,
+  // follow any associated namespace chain, as those declarations must be
+  // marked as referenced as well.
+  // Example:
+  //
+  //   namespace N {
+  //     int var;
+  //   }
+  //
+  //   void Fd() {
+  //     namespace NA = N;     // Referenced
+  //     namespace NB = NA;    // Referenced
+  //     NB::var = 4;
+  //   }
+
+  if (auto *NNS = SS ? SS->getScopeRep()
+                     : E ? cast<DeclRefExpr>(E)->getQualifier() : nullptr) {
+    MarkNamespaceAliasReferenced(NNS->getAsNamespaceAlias());
+    return;
+  }
+
+  // Lookup the named declaration.
+  LookupResult R(*this, ND->getDeclName(), Loc, LookupAnyName);
+  R.suppressDiagnostics();
+  R.setAddUsingDirectives();
+  LookupName(R, getCurScope());
+
+  // Any using-directive namespace target.
+  auto *Target = dyn_cast<NamespaceDecl>(DC);
+
+  for (auto *I : R) {
+    NamedDecl *D = I->getUnderlyingDecl();
+    if (auto *UD = dyn_cast<UsingDecl>(D)) {
+      // The declaration was introduced by a 'using-declaration'.
+      UD->setReferenced();
+      for (auto *UsingShadow : UD->shadows())
+        UsingShadow->setReferenced();
+      if (auto *NNS = UD->getQualifier())
+        MarkNamespaceAliasReferenced(NNS->getAsNamespaceAlias());
+      return;
+    } else if (auto *UDir = dyn_cast<UsingDirectiveDecl>(D))
+      // The declaration was introduced by a 'using-directive'.
+      if (UDir->getNominatedNamespace() == Target) {
+        UDir->setReferenced();
+        MarkNamespaceAliasReferenced(UDir->getNominatedNamespaceAsWritten());
+        return;
+      }
+  }
+}

lib/Sema/SemaExpr.cpp

static bool isImplicitlyDefinableConstexprFunction(FunctionDecl *Func) {
   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Func);
   return Func->isConstexpr() &&
          (Func->isImplicitlyInstantiable() || (MD && !MD->isUserProvided()));
 }
 
 /// 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 *E) {
   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 [...].
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);
+  MarkUsingReferenced(Func, Loc, /*SS=*/nullptr, E);
 }
 
 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
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, /*SS=*/nullptr, 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, /*SS=*/nullptr, E);
 }
 
 /// 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);
 }
 
 /// 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, CXXScopeSpec *SS,
+                                 Expr *E) {
   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, E);
     return;
   }
   D->setReferenced();
+  MarkUsingReferenced(dyn_cast<NamedDecl>(D), Loc, SS, E);
 }
 
 namespace {
   // Mark all of the declarations used by a type as referenced.
   // FIXME: Not fully implemented yet! We need to have a better understanding
   // of when we're entering a context we should not recurse into.
   // FIXME: This is and EvaluatedExprMarker are more-or-less equivalent to
   // TreeTransforms rebuilding the type in a new context. Rather than

lib/Sema/SemaExprCXX.cpp

for (unsigned Step = 0; Step != 2; ++Step) {
     }
 
     // FIXME: Should we be suppressing ambiguities here?
     if (Found.isAmbiguous())
       return nullptr;
 
     if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
       QualType T = Context.getTypeDeclType(Type);
-      MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
+      MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false, &SS);
 
       if (SearchType.isNull() || SearchType->isDependentType() ||
           Context.hasSameUnqualifiedType(T, SearchType)) {
         // We found our type!
 
         return CreateParsedType(T,
                                 Context.getTrivialTypeSourceInfo(T, NameLoc));
       }

lib/Sema/SemaLookup.cpp

namespace {
   class UnqualUsingDirectiveSet {
     Sema &SemaRef;
 
     typedef SmallVector<UnqualUsingEntry, 8> ListTy;
 
     ListTy list;
     llvm::SmallPtrSet<DeclContext*, 8> visited;
 
+    using UsingDirs = llvm::SmallPtrSet<UsingDirectiveDecl *, 8>;
+    UsingDirs usings;
+
   public:
     UnqualUsingDirectiveSet(Sema &SemaRef) : SemaRef(SemaRef) {}
 
     void visitScopeChain(Scope *S, Scope *InnermostFileScope) {
       // C++ [namespace.udir]p1:
       //   During unqualified name lookup, the names appear as if they
       //   were declared in the nearest enclosing namespace which contains
       //   both the using-directive and the nominated namespace.
void addUsingDirective(UsingDirectiveDecl *UD, DeclContext *EffectiveDC) {
       // Find the common ancestor between the effective context and
       // the nominated namespace.
       DeclContext *Common = UD->getNominatedNamespace();
       while (!Common->Encloses(EffectiveDC))
         Common = Common->getParent();
       Common = Common->getPrimaryContext();
 
       list.push_back(UnqualUsingEntry(UD->getNominatedNamespace(), Common));
+      // Insert the using directive.
+      usings.insert(UD);
+    }
+
+    // Add the collected using directives to the given lookup results.
+    void addUsingDirective(LookupResult &R) {
+      for (auto *I : usings)
+        R.addDecl(I);
     }
 
     void done() {
       llvm::sort(list.begin(), list.end(), UnqualUsingEntry::Comparator());
     }
 
     typedef ListTy::const_iterator const_iterator;
 
struct FindLocalExternScope {
   ~FindLocalExternScope() {
     restore();
   }
   LookupResult &R;
   bool OldFindLocalExtern;
 };
 } // end anonymous namespace
 
+// Add any using directives to the lookup results.
+static void AddUsingDirectives(LookupResult &R,
+                               UnqualUsingDirectiveSet &UDirs) {
+  if (R.isAddUsingDirectives())
+    UDirs.addUsingDirective(R);
+}
+
 bool Sema::CppLookupName(LookupResult &R, Scope *S) {
   assert(getLangOpts().CPlusPlus && "Can perform only C++ lookup");
 
   DeclarationName Name = R.getLookupName();
   Sema::LookupNameKind NameKind = R.getLookupKind();
 
   // If this is the name of an implicitly-declared special member function,
   // go through the scope stack to implicitly declare
if (Ctx) {
             // from local scopes.
             Scope *InnermostFileScope = S;
             while (InnermostFileScope &&
                    !isNamespaceOrTranslationUnitScope(InnermostFileScope))
               InnermostFileScope = InnermostFileScope->getParent();
             UDirs.visitScopeChain(Initial, InnermostFileScope);
 
             UDirs.done();
+            AddUsingDirectives(R, UDirs);
 
             VisitedUsingDirectives = true;
           }
 
           if (CppNamespaceLookup(*this, R, Context, Ctx, UDirs)) {
             R.resolveKind();
             return true;
           }
bool Sema::CppLookupName(LookupResult &R, Scope *S) {
   // Collect UsingDirectiveDecls in all scopes, and recursively all
   // nominated namespaces by those using-directives.
   //
   // FIXME: Cache this sorted list in Scope structure, and DeclContext, so we
   // don't build it for each lookup!
   if (!VisitedUsingDirectives) {
     UDirs.visitScopeChain(Initial, S);
     UDirs.done();
+    AddUsingDirectives(R, UDirs);
   }
 
   // If we're not performing redeclaration lookup, do not look for local
   // extern declarations outside of a function scope.
   if (!R.isForRedeclaration())
     FindLocals.restore();
 
   // Lookup namespace scope, and global scope.

lib/Sema/SemaTemplate.cpp

if (TypeDecl *Type = dyn_cast<TypeDecl>(Result.getFoundDecl())) {
       if (Keyword == ETK_Typename && LookupRD && FoundRD &&
           FoundRD->isInjectedClassName() &&
           declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
         Diag(IILoc, diag::ext_out_of_line_qualified_id_type_names_constructor)
             << &II << 1 << 0 /*'typename' keyword used*/;
 
       // We found a type. Build an ElaboratedType, since the
       // typename-specifier was just sugar.
-      MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
+      MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false, &SS);
       return Context.getElaboratedType(Keyword,
                                        QualifierLoc.getNestedNameSpecifier(),
                                        Context.getTypeDeclType(Type));
     }
 
     // C++ [dcl.type.simple]p2:
     //   A type-specifier of the form
     //     typename[opt] nested-name-specifier[opt] template-name

test/PCH/cxx-templates.cpp

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

test/SemaCXX/referenced_alias_declaration_1.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+namespace N {
+int var;
+} // namespace N
+
+void Fa() {
+  namespace NN = N;   // Referenced
+  using namespace NN; // Referenced
+  var = 1;
+}
+
+void Fb() {
+  namespace NA = N;   // Referenced
+  namespace NB = NA;  // Referenced
+  namespace NC = NB;  // Referenced
+  using namespace NC; // Referenced
+  var = 2;
+  namespace ND = NC;
+}
+
+void Fc() {
+  namespace NA = N;
+  using namespace NA;
+  N::var = 3;
+}
+
+void Fd() {
+  namespace NA = N;  // Referenced
+  namespace NB = NA; // Referenced
+  NB::var = 4;
+}
+
+//CHECK:      |-FunctionDecl {{.*}} Fa 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-NamespaceAliasDecl {{.*}} referenced NN
+//CHECK-NEXT: |   |   `-Namespace {{.*}} 'N'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDirectiveDecl {{.*}} referenced Namespace {{.*}} 'N'
+//CHECK-NEXT: |   `-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT: |     |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var' 'int'
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT: |-FunctionDecl {{.*}} Fb 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-NamespaceAliasDecl {{.*}} referenced NA
+//CHECK-NEXT: |   |   `-Namespace {{.*}} 'N'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-NamespaceAliasDecl {{.*}} referenced NB
+//CHECK-NEXT: |   |   `-NamespaceAlias {{.*}} 'NA'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-NamespaceAliasDecl {{.*}} referenced NC
+//CHECK-NEXT: |   |   `-NamespaceAlias {{.*}} 'NB'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDirectiveDecl {{.*}} referenced Namespace {{.*}} 'N'
+//CHECK-NEXT: |   |-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT: |   | |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var' 'int'
+//CHECK-NEXT: |   | `-IntegerLiteral {{.*}} 'int' 2
+//CHECK-NEXT: |   `-DeclStmt {{.*}}
+//CHECK-NEXT: |     `-NamespaceAliasDecl {{.*}} ND
+//CHECK-NEXT: |       `-NamespaceAlias {{.*}} 'NC'
+//CHECK-NEXT: |-FunctionDecl {{.*}} Fc 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-NamespaceAliasDecl {{.*}} NA
+//CHECK-NEXT: |   |   `-Namespace {{.*}} 'N'
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDirectiveDecl {{.*}} Namespace {{.*}} 'N'
+//CHECK-NEXT: |   `-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT: |     |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var' 'int'
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'int' 3
+//CHECK-NEXT: `-FunctionDecl {{.*}} Fd 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-NamespaceAliasDecl {{.*}} referenced NA
+//CHECK-NEXT:     |   `-Namespace {{.*}} 'N'
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-NamespaceAliasDecl {{.*}} referenced NB
+//CHECK-NEXT:     |   `-NamespaceAlias {{.*}} 'NA'
+//CHECK-NEXT:     `-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT:       |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var' 'int'
+//CHECK-NEXT:       `-IntegerLiteral {{.*}} 'int' 4

test/SemaCXX/referenced_alias_declaration_2.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+namespace A {
+namespace B {
+namespace C {
+typedef int Integer;
+} // namespace C
+} // namespace B
+} // namespace A
+
+void foo() {
+  {
+    namespace N_A = A; // Referenced
+    {
+      namespace N_AB = N_A::B; // Referenced
+      {
+        namespace N_ABC = N_AB::C; // Referenced
+        {
+          using N_ABC::Integer; // Referenced
+          Integer var;
+        }
+      }
+    }
+  }
+  {
+    namespace N_A = A;
+    {
+      namespace N_AB = N_A::B;
+      {
+        namespace N_ABC = N_AB::C;
+        {
+          A::B::C::Integer var;
+        }
+      }
+    }
+  }
+}
+
+//CHECK:      `-FunctionDecl {{.*}} foo 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-CompoundStmt {{.*}}
+//CHECK-NEXT:     | |-DeclStmt {{.*}}
+//CHECK-NEXT:     | | `-NamespaceAliasDecl {{.*}} referenced N_A
+//CHECK-NEXT:     | |   `-Namespace {{.*}} 'A'
+//CHECK-NEXT:     | `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |   |-DeclStmt {{.*}}
+//CHECK-NEXT:     |   | `-NamespaceAliasDecl {{.*}} referenced N_AB
+//CHECK-NEXT:     |   |   `-Namespace {{.*}} 'B'
+//CHECK-NEXT:     |   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |     |-DeclStmt {{.*}}
+//CHECK-NEXT:     |     | `-NamespaceAliasDecl {{.*}} referenced N_ABC
+//CHECK-NEXT:     |     |   `-Namespace {{.*}} 'C'
+//CHECK-NEXT:     |     `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |       |-DeclStmt {{.*}}
+//CHECK-NEXT:     |       | `-UsingDecl {{.*}} referenced N_ABC::Integer
+//CHECK-NEXT:     |       `-DeclStmt {{.*}}
+//CHECK-NEXT:     |         `-VarDecl {{.*}} var 'A::B::C::Integer':'int'
+//CHECK-NEXT:     `-CompoundStmt {{.*}}
+//CHECK-NEXT:       |-DeclStmt {{.*}}
+//CHECK-NEXT:       | `-NamespaceAliasDecl {{.*}} N_A
+//CHECK-NEXT:       |   `-Namespace {{.*}} 'A'
+//CHECK-NEXT:       `-CompoundStmt {{.*}}
+//CHECK-NEXT:         |-DeclStmt {{.*}}
+//CHECK-NEXT:         | `-NamespaceAliasDecl {{.*}} N_AB
+//CHECK-NEXT:         |   `-Namespace {{.*}} 'B'
+//CHECK-NEXT:         `-CompoundStmt {{.*}}
+//CHECK-NEXT:           |-DeclStmt {{.*}}
+//CHECK-NEXT:           | `-NamespaceAliasDecl {{.*}} N_ABC
+//CHECK-NEXT:           |   `-Namespace {{.*}} 'C'
+//CHECK-NEXT:           `-CompoundStmt {{.*}}
+//CHECK-NEXT:             `-DeclStmt {{.*}}
+//CHECK-NEXT:               `-VarDecl {{.*}} var 'A::B::C::Integer':'int'

test/SemaCXX/referenced_using_all.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+namespace A {
+typedef char Char;
+typedef int Integer;
+typedef float Float;
+int var;
+} // namespace A
+
+using A::Char;
+using A::Float;
+using A::Integer; // Referenced
+
+namespace B {
+using A::Char; // Referenced
+template <class T>
+T FuncTempl(T p1, Char p2) {
+  using A::Float; // Referenced
+  typedef Float Type;
+  Integer I;
+  return p1;
+}
+} // namespace B
+
+using A::Char; // Referenced
+using A::Integer;
+namespace ND1 = A;
+void foo() {
+  using A::Integer;    // Referenced
+  namespace ND2 = ND1; // Referenced
+  {
+    Integer Ivar;
+    namespace ND3 = ND2; // Referenced
+    {
+      namespace ND4 = ND3; // Referenced
+      Char Cvar;
+      {
+        using ND4::var; // Referenced
+        var = 1;
+      }
+    }
+  }
+  using A::Char;       // Referenced
+  using namespace ::B; // Referenced
+  FuncTempl<Char>(1, 'a');
+}
+
+//CHECK:      |-UsingDecl {{.*}} A::Char
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Typedef {{.*}} 'Char'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'A::Char' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Char'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'char'
+//CHECK-NEXT: |-UsingDecl {{.*}} A::Float
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Typedef {{.*}} 'Float'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'A::Float' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Float'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'float'
+//CHECK-NEXT: |-UsingDecl {{.*}} referenced A::Integer
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit referenced Typedef {{.*}} 'Integer'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'A::Integer' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Integer'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'int'
+//CHECK-NEXT: |-NamespaceDecl {{.*}} B
+//CHECK-NEXT: | |-UsingDecl {{.*}} referenced A::Char
+//CHECK-NEXT: | |-UsingShadowDecl {{.*}} implicit referenced Typedef {{.*}} 'Char'
+//CHECK-NEXT: | | `-TypedefType {{.*}} 'A::Char' sugar
+//CHECK-NEXT: | |   |-Typedef {{.*}} 'Char'
+//CHECK-NEXT: | |   `-BuiltinType {{.*}} 'char'
+//CHECK-NEXT: | `-FunctionTemplateDecl {{.*}} FuncTempl
+//CHECK-NEXT: |   |-TemplateTypeParmDecl {{.*}} referenced class depth 0 index 0 T
+//CHECK-NEXT: |   |-FunctionDecl {{.*}} FuncTempl 'T (T, A::Char)'
+//CHECK-NEXT: |   | |-ParmVarDecl {{.*}} referenced p1 'T'
+//CHECK-NEXT: |   | |-ParmVarDecl {{.*}} 'A::Char':'char'
+//CHECK-NEXT: |   | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   |   | `-UsingDecl {{.*}} referenced A::Float
+//CHECK-NEXT: |   |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   |   | `-TypedefDecl {{.*}} Type 'A::Float':'float'
+//CHECK-NEXT: |   |   |   `-TypedefType {{.*}} 'A::Float' sugar
+//CHECK-NEXT: |   |   |     |-Typedef {{.*}} 'Float'
+//CHECK-NEXT: |   |   |     `-BuiltinType {{.*}} 'float'
+//CHECK-NEXT: |   |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   |   | `-VarDecl {{.*}} I 'A::Integer':'int'
+//CHECK-NEXT: |   |   `-ReturnStmt {{.*}}
+//CHECK-NEXT: |   |     `-DeclRefExpr {{.*}} 'T' lvalue ParmVar {{.*}} 'p1' 'T'
+//CHECK-NEXT: |   `-FunctionDecl {{.*}} used FuncTempl 'char (char, A::Char)'
+//CHECK-NEXT: |     |-TemplateArgument type 'char'
+//CHECK-NEXT: |     |-ParmVarDecl {{.*}} used p1 'char':'char'
+//CHECK-NEXT: |     |-ParmVarDecl {{.*}} p2 'A::Char':'char'
+//CHECK-NEXT: |     `-CompoundStmt {{.*}}
+//CHECK-NEXT: |       |-DeclStmt {{.*}}
+//CHECK-NEXT: |       | `-UsingDecl {{.*}} A::Float
+//CHECK-NEXT: |       |-DeclStmt {{.*}}
+//CHECK-NEXT: |       | `-TypedefDecl {{.*}} Type 'A::Float':'float'
+//CHECK-NEXT: |       |   `-TypedefType {{.*}} 'A::Float' sugar
+//CHECK-NEXT: |       |     |-Typedef {{.*}} 'Float'
+//CHECK-NEXT: |       |     `-BuiltinType {{.*}} 'float'
+//CHECK-NEXT: |       |-DeclStmt {{.*}}
+//CHECK-NEXT: |       | `-VarDecl {{.*}} I 'A::Integer':'int'
+//CHECK-NEXT: |       `-ReturnStmt {{.*}}
+//CHECK-NEXT: |         `-ImplicitCastExpr {{.*}} 'char':'char' <LValueToRValue>
+//CHECK-NEXT: |           `-DeclRefExpr {{.*}} 'char':'char' lvalue ParmVar {{.*}} 'p1' 'char':'char'
+//CHECK-NEXT: |-UsingDecl {{.*}} referenced A::Char
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit referenced Typedef {{.*}} 'Char'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'A::Char' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Char'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'char'
+//CHECK-NEXT: |-UsingDecl {{.*}} A::Integer
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Typedef {{.*}} 'Integer'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'A::Integer' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Integer'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'int'
+//CHECK-NEXT: |-NamespaceAliasDecl {{.*}} referenced ND1
+//CHECK-NEXT: | `-Namespace {{.*}} 'A'
+//CHECK-NEXT: `-FunctionDecl {{.*}} foo 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} referenced A::Integer
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-NamespaceAliasDecl {{.*}} referenced ND2
+//CHECK-NEXT:     |   `-NamespaceAlias {{.*}} 'ND1'
+//CHECK-NEXT:     |-CompoundStmt {{.*}}
+//CHECK-NEXT:     | |-DeclStmt {{.*}}
+//CHECK-NEXT:     | | `-VarDecl {{.*}} Ivar 'A::Integer':'int'
+//CHECK-NEXT:     | |-DeclStmt {{.*}}
+//CHECK-NEXT:     | | `-NamespaceAliasDecl {{.*}} referenced ND3
+//CHECK-NEXT:     | |   `-NamespaceAlias {{.*}} 'ND2'
+//CHECK-NEXT:     | `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |   |-DeclStmt {{.*}}
+//CHECK-NEXT:     |   | `-NamespaceAliasDecl {{.*}} referenced ND4
+//CHECK-NEXT:     |   |   `-NamespaceAlias {{.*}} 'ND3'
+//CHECK-NEXT:     |   |-DeclStmt {{.*}}
+//CHECK-NEXT:     |   | `-VarDecl {{.*}} Cvar 'A::Char':'char'
+//CHECK-NEXT:     |   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |     |-DeclStmt {{.*}}
+//CHECK-NEXT:     |     | `-UsingDecl {{.*}} referenced ND4::var
+//CHECK-NEXT:     |     `-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT:     |       |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var' 'int' (UsingShadow {{.*}} 'var')
+//CHECK-NEXT:     |       `-IntegerLiteral {{.*}} <col:15> 'int' 1
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} referenced A::Char
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDirectiveDecl {{.*}} referenced Namespace {{.*}} 'B'
+//CHECK-NEXT:     `-CallExpr {{.*}} 'char':'char'
+//CHECK-NEXT:       |-ImplicitCastExpr {{.*}} 'char (*)(char, A::Char)' <FunctionToPointerDecay>
+//CHECK-NEXT:       | `-DeclRefExpr {{.*}} 'char (char, A::Char)' lvalue Function {{.*}} 'FuncTempl' 'char (char, A::Char)' (FunctionTemplate {{.*}} 'FuncTempl')
+//CHECK-NEXT:       |-ImplicitCastExpr {{.*}} 'char':'char' <IntegralCast>
+//CHECK-NEXT:       | `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT:       `-CharacterLiteral {{.*}} 'char' 97

test/SemaCXX/referenced_using_declaration_1.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+namespace N {
+// Types.
+typedef int Integer;
+struct Record {
+  int a;
+};
+
+// Variables.
+int var1;
+int var2;
+
+// Functions.
+void func1();
+void func2();
+} // namespace N
+
+using N::func1;
+using N::func2;
+using N::Integer;
+using N::Record;
+using N::var1;
+using N::var2;
+
+void Foo() {
+  using N::Integer;
+  N::Integer int_var;
+  int_var = 1;
+
+  using N::Record; // Referenced
+  Record rec_var;
+  rec_var.a = 2;
+
+  using N::var1;
+  N::var1 = 3;
+
+  using N::var2; // Referenced
+  var2 = 4;
+
+  using N::func1;
+  N::func1();
+
+  using N::func2; // Referenced
+  func2();
+}
+
+//CHECK:      |-UsingDecl {{.*}} N::func1
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Function {{.*}} 'func1' 'void ()'
+//CHECK-NEXT: |-UsingDecl {{.*}} N::func2
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Function {{.*}} 'func2' 'void ()'
+//CHECK-NEXT: |-UsingDecl {{.*}} N::Integer
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Typedef {{.*}} 'Integer'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'N::Integer' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Integer'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'int'
+//CHECK-NEXT: |-UsingDecl {{.*}} N::Record
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit CXXRecord {{.*}} 'Record'
+//CHECK-NEXT: | `-RecordType {{.*}} 'N::Record'
+//CHECK-NEXT: |   `-CXXRecord {{.*}} 'Record'
+//CHECK-NEXT: |-UsingDecl {{.*}} N::var1
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Var {{.*}} 'var1' 'int'
+//CHECK-NEXT: |-UsingDecl {{.*}} N::var2
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Var {{.*}} 'var2' 'int'
+//CHECK-NEXT: `-FunctionDecl {{.*}} Foo 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} N::Integer
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used int_var 'N::Integer':'int'
+//CHECK-NEXT:     |-BinaryOperator {{.*}} 'N::Integer':'int' lvalue '='
+//CHECK-NEXT:     | |-DeclRefExpr {{.*}} 'N::Integer':'int' lvalue Var {{.*}} 'int_var' 'N::Integer':'int'
+//CHECK-NEXT:     | `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} referenced N::Record
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-VarDecl {{.*}} used rec_var 'N::Record' callinit
+//CHECK-NEXT:     |   `-CXXConstructExpr {{.*}} 'N::Record' 'void () noexcept'
+//CHECK-NEXT:     |-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT:     | |-MemberExpr {{.*}} 'int' lvalue .a {{.*}}
+//CHECK-NEXT:     | | `-DeclRefExpr {{.*}} 'N::Record' lvalue Var {{.*}} 'rec_var' 'N::Record'
+//CHECK-NEXT:     | `-IntegerLiteral {{.*}} 'int' 2
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} N::var1
+//CHECK-NEXT:     |-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT:     | |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var1' 'int'
+//CHECK-NEXT:     | `-IntegerLiteral {{.*}} 'int' 3
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} referenced N::var2
+//CHECK-NEXT:     |-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT:     | |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var2' 'int' (UsingShadow {{.*}} 'var2')
+//CHECK-NEXT:     | `-IntegerLiteral {{.*}} 'int' 4
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} N::func1
+//CHECK-NEXT:     |-CallExpr {{.*}} 'void'
+//CHECK-NEXT:     | `-ImplicitCastExpr {{.*}} 'void (*)()' <FunctionToPointerDecay>
+//CHECK-NEXT:     |   `-DeclRefExpr {{.*}} 'void ()' lvalue Function {{.*}} 'func1' 'void ()'
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} referenced N::func2
+//CHECK-NEXT:     `-CallExpr {{.*}} 'void'
+//CHECK-NEXT:       `-ImplicitCastExpr {{.*}} 'void (*)()' <FunctionToPointerDecay>
+//CHECK-NEXT:         `-DeclRefExpr {{.*}} 'void ()' lvalue Function {{.*}} 'func2' 'void ()' (UsingShadow {{.*}} 'func2')

test/SemaCXX/referenced_using_declaration_2.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+namespace N {
+typedef int Integer;
+typedef char Char;
+} // namespace N
+
+using N::Char; // Referenced
+using N::Integer;
+
+void Foo(int p1, N::Integer p2, Char p3) {
+  N::Integer var;
+  var = 0;
+}
+
+using N::Integer; // Referenced
+Integer Bar() {
+  using N::Char;
+  return 0;
+}
+
+//CHECK:      |-UsingDecl {{.*}} referenced N::Char
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit referenced Typedef {{.*}} 'Char'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'N::Char' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Char'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'char'
+//CHECK-NEXT: |-UsingDecl {{.*}} N::Integer
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit Typedef {{.*}} 'Integer'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'N::Integer' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Integer'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'int'
+//CHECK-NEXT: |-FunctionDecl {{.*}} Foo 'void (int, N::Integer, N::Char)'
+//CHECK-NEXT: | |-ParmVarDecl {{.*}} p1 'int'
+//CHECK-NEXT: | |-ParmVarDecl {{.*}} p2 'N::Integer':'int'
+//CHECK-NEXT: | |-ParmVarDecl {{.*}} p3 'N::Char':'char'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-VarDecl {{.*}} used var 'N::Integer':'int'
+//CHECK-NEXT: |   `-BinaryOperator {{.*}} 'N::Integer':'int' lvalue '='
+//CHECK-NEXT: |     |-DeclRefExpr {{.*}} 'N::Integer':'int' lvalue Var {{.*}} 'var' 'N::Integer':'int'
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'int' 0
+//CHECK-NEXT: |-UsingDecl {{.*}} referenced N::Integer
+//CHECK-NEXT: |-UsingShadowDecl {{.*}} implicit referenced Typedef {{.*}} 'Integer'
+//CHECK-NEXT: | `-TypedefType {{.*}} 'N::Integer' sugar
+//CHECK-NEXT: |   |-Typedef {{.*}} 'Integer'
+//CHECK-NEXT: |   `-BuiltinType {{.*}} 'int'
+//CHECK-NEXT: `-FunctionDecl {{.*}} Bar 'N::Integer ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDecl {{.*}} N::Char
+//CHECK-NEXT:     `-ReturnStmt {{.*}}
+//CHECK-NEXT:       `-IntegerLiteral {{.*}} 'int' 0

test/SemaCXX/referenced_using_directive.cpp

+// RUN: %clang_cc1 -std=c++11 -ast-dump %s | FileCheck %s --strict-whitespace
+
+namespace N {
+typedef int Integer;
+int var;
+} // namespace N
+
+void Fa() {
+  using namespace N; // Referenced
+  var = 1;
+}
+
+void Fb() {
+  using namespace N;
+  N::var = 1;
+}
+
+void Fc() {
+  using namespace N; // Referenced
+  Integer var = 1;
+}
+
+void Fd() {
+  using namespace N;
+  N::Integer var = 1;
+}
+
+//CHECK:      |-FunctionDecl {{.*}} Fa 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDirectiveDecl {{.*}} referenced Namespace {{.*}} 'N'
+//CHECK-NEXT: |   `-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT: |     |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var' 'int'
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT: |-FunctionDecl {{.*}} Fb 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDirectiveDecl {{.*}} Namespace {{.*}} 'N'
+//CHECK-NEXT: |   `-BinaryOperator {{.*}} 'int' lvalue '='
+//CHECK-NEXT: |     |-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'var' 'int'
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT: |-FunctionDecl {{.*}} Fc 'void ()'
+//CHECK-NEXT: | `-CompoundStmt {{.*}}
+//CHECK-NEXT: |   |-DeclStmt {{.*}}
+//CHECK-NEXT: |   | `-UsingDirectiveDecl {{.*}} referenced Namespace {{.*}} 'N'
+//CHECK-NEXT: |   `-DeclStmt {{.*}}
+//CHECK-NEXT: |     `-VarDecl {{.*}} var 'N::Integer':'int' cinit
+//CHECK-NEXT: |       `-IntegerLiteral {{.*}} 'int' 1
+//CHECK-NEXT: `-FunctionDecl {{.*}} Fd 'void ()'
+//CHECK-NEXT:   `-CompoundStmt {{.*}}
+//CHECK-NEXT:     |-DeclStmt {{.*}}
+//CHECK-NEXT:     | `-UsingDirectiveDecl {{.*}} Namespace {{.*}} 'N'
+//CHECK-NEXT:     `-DeclStmt {{.*}}
+//CHECK-NEXT:       `-VarDecl {{.*}} var 'N::Integer':'int' cinit
+//CHECK-NEXT:         `-IntegerLiteral {{.*}} 'int' 1