Add support for attribute 'using_if_exists'

[ldionne]

Summary

This attribute applies to a using declaration, and permits importing a declaration without knowing if that declaration exists. This is useful for libc++ c wrapper headers that re-export declarations in std::.

As far as implementation goes, when some declarations are found, this attribute has no effect. When no declaration is found, Sema creates a single UsingShadowDecl that targets an UnresolvedUsingIfExistsDecl. If the UnresolvedUsingIfExistsDecl is referred to later, then an error is emitted. If the using-declaration is dependent, then Sema creates an UnresolvedUsingValueDecl/UnresolvedUsingTypenameDecl (as usual), but on instantiation they generate a UsingDecl that refers to an UnresolvedUsingIfExistsDecl.

This was proposed by Louis Dionne here: http://lists.llvm.org/pipermail/cfe-dev/2020-June/066038.html
rdar://69313357

Thanks for taking a look!

[ldionne]

clang/test/SemaCXX/using-if-exists-attr.cpp

16 ↗

(On Diff #300716)

I assume the attribute is ignored on these declarations? Why is this not an error instead, since it's clearly a programmer mistake?

[erik.pilkington]

clang/test/SemaCXX/using-if-exists-attr.cpp

16 ↗

(On Diff #300716)

Yeah, its just ignored. This is how clang behaves generally with any mis-applied attribute. An error seems more appropriate to me too honestly, but that seems like a separate policy change. Maybe @aaron.ballman knows more about the history/justification for this behaviour?

[Mordante]

A few questions. I'm not familiar enough with the code to accept the patch.

clang/include/clang/Basic/AttrDocs.td

5266

using_if_exists please add two backticks before and after the attribute name so it renders nicer.

5273

Can you add an example using [[clang::using_if_exists]] or use that instead of this attribute?

5273

Why is the attribute placed here? I would expect the attribute before the declaration [[clang::using_if_exists]] using empty_namespace::does_not_exist;

clang/lib/Sema/SemaDecl.cpp

497

Why do you want recover instead of returning a nullptr?

clang/test/SemaCXX/using-if-exists-attr.cpp

1 ↗

(On Diff #300716)

Does the test require C++20? If so can you use -std=c++20 since Clang supports it, same for the other test.

9 ↗

(On Diff #300716)

I would prefer to allow the C++ spelling, the square brackets are also supported in C when using -fdouble-square-bracket-attributes. (Not too useful in this case since C doesn't support namespaces.) But as mentioned before I prefer the attribute before the using declaration.

[rsmith]

In addition to moving the diagnostic to DiagnoseUseOfDecl, you may well get better error recovery if you teach ClassifyName about the new kind of declaration, and have it DiagnoseUseOfDecl it immediately and return NameClassification::Error() -- that way, the parser knows it can't use the kind of the name to disambiguate the parse and should use heuristics to figure out whether a type or non-type was intended instead.

clang/lib/AST/DeclBase.cpp

816

Hmm. This is tricky: IDNS_Type isn't necessarily appropriate, but we don't know one way or the other. Consider:

namespace N {
  using ::stat [[clang::using_if_exists]];
  struct stat;
}

Should we accept or reject? If the intent is that the using-declaration brings in only a non-type name, then this should be valid, but if it's intended to also bring in a type, then we'd have a conflict.

I suppose on balance being more restrictive (including IDNS_Type here) is probably better.

You don't need IDNS_Member here; that's only different from IDNS_Ordinary in C.

clang/lib/Sema/SemaDecl.cpp

438–439

Can you use getUnderlyingDecl for this?

440–441

497

I agree. Producing IntTy here is liable to result in follow-on diagnostics. It seems better to tell downstream code that you found a non-type. Can you remove this special case entirely?

clang/lib/Sema/SemaDeclCXX.cpp

12119

It might be simpler to create the UnresolvedUsingIfExistsDecl earlier (before this if) and add it to the lookup result for the checks here and below. That would avoid some of the special-case logic here.

clang/lib/Sema/SemaExpr.cpp

3146–3150

I think this should instead be done by DiagnoseUseOfDecl / CanUseDecl. All the code paths we care about already go through that.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

3192–3193

Is this reachable? I'd expect the only way we can see these is via the list of shadow declarations of the UsingDecl, so we should never try to instantiate one by itself.

clang/lib/Sema/TreeTransform.h

14115–14123

We should DiagnoseUseOfDecl along this code path rather than adding an ad-hoc check for this one case. That would also fix another, related bug:

struct A { struct __attribute__((deprecated)) B {}; };
// warns that B is deprecated
struct C : A { using typename A::B; B b; };
// fails to warn that B is deprecated
template<typename T> struct D : A { using typename A::B; B b; };
D<A> da;

[aaron.ballman]

clang/test/SemaCXX/using-if-exists-attr.cpp

16 ↗

(On Diff #300716)

It depends entirely on how you write the Subjects line in Attr.td as to whether this will warn or err. By default, we warn because most attributes should be things you can ignore. But if the semantics of the attribute suggest that an error is a better approach, you can slap an ErrorDiag after the subject list to cause errors if the attribute is written on the wrong subject.

[aaron.ballman]

clang/include/clang/AST/DeclCXX.h

3801

Why is this inheriting from a NamedDecl rather than a UsingDecl? Given that this is a type of using declaration, I guess I would have expected it to appear as such in the AST hierarchy. For instance, should people using AST matchers be able to match one of these as a using declaration or are they so different semantically that they need to be sibling AST nodes?

clang/include/clang/Basic/DiagnosticSemaKinds.td

554

Please add single quotes around the attribute name.

clang/lib/Sema/SemaDecl.cpp

1172

const auto *

clang/lib/Sema/SemaExpr.cpp

3146

const auto *

clang/lib/Sema/SemaExprMember.cpp

1169 ↗

(On Diff #300716)

const auto *

clang/test/SemaCXX/using-if-exists-attr.cpp

9 ↗

(On Diff #300716)

I'm not certain what this FIXME means given that it is using the C++ spelling there.

[erik.pilkington]

Address review comments, thanks!

clang/include/clang/AST/DeclCXX.h

3801

This node isn't a kind of using declaration, it is a declaration that gets inserted into the scope via a usual UsingDecl & UsingShadowDecl mechanism that Sema knows to error out on if it is ever used. So presumably existing AST users would still recognize that this is a UsingDecl that adds a single declaration into the current context, but wouldn't really know anything about that declaration. I updated the doc comment above to make that more clear.

clang/include/clang/Basic/AttrDocs.td

5273

The attribute is written like that because clang rejects C++ style attributes on using declarations, and only accepts attributes in that position. I think this is the first attribute we actually support on using-declarations, so maybe we should consider supporting it.

clang/lib/Sema/SemaDecl.cpp

440–441

Huh, didn't know isa did that!

497

Hmm, removing this case seems to result in worse diagnostics. For instance, here:

using NS::X __attribute__((using_if_exists));
X y;

If we remove this check and let getTypeName() just return nullptr on X, then the parser just emits a generic "unknown type name X" diagnostic. This is the only place in that path where lookup is done on X, so ISTM like the place where we should be checking this.

If we don't recover with some type, then the parser will sometimes assume that this is unworkable as a type, and attempt to recover by parsing it as something else, which can lead to duplicate diagnostics. e.g., here: int i = X();

I guess we could make getTypeName() return an Optional<ParsedType> that indicated to callers that they should assume that the name was a type, even if it can't be represented by a type node. That seems a little heavy-handed though. WDYT?

1172

This would lead to a bit of a const-goosechase in DiagnoseUseOfDecl. I thought we generally weren't too interested in const on AST nodes since they're assumed to be immutable anyways, so it doesn't really show much intent.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

3192–3193

Yeah, this is unreachable. I added a llvm_unreachable.

clang/lib/Sema/TreeTransform.h

14115–14123

Sure, the update adds that testcase in.

clang/test/SemaCXX/using-if-exists-attr.cpp

1 ↗

(On Diff #300716)

It doesn't require C++20, I just think its good practice to always specify the default in a testcase, since clang sometimes updates the default version and downstream users sometimes can't take those updates, which can lead to test breakages. New patch uses the 20 spelling, though.

9 ↗

(On Diff #300716)

The C++ spelling is getting rejected with an error message, though. It seems like this was an intentional decision: https://github.com/llvm/llvm-project/blob/3c050a597c599cea035537b8875774dcc48922c3/clang/lib/Parse/ParseDeclCXX.cpp#L715. I'm happy add parsing support for C++ attributes if that's what we want. I think we could also support attributes before the using-declaration if we wanted to (and have the attributes there apply to each using-declarator), which I'm also happy to add. Note that the C++ grammar doesn't support attributes anywhere on using-declarations.

16 ↗

(On Diff #300716)

Ok sure, I agree with Louis that the error makes sense here so I added ErrorDiag.

[aaron.ballman]

clang/include/clang/AST/DeclCXX.h

3801

So given code like this:

using empty_namespace::does_not_exist __attribute__((using_if_exists));

would you expect this AST matcher to match or not?

usingDecl()

(I hope the answer is "yes" because otherwise the behavior is rather inexplicable to me.)

clang/include/clang/Basic/AttrDocs.td

5273

I think this is the first attribute we actually support on using-declarations, so maybe we should consider supporting it.

This isn't the first attribute we *should* be supporting on using declarations. Any attribute that appertains to a NamedDecl should apply as should the annotate attribute.

However:

[[clang::whatever]] using foo::bar; // Correct to reject, #1
using foo::bar [[clang::whatever]]; // Correct to reject, #2

#1 is rejected because it's a declaration-statement and those cannot have a leading attribute-specifier-seq (http://eel.is/c++draft/stmt.stmt#stmt.pre-1). #2 is rejected because the using-declaration cannot have a trailing attribute-specifier-seq (http://eel.is/c++draft/namespace.udecl#nt:using-declaration).

This seems like a case where we may want to explore an extension to C++ that we propose to WG21.

clang/lib/Sema/SemaDecl.cpp

1172

Ah, then don't bother with the goose chase. We don't require const correctness because of these kinds of goose chases, but we usually strive for const correctness when it's cheap to do so.

[erik.pilkington]

clang/include/clang/AST/DeclCXX.h

3801

Yeah, the answer is "yes". The AST representation for a using_if_exists declaration that failed to lookup anything would look something like this:

|-UsingDecl 0x7fa42b84a3a0 <t.cpp:20:1, col:9> col:9 ::X
|-UsingShadowDecl 0x7fa42b84a3f8 <col:9> col:9 implicit UnresolvedUsingIfExists 0x7fa42b84a370 'X'

So its still using the typical UsingDecl machinery, its just that the declaration thats being imported is different.

clang/include/clang/Basic/AttrDocs.td

5273

This isn't the first attribute we *should* be supporting on using declarations. Any attribute that appertains to a NamedDecl should apply as should the annotate attribute.

Yeah, agreed. Its just that Sema was failing to call ProcessDeclAttributeList for UsingDecls, so no attributes were actually getting applied in practice.

Okay, if our policy is to only parse C++-style attributes in places that the C++ grammar allows them then I agree that this would be an issue for the standards committee.

[aaron.ballman]

clang/include/clang/AST/DeclCXX.h

3801

Awesome, thank you for clarifying!

[Mordante]

clang/include/clang/Basic/AttrDocs.td

5273

I would be in favour to implement this as an extension and propose it to the committee. I wonder whether it's not allowed because the committee objected or nobody wrote a paper. (Attributes are already allowed on using namespace directives http://eel.is/c++draft/namespace.udir.)

[aaron.ballman]

clang/include/clang/Basic/AttrDocs.td

5273

I wouldn't be opposed to adding an extension for parsing C++-style attributes on parts of a using declaration so long as we diagnosed them as an extension to alert people to portability issues. I would say that the attribute should be written as a prefix attribute (similar to the using-directive grammar) and after the using-declarator. This would allow you to do:

[[]] using foo::bar;
using foo::bar [[]];
using foo::bar [[]], baz::quux;

[rsmith]

clang/include/clang/Basic/AttrDocs.td

5273

FWIW, this matches my intuition for attribute placement.

[erik.pilkington]

Add support for C++11-style attributes on using-declarations.

[aaron.ballman]

In D90188#2394361, @erik.pilkington wrote:

Add support for C++11-style attributes on using-declarations.

FWIW, it'd be a bit easier if those changes were split off into their own patch, as they're orthogonal to using_if_exists.

clang/include/clang/Basic/AttrDocs.td

5376

Do you think the docs should call out that using the C++ spelling on a using declaration is currently a Clang extension? It's a bit of an odd place to put that information, but I don't know of where else to mention that this attribute is nonportable in a few different ways.

clang/include/clang/Basic/DiagnosticParseKinds.td

689 ↗

(On Diff #305193)

I'm not certain what @rsmith thinks, but I think this should be ExtWarn and have the DefaultIgnore removed -- this is a conforming extension of something that's nonportable even in the absence of any attributes in the attribute list. e.g., [[]] using foo::bar;`` is not portable to parse.

690 ↗

(On Diff #305193)

I think that should say ISO C++ instead of just C++ to make it clear that this is a standards thing, not a C++-as-it-really-is thing.

clang/include/clang/Serialization/ASTBitCodes.h

1364

Does this mean you need to bump VERSION_MAJOR as well?

clang/test/Parser/cxx0x-attributes.cpp

160 ↗

(On Diff #305193)

Can you also add a test for using foo [[]], bar []]]; syntax?

clang/test/SemaCXX/using-if-exists-attr.cpp

9–17 ↗

(On Diff #305193)

These test cases look like they belong in a Parser test not a SemaCXX test.

[erik.pilkington]

Split off parsing support for C++ attributes.

[erik.pilkington]

In D90188#2397441, @aaron.ballman wrote:

FWIW, it'd be a bit easier if those changes were split off into their own patch, as they're orthogonal to using_if_exists.

Ok, I moved this part to: https://reviews.llvm.org/D91630

clang/include/clang/Basic/AttrDocs.td

5376

Sure, I'll mention it. I'm also switching back to the GCC spelling here since we're warning on the C++ spelling by default.

clang/include/clang/Basic/DiagnosticParseKinds.td

689 ↗

(On Diff #305193)

Sure, I'll update the docs to prefer using the GNU spelling if we're going to warn by default on this spelling.

clang/include/clang/Serialization/ASTBitCodes.h

1364

Hmm, I don't think so, it looks like the git hash is taken into account based on the comment in ASTBitCodes.h:

/// Version 4 of AST files also requires that the version control branch and
/// revision match exactly, since there is no backward compatibility of
/// AST files at this time.
const unsigned VERSION_MAJOR = 11;

FWIW it seems like nobody else who adds new AST nodes is bumping this version.

clang/test/Parser/cxx0x-attributes.cpp

160 ↗

(On Diff #305193)

Sure, I did this in the parser patch.

clang/test/SemaCXX/using-if-exists-attr.cpp

9–17 ↗

(On Diff #305193)

Sure, I moved this file over to Parser.

[aaron.ballman]

clang/lib/Sema/SemaDecl.cpp

442

1173

clang/lib/Sema/SemaExpr.cpp

3175

auto *VD = cast<ValueDecl>(D);

clang/lib/Serialization/ASTReaderDecl.cpp

1704–1707

I'm not super familiar with this code, but is this change actually necessary? I would have expected this to be handled via VisitNamedDecl by virtue of UnresolvedUsingIfExistsDecl inheriting from NamedDecl.

[erik.pilkington]

Address review comments.

clang/lib/Serialization/ASTReaderDecl.cpp

1704–1707

I think its necessary -- DeclVisitor doesn't automatically visit the base classes. Every other Visit* function here manually visits the base classes too FWIW.

[aaron.ballman]

LGTM aside from a minor nit, thank you!

clang/lib/Sema/SemaDeclCXX.cpp

11681

You can use isa_and_nonnull<>() instead of testing for null yourself.

[• Quuxplusone]

clang/test/SemaCXX/using-if-exists.cpp

11

Do you also have a test for using NS::NotNS::x UIE;?
(Both of these NotNS tests produce hard errors; [[using_if_exists]] does the silent-ignore thing only when the tippymost identifier is nonexistent, not if some intermediate name is nonexistent. This seems reasonable enough.)

60

An inheritance case not yet covered here errors out with error: no matching constructor for initialization of 'Derived<Base>':

struct Base { Base(int); };
template<class T> struct Derived : T {
    using T::T [[clang::using_if_exists]];
};
Derived<Base> d(1);

Does this make sense? Should this attribute perhaps give a hard error if you try to use it to inherit a constructor overload set like this, instead of (apparently) just no-opping the construct?

79

I notice there's a hard error: 'using_if_exists' attribute cannot be applied to types on

using B::operator int UIE;

Any thoughts on how to disambiguate that grammar?

107

This is a very good test, but it feels to me as if

struct B { static int f(int); };
struct C { };
template<class... Ts> struct D : Ts... {
    using Ts::f... [[clang::using_if_exists]];
};
int main() { D<B, C>::f(1); }

ought to be at least as well-formed as

struct B { static int f(int); };
struct C { static void f(); };
template<class... Ts> struct D : Ts... {
    using Ts::f... [[clang::using_if_exists]];
};
int main() { D<B, C>::f(1); }

I guess what's going on here is that an "unresolved using decl" is considered a separate kind of entity, i.e. using Ts::f... will work if all Ts::f... are variables, or if all of them are functions, or if all of them are unresolved, but it doesn't work if you have a mix of variables and functions, or variables and unresolveds, or functions and unresolveds. Is that basically correct, and intended?

199

IMHO this test would be clearer if it used obviously fake names, e.g. using ::fake_FILE, using ::fake_printf, etc.

[erik.pilkington]

Address review comments.

clang/test/SemaCXX/using-if-exists.cpp

11

Yeah, this is only about the tippymost name :). New patch adds a test for non-existent names in the middle, which was previously untested.

60

Hmm, yeah, I don't think that inheriting constructors really make sense with this attribute. New patch adds an error.

79

Hmm, that's an interesting case. I'm not sure what the right approach is. I think it would be a bit awkward to decide where to attach the attribute depending on what kind of entities the attribute could potentially apply to. FWIW this isn't a semantic restriction, since you can always just use the prefix syntax: UIE using B::operator int;. Maybe @aaron.ballman has some thoughts here?

107

I guess what's going on here is that an "unresolved using decl" is considered a separate kind of entity, i.e. using Ts::f... will work if all Ts::f... are variables, or if all of them are functions, or if all of them are unresolved, but it doesn't work if you have a mix of variables and functions, or variables and unresolveds, or functions and unresolveds. Is that basically correct, and intended?

Yeah, exactly. My mental model for how this attribute works is that an unresolved using-declaration introduces an entity that isn't a function, value, or type, and is incompatible with all of those. Sometimes, that isn't what you want for overloaded functions, like Louis ran into an issue while testing this where remove(const char *) in <cstdio> being unresolved lead to a compile error on the declaration of remove(iter, iter, val) in <algorithm>. That seems to basically be the same issue you're seeing in your first test case.

Personally, my inclination is to conservatively just disallow any interplay with an unresolved using-declaration and a function, and if we run into a lot of problems in practice then we can come up with a more nuanced approach for this case without breaking backwards compatibility. WDYT?

[erik.pilkington]

Ping!

[aaron.ballman]

clang/test/SemaCXX/using-if-exists.cpp

79

By my reading of the standard, an attribute in that position really does apply to the type int in that case.

https://eel.is/c++draft/namespace.udecl#nt:using-declarator
https://eel.is/c++draft/expr.prim.id.unqual#nt:unqualified-id
https://eel.is/c++draft/class.conv.fct#nt:conversion-function-id
https://eel.is/c++draft/class.conv.fct#nt:conversion-type-id
https://eel.is/c++draft/dcl.type.general#nt:type-specifier-seq
https://eel.is/c++draft/dcl.type.general#1.sentence-2

That said, I don't know if that's really *expected* behavior, so this might be a question for WG21.

[erik.pilkington]

Does anyone have any remaining concerns or a desire to take another pass through this patch? If not, then I'll commit this later this week on Aaron's LGTM.

[ldionne]

Rebase onto main.

[ldionne]

Rebase onto main to trigger CI.

[ldionne]

Run clang-format.

[ldionne]

Fix CI issues (hopefully - at least everything runs locally).

clang/include/clang/AST/DeclCXX.h

   const UnresolvedUsingTypenameDecl *getCanonicalDecl() const {
     return getFirstDecl();
   }
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == UnresolvedUsingTypename; }
 };
 
+/// This node is generated when a using-declaration that was annotated with
+/// __attribute__((using_if_exists)) failed to resolve to a known declaration.
+/// In that case, Sema builds a UsingShadowDecl whose target is an instance of
+/// this declaration, adding it to the current scope. Referring to this
+/// declaration in any way is an error.
+class UnresolvedUsingIfExistsDecl final : public NamedDecl {
+  UnresolvedUsingIfExistsDecl(DeclContext *DC, SourceLocation Loc,
+                              DeclarationName Name);
+
+  void anchor() override;
+public:
+  static UnresolvedUsingIfExistsDecl *Create(ASTContext &Ctx, DeclContext *DC,
+                                             SourceLocation Loc,
+                                             DeclarationName Name);
+  static UnresolvedUsingIfExistsDecl *CreateDeserialized(ASTContext &Ctx,
+                                                         unsigned ID);
+
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) {
+    return K == Decl::UnresolvedUsingIfExists;
+  }
+};
+
 /// Represents a C++11 static_assert declaration.
 class StaticAssertDecl : public Decl {
   llvm::PointerIntPair<Expr *, 1, bool> AssertExprAndFailed;
   StringLiteral *Message;
   SourceLocation RParenLoc;
 
   StaticAssertDecl(DeclContext *DC, SourceLocation StaticAssertLoc,
                    Expr *AssertExpr, StringLiteral *Message,

clang/include/clang/AST/RecursiveASTVisitor.h

   // A dependent using declaration which was marked with 'typename'.
   //   template<class T> class A : public B<T> { using typename B<T>::foo; };
   TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
   // We shouldn't traverse D->getTypeForDecl(); it's a result of
   // declaring the type, not something that was written in the
   // source.
 })
 
+DEF_TRAVERSE_DECL(UnresolvedUsingIfExistsDecl, {})
+
 DEF_TRAVERSE_DECL(EnumDecl, {
   TRY_TO(TraverseDeclTemplateParameterLists(D));
 
   if (D->getTypeForDecl())
     TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
 
   TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
   // The enumerators are already traversed by

clang/include/clang/Basic/Attr.td

 
 def NoBuiltin : Attr {
   let Spellings = [Clang<"no_builtin">];
   let Args = [VariadicStringArgument<"BuiltinNames">];
   let Subjects = SubjectList<[Function]>;
   let Documentation = [NoBuiltinDocs];
 }
 
+def UsingIfExists : InheritableAttr {
+  let Spellings = [Clang<"using_if_exists", 0>];
+  let Subjects = SubjectList<[Using,
+                              UnresolvedUsingTypename,
+                              UnresolvedUsingValue], ErrorDiag>;
+  let Documentation = [UsingIfExistsDocs];
+}
+
 // FIXME: This attribute is not inheritable, it will not be propagated to
 // redecls. [[clang::lifetimebound]] has the same problems. This should be
 // fixed in TableGen (by probably adding a new inheritable flag).
 def AcquireHandle : DeclOrTypeAttr {
   let Spellings = [Clang<"acquire_handle">];
   let Args = [StringArgument<"HandleType">];
   let Subjects = SubjectList<[Function, TypedefName, ParmVar]>;
   let Documentation = [AcquireHandleDocs];

clang/include/clang/Basic/AttrDocs.td

   int f() {
     IntPointer P;
     if (true) {
       IntOwner O(7);
       P = IntPointer(O); // P "points into" O
     } // P is dangling
     return P.get(); // error: Using a dangling Pointer.
   }
 
 }];
 }
 
 def ArmBuiltinAliasDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 This attribute is used in the implementation of the ACLE intrinsics.
 It allows the intrinsic functions to
 be declared using the names defined in ACLE, and still be recognized
 as clang builtins equivalent to the underlying name. For example,
 ``arm_mve.h`` declares the function ``vaddq_u32`` with
 ``__attribute__((__clang_arm_mve_alias(__builtin_arm_mve_vaddq_u32)))``,
 and similarly, one of the type-overloaded declarations of ``vaddq``
 will have the same attribute. This ensures that both functions are
 recognized as that clang builtin, and in the latter case, the choice

     // `__builtin_memset(data, 0xFE, count);` but cannot generate any
     // `__builtin_memcpy`
     for (size_t i = 0; i < count; ++i)
       data[i] = 0xFE;
   }
   }];
 }
 
+def UsingIfExistsDocs : Documentation {
+  let Category = DocCatDecl;
+  let Content = [{
+The ``using_if_exists`` attribute applies to a using-declaration. It allows
+programmers to import a declaration that potentially does not exist, instead
+deferring any errors to the point of use. For instance:
+
+.. code-block:: c++
+
+  namespace empty_namespace {};
+  __attribute__((using_if_exists))
+  using empty_namespace::does_not_exist; // no error!
+
+  does_not_exist x; // error: use of unresolved 'using_if_exists'
+
+The C++ spelling of the attribte (`[[clang::using_if_exists]]`) is also
+supported as a clang extension, since ISO C++ doesn't support attributes in this
+position. If the entity referred to by the using-declaration is found by name
+lookup, the attribute has no effect. This attribute is useful for libraries
+(primarily, libc++) that wish to redeclare a set of declarations in another
+namespace, when the availability of those declarations is difficult or
+impossible to detect at compile time with the preprocessor.
+  }];
+}
+
 def HandleDocs : DocumentationCategory<"Handle Attributes"> {
   let Content = [{
 Handles are a way to identify resources like files, sockets, and processes.
 They are more opaque than pointers and widely used in system programming. They
 have similar risks such as never releasing a resource associated with a handle,
 attempting to use a handle that was already released, or trying to release a
 handle twice. Using the annotations below it is possible to make the ownership
 of the handles clear: whose responsibility is to release them. They can also
 aid static analysis tools to find bugs.
   }];
 }
 
 def AcquireHandleDocs : Documentation {
   let Category = HandleDocs;
   let Content = [{
 If this annotation is on a function or a function type it is assumed to return
 a new handle. In case this annotation is on an output parameter,
 the function is assumed to fill the corresponding argument with a new
 handle.
 
 .. code-block:: c++
 
   // Output arguments from Zircon.
   zx_status_t zx_socket_create(uint32_t options,
                                zx_handle_t __attribute__((acquire_handle)) * out0,
                                zx_handle_t* out1 [[clang::acquire_handle]]);
 
 
   // Returned handle.
   [[clang::acquire_handle]] int open(const char *path, int oflag, ... );
   int open(const char *path, int oflag, ... ) __attribute__((acquire_handle));

clang/include/clang/Basic/DeclNodes.td

def RedeclarableTemplate : DeclNode<Template, "redeclarable templates", 1>;
       def TypeAliasTemplate : DeclNode<RedeclarableTemplate>;
     def TemplateTemplateParm : DeclNode<Template>;
     def BuiltinTemplate : DeclNode<Template>;
     def Concept : DeclNode<Template>;
   def Using : DeclNode<Named>;
   def UsingPack : DeclNode<Named>;
   def UsingShadow : DeclNode<Named>;
     def ConstructorUsingShadow : DeclNode<UsingShadow>;
+  def UnresolvedUsingIfExists : DeclNode<Named>;
   def ObjCMethod : DeclNode<Named, "Objective-C methods">, DeclContext;
   def ObjCContainer : DeclNode<Named, "Objective-C containers", 1>, DeclContext;
     def ObjCCategory : DeclNode<ObjCContainer>;
     def ObjCProtocol : DeclNode<ObjCContainer, "Objective-C protocols">;
     def ObjCInterface : DeclNode<ObjCContainer, "Objective-C interfaces">;
     def ObjCImpl
         : DeclNode<ObjCContainer, "Objective-C implementation declarations", 1>;
       def ObjCCategoryImpl : DeclNode<ObjCImpl>;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_using_decl_redeclaration : Error<"redeclaration of using declaration">;
 def err_using_decl_conflict : Error<
   "target of using declaration conflicts with declaration already in scope">;
 def err_using_decl_conflict_reverse : Error<
   "declaration conflicts with target of using declaration already in scope">;
 def note_using_decl : Note<"%select{|previous }0using declaration">;
 def err_using_decl_redeclaration_expansion : Error<
   "using declaration pack expansion at block scope produces multiple values">;
+def err_use_of_empty_using_if_exists : Error<
+  "reference to unresolved using declaration">;
+def note_empty_using_if_exists_here : Note<
+  "using declaration annotated with 'using_if_exists' here">;
 
 def warn_access_decl_deprecated : Warning<
   "access declarations are deprecated; use using declarations instead">,
   InGroup<Deprecated>;
 def err_access_decl : Error<
   "ISO C++11 does not allow access declarations; "
   "use using declarations instead">;
 def warn_deprecated_copy_operation : Warning<

clang/include/clang/Sema/Sema.h

                                const CXXScopeSpec &SS,
                                const DeclarationNameInfo &NameInfo,
                                SourceLocation NameLoc);
 
   NamedDecl *BuildUsingDeclaration(
       Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
       bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
       DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
-      const ParsedAttributesView &AttrList, bool IsInstantiation);
+      const ParsedAttributesView &AttrList, bool IsInstantiation,
+      bool IsUsingIfExists);
   NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
                                 ArrayRef<NamedDecl *> Expansions);
 
   bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
 
   /// Given a derived-class using shadow declaration for a constructor and the
   /// correspnding base class constructor, find or create the implicit
   /// synthesized derived class constructor to use for this initialization.

clang/include/clang/Serialization/ASTBitCodes.h

       DECL_USING_DIRECTIVE,
 
       /// An UnresolvedUsingValueDecl record.
       DECL_UNRESOLVED_USING_VALUE,
 
       /// An UnresolvedUsingTypenameDecl record.
       DECL_UNRESOLVED_USING_TYPENAME,
 
+      /// An UnresolvedUsingIfExistsDecl record.
+      DECL_UNRESOLVED_USING_IF_EXISTS,
+
       /// A LinkageSpecDecl record.
       DECL_LINKAGE_SPEC,
 
       /// An ExportDecl record.
       DECL_EXPORT,
 
       /// A CXXRecordDecl record.
       DECL_CXX_RECORD,

clang/lib/AST/DeclBase.cpp

     case FunctionTemplate:
       return IDNS_Ordinary;
 
     case ClassTemplate:
     case TemplateTemplateParm:
     case TypeAliasTemplate:
       return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
 
+    case UnresolvedUsingIfExists:
+      return IDNS_Type | IDNS_Ordinary;
+
     case OMPDeclareReduction:
       return IDNS_OMPReduction;
 
     case OMPDeclareMapper:
       return IDNS_OMPMapper;
 
     // Never have names.
     case Friend:

clang/lib/AST/DeclCXX.cpp

 
 UnresolvedUsingTypenameDecl *
 UnresolvedUsingTypenameDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) UnresolvedUsingTypenameDecl(
       nullptr, SourceLocation(), SourceLocation(), NestedNameSpecifierLoc(),
       SourceLocation(), nullptr, SourceLocation());
 }
 
+UnresolvedUsingIfExistsDecl *
+UnresolvedUsingIfExistsDecl::Create(ASTContext &Ctx, DeclContext *DC,
+                                    SourceLocation Loc, DeclarationName Name) {
+  return new (Ctx, DC) UnresolvedUsingIfExistsDecl(DC, Loc, Name);
+}
+
+UnresolvedUsingIfExistsDecl *
+UnresolvedUsingIfExistsDecl::CreateDeserialized(ASTContext &Ctx, unsigned ID) {
+  return new (Ctx, ID)
+      UnresolvedUsingIfExistsDecl(nullptr, SourceLocation(), DeclarationName());
+}
+
+UnresolvedUsingIfExistsDecl::UnresolvedUsingIfExistsDecl(DeclContext *DC,
+                                                         SourceLocation Loc,
+                                                         DeclarationName Name)
+    : NamedDecl(Decl::UnresolvedUsingIfExists, DC, Loc, Name) {}
+
+void UnresolvedUsingIfExistsDecl::anchor() {}
+
 void StaticAssertDecl::anchor() {}
 
 StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
                                            SourceLocation StaticAssertLoc,
                                            Expr *AssertExpr,
                                            StringLiteral *Message,
                                            SourceLocation RParenLoc,
                                            bool Failed) {

clang/lib/CodeGen/CGDecl.cpp

void CodeGenFunction::EmitDecl(const Decl &D) {
   case Decl::FriendTemplate:
   case Decl::Block:
   case Decl::Captured:
   case Decl::ClassScopeFunctionSpecialization:
   case Decl::UsingShadow:
   case Decl::ConstructorUsingShadow:
   case Decl::ObjCTypeParam:
   case Decl::Binding:
+  case Decl::UnresolvedUsingIfExists:
     llvm_unreachable("Declaration should not be in declstmts!");
   case Decl::Record:    // struct/union/class X;
   case Decl::CXXRecord: // struct/union/class X; [C++]
     if (CGDebugInfo *DI = getDebugInfo())
       if (cast<RecordDecl>(D).getDefinition())
         DI->EmitAndRetainType(getContext().getRecordType(cast<RecordDecl>(&D)));
     return;
   case Decl::Enum:      // enum X;

clang/lib/Sema/SemaDecl.cpp

case LookupResult::Ambiguous:
     if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
       Result.suppressDiagnostics();
       return nullptr;
     }
 
     // Look to see if we have a type anywhere in the list of results.
     for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
          Res != ResEnd; ++Res) {
-      if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res) ||
-          (AllowDeducedTemplate && getAsTypeTemplateDecl(*Res))) {
+      NamedDecl *RealRes = (*Res)->getUnderlyingDecl();
+      if (isa<TypeDecl, ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(RealRes) ||
+          (AllowDeducedTemplate && getAsTypeTemplateDecl(RealRes))) {
         if (!IIDecl ||
-            (*Res)->getLocation().getRawEncoding() <
+            // Make the selection of the recovery decl deterministic.
+            RealRes->getLocation().getRawEncoding() <
               IIDecl->getLocation().getRawEncoding())
-          IIDecl = *Res;
+          IIDecl = RealRes;
       }
     }
 
     if (!IIDecl) {
       // None of the entities we found is a type, so there is no way
       // to even assume that the result is a type. In this case, don't
       // complain about the ambiguity. The parser will either try to
       // perform this lookup again (e.g., as an object name), which
if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
     DiagnoseUseOfDecl(IIDecl, NameLoc);
 
     T = Context.getTypeDeclType(TD);
     MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
   } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
     (void)DiagnoseUseOfDecl(IDecl, NameLoc);
     if (!HasTrailingDot)
       T = Context.getObjCInterfaceType(IDecl);
+  } else if (auto *UD = dyn_cast<UnresolvedUsingIfExistsDecl>(IIDecl)) {
+    (void)DiagnoseUseOfDecl(UD, NameLoc);
+    // Recover with 'int'
+    T = Context.IntTy;
   } else if (AllowDeducedTemplate) {
     if (auto *TD = getAsTypeTemplateDecl(IIDecl))
       T = Context.getDeducedTemplateSpecializationType(TemplateName(TD),
                                                        QualType(), false);
   }
 
   if (T.isNull()) {
     // If it's not plausibly a type, suppress diagnostics.
     Result.suppressDiagnostics();
     return nullptr;
   }
 
   // NOTE: avoid constructing an ElaboratedType(Loc) if this is a
   // constructor or destructor name (in such a case, the scope specifier
   // will be attached to the enclosing Expr or Decl node).
   if (SS && SS->isNotEmpty() && !IsCtorOrDtorName &&
-      !isa<ObjCInterfaceDecl>(IIDecl)) {
+      !isa<ObjCInterfaceDecl, UnresolvedUsingIfExistsDecl>(IIDecl)) {
     if (WantNontrivialTypeSourceInfo) {
       // Construct a type with type-source information.
       TypeLocBuilder Builder;
       Builder.pushTypeSpec(T).setNameLoc(NameLoc);
 
       T = getElaboratedType(ETK_None, *SS, T);
       ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
       ElabTL.setElaboratedKeywordLoc(SourceLocation());
if (Class) {
     QualType T = Context.getObjCInterfaceType(Class);
     return ParsedType::make(T);
   }
 
   if (isa<ConceptDecl>(FirstDecl))
     return NameClassification::Concept(
         TemplateName(cast<TemplateDecl>(FirstDecl)));
 
+  if (auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(FirstDecl)) {
+    (void)DiagnoseUseOfDecl(EmptyD, NameLoc);
+    return NameClassification::Error();
+  }
+
   // We can have a type template here if we're classifying a template argument.
   if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl) &&
       !isa<VarTemplateDecl>(FirstDecl))
     return NameClassification::TypeTemplate(
         TemplateName(cast<TemplateDecl>(FirstDecl)));
 
   // Check for a tag type hidden by a non-type decl in a few cases where it
   // seems likely a type is wanted instead of the non-type that was found.

clang/lib/Sema/SemaDeclAttr.cpp

 
   case ParsedAttr::AT_ReleaseHandle:
     handleHandleAttr<ReleaseHandleAttr>(S, D, AL);
     break;
 
   case ParsedAttr::AT_UseHandle:
     handleHandleAttr<UseHandleAttr>(S, D, AL);
     break;
+
+  case ParsedAttr::AT_UsingIfExists:
+    handleSimpleAttribute<UsingIfExistsAttr>(S, D, AL);
+    break;
   }
 }
 
 /// ProcessDeclAttributeList - Apply all the decl attributes in the specified
 /// attribute list to the specified decl, ignoring any type attributes.
 void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
                                     const ParsedAttributesView &AttrList,
                                     bool IncludeCXX11Attributes) {

clang/lib/Sema/SemaDeclCXX.cpp

     if (!SS.getScopeRep()->containsUnexpandedParameterPack() &&
         !TargetNameInfo.containsUnexpandedParameterPack()) {
       Diag(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)
         << SourceRange(SS.getBeginLoc(), TargetNameInfo.getEndLoc());
       EllipsisLoc = SourceLocation();
     }
   }
 
-  NamedDecl *UD =
-      BuildUsingDeclaration(S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc,
-                            SS, TargetNameInfo, EllipsisLoc, AttrList,
-                            /*IsInstantiation*/false);
+  NamedDecl *UD = BuildUsingDeclaration(
+      S, AS, UsingLoc, TypenameLoc.isValid(), TypenameLoc, SS, TargetNameInfo,
+      EllipsisLoc, AttrList,
+      /*IsInstantiation=*/false,
+      AttrList.hasAttribute(ParsedAttr::AT_UsingIfExists));
   if (UD)
     PushOnScopeChains(UD, S, /*AddToContext*/ false);
 
   return UD;
 }
 
 /// Determine whether a using declaration considers the given
 /// declarations as "equivalent", e.g., if they are redeclarations of
 /// the same entity or are both typedefs of the same type.
 static bool
 IsEquivalentForUsingDecl(ASTContext &Context, NamedDecl *D1, NamedDecl *D2) {
   if (D1->getCanonicalDecl() == D2->getCanonicalDecl())
     return true;
 
   if (TypedefNameDecl *TD1 = dyn_cast<TypedefNameDecl>(D1))
     if (TypedefNameDecl *TD2 = dyn_cast<TypedefNameDecl>(D2))
       return Context.hasSameType(TD1->getUnderlyingType(),
                                  TD2->getUnderlyingType());
 
+  // Two using_if_exists using-declarations are equivalent if both are
+  // unresolved.
+  if (isa<UnresolvedUsingIfExistsDecl>(D1) &&
+      isa<UnresolvedUsingIfExistsDecl>(D2))
+    return true;
+
   return false;
 }
 
 
 /// Determines whether to create a using shadow decl for a particular
 /// decl, given the set of decls existing prior to this using lookup.
 bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
                                 const LookupResult &Previous,

 
     if (isVisible(D))
       (isa<TagDecl>(D) ? Tag : NonTag) = D;
   }
 
   if (FoundEquivalentDecl)
     return false;
 
+  // Always emit a diagnostic for a mismatch between an unresolved
+  // using_if_exists and a resolved using declaration in either direction.
+  if (isa<UnresolvedUsingIfExistsDecl>(Target) !=
+      (NonTag && isa<UnresolvedUsingIfExistsDecl>(NonTag))) {
+    if (!NonTag && !Tag)
+      return false;
+    Diag(Using->getLocation(), diag::err_using_decl_conflict);
+    Diag(Target->getLocation(), diag::note_using_decl_target);
+    Diag((NonTag ? NonTag : Tag)->getLocation(), diag::note_using_decl_conflict);
+    Using->setInvalidDecl();
+    return true;
+  }
+
   if (FunctionDecl *FD = Target->getAsFunction()) {
     NamedDecl *OldDecl = nullptr;
     switch (CheckOverload(nullptr, FD, Previous, OldDecl,
                           /*IsForUsingDecl*/ true)) {
     case Ovl_Overload:
       return false;
 
     case Ovl_NonFunction:

 ///
 /// \param IsInstantiation - Whether this call arises from an
 ///   instantiation of an unresolved using declaration.  We treat
 ///   the lookup differently for these declarations.
 NamedDecl *Sema::BuildUsingDeclaration(
     Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
     bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
     DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
-    const ParsedAttributesView &AttrList, bool IsInstantiation) {
+    const ParsedAttributesView &AttrList, bool IsInstantiation,
+    bool IsUsingIfExists) {
   assert(!SS.isInvalid() && "Invalid CXXScopeSpec.");
   SourceLocation IdentLoc = NameInfo.getLoc();
   assert(IdentLoc.isValid() && "Invalid TargetName location.");
 
   // FIXME: We ignore attributes for now.
 
   // For an inheriting constructor declaration, the name of the using
   // declaration is the name of a constructor in this class, not in the

   // equal to that of the current context.
   if (CurContext->isRecord()) {
     R.setBaseObjectType(
                    Context.getTypeDeclType(cast<CXXRecordDecl>(CurContext)));
   }
 
   LookupQualifiedName(R, LookupContext);
 
+  if (R.empty() && IsUsingIfExists)
+    R.addDecl(UnresolvedUsingIfExistsDecl::Create(Context, CurContext, UsingLoc,
+                                                  UsingName.getName()), AS_public);
+
   // Try to correct typos if possible. If constructor name lookup finds no
   // results, that means the named class has no explicit constructors, and we
   // suppressed declaring implicit ones (probably because it's dependent or
   // invalid).
   if (R.empty() &&
       NameInfo.getName().getNameKind() != DeclarationName::CXXConstructorName) {
     // HACK: Work around a bug in libstdc++'s detection of ::gets. Sometimes
     // it will believe that glibc provides a ::gets in cases where it does not,

 
       // If we picked a correction with no attached Decl we can't do anything
       // useful with it, bail out.
       NamedDecl *ND = Corrected.getCorrectionDecl();
       if (!ND)
         return BuildInvalid();
 
       // If we corrected to an inheriting constructor, handle it as one.
       auto *RD = dyn_cast<CXXRecordDecl>(ND);
       if (RD && RD->isInjectedClassName()) {
         // The parent of the injected class name is the class itself.
         RD = cast<CXXRecordDecl>(RD->getParent());
 
         // Fix up the information we'll use to build the using declaration.
         if (Corrected.WillReplaceSpecifier()) {
           NestedNameSpecifierLocBuilder Builder;
           Builder.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),

     }
   }
 
   if (R.isAmbiguous())
     return BuildInvalid();
 
   if (HasTypenameKeyword) {
     // If we asked for a typename and got a non-type decl, error out.
-    if (!R.getAsSingle<TypeDecl>()) {
+    if (!R.getAsSingle<TypeDecl>() &&
+        !R.getAsSingle<UnresolvedUsingIfExistsDecl>()) {
       Diag(IdentLoc, diag::err_using_typename_non_type);
       for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
         Diag((*I)->getUnderlyingDecl()->getLocation(),
              diag::note_using_decl_target);
       return BuildInvalid();
     }
   } else {
     // If we asked for a non-typename and we got a type, error out,
     // but only if this is an instantiation of an unresolved using
     // decl.  Otherwise just silently find the type name.
     if (IsInstantiation && R.getAsSingle<TypeDecl>()) {
       Diag(IdentLoc, diag::err_using_dependent_value_is_type);
       Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);
       return BuildInvalid();
     }
   }
 
   // C++14 [namespace.udecl]p6:
   // A using-declaration shall not name a namespace.
   if (R.getAsSingle<NamespaceDecl>()) {
     Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace)
         << SS.getRange();
     return BuildInvalid();
   }
 
   // C++14 [namespace.udecl]p7:
   // A using-declaration shall not name a scoped enumerator.
   if (auto *ED = R.getAsSingle<EnumConstantDecl>()) {
     if (cast<EnumDecl>(ED->getDeclContext())->isScoped()) {
       Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_scoped_enum)
           << SS.getRange();
       return BuildInvalid();
     }
   }
 
   UsingDecl *UD = BuildValid();
 
   // Some additional rules apply to inheriting constructors.
   if (UsingName.getName().getNameKind() ==

clang/lib/Sema/SemaExpr.cpp

       return false;
   }
 
   // See if this function is unavailable.
   if (TreatUnavailableAsInvalid && D->getAvailability() == AR_Unavailable &&
       cast<Decl>(CurContext)->getAvailability() != AR_Unavailable)
     return false;
 
+  if (isa<UnresolvedUsingIfExistsDecl>(D))
+    return false;
+
   return true;
 }
 
 static void DiagnoseUnusedOfDecl(Sema &S, NamedDecl *D, SourceLocation Loc) {
   // Warn if this is used but marked unused.
   if (const auto *A = D->getAttr<UnusedAttr>()) {
     // [[maybe_unused]] should not diagnose uses, but __attribute__((unused))
     // should diagnose them.

   if (LangOpts.OpenMP && isa<VarDecl>(D) &&
       !isOpenMPDeclareMapperVarDeclAllowed(cast<VarDecl>(D))) {
     Diag(Loc, diag::err_omp_declare_mapper_wrong_var)
         << getOpenMPDeclareMapperVarName();
     Diag(D->getLocation(), diag::note_entity_declared_at) << D;
     return true;
   }
 
+  if (const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(D)) {
+    Diag(Loc, diag::err_use_of_empty_using_if_exists);
+    Diag(EmptyD->getLocation(), diag::note_empty_using_if_exists_here);
+    return true;
+  }
+
   DiagnoseAvailabilityOfDecl(D, Locs, UnknownObjCClass, ObjCPropertyAccess,
                              AvoidPartialAvailabilityChecks, ClassReceiver);
 
   DiagnoseUnusedOfDecl(*this, D, Loc);
 
   diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);
 
   if (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)) {

                                    ValueDecl *var, DeclContext *DC);
 
 /// Complete semantic analysis for a reference to the given declaration.
 ExprResult Sema::BuildDeclarationNameExpr(
     const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
     NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs,
     bool AcceptInvalidDecl) {
   assert(D && "Cannot refer to a NULL declaration");
   assert(!isa<FunctionTemplateDecl>(D) &&
          "Cannot refer unambiguously to a function template");
 
   SourceLocation Loc = NameInfo.getLoc();
   if (CheckDeclInExpr(*this, Loc, D))
     return ExprError();
 
   if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) {
     // Specifically diagnose references to class templates that are missing
     // a template argument list.
     diagnoseMissingTemplateArguments(TemplateName(Template), Loc);
     return ExprError();
   }
 
   // Make sure that we're referring to a value.
-  ValueDecl *VD = dyn_cast<ValueDecl>(D);
-  if (!VD) {
+  if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(D)) {
     Diag(Loc, diag::err_ref_non_value)
       << D << SS.getRange();
     Diag(D->getLocation(), diag::note_declared_at);
     return ExprError();
   }
 
   // Check whether this declaration can be used. Note that we suppress
   // this check when we're going to perform argument-dependent lookup
   // on this function name, because this might not be the function
   // that overload resolution actually selects.
-  if (DiagnoseUseOfDecl(VD, Loc))
+  if (DiagnoseUseOfDecl(D, Loc))
     return ExprError();
 
+  auto *VD = cast<ValueDecl>(D);
+
   // Only create DeclRefExpr's for valid Decl's.
   if (VD->isInvalidDecl() && !AcceptInvalidDecl)
     return ExprError();
 
   // Handle members of anonymous structs and unions.  If we got here,
   // and the reference is to a class member indirect field, then this
   // must be the subject of a pointer-to-member expression.
   if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD))

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

   for (auto *Shadow : D->shadows()) {
     // FIXME: UsingShadowDecl doesn't preserve its immediate target, so
     // reconstruct it in the case where it matters.
     NamedDecl *OldTarget = Shadow->getTargetDecl();
     if (auto *CUSD = dyn_cast<ConstructorUsingShadowDecl>(Shadow))
       if (auto *BaseShadow = CUSD->getNominatedBaseClassShadowDecl())
         OldTarget = BaseShadow;
 
-    NamedDecl *InstTarget =
-        cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
-            Shadow->getLocation(), OldTarget, TemplateArgs));
+    NamedDecl *InstTarget = nullptr;
+    if (auto *EmptyD =
+            dyn_cast<UnresolvedUsingIfExistsDecl>(Shadow->getTargetDecl())) {
+      InstTarget = UnresolvedUsingIfExistsDecl::Create(
+          SemaRef.Context, Owner, EmptyD->getLocation(), EmptyD->getDeclName());
+    } else {
+      InstTarget = cast_or_null<NamedDecl>(SemaRef.FindInstantiatedDecl(
+          Shadow->getLocation(), OldTarget, TemplateArgs));
+    }
     if (!InstTarget)
       return nullptr;
 
     UsingShadowDecl *PrevDecl = nullptr;
     if (CheckRedeclaration) {
       if (SemaRef.CheckUsingShadowDecl(NewUD, InstTarget, Prev, PrevDecl))
         continue;
     } else if (UsingShadowDecl *OldPrev =

 
   // Produce a pack expansion only if we're not instantiating a particular
   // slice of a pack expansion.
   bool InstantiatingSlice = D->getEllipsisLoc().isValid() &&
                             SemaRef.ArgumentPackSubstitutionIndex != -1;
   SourceLocation EllipsisLoc =
       InstantiatingSlice ? SourceLocation() : D->getEllipsisLoc();
 
+  bool IsUsingIfExists = D->template hasAttr<UsingIfExistsAttr>();
   NamedDecl *UD = SemaRef.BuildUsingDeclaration(
       /*Scope*/ nullptr, D->getAccess(), D->getUsingLoc(),
       /*HasTypename*/ TD, TypenameLoc, SS, NameInfo, EllipsisLoc,
       ParsedAttributesView(),
-      /*IsInstantiation*/ true);
-  if (UD)
+      /*IsInstantiation*/ true, IsUsingIfExists);
+  if (UD) {
+    SemaRef.InstantiateAttrs(TemplateArgs, D, UD);
     SemaRef.Context.setInstantiatedFromUsingDecl(UD, D);
+  }
 
   return UD;
 }
 
 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingTypenameDecl(
     UnresolvedUsingTypenameDecl *D) {
   return instantiateUnresolvedUsingDecl(D);
 }
 
 Decl *TemplateDeclInstantiator::VisitUnresolvedUsingValueDecl(
     UnresolvedUsingValueDecl *D) {
   return instantiateUnresolvedUsingDecl(D);
 }
 
+Decl *TemplateDeclInstantiator::VisitUnresolvedUsingIfExistsDecl(
+    UnresolvedUsingIfExistsDecl *D) {
+  llvm_unreachable("referring to unresolved decl out of UsingShadowDecl");
+}
+
 Decl *TemplateDeclInstantiator::VisitUsingPackDecl(UsingPackDecl *D) {
   SmallVector<NamedDecl*, 8> Expansions;
   for (auto *UD : D->expansions()) {
     if (NamedDecl *NewUD =
             SemaRef.FindInstantiatedDecl(D->getLocation(), UD, TemplateArgs))
       Expansions.push_back(NewUD);
     else
       return nullptr;

clang/lib/Sema/TreeTransform.h

     }
     return T.isNull() ? FallbackT : T;
   } else if (auto *Using = dyn_cast<UsingDecl>(D)) {
     assert(Using->hasTypename() &&
            "UnresolvedUsingTypenameDecl transformed to non-typename using");
 
     // A valid resolved using typename decl points to exactly one type decl.
     assert(++Using->shadow_begin() == Using->shadow_end());
-    Ty = cast<TypeDecl>((*Using->shadow_begin())->getTargetDecl());
+
+    NamedDecl *Target = Using->shadow_begin()->getTargetDecl();
+    if (SemaRef.DiagnoseUseOfDecl(Target, Loc))
+      return QualType();
+    Ty = cast<TypeDecl>(Target);
   } else {
     assert(isa<UnresolvedUsingTypenameDecl>(D) &&
            "UnresolvedUsingTypenameDecl transformed to non-using decl");
     Ty = cast<UnresolvedUsingTypenameDecl>(D);
   }
 
   return SemaRef.Context.getTypeDeclType(Ty);
 }
 
 template<typename Derived>
 QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E,
                                                        SourceLocation Loc) {
   return SemaRef.BuildTypeofExprType(E, Loc);

clang/lib/Serialization/ASTCommon.cpp

bool serialization::isRedeclarableDeclKind(unsigned Kind) {
   case Decl::OMPDeclareReduction:
   case Decl::OMPDeclareMapper:
   case Decl::BuiltinTemplate:
   case Decl::Decomposition:
   case Decl::Binding:
   case Decl::Concept:
   case Decl::LifetimeExtendedTemporary:
   case Decl::RequiresExprBody:
+  case Decl::UnresolvedUsingIfExists:
     return false;
 
   // These indirectly derive from Redeclarable<T> but are not actually
   // redeclarable.
   case Decl::ImplicitParam:
   case Decl::ParmVar:
   case Decl::ObjCTypeParam:
     return false;

clang/lib/Serialization/ASTReaderDecl.cpp

     void VisitNamespaceDecl(NamespaceDecl *D);
     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
     void VisitTypeDecl(TypeDecl *TD);
     RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
     void VisitTypedefDecl(TypedefDecl *TD);
     void VisitTypeAliasDecl(TypeAliasDecl *TD);
     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
+    void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
     RedeclarableResult VisitTagDecl(TagDecl *TD);
     void VisitEnumDecl(EnumDecl *ED);
     RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
     void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
     RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
     void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
     RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
                                             ClassTemplateSpecializationDecl *D);

   D->QualifierLoc = Record.readNestedNameSpecifierLoc();
   D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());
   D->EllipsisLoc = readSourceLocation();
   mergeMergeable(D);
 }
 
 void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
                                                UnresolvedUsingTypenameDecl *D) {
   VisitTypeDecl(D);
   D->TypenameLocation = readSourceLocation();
   D->QualifierLoc = Record.readNestedNameSpecifierLoc();
   D->EllipsisLoc = readSourceLocation();
   mergeMergeable(D);
 }
 
+void ASTDeclReader::VisitUnresolvedUsingIfExistsDecl(
+    UnresolvedUsingIfExistsDecl *D) {
+  VisitNamedDecl(D);
+}
+
 void ASTDeclReader::ReadCXXDefinitionData(
     struct CXXRecordDecl::DefinitionData &Data, const CXXRecordDecl *D) {
   #define FIELD(Name, Width, Merge) \
   Data.Name = Record.readInt();
   #include "clang/AST/CXXRecordDeclDefinitionBits.def"
 
   // Note: the caller has deserialized the IsLambda bit already.
   Data.ODRHash = Record.readInt();

     D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_UNRESOLVED_USING_VALUE:
     D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_UNRESOLVED_USING_TYPENAME:
     D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
     break;
+  case DECL_UNRESOLVED_USING_IF_EXISTS:
+    D = UnresolvedUsingIfExistsDecl::CreateDeserialized(Context, ID);
+    break;
   case DECL_CXX_RECORD:
     D = CXXRecordDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_CXX_DEDUCTION_GUIDE:
     D = CXXDeductionGuideDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_CXX_METHOD:
     D = CXXMethodDecl::CreateDeserialized(Context, ID);

clang/lib/Serialization/ASTWriterDecl.cpp

     void VisitNamespaceDecl(NamespaceDecl *D);
     void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
     void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
     void VisitTypeDecl(TypeDecl *D);
     void VisitTypedefNameDecl(TypedefNameDecl *D);
     void VisitTypedefDecl(TypedefDecl *D);
     void VisitTypeAliasDecl(TypeAliasDecl *D);
     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
+    void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
     void VisitTagDecl(TagDecl *D);
     void VisitEnumDecl(EnumDecl *D);
     void VisitRecordDecl(RecordDecl *D);
     void VisitCXXRecordDecl(CXXRecordDecl *D);
     void VisitClassTemplateSpecializationDecl(
                                             ClassTemplateSpecializationDecl *D);
     void VisitClassTemplatePartialSpecializationDecl(
                                      ClassTemplatePartialSpecializationDecl *D);

                                                UnresolvedUsingTypenameDecl *D) {
   VisitTypeDecl(D);
   Record.AddSourceLocation(D->getTypenameLoc());
   Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
   Record.AddSourceLocation(D->getEllipsisLoc());
   Code = serialization::DECL_UNRESOLVED_USING_TYPENAME;
 }
 
+void ASTDeclWriter::VisitUnresolvedUsingIfExistsDecl(
+    UnresolvedUsingIfExistsDecl *D) {
+  VisitNamedDecl(D);
+  Code = serialization::DECL_UNRESOLVED_USING_IF_EXISTS;
+}
+
 void ASTDeclWriter::VisitCXXRecordDecl(CXXRecordDecl *D) {
   VisitRecordDecl(D);
 
   enum {
     CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
   };
   if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
     Record.push_back(CXXRecTemplate);

clang/test/Parser/using-if-exists-attr.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only %s -pedantic -verify
+
+#define UIE __attribute__((using_if_exists))
+
+namespace NS { typedef int x; }
+
+using NS::x __attribute__((using_if_exists));
+
+using NS::x [[clang::using_if_exists]]; // expected-warning{{ISO C++ does not allow an attribute list to appear here}}
+
+[[clang::using_if_exists]] // expected-warning{{ISO C++ does not allow an attribute list to appear here}}
+using NS::not_there, NS::not_there2;
+
+using NS::not_there3, // expected-error {{no member named 'not_there3' in namespace 'NS'}}
+      NS::not_there4 [[clang::using_if_exists]]; // expected-warning{{C++ does not allow an attribute list to appear here}}
+
+[[clang::using_if_exists]] using NS::not_there5 [[clang::using_if_exists]]; // expected-warning 2 {{ISO C++ does not allow}}
+
+struct Base {};
+struct Derived : Base {
+  [[clang::using_if_exists]] using Base::x; // expected-warning {{ISO C++ does not allow an attribute list to appear here}}
+  using Base::y [[clang::using_if_exists]]; // expected-warning {{ISO C++ does not allow an attribute list to appear here}}
+  [[clang::using_if_exists]] using Base::z, Base::q; // expected-warning {{C++ does not allow an attribute list to appear here}}
+};

clang/test/SemaCXX/attr-deprecated.cpp

namespace test7 {
   }
 }
 
 // rdar://problem/15044218
 typedef struct TDS {
 } TDS __attribute__((deprecated)); // expected-note {{'TDS' has been explicitly marked deprecated here}}
 TDS tds; // expected-warning {{'TDS' is deprecated}}
 struct TDS tds2; // no warning, attribute only applies to the typedef.
+
+namespace test8 {
+struct A {
+  // expected-note@+1 {{'B' has been explicitly marked deprecated here}}
+  struct __attribute__((deprecated)) B {};
+};
+template <typename T> struct D : T {
+  using typename T::B;
+  B b; // expected-warning {{'B' is deprecated}}
+};
+D<A> da; // expected-note {{in instantiation of template class}}
+}

clang/test/SemaCXX/using-if-exists.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only %s -verify
+
+#define UIE __attribute__((using_if_exists))
+
+namespace test_basic {
+namespace NS {}
+
+using NS::x UIE; // expected-note{{using declaration annotated with 'using_if_exists' here}}
+x usex(); // expected-error{{reference to unresolved using declaration}}
+
+using NotNS::x UIE; // expected-error{{use of undeclared identifier 'NotNS'}}
+} // test_basic
+
+namespace test_redecl {
+namespace NS {}
+
+using NS::x UIE;
+using NS::x UIE;
+
+namespace NS1 {}
+namespace NS2 {}
+namespace NS3 {
+int A(); // expected-note{{target of using declaration}}
+struct B {}; // expected-note{{target of using declaration}}
+int C(); // expected-note{{conflicting declaration}}
+struct D {}; // expected-note{{conflicting declaration}}
+}
+
+using NS1::A UIE;
+using NS2::A UIE; // expected-note{{using declaration annotated with 'using_if_exists' here}} expected-note{{conflicting declaration}}
+using NS3::A UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}}
+int i = A(); // expected-error{{reference to unresolved using declaration}}
+
+using NS1::B UIE;
+using NS2::B UIE; // expected-note{{conflicting declaration}} expected-note{{using declaration annotated with 'using_if_exists' here}}
+using NS3::B UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}}
+B myB; // expected-error{{reference to unresolved using declaration}}
+
+using NS3::C UIE;
+using NS2::C UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
+int j = C();
+
+using NS3::D UIE;
+using NS2::D UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
+D myD;
+} // test_redecl
+
+namespace test_dependent {
+template <class B>
+struct S : B {
+  using B::mf UIE; // expected-note 3 {{using declaration annotated with 'using_if_exists' here}}
+  using typename B::mt UIE; // expected-note{{using declaration annotated with 'using_if_exists' here}}
+};
+
+struct BaseEmpty {
+};
+struct BaseNonEmpty {
+  void mf();
+  typedef int mt;
+};
+
+void f() {
+  S<BaseEmpty> empty;
+  S<BaseNonEmpty> nonempty;
+  empty.mf(); // expected-error {{reference to unresolved using declaration}}
+  nonempty.mf();
+  (&empty)->mf(); // expected-error {{reference to unresolved using declaration}}
+  (&nonempty)->mf();
+
+  S<BaseEmpty>::mt y; // expected-error {{reference to unresolved using declaration}}
+  S<BaseNonEmpty>::mt z;
+
+  S<BaseEmpty>::mf(); // expected-error {{reference to unresolved using declaration}}
+}
+
+template <class B>
+struct Implicit : B {
+  using B::mf UIE; // expected-note {{using declaration annotated with 'using_if_exists' here}}
+  using typename B::mt UIE; // expected-note 2 {{using declaration annotated with 'using_if_exists' here}}
+
+  void use() {
+    mf(); // expected-error {{reference to unresolved using declaration}}
+    mt x; // expected-error {{reference to unresolved using declaration}}
+  }
+
+  mt alsoUse(); // expected-error {{reference to unresolved using declaration}}
+};
+
+void testImplicit() {
+  Implicit<BaseNonEmpty> nonempty;
+  Implicit<BaseEmpty> empty; // expected-note {{in instantiation}}
+  nonempty.use();
+  empty.use(); // expected-note {{in instantiation}}
+}
+
+template <class>
+struct NonDep : BaseEmpty {
+  using BaseEmpty::x UIE; // expected-note{{using declaration annotated with 'using_if_exists' here}}
+  x y(); // expected-error{{reference to unresolved using declaration}}
+};
+} // test_dependent
+
+namespace test_using_pack {
+template <class... Ts>
+struct S : Ts... {
+  using typename Ts::x... UIE; // expected-error 2 {{target of using declaration conflicts with declaration already in scope}} expected-note{{conflicting declaration}} expected-note{{target of using declaration}}
+};
+
+struct E1 {};
+struct E2 {};
+S<E1, E2> a;
+
+struct F1 { typedef int x; }; // expected-note 2 {{conflicting declaration}}
+struct F2 { typedef int x; }; // expected-note 2 {{target of using declaration}}
+S<F1, F2> b;
+
+S<E1, F2> c; // expected-note{{in instantiation of template class}}
+S<F1, E2> d; // expected-note{{in instantiation of template class}}
+
+template <class... Ts>
+struct S2 : Ts... {
+  using typename Ts::x... UIE; // expected-error 2 {{target of using declaration conflicts with declaration already in scope}} expected-note 3 {{using declaration annotated with 'using_if_exists' here}} expected-note{{conflicting declaration}} expected-note{{target of using declaration}}
+
+  x mem(); // expected-error 3 {{reference to unresolved using declaration}}
+};
+
+S2<E1, E2> e; // expected-note{{in instantiation of template class}}
+S2<F1, F2> f;
+S2<E1, F2> g; // expected-note{{in instantiation of template class}}
+S2<F1, E2> h; // expected-note{{in instantiation of template class}}
+
+template <class... Ts>
+struct S3 : protected Ts... {
+  using Ts::m... UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
+};
+struct B1 { enum {m}; }; // expected-note{{conflicting declaration}}
+struct B2 {};
+
+S3<B1, B2> i; // expected-note{{in instantiation of template}}
+S<B2, B1> j;
+
+} // test_using_pack
+
+namespace test_nested {
+namespace NS {}
+
+using NS::x UIE; // expected-note {{using declaration annotated with 'using_if_exists' here}}
+
+namespace NS2 {
+using ::test_nested::x UIE;
+}
+
+NS2::x y; // expected-error {{reference to unresolved using declaration}}
+} // test_nested
+
+namespace test_scope {
+int x; // expected-note{{conflicting declaration}}
+void f() {
+  int x; // expected-note{{conflicting declaration}}
+  {
+    using ::x UIE; // expected-note {{using declaration annotated with 'using_if_exists' here}}
+    (void)x; // expected-error {{reference to unresolved using declaration}}
+  }
+
+  {
+    using test_scope::x;
+    using ::x UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
+    (void)x;
+  }
+
+  (void)x;
+
+  using ::x UIE; // expected-error{{target of using declaration conflicts with declaration already in scope}} expected-note{{target of using declaration}}
+  (void)x;
+}
+} // test_scope
+
+namespace test_appertains_to {
+namespace NS { typedef int x; }
+
+// FIXME: This diagnostics is wrong.
+using alias UIE = NS::x; // expected-error {{'using_if_exists' attribute only applies to named declarations, types, and value declarations}}
+
+template <class>
+using template_alias UIE = NS::x; // expected-error {{'using_if_exists' attribute only applies to named declarations, types, and value declarations}}
+
+void f() UIE; // expected-error {{'using_if_exists' attribute only applies to named declarations, types, and value declarations}}
+
+using namespace NS UIE; // expected-error {{'using_if_exists' attribute only applies to named declarations, types, and value declarations}}
+}
+
+typedef int *FILE;
+int printf();
+
+namespace std {
+using ::FILE UIE;
+using ::printf UIE;
+using ::fopen UIE; // expected-note {{using declaration annotated with 'using_if_exists' here}}
+using ::size_t UIE; // expected-note {{using declaration annotated with 'using_if_exists' here}}
+}
+
+int main() {
+  std::FILE file;
+  file = std::fopen(); // expected-error {{reference to unresolved using declaration}} expected-error{{incompatible integer to pointer}}
+  std::size_t size; // expected-error {{reference to unresolved using declaration}}
+  size = printf();
+}

clang/tools/libclang/CIndex.cpp

   case Decl::ObjCTypeParam:
   case Decl::BuiltinTemplate:
   case Decl::PragmaComment:
   case Decl::PragmaDetectMismatch:
   case Decl::UsingPack:
   case Decl::Concept:
   case Decl::LifetimeExtendedTemporary:
   case Decl::RequiresExprBody:
+  case Decl::UnresolvedUsingIfExists:
     return C;
 
   // Declaration kinds that don't make any sense here, but are
   // nonetheless harmless.
   case Decl::Empty:
   case Decl::TranslationUnit:
   case Decl::ExternCContext:
     break;