[clang] adding explicit(bool) from c++2a

[Tyker]

Summary

this patch adds support for the explicit bool specifier.

Changes:

• The parsing for the explicit(bool) specifier was added in ParseDecl.cpp.
• The explicit specifier is now stored everywhere with the ExplicitSpecifier class.
• Following the AST change, Serialization, ASTMatchers, ASTComparator and ASTPrinter were adapted.
• Template instantiation was adapted to instantiate the potential expressions of the explicit(bool) specifier When instantiating their associated declaration.
• The Add*Candidate functions were adapted, they now take a Boolean indicating if the context allowing explicit constructor or conversion function and this boolean is used to remove invalid overloads that required template instantiation to be detected.
• Test for Semantic and Serialization were added.

[• Quuxplusone]

clang/include/clang/AST/DeclCXX.h

2620 ↗

(On Diff #195966)

s/Specifer/Specifier/ (and please git grep for other instances of the same typo)

clang/include/clang/Basic/DiagnosticParseKinds.td

40 ↗

(On Diff #195966)

"C++2a" should be uppercased.

clang/include/clang/Basic/DiagnosticSemaKinds.td

2125 ↗

(On Diff #195966)

s/specfier/specifier/ (and please git grep for other instances)

clang/lib/Sema/DeclSpec.cpp

959 ↗

(On Diff #195966)

Spelling/grammar/capitalization-of-C++2a.
Also, it seems to me that you've got a CWG wording issue here: what does N4810 mean by "Each decl-specifier shall appear at most once in a complete decl-specifier-seq, except that long may appear twice"? What is "each" decl-specifier? Is explicit(true) a different decl-specifier from explicit(1+1==2)? Is explicit(true) different from explicit(false)?

clang/test/SemaCXX/explicit.cpp

189 ↗

(On Diff #195966)

Why?

[riccibruno]

This patch certainly took a few hours to write. Can you spend 5 minutes on making the summary readable (spelling, capitalization, formatting, well-formed sentences, ...) ?

[Tyker]

clang/lib/Sema/DeclSpec.cpp

959 ↗

(On Diff #195966)

I agree that it isn't clear. but i assumed that each counts every explicit-specifier as one.

clang/test/SemaCXX/explicit.cpp

189 ↗

(On Diff #195966)

i added a run line with the -std=c++2a flag to ensure no regression in c++2a mode as well as in c++11 mode. the warning that is being tested doesn't appear with this flag. the #if is to prevent the test from failling with the -stdc++2a flag. i don't know if the flag's behavior is intended or not.
godbolt example

[Tyker]

@Quuxplusone @riccibruno fixed / answered feedback

[martong]

clang/lib/AST/ASTImporter.cpp

3126 ↗

(On Diff #195990)

Why is it needed to import the explicit specifier here again?
You already imported that above. Perhaps this hunk is not needed here at all?

clang/lib/AST/ASTStructuralEquivalence.cpp

965 ↗

(On Diff #195990)

Would it work if Method1 has a different ASTContext than `Method2?
That is exactly the case when we import an AST into another with ASTImporter.

[Tyker]

Fixed issues form feedback by @martong

Added:

• CTAD and deduction guide support.
• improved tests

[Rakete1111]

Thanks for working on this! :)

clang/lib/Parse/ParseDecl.cpp

3533 ↗

(On Diff #196285)

This is a useful diagnostic but you'll need to fix (a lot) of false positives:

template <typename T> struct Foo { explicit(T{} +) Foo(); };

gets me:

main.cpp:1:50: error: expected expression
template <typename T> struct Foo { explicit(T{} +) Foo(); };
                                                 ^
main.cpp:1:44: note: this expression is parsed as explicit(bool) since C++2a
template <typename T> struct Foo { explicit(T{} +) Foo(); };
                                   ~~~~~~~~^
                                   explicit(true)

Fixit hints should only be used when it is 100% the right fix that works, always.

3534 ↗

(On Diff #196285)

FixIt Hints also need tests :)

clang/lib/Sema/DeclSpec.cpp

952 ↗

(On Diff #196285)

The comment seems to explain something else than the code.

956 ↗

(On Diff #196285)

We accept explicit explicit, but we really shouldn't accept explicit(some-expr) explicit(some-other-expr). That would just be confusing. explicit explicit(some-expr) is also borderline.

1316 ↗

(On Diff #196285)

Please change this warning so that the whole *explicit-specifier* is underlined (or even change the text for conditional explicit):

main.cpp:1:36: error: 'explicit' can only be applied to a constructor or conversion function
template <typename T> struct Foo { explicit(false) void foo(); };
                                   ^~~~~~~~
1 error generated.

This will also fix the FixIt Hint.

clang/lib/Sema/SemaDeclCXX.cpp

8641 ↗

(On Diff #196285)

You should amend the diagnostic, because as of right now explicit(true) is being diagnosed as C++11 feature.

10870 ↗

(On Diff #196285)

This assumes that we are in a [constexpr] if, leading to errors like this:

int a;
template <typename T> struct Foo { explicit(a) Foo(); };

main.cpp:2:45: error: constexpr if condition is not a constant expression
template <typename T> struct Foo { explicit(a) Foo(); };
                                            ^

10876–10881 ↗

(On Diff #196285)

Wrong diagnostic.

clang/lib/Sema/SemaOverload.cpp

10359 ↗

(On Diff #196285)

typo.

10361 ↗

(On Diff #196285)

This fires for an instantiation dependent (but not value dependent) explicit specifier that is invalid:

template <typename T> struct Foo { explicit((T{}, false)) Foo(int); };

int main() { Foo<void> f = 1; }

clang/test/SemaCXX/cxx2a-compat.cpp

46 ↗

(On Diff #196285)

would -> will

51 ↗

(On Diff #196285)

A fixit hint for this would be great. Also it would be nice if there was a nicer error message.

[martong]

In D60934#1475908, @Tyker wrote:

Fixed issues form feedback by @martong

Thank you for addressing the comments. ASTImporter.cpp and ASTStructuralEquivalence.cpp looks good to me now. However, about the equivalence check, do you think it would be possible to have a unit test for explicit(bool) in StructuralEquivalenceTest.cpp? That test would exercise the static EquivalentExplicit() function too.

[rsmith]

clang/include/clang/AST/DeclCXX.h

2022 ↗

(On Diff #196285)

I think this is too special-case to live on CXXDeductionGuideDecl. Instead, I suggest:

• Add a class wrapping ExplicitSpecInfo, maybe called ExplicitSpecifier
• Change all the AST interfaces that deal in ExplicitSpecInfo to instead deal in ExplicitSpecifier objects
• Move this comparison logic there, along with the more uncommon members you add below.

I think we should be able to reduce the set of explicit-related members on the various Decl subclasses to just getExplicitSpecifier() and isExplicit().

2033 ↗

(On Diff #196285)

Generally we don't want to have setters in the AST; the AST is intended to be immutable after creation. Is this necessary?

2519 ↗

(On Diff #196285)

Consider storing this in a TrailingObject rather than making all constructors a pointer wider for this (presumably relatively uncommon) special case.

clang/include/clang/Basic/DiagnosticParseKinds.td

37 ↗

(On Diff #196285)

would be -> will be

38 ↗

(On Diff #196285)

Nit: comma on previous line, please.

40 ↗

(On Diff #196285)

This should be a warning in the CXXPre2aCompat group, phrased as "explicit(bool) is incompatible with C++ standards before C++2a".

clang/include/clang/Basic/DiagnosticSemaKinds.td

2124–2129 ↗

(On Diff #196285)

I don't believe there is any such rule; instead, the rule is simply that deduction guides cannot be redeclared at all. See [temp.deduct.guide]/3: "Two deduction guide declarations in the same translation unit for the same class template shall not have equivalent parameter-declaration-clauses." (That's obviously wrong; we should compare the template-head as well, but the intention is that deduction guides cannot be redeclared.)

clang/include/clang/Basic/Specifiers.h

27–29 ↗

(On Diff #196285)

Please capitalize these enumerator names, and consider using an 'enum class' instead of an ESF_ prefix. (We use lowercase for the next few enums because their enumerators are (prefixed) keywords.)

clang/include/clang/Sema/DeclSpec.h

376 ↗

(On Diff #196285)

If this is a fully-semantically-analyzed explicit-specifier, this should use the same type we use in the AST representation. If it's a parsed-but-not-yet-semantically-analyzed explicit-specifier, using ExplicitSpecFlag doesn't seem right: you haven't tried to resolve it yet in that case.

clang/lib/AST/DeclCXX.cpp

1867–1878 ↗

(On Diff #196285)

Please don't evaluate the explicit specifier here. Instead, it should be evaluated by Sema when it's initially formed (if it's not value-dependent) and during template instantiation (if a value-dependent explicit-specifier becomes non-value-dependent). Note that Sema needs to evaluate it at those times anyway, in order to properly diagnose non-constant explicit-specifiers.

2514–2522 ↗

(On Diff #196285)

I don't think this should work this way any more: we can't tell whether a constructor template forms a converting constructor before substituting into it.

Another point of note: the "that can be called with a single parameter" part of the language rule has been removed (and was never necessary). So "isConvertingConstructor" is really just "is not explicit".

So: I think we should rename this function to a more general "could this function ever be called with exactly N arguments?" function (moved to FunctionDecl, adjacent to getMinRequiredArguments), and use it in the current callers of isConvertingConstructor just to filter out functions that can't be called with exactly one argument from the candidate list for copy-initialization. Then change the current callers of this function to call Add*OverloadCandidate with AllowExplicit = false in the cases where they currently require a converting constructor.

It'd make sense to do that as a separate change / refactoring before adding explicit(bool) support.

clang/lib/AST/DeclPrinter.cpp

555 ↗

(On Diff #196285)

Function names should generally be verb phrases, not noun phrases. printExceptionSpecifier maybe?

clang/lib/Parse/ParseDecl.cpp

3523 ↗

(On Diff #196285)

Please try to avoid using lookahead for this. (You may need to change the code after the loop so you can tell it that you already consumed the specifier, or factor out that code into a lambda that you can call from both there and here.)

3533–3537 ↗

(On Diff #196285)

This "add a note after an error" construct is an anti-pattern, and will fail in a bunch of cases (for example: if multiple diagnostics are produced, it gets attached to the last one rather than the first; if a disabled warning / remark is produced last, the note is not displayed at all).

As noted above, the conventional way to handle this is to unconditionally produce a -Wc++17-compat warning when we see explicit(. Attaching a context note to the diagnostic if building the expression fails (catching both Parse and Sema diagnostics) will require more invasive changes and I'd prefer to see that left to a separate patch (if we do it at all).

clang/lib/Sema/DeclSpec.cpp

959 ↗

(On Diff #195966)

I reported this on the core reflector nearly a year ago (http://lists.isocpp.org/core/2018/06/4673.php); sadly the issue process is a long way behind so we don't have an issue number yet, but I think the intent is clear, and matches what is implemented here.

clang/lib/Sema/SemaDeclCXX.cpp

10866 ↗

(On Diff #196285)

Return an ExplicitSpecifier here rather than splitting it up into an ExprResult and an ExplicitSpecFlag.

10870 ↗

(On Diff #196285)

This is wrong; a "condition" is the thing that appears after if ( or while ( or in the middle term of a for (;;.

An explicit-specifier requires a contextually-converted constant expression of type bool, so you should call CheckConvertedContantExpression, and add a new CCEKind for this conversion (look at what we do for CCEK_ConstexprIf to find how to get it to convert to bool). You'll need to update its CCEKind-specific diagnostics (eg, ext_cce_narrowing, err_expr_not_cce) to properly diagnose explicit-specifiers.

clang/lib/Sema/SemaInit.cpp

3818 ↗

(On Diff #196285)

Please use a variable with a different name here, such as AllowExplicitConversion. Changing a variable with a larger scope to match the semantics required in a smaller scope like this is error-prone (even though the code is correct right now). Also, please hoist that new variable out of the for loop.

3819 ↗

(On Diff #196285)

Consider just removing this if. It's not clear that it carries its weight.

5001–5002 ↗

(On Diff #196285)

Likewise.

9361 ↗

(On Diff #196285)

We need to substitute into the deduction guide first to detect whether it forms a "converting constructor", and that will need to be done inside AddTemplateOverloadCandidate.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

387–403 ↗

(On Diff #196285)

Please factor out the common code between this and ActOnExplicitSpecifier. (We usually call such a function BuildSomething, such as Sema::BuildExplicitSpecifier).

388 ↗

(On Diff #196285)

This needs to be done in a ConstantEvaluated context too.

[martong]

clang/lib/AST/ASTStructuralEquivalence.cpp

965 ↗

(On Diff #195990)

isEquivalentExplicit calls EquivalentExplicit, which in turn calls Stmt::Profile.
Seems like Stmt::Profile relies on pointer equivalencies, however, here we may have two different ASTContexts for each Method, so we must not rely on pointer values.
I suggest to use a version of EquivalentExplicit which uses Stmt::ProcessODRHash, that one does not rely on pointer values.

[Tyker]

clang/include/clang/AST/DeclCXX.h

2033 ↗

(On Diff #196285)

this is used in 2 cases:

• for deserialization.
• for in Sema::ActOnFunctionDeclarator to make every declaration of the same function have the same explicit specifier as the canonical one. there is probably a better way to do this but i didn't find how.

the second use case will need to be changed because the constructor's explicit specifier will be tail-allocated so the explicit specifier from the canonical declaration will need to be recovered before construction to allocate storage.

how can we find the canonical declaration of a function before it is constructed ?

clang/lib/Sema/SemaInit.cpp

3819 ↗

(On Diff #196285)

this if prevent conversion that are already known not to be valid from being added to the overload set. removing it is still correct because it will be removed later. but we would be doing "useless" work because we are adding the to the overload set knowing they will be removed.
the only benefit i see of removing this if is to make all explicit conversion appear in overload resolution failure messages. is it the intent ?

[Tyker]

Fixed based on Feedback from @rsmith @martong @Rakete1111.

feedback that weren't fixed have comment explaining why.

notable changes:

• ExplicitSpecInfo that was a type alias on llvm::PointerIntPair<Expr*, 2, ExplicitSpecFlag> is now replaced everywhere by the ExplicitSpecifier class.
• CXXConstructorDecl now stores its ExplicitSpecfier in the TraillingObjects.
• most explicit related function in CXXConstructorDecl, CXXConversionDecl and CXXDeductionGuideDecl have been moved to ExplicitSpecifier.
• removed the note "this expression is parsed as explicit(bool) since C++2a" as it had to many false positive and fixing them would be quite complicated.
• fixed an issue where ExplicitSpecifiers loaded from a PCH weren't exactly similar to the original.
• fixed issues with Diagnostics underlining the explicit keyword instead of the whole explicit-specifier.
• having multiple explicit-specifier with at least one having an expression is now an error instead of a warning.
• redeclaring a deduction guide for which the arguments are equivalent the previous one is now always an error (as specified by the standard). instead of emitting an error only when explicit-specifiers don't match. test were adapted accordingly.
• ExplicitSpecifier::isEquivalent the replacement for EquivalentExplicit is now based on ODRHashs.
• ExplicitSpecifiers are now evaluated using CheckConvertedConstantExpression.
• Added tests in StructuralEquivalenceTest.cpp for the ExplicitSpecifier

clang/include/clang/AST/DeclCXX.h

2033 ↗

(On Diff #196285)

i found a solution around that issue.
now setExplicitSpecifier is only used for deserialization.

clang/include/clang/Basic/DiagnosticParseKinds.td

40 ↗

(On Diff #196285)

explicit(bool) can only be parse with the c++2a option because code like:

struct C {
 explicit(C)(int);
};

is correct before c++2a but is parsed as explicit(bool) and fail to complie in c++2a.
so i don't think this warning can be fired in any case. so i removed it.

clang/lib/Parse/ParseDecl.cpp

3533 ↗

(On Diff #196285)

after the comment from rsmith i will remove it at least for now.

clang/lib/Sema/SemaInit.cpp

9361 ↗

(On Diff #196285)

similarly as the previous if. this check removes deduction guide that are already resolve to be explicit when we are in a context that doesn't allow explicit.
every time the explicitness was checked before my change i replaced it by a check that removes already resolved explicit specifiers.

clang/test/SemaCXX/cxx2a-compat.cpp

51 ↗

(On Diff #196285)

this had a fix it in the previous patch with the "this expression is parsed as explicit(bool) since C++2a" note. but i removed it because to much false positive and fixing it would make the patch even bigger.

[Tyker]

merged similar code for AST serialization of ExplicitSpecifier in a static function

[martong]

ASTImporter.cpp and ASTStructuralEquivalence.cpp looks good to me now. I am resigning as a reviewer since I don't feel competent enough to review the rest of the change.

[rsmith]

Thanks, this is looking really good. (Lots of comments but they're mostly mechanical at this point.)

clang/include/clang/AST/DeclBase.h

1539–1541 ↗

(On Diff #197085)

I would prefer that we keep an explicit number here so that we can ensure that this field has the range we desire.

1544–1548 ↗

(On Diff #197085)

Typo "Wether" (x2).

1545–1548 ↗

(On Diff #197085)

Maybe HasSimpleExplicit, HasTrailingExplicitSpecifier would be better names? (Please capitalize these to match the surrounding style.)

clang/include/clang/AST/DeclCXX.h

1995 ↗

(On Diff #197085)

Usually we'd call this Kind, not Flag.

[rsmith]

clang/include/clang/AST/DeclCXX.h

2013 ↗

(On Diff #197085)

"this" -> "This".

2018–2020 ↗

(On Diff #197085)

Do we need this? = ExplicitSpecifier(E, Kind) seems just as good and arguably clearer.

clang/include/clang/ASTMatchers/ASTMatchers.h

6174 ↗

(On Diff #197085)

This will match explicit(false) constructors. I think getExplicitSpecifier().isExplicit() would be better, but please also add a FIXME here: it's not clear whether this should match a dependent explicit(....).

clang/include/clang/Basic/DiagnosticSemaKinds.td

2119 ↗

(On Diff #197085)

Drop the "a" here.

clang/include/clang/Basic/Specifiers.h

26–28 ↗

(On Diff #197085)

My apologies, I led you the wrong way: the style to use for these is ResolvedFalse, ResolvedTrue, Unresolved. (I meant to capitalize only the first letter, not the whole thing, in my prior comment.)

31 ↗

(On Diff #197085)

Instead of exposing this serialization detail here, please localize this to the serialization code. One nice way is to serialize (Kind << 1) | HasExpr (use the bottom bit for the flag, not the top bit).

clang/include/clang/Sema/DeclSpec.h

437 ↗

(On Diff #197085)

Default-construct this.

572–574 ↗

(On Diff #197085)

Can you use FS_explicit_specifier.isSpecified() here?

593–594 ↗

(On Diff #197085)

Can you use = ExplicitSpecifier();?

clang/include/clang/Sema/Sema.h

10124 ↗

(On Diff #197085)

Missing last word from this comment?

clang/include/clang/Serialization/ASTBitCodes.h

1444–1449 ↗

(On Diff #197085)

For previous similar cases we've put the necessary data to pass into ::CreateDeserialized(...) at the start of the record (eg, see the Record.readInt() calls in ReadDeclRecord). We're starting to get a combinatorial explosion here (all 4 combinations of the two possible trailing objects), so maybe now's the time for that.

clang/include/clang/Serialization/ASTReader.h

2434 ↗

(On Diff #197085)

For consistency with nearby code, please name this variable starting with a capital letter.

clang/lib/AST/DeclCXX.cpp

1905 ↗

(On Diff #197085)

Default-construct.

2367 ↗

(On Diff #197085)

Default-construct.

2370 ↗

(On Diff #197085)

This leaves the tail-allocated ExplicitSpecifier uninitialized, because the constructor thought there was no explicit specifier; consider calling setExplicitSpecifier(ExplicitSpecifier()); here if hasTailExplicit.

2540 ↗

(On Diff #197085)

Default-construct.

clang/lib/Parse/ParseDecl.cpp

3532 ↗

(On Diff #197085)

There's no guarantee that you have an r_paren here. Use Tracker.consumeClose() instead; it will do the right thing (including producing a suitable error if the next token is something other than a )).

3536–3539 ↗

(On Diff #197085)

Now we have a representation for an invalid *explicit-specifier*, I think you should be able to just carry on here and parse more specifiers and the rest of the declaration.

3898–3908 ↗

(On Diff #197085)

In the isAlreadyConsumed case, Tok will be the wrong token here (it'll be the token after the explicit-specifier). Factoring this out into a lambda taking a SourceLocation (to be called from the explicit case) would help; alternatively you could grab the SourceLocation of Tok before the switch and use it here instead of Tok.

clang/lib/Sema/DeclSpec.cpp

958 ↗

(On Diff #197085)

The latter case should be ext_ not warn_: under CWG issue 1830 (http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1830) repeated decl-specifiers (including explicit) are ill-formed (and that issue is in DR status, so should be applied retroactively).

1323 ↗

(On Diff #197085)

Default-construct.

clang/lib/Sema/SemaDeclCXX.cpp

10880 ↗

(On Diff #197085)

Loc here is unused; can you remove it?

11038 ↗

(On Diff #197085)

Default-construct.

12611 ↗

(On Diff #197085)

Default-construct.

12742 ↗

(On Diff #197085)

Default-construct.

clang/lib/Sema/SemaInit.cpp

3817–3831 ↗

(On Diff #197085)

We no longer pass false for AllowExplicit to Add*Candidate when CopyInitializing is true. Is that an intentional change?

3819 ↗

(On Diff #196285)

The intent was to simplify the logic here, and to have only one place where we check the same explicit-specifier (rather than checking it twice, with one check sometimes being incomplete). Let's leave this alone for now, to keep this patch smaller.

9361 ↗

(On Diff #196285)

Unlike in the previous case, we do not yet pass an AllowExplicit flag into AddTemplateOverloadCandidate here, so this will incorrectly allow dependent explicit-specifiers that evaluate to true in copy-initialization contexts.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

375 ↗

(On Diff #197085)

Please add an ExplicitSpecifier ExplicitSpecifier::invalid() static member function to build the "invalid" state, rather than hardcoding the invalid state here.

384 ↗

(On Diff #197085)

return ExplicitSpecifier::invalid(); here, and don't declare Result until you are ready to initialize it below.

1754–1757 ↗

(On Diff #197085)

C++ language rules require that we substitute into the declaration in lexical order (this matters for SFINAE versus non-immediate-context errors). You should instantiate the explicit specifier prior to the call to SubstFunctionType to match source order.

2067–2071 ↗

(On Diff #197085)

Likewise, this should be done after instantiating the template parameter lists and before substitution into the function type.

clang/lib/Serialization/ASTReaderDecl.cpp

2021 ↗

(On Diff #197085)

Please delete this.

clang/test/CXX/temp/temp.deduct.guide/p3.cpp

9–10 ↗

(On Diff #197085)

Please delete this (out of date) comment.

[Tyker]

clang/include/clang/AST/DeclBase.h

1539–1541 ↗

(On Diff #197085)

couldn't we compute the value and static_assert on it. having to modify this each time we modify DeclContextBits or FunctionDeclBits is sad. and there isn't anything reminding us to do so in some cases.
what would be a reasonable minimum ?

clang/lib/Sema/SemaInit.cpp

3817–3831 ↗

(On Diff #197085)

yes. i didn't found any cases in which AllowExplicit was false but CopyInitializing was true. so i assumed that relying only on AllowExplicit is better. the regression tests passes after the change.

[Tyker]

@rsmith fixed feedbacks

except one i commented on.

clang/include/clang/AST/DeclCXX.h

2033 ↗

(On Diff #196285)

as it is only used by deserialization and ASTDeclReader is friend to all class with a setExplicitSpecifier.
I made setExplicitSpecifier private.

clang/include/clang/ASTMatchers/ASTMatchers.h

6174 ↗

(On Diff #197085)

shouldn't this be able to match with deduction guides too ?

clang/lib/Sema/SemaInit.cpp

9361 ↗

(On Diff #196285)

the default value for AllowExplicit is false. so the conversion will be removed in AddTemplateOverloadCandidate.

[rsmith]

This is great, thank you so much!

clang/include/clang/AST/DeclBase.h

1539–1541 ↗

(On Diff #197085)

I think it'd be reasonable to reduce this to 20 if you like. (Going down as far as 16 or so seems acceptable, but I'd be worried about generated code having thousands of members, so I'd be hesitant to go below that.) The existing static_assert on line ~1721 will then catch if we add too many bit-field members.

clang/include/clang/AST/DeclCXX.h

2604 ↗

(On Diff #197378)

Please wrap this to 80 columns.

clang/include/clang/ASTMatchers/ASTMatchers.h

6174 ↗

(On Diff #197378)

Typo "FIXEME" -> "FIXME"

6174 ↗

(On Diff #197085)

Yes, it should. This patch is doing a lot of things already, though, so I'd prefer that we fix that as a separate change.

clang/lib/Parse/ParseDecl.cpp

3906 ↗

(On Diff #197378)

These diagnostics need to be updated to use a different location (rather than using Tok) if isAlreadyConsumed.

clang/lib/Sema/SemaInit.cpp

9361 ↗

(On Diff #196285)

That doesn't sound right: that'd mean we never use explicit deduction guides (we never pass AllowExplicit = true to AddTemplateOverloadCandidate). Do we have any test coverage that demonstrates that conditionally-explicit deduction guides are handled properly?

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

2076 ↗

(On Diff #197378)

Please reflow to 80 columns.

[xbolva00]

clang/include/clang/AST/DeclBase.h

1534 ↗

(On Diff #197378)

Small typo + update comment

[Rakete1111]

clang/include/clang/AST/DeclCXX.h

2579 ↗

(On Diff #197378)

Your or needs parens or the disambiguation is wrong.

clang/include/clang/Serialization/ASTReader.h

2435 ↗

(On Diff #197378)

same here.

clang/lib/Sema/DeclSpec.cpp

952 ↗

(On Diff #197378)

typo.

clang/test/CXX/temp/temp.deduct.guide/p1.cpp

74 ↗

(On Diff #197043)

Is there a reason why you changed this?

[Tyker]

fixed feedback from @rsmith @Rakete1111 @xbolva00

clang/include/clang/AST/DeclCXX.h

2579 ↗

(On Diff #197378)

i don't understand. but there is no need for disambiguation, a && true == a so this will work regardless of operator priority.

clang/include/clang/Serialization/ASTReader.h

2435 ↗

(On Diff #197378)

what is the issue

clang/lib/Sema/SemaInit.cpp

9361 ↗

(On Diff #196285)

my mistake. the default value for AllowExplicit is false. but AddTemplateOverloadCandidate will only remove conversions and constructors. dependent explicit specifier that are resolved to true on deduction guides are removed at line 9480. they are not removed from the overload set. CTAD just fails if a explicit deduction guide is selected in a CopyInitList. i agree this is weird but the behavior is the same as before the patch.
the result on clang is:

template<typename T>
struct A {
  explicit A(T);
};
A a = 0; // error with explicit constructor meaning CTAD succeed.
A a = { 0 }; // error with explicit deduction guide

all compiler don't agree on this https://godbolt.org/z/ElHlkE. icc and clang have this behavior, gcc and msvc fail at CTAD time on both initialization. as of what the standard say from what i read, it isn't clear, the standard is clear when calling an explicit constructor should fail. but it doesn't appear to say for deduction guides.
as this was the previous behavior i did not change it with explicit(bool).

clang/test/CXX/temp/temp.deduct.guide/p1.cpp

74 ↗

(On Diff #197043)

yes. One of change that was made is making deduction guide redeclaration be an error. Without this change, this line was a redeclartion so the test didn't serve its purpose.

[Rakete1111]

clang/include/clang/AST/DeclCXX.h

2579 ↗

(On Diff #197378)

Yeah sorry you're right, I meant that the parens are needed to shut up -Wparens warning about disambiguation.

clang/include/clang/Serialization/ASTReader.h

2435 ↗

(On Diff #197378)

For consistency with nearby code, please name this variable starting with a capital letter.

[rsmith]

clang/lib/Sema/SemaInit.cpp

9361 ↗

(On Diff #196285)

the standard is clear when calling an explicit constructor should fail. but it doesn't appear to say for deduction guides

The standard says that you take the set of deduction guides and notionally form a set of constructors from them (see [over.match.class.deduct]). So the constructor rules apply to deduction guides too.

as this was the previous behavior i did not change it with explicit(bool).

I don't think that's correct. We filter out explicit deduction guides for non-list copy-initialization on line ~9239 (prior to this change). Today we get this result:

template<typename T> struct X { X(int); };

explicit X(int) -> X<int>; // #1

X a = 0; // error: no viable deduction guide, #1 is not a candidate
X b = {0}; // error: selected explicit deduction guide #1
X c{0}; // ok
X d(0); // ok

... which is correct. If we change the deduction guide to have a dependent explicit(bool) specifier:

template<bool E = true>
explicit(E) X(int) -> X<int>;

... we should get the same result, but I think we won't get that result with this patch: I think we'll incorrectly select an explicit deduction guide for the declaration of a, because we never filter out explicit deduction guides.

DeduceTemplateSpecializationFromInitializer should compute an AllowExplicit flag (= !Kind.isCopyInit() || ListInit), pass it into AddTemplateOverloadCandidate, and that should filter out explicit deduction guide specializations if it's true.

[Tyker]

fixed feedback from @rsmith @Rakete1111.

clang/lib/Sema/SemaInit.cpp

9361 ↗

(On Diff #196285)

there was an issue. now fixed.

[rsmith]

Looks good, thank you!

clang/lib/Sema/SemaInit.cpp

9359 ↗

(On Diff #197722)

Please simplify this to if (!AllowExplicit)

[xbolva00]

Also please update
https://clang.llvm.org/cxx_status.html

[Tyker]

@rsmith I made the last requested few changes. But i can't push the change, i don't have the permission.

[Rakete1111]

@Tyker This broke the Chromium build, could you investigate please? http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20190506/270340.html

[Tyker]

yes i am on it.

[Tyker]

Changes:

• merged with the adaptation of lldb at https://reviews.llvm.org/rL359966.
• fixed the issue reported at http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20190506/270340.html.
• added the failing code to the test in explicit.cpp

sorry for the inconvenience.

[rsmith]

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

373–374 ↗

(On Diff #198289)

This is incorrect: you still need to substitute into an explicit-specifier even if you've already resolved it, at least if it's instantiation-dependent. (Substitution could fail, and if it does, you need to produce the error.) For example:

template<typename T> struct A {
  explicit(sizeof(sizeof(T::error)) == sizeof(sizeof(int))) A();
};

Here, the expression in the explicit-specifier is neither type-dependent nor value-dependent, but it is instantiation-dependent, and substitution into it should fail when, say, T is int. (Instantiating A<int> should fail with an error.)

[Tyker]

fixed that issue

[Tyker]

could you commit this for me ?

[RKSimon]

cfe/trunk/lib/Parse/ParseDecl.cpp

3939

@Tyker @rsmith We're seeing -Wparentheses warnings because of this - please can you take a look? The logic looks a little dodgy for a both/neither assertion as well.

http://lab.llvm.org:8011/builders/clang-ppc64be-linux-lnt/builds/27322/steps/build%20stage%201/logs/warnings%20%281%29

[Tyker]

cfe/trunk/lib/Parse/ParseDecl.cpp

3939

i made a revision that fixes this: https://reviews.llvm.org/D61731

cfe/trunk/include/clang/AST/Decl.h

public:
   /// Flag that this function is implicitly inline.
   void setImplicitlyInline(bool I = true) { FunctionDeclBits.IsInline = I; }
 
   /// Determine whether this function should be inlined, because it is
   /// either marked "inline" or "constexpr" or is a member function of a class
   /// that was defined in the class body.
   bool isInlined() const { return FunctionDeclBits.IsInline; }
 
-  /// Whether this function is marked as explicit explicitly.
-  bool isExplicitSpecified() const {
-    return FunctionDeclBits.IsExplicitSpecified;
-  }
-
-  /// State that this function is marked as explicit explicitly.
-  void setExplicitSpecified(bool ExpSpec = true) {
-    FunctionDeclBits.IsExplicitSpecified = ExpSpec;
-  }
-
   bool isInlineDefinitionExternallyVisible() const;
 
   bool isMSExternInline() const;
 
   bool doesDeclarationForceExternallyVisibleDefinition() const;
 
   /// Whether this function declaration represents an C++ overloaded
   /// operator, e.g., "operator+".

cfe/trunk/include/clang/AST/DeclBase.h

class FunctionDeclBitfields {
     friend class CXXDeductionGuideDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
 
     uint64_t SClass : 3;
     uint64_t IsInline : 1;
     uint64_t IsInlineSpecified : 1;
 
-    /// This is shared by CXXConstructorDecl,
-    /// CXXConversionDecl, and CXXDeductionGuideDecl.
-    uint64_t IsExplicitSpecified : 1;
-
     uint64_t IsVirtualAsWritten : 1;
     uint64_t IsPure : 1;
     uint64_t HasInheritedPrototype : 1;
     uint64_t HasWrittenPrototype : 1;
     uint64_t IsDeleted : 1;
     /// Used by CXXMethodDecl
     uint64_t IsTrivial : 1;
 
class FunctionDeclBitfields {
     /// deduction candidate' (is used during overload resolution).
     uint64_t IsCopyDeductionCandidate : 1;
 
     /// Store the ODRHash after first calculation.
     uint64_t HasODRHash : 1;
   };
 
   /// Number of non-inherited bits in FunctionDeclBitfields.
-  enum { NumFunctionDeclBits = 25 };
+  enum { NumFunctionDeclBits = 24 };
 
   /// Stores the bits used by CXXConstructorDecl. If modified
   /// NumCXXConstructorDeclBits and the accessor
   /// methods in CXXConstructorDecl should be updated appropriately.
   class CXXConstructorDeclBitfields {
     friend class CXXConstructorDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
     /// For the bits in FunctionDeclBitfields.
     uint64_t : NumFunctionDeclBits;
 
-    /// 25 bits to fit in the remaining availible space.
+    /// 24 bits to fit in the remaining available space.
     /// Note that this makes CXXConstructorDeclBitfields take
     /// exactly 64 bits and thus the width of NumCtorInitializers
     /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
     /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
-    uint64_t NumCtorInitializers : 25;
+    uint64_t NumCtorInitializers : 24;
     uint64_t IsInheritingConstructor : 1;
+
+    /// Whether this constructor has a trail-allocated explicit specifier.
+    uint64_t HasTrailingExplicitSpecifier : 1;
+    /// If this constructor does't have a trail-allocated explicit specifier.
+    /// Whether this constructor is explicit specified.
+    uint64_t IsSimpleExplicit : 1;
   };
 
   /// Number of non-inherited bits in CXXConstructorDeclBitfields.
-  enum { NumCXXConstructorDeclBits = 26 };
+  enum {
+    NumCXXConstructorDeclBits = 64 - NumDeclContextBits - NumFunctionDeclBits
+  };
 
   /// Stores the bits used by ObjCMethodDecl.
   /// If modified NumObjCMethodDeclBits and the accessor
   /// methods in ObjCMethodDecl should be updated appropriately.
   class ObjCMethodDeclBitfields {
     friend class ObjCMethodDecl;
 
     /// For the bits in DeclContextBitfields.

cfe/trunk/include/clang/AST/DeclCXX.h

   bool isInterfaceLike() const;
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) {
     return K >= firstCXXRecord && K <= lastCXXRecord;
   }
 };
 
+/// Store information needed for an explicit specifier.
+/// used by CXXDeductionGuideDecl, CXXConstructorDecl and CXXConversionDecl.
+class ExplicitSpecifier {
+  llvm::PointerIntPair<Expr *, 2, ExplicitSpecKind> ExplicitSpec{
+      nullptr, ExplicitSpecKind::ResolvedFalse};
+
+public:
+  ExplicitSpecifier() = default;
+  ExplicitSpecifier(Expr *Expression, ExplicitSpecKind Kind)
+      : ExplicitSpec(Expression, Kind) {}
+  ExplicitSpecKind getKind() const { return ExplicitSpec.getInt(); }
+  const Expr *getExpr() const { return ExplicitSpec.getPointer(); }
+  Expr *getExpr() { return ExplicitSpec.getPointer(); }
+
+  /// Return true if the ExplicitSpecifier isn't defaulted.
+  bool isSpecified() const {
+    return ExplicitSpec.getInt() != ExplicitSpecKind::ResolvedFalse ||
+           ExplicitSpec.getPointer();
+  }
+
+  /// Check for Equivalence of explicit specifiers.
+  /// Return True if the explicit specifier are equivalent false otherwise.
+  bool isEquivalent(const ExplicitSpecifier Other) const;
+  /// Return true if the explicit specifier is already resolved to be explicit.
+  bool isExplicit() const {
+    return ExplicitSpec.getInt() == ExplicitSpecKind::ResolvedTrue;
+  }
+  /// Return true if the ExplicitSpecifier isn't valid.
+  /// This state occurs after a substitution failures.
+  bool isInvalid() const {
+    return ExplicitSpec.getInt() == ExplicitSpecKind::Unresolved &&
+           !ExplicitSpec.getPointer();
+  }
+  void setKind(ExplicitSpecKind Kind) { ExplicitSpec.setInt(Kind); }
+  void setExpr(Expr *E) { ExplicitSpec.setPointer(E); }
+  // getFromDecl - retrieve the explicit specifier in the given declaration.
+  // if the given declaration has no explicit. the returned explicit specifier
+  // is defaulted. .isSpecified() will be false.
+  static ExplicitSpecifier getFromDecl(FunctionDecl *Function);
+  static ExplicitSpecifier Invalid() {
+    return ExplicitSpecifier(nullptr, ExplicitSpecKind::Unresolved);
+  }
+};
+
 /// Represents a C++ deduction guide declaration.
 ///
 /// \code
 /// template<typename T> struct A { A(); A(T); };
 /// A() -> A<int>;
 /// \endcode
 ///
 /// In this example, there will be an explicit deduction guide from the
 /// second line, and implicit deduction guide templates synthesized from
 /// the constructors of \c A.
 class CXXDeductionGuideDecl : public FunctionDecl {
   void anchor() override;
 
 private:
   CXXDeductionGuideDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
-                        bool IsExplicit, const DeclarationNameInfo &NameInfo,
-                        QualType T, TypeSourceInfo *TInfo,
-                        SourceLocation EndLocation)
+                        ExplicitSpecifier ES,
+                        const DeclarationNameInfo &NameInfo, QualType T,
+                        TypeSourceInfo *TInfo, SourceLocation EndLocation)
       : FunctionDecl(CXXDeductionGuide, C, DC, StartLoc, NameInfo, T, TInfo,
-                     SC_None, false, false) {
+                     SC_None, false, false),
+        ExplicitSpec(ES) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
-    setExplicitSpecified(IsExplicit);
     setIsCopyDeductionCandidate(false);
   }
 
+  ExplicitSpecifier ExplicitSpec;
+  void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
+
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
-  static CXXDeductionGuideDecl *Create(ASTContext &C, DeclContext *DC,
-                                       SourceLocation StartLoc, bool IsExplicit,
-                                       const DeclarationNameInfo &NameInfo,
-                                       QualType T, TypeSourceInfo *TInfo,
-                                       SourceLocation EndLocation);
+  static CXXDeductionGuideDecl *
+  Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+         ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T,
+         TypeSourceInfo *TInfo, SourceLocation EndLocation);
 
   static CXXDeductionGuideDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
-  /// Whether this deduction guide is explicit.
-  bool isExplicit() const { return isExplicitSpecified(); }
+  ExplicitSpecifier getExplicitSpecifier() { return ExplicitSpec; }
+  const ExplicitSpecifier getExplicitSpecifier() const { return ExplicitSpec; }
+
+  /// Return true if the declartion is already resolved to be explicit.
+  bool isExplicit() const { return ExplicitSpec.isExplicit(); }
 
   /// Get the template for which this guide performs deduction.
   TemplateDecl *getDeducedTemplate() const {
     return getDeclName().getCXXDeductionGuideTemplate();
   }
 
   void setIsCopyDeductionCandidate(bool isCDC = true) {
     FunctionDeclBits.IsCopyDeductionCandidate = isCDC;

 /// \code
 /// class X {
 /// public:
 ///   explicit X(int); // represented by a CXXConstructorDecl.
 /// };
 /// \endcode
 class CXXConstructorDecl final
     : public CXXMethodDecl,
-      private llvm::TrailingObjects<CXXConstructorDecl, InheritedConstructor> {
+      private llvm::TrailingObjects<CXXConstructorDecl, InheritedConstructor,
+                                    ExplicitSpecifier> {
   // This class stores some data in DeclContext::CXXConstructorDeclBits
   // to save some space. Use the provided accessors to access it.
 
   /// \name Support for base and member initializers.
   /// \{
   /// The arguments used to initialize the base or member.
   LazyCXXCtorInitializersPtr CtorInitializers;
 
   CXXConstructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-                     const DeclarationNameInfo &NameInfo,
-                     QualType T, TypeSourceInfo *TInfo,
-                     bool isExplicitSpecified, bool isInline,
+                     const DeclarationNameInfo &NameInfo, QualType T,
+                     TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool isInline,
                      bool isImplicitlyDeclared, bool isConstexpr,
                      InheritedConstructor Inherited);
 
   void anchor() override;
 
+  size_t numTrailingObjects(OverloadToken<InheritedConstructor>) const {
+    return CXXConstructorDeclBits.IsInheritingConstructor;
+  }
+  size_t numTrailingObjects(OverloadToken<ExplicitSpecifier>) const {
+    return CXXConstructorDeclBits.HasTrailingExplicitSpecifier;
+  }
+
+  ExplicitSpecifier getExplicitSpecifierInternal() const {
+    if (CXXConstructorDeclBits.HasTrailingExplicitSpecifier)
+      return *getCanonicalDecl()->getTrailingObjects<ExplicitSpecifier>();
+    return ExplicitSpecifier(
+        nullptr, getCanonicalDecl()->CXXConstructorDeclBits.IsSimpleExplicit
+                     ? ExplicitSpecKind::ResolvedTrue
+                     : ExplicitSpecKind::ResolvedFalse);
+  }
+
+  void setExplicitSpecifier(ExplicitSpecifier ES) {
+    assert((!ES.getExpr() ||
+            CXXConstructorDeclBits.HasTrailingExplicitSpecifier) &&
+           "cannot set this explicit specifier. no trail-allocated space for "
+           "explicit");
+    if (ES.getExpr())
+      *getCanonicalDecl()->getTrailingObjects<ExplicitSpecifier>() = ES;
+    else
+      CXXConstructorDeclBits.IsSimpleExplicit = ES.isExplicit();
+  }
+
+  enum TraillingAllocKind {
+    TAKInheritsConstructor = 1,
+    TAKHasTailExplicit = 1 << 1,
+  };
+
+  uint64_t getTraillingAllocKind() const {
+    return numTrailingObjects(OverloadToken<InheritedConstructor>()) |
+           (numTrailingObjects(OverloadToken<ExplicitSpecifier>()) << 1);
+  }
+
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
   friend TrailingObjects;
 
   static CXXConstructorDecl *CreateDeserialized(ASTContext &C, unsigned ID,
-                                                bool InheritsConstructor);
+                                                uint64_t AllocKind);
   static CXXConstructorDecl *
   Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
-         bool isExplicit, bool isInline, bool isImplicitlyDeclared,
+         ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared,
          bool isConstexpr,
          InheritedConstructor Inherited = InheritedConstructor());
 
+  ExplicitSpecifier getExplicitSpecifier() {
+    return getExplicitSpecifierInternal();
+  }
+  const ExplicitSpecifier getExplicitSpecifier() const {
+    return getExplicitSpecifierInternal();
+  }
+
+  /// Return true if the declartion is already resolved to be explicit.
+  bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
+
   /// Iterates through the member/base initializer list.
   using init_iterator = CXXCtorInitializer **;
 
   /// Iterates through the member/base initializer list.
   using init_const_iterator = CXXCtorInitializer *const *;
 
   using init_range = llvm::iterator_range<init_iterator>;
   using init_const_range = llvm::iterator_range<init_const_iterator>;
void setNumCtorInitializers(unsigned numCtorInitializers) {
     assert(CXXConstructorDeclBits.NumCtorInitializers ==
            numCtorInitializers && "NumCtorInitializers overflow!");
   }
 
   void setCtorInitializers(CXXCtorInitializer **Initializers) {
     CtorInitializers = Initializers;
   }
 
-  /// Whether this function is explicit.
-  bool isExplicit() const {
-    return getCanonicalDecl()->isExplicitSpecified();
-  }
-
   /// Determine whether this constructor is a delegating constructor.
   bool isDelegatingConstructor() const {
     return (getNumCtorInitializers() == 1) &&
            init_begin()[0]->isDelegatingInitializer();
   }
 
   /// When this constructor delegates to another, retrieve the target.
   CXXConstructorDecl *getTargetConstructor() const;

 /// class X {
 /// public:
 ///   operator bool();
 /// };
 /// \endcode
 class CXXConversionDecl : public CXXMethodDecl {
   CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                     const DeclarationNameInfo &NameInfo, QualType T,
-                    TypeSourceInfo *TInfo, bool isInline,
-                    bool isExplicitSpecified, bool isConstexpr,
-                    SourceLocation EndLocation)
+                    TypeSourceInfo *TInfo, bool isInline, ExplicitSpecifier ES,
+                    bool isConstexpr, SourceLocation EndLocation)
       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
-                      SC_None, isInline, isConstexpr, EndLocation) {
-    setExplicitSpecified(isExplicitSpecified);
-  }
-
+                      SC_None, isInline, isConstexpr, EndLocation),
+        ExplicitSpec(ES) {}
   void anchor() override;
 
+  ExplicitSpecifier ExplicitSpec;
+
+  void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
+
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
-  static CXXConversionDecl *Create(ASTContext &C, CXXRecordDecl *RD,
-                                   SourceLocation StartLoc,
-                                   const DeclarationNameInfo &NameInfo,
-                                   QualType T, TypeSourceInfo *TInfo,
-                                   bool isInline, bool isExplicit,
-                                   bool isConstexpr,
-                                   SourceLocation EndLocation);
+  static CXXConversionDecl *
+  Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
+         const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+         bool isInline, ExplicitSpecifier ES, bool isConstexpr,
   static CXXConversionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
-  /// Whether this function is explicit.
-  bool isExplicit() const {
-    return getCanonicalDecl()->isExplicitSpecified();
+  ExplicitSpecifier getExplicitSpecifier() {
+    return getCanonicalDecl()->ExplicitSpec;
   }
 
+  const ExplicitSpecifier getExplicitSpecifier() const {
+    return getCanonicalDecl()->ExplicitSpec;
+  }
+
+  /// Return true if the declartion is already resolved to be explicit.
+  bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
+
   /// Returns the type that this conversion function is converting to.
   QualType getConversionType() const {
     return getType()->getAs<FunctionType>()->getReturnType();
   }
 
   /// Determine whether this conversion function is a conversion from
   /// a lambda closure type to a block pointer.
   bool isLambdaToBlockPointerConversion() const;

cfe/trunk/include/clang/ASTMatchers/ASTMatchers.h

 ///     explicit operator bool(); // #4
 ///   };
 /// \endcode
 /// cxxConstructorDecl(isExplicit()) will match #2, but not #1.
 /// cxxConversionDecl(isExplicit()) will match #4, but not #3.
 AST_POLYMORPHIC_MATCHER(isExplicit,
                         AST_POLYMORPHIC_SUPPORTED_TYPES(CXXConstructorDecl,
                                                         CXXConversionDecl)) {
+  // FIXME : it's not clear whether this should match a dependent
+  //         explicit(....). this matcher should also be able to match
+  //         CXXDeductionGuideDecl with explicit specifier.
   return Node.isExplicit();
 }
 
 /// Matches function and namespace declarations that are marked with
 /// the inline keyword.
 ///
 /// Given
 /// \code

cfe/trunk/include/clang/Basic/DiagnosticCommonKinds.td

 
 def ext_duplicate_declspec : Extension<"%sub{duplicate_declspec}0">,
   InGroup<DuplicateDeclSpecifier>;
 def ext_warn_duplicate_declspec : ExtWarn<"%sub{duplicate_declspec}0">,
   InGroup<DuplicateDeclSpecifier>;
 def warn_duplicate_declspec : Warning<"%sub{duplicate_declspec}0">,
   InGroup<DuplicateDeclSpecifier>;
 
+def err_duplicate_declspec : Error<"%sub{duplicate_declspec}0">;
+
 def err_friend_decl_spec : Error<"'%0' is invalid in friend declarations">;
 
 def err_invalid_member_in_interface : Error<
   "%select{data member |non-public member function |static member function |"
           "user-declared constructor|user-declared destructor|operator |"
           "nested class }0%1 is not permitted within an interface type">;
 
 def err_attribute_uuid_malformed_guid : Error<

cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td

 def err_gnu_inline_asm_disabled : Error<
   "GNU-style inline assembly is disabled">;
 def err_asm_goto_not_supported_yet : Error<
   "'asm goto' constructs are not supported yet">;
 }
 
 let CategoryName = "Parse Issue" in {
 
+def warn_cxx2a_compat_explicit_bool : Warning<
+  "this expression will be parsed as explicit(bool) in C++2a">,
+  InGroup<CXX2aCompat>, DefaultIgnore;
+
 def ext_empty_translation_unit : Extension<
   "ISO C requires a translation unit to contain at least one declaration">,
   InGroup<DiagGroup<"empty-translation-unit">>;
 def warn_cxx98_compat_top_level_semi : Warning<
   "extra ';' outside of a function is incompatible with C++98">,
   InGroup<CXX98CompatExtraSemi>, DefaultIgnore;
 def ext_extra_semi : Extension<
   "extra ';' %select{"

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def err_typecheck_converted_constant_expression : Error<
   "value of type %0 is not implicitly convertible to %1">;
 def err_typecheck_converted_constant_expression_disallowed : Error<
   "conversion from %0 to %1 is not allowed in a converted constant expression">;
 def err_typecheck_converted_constant_expression_indirect : Error<
   "conversion from %0 to %1 in converted constant expression would "
   "bind reference to a temporary">;
 def err_expr_not_cce : Error<
   "%select{case value|enumerator value|non-type template argument|"
-  "array size|constexpr if condition}0 "
+  "array size|constexpr if condition|explicit specifier argument}0 "
   "is not a constant expression">;
 def ext_cce_narrowing : ExtWarn<
   "%select{case value|enumerator value|non-type template argument|"
-  "array size|constexpr if condition}0 "
+  "array size|constexpr if condition|explicit specifier argument}0 "
   "%select{cannot be narrowed from type %2 to %3|"
   "evaluates to %2, which cannot be narrowed to type %3}1">,
   InGroup<CXX11Narrowing>, DefaultError, SFINAEFailure;
 def err_ice_not_integral : Error<
   "integral constant expression must have integral or unscoped enumeration "
   "type, not %0">;
 def err_ice_incomplete_type : Error<
   "integral constant expression has incomplete class type %0">;

 def err_deduction_guide_name_not_class_template : Error<
   "cannot specify deduction guide for "
   "%select{<error>|function template|variable template|alias template|"
   "template template parameter|dependent template name}0 %1">;
 def err_deduction_guide_wrong_scope : Error<
   "deduction guide must be declared in the same scope as template %q0">;
 def err_deduction_guide_defines_function : Error<
   "deduction guide cannot have a function definition">;
-def err_deduction_guide_explicit_mismatch : Error<
-  "deduction guide is %select{not |}0declared 'explicit' but "
-  "previous declaration was%select{ not|}0">;
+def err_deduction_guide_redeclared : Error<
+  "redeclaration of deduction guide">;
 def err_deduction_guide_specialized : Error<"deduction guide cannot be "
   "%select{explicitly instantiated|explicitly specialized}0">;
 def err_deduction_guide_template_not_deducible : Error<
   "deduction guide template contains "
   "%select{a template parameter|template parameters}0 that cannot be "
   "deduced">;
 def err_deduction_guide_wrong_access : Error<
   "deduction guide has different access from the corresponding "
def note_ovl_candidate : Note<
     "%select{| has different class%diff{ (expected $ but has $)|}5,6"
     "| has different number of parameters (expected %5 but has %6)"
     "| has type mismatch at %ordinal5 parameter"
     "%diff{ (expected $ but has $)|}6,7"
     "| has different return type%diff{ ($ expected but has $)|}5,6"
     "| has different qualifiers (expected %5 but found %6)"
     "| has different exception specification}4">;
 
+def note_ovl_candidate_explicit_forbidden : Note<
+    "candidate %0 ignored: cannot be explicit">;
+def note_explicit_bool_resolved_to_true : Note<
+    "explicit(bool) specifier resolved to true">;
 def note_ovl_candidate_inherited_constructor : Note<
     "constructor from base class %0 inherited here">;
 def note_ovl_candidate_inherited_constructor_slice : Note<
     "candidate %select{constructor|template}0 ignored: "
     "inherited constructor cannot be used to %select{copy|move}1 object">;
 def note_ovl_candidate_illegal_constructor : Note<
     "candidate %select{constructor|template}0 ignored: "
     "instantiation %select{takes|would take}0 its own class type by value">;

cfe/trunk/include/clang/Basic/Specifiers.h

 #ifndef LLVM_CLANG_BASIC_SPECIFIERS_H
 #define LLVM_CLANG_BASIC_SPECIFIERS_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace clang {
+
+  /// Define the meaning of possible values of the kind in ExplicitSpecifier.
+  enum class ExplicitSpecKind : unsigned {
+    ResolvedFalse,
+    ResolvedTrue,
+    Unresolved,
+  };
+
   /// Specifies the width of a type, e.g., short, long, or long long.
   enum TypeSpecifierWidth {
     TSW_unspecified,
     TSW_short,
     TSW_long,
     TSW_longlong
   };
 

cfe/trunk/include/clang/Sema/DeclSpec.h

 ///                            declarators
 /// \endverbatim
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_SEMA_DECLSPEC_H
 #define LLVM_CLANG_SEMA_DECLSPEC_H
 
+#include "clang/AST/DeclCXX.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/Basic/ExceptionSpecificationType.h"
 #include "clang/Basic/Lambda.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Lex/Token.h"
 #include "clang/Sema/Ownership.h"
 #include "clang/Sema/ParsedAttr.h"
private:
 
   // type-qualifiers
   unsigned TypeQualifiers : 5;  // Bitwise OR of TQ.
 
   // function-specifier
   unsigned FS_inline_specified : 1;
   unsigned FS_forceinline_specified: 1;
   unsigned FS_virtual_specified : 1;
-  unsigned FS_explicit_specified : 1;
   unsigned FS_noreturn_specified : 1;
 
   // friend-specifier
   unsigned Friend_specified : 1;
 
   // constexpr-specifier
   unsigned Constexpr_specified : 1;
 
   union {
     UnionParsedType TypeRep;
     Decl *DeclRep;
     Expr *ExprRep;
   };
 
+  /// ExplicitSpecifier - Store information about explicit spicifer.
+  ExplicitSpecifier FS_explicit_specifier;
+
   // attributes.
   ParsedAttributes Attrs;
 
   // Scope specifier for the type spec, if applicable.
   CXXScopeSpec TypeScope;
 
   // SourceLocation info.  These are null if the item wasn't specified or if
   // the setting was synthesized.
   SourceRange Range;
 
   SourceLocation StorageClassSpecLoc, ThreadStorageClassSpecLoc;
   SourceRange TSWRange;
   SourceLocation TSCLoc, TSSLoc, TSTLoc, AltiVecLoc, TSSatLoc;
   /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union,
   /// typename, then this is the location of the named type (if present);
   /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and
   /// TSTNameLoc provides source range info for tag types.
   SourceLocation TSTNameLoc;
   SourceRange TypeofParensRange;
   SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
       TQ_unalignedLoc;
   SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
+  SourceLocation FS_explicitCloseParenLoc;
   SourceLocation FS_forceinlineLoc;
   SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
   SourceLocation TQ_pipeLoc;
 
   WrittenBuiltinSpecs writtenBS;
   void SaveWrittenBuiltinSpecs();
 
   ObjCDeclSpec *ObjCQualifiers;

 public:
   static bool isDeclRep(TST T) {
     return (T == TST_enum || T == TST_struct ||
             T == TST_interface || T == TST_union ||
             T == TST_class);
   }
 
   DeclSpec(AttributeFactory &attrFactory)
       : StorageClassSpec(SCS_unspecified),
         ThreadStorageClassSpec(TSCS_unspecified),
-      SCS_extern_in_linkage_spec(false),
-      TypeSpecWidth(TSW_unspecified),
-      TypeSpecComplex(TSC_unspecified),
-      TypeSpecSign(TSS_unspecified),
-      TypeSpecType(TST_unspecified),
-      TypeAltiVecVector(false),
-      TypeAltiVecPixel(false),
-      TypeAltiVecBool(false),
-      TypeSpecOwned(false),
-      TypeSpecPipe(false),
-      TypeSpecSat(false),
-      TypeQualifiers(TQ_unspecified),
-      FS_inline_specified(false),
-      FS_forceinline_specified(false),
-      FS_virtual_specified(false),
-      FS_explicit_specified(false),
-      FS_noreturn_specified(false),
-      Friend_specified(false),
-      Constexpr_specified(false),
-      Attrs(attrFactory),
-      writtenBS(),
-      ObjCQualifiers(nullptr) {
-  }
+        SCS_extern_in_linkage_spec(false), TypeSpecWidth(TSW_unspecified),
+        TypeSpecComplex(TSC_unspecified), TypeSpecSign(TSS_unspecified),
+        TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
+        TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
+        TypeSpecPipe(false), TypeSpecSat(false), TypeQualifiers(TQ_unspecified),
+        FS_inline_specified(false), FS_forceinline_specified(false),
+        FS_virtual_specified(false), FS_noreturn_specified(false),
+        Friend_specified(false), Constexpr_specified(false),
+        FS_explicit_specifier(), Attrs(attrFactory), writtenBS(),
+        ObjCQualifiers(nullptr) {}
 
   // storage-class-specifier
   SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
   TSCS getThreadStorageClassSpec() const {
     return (TSCS)ThreadStorageClassSpec;
   }
   bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
   void setExternInLinkageSpec(bool Value) {
public:
   // function-specifier
   bool isInlineSpecified() const {
     return FS_inline_specified | FS_forceinline_specified;
   }
   SourceLocation getInlineSpecLoc() const {
     return FS_inline_specified ? FS_inlineLoc : FS_forceinlineLoc;
   }
 
+  ExplicitSpecifier getExplicitSpecifier() const {
+    return FS_explicit_specifier;
+  }
+
   bool isVirtualSpecified() const { return FS_virtual_specified; }
   SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; }
 
-  bool isExplicitSpecified() const { return FS_explicit_specified; }
+  bool hasExplicitSpecifier() const {
+    return FS_explicit_specifier.isSpecified();
+  }
   SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; }
+  SourceRange getExplicitSpecRange() const {
+    return FS_explicit_specifier.getExpr()
+               ? SourceRange(FS_explicitLoc, FS_explicitCloseParenLoc)
+               : SourceRange(FS_explicitLoc);
+  }
 
   bool isNoreturnSpecified() const { return FS_noreturn_specified; }
   SourceLocation getNoreturnSpecLoc() const { return FS_noreturnLoc; }
 
   void ClearFunctionSpecs() {
     FS_inline_specified = false;
     FS_inlineLoc = SourceLocation();
     FS_forceinline_specified = false;
     FS_forceinlineLoc = SourceLocation();
     FS_virtual_specified = false;
     FS_virtualLoc = SourceLocation();
-    FS_explicit_specified = false;
+    FS_explicit_specifier = ExplicitSpecifier();
     FS_explicitLoc = SourceLocation();
+    FS_explicitCloseParenLoc = SourceLocation();
     FS_noreturn_specified = false;
     FS_noreturnLoc = SourceLocation();
   }
 
   /// This method calls the passed in handler on each CVRU qual being
   /// set.
   /// Handle - a handler to be invoked.
   void forEachCVRUQualifier(
public:
 
   bool setFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec,
                              unsigned &DiagID);
   bool setFunctionSpecForceInline(SourceLocation Loc, const char *&PrevSpec,
                                   unsigned &DiagID);
   bool setFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec,
                               unsigned &DiagID);
   bool setFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec,
-                               unsigned &DiagID);
+                               unsigned &DiagID, ExplicitSpecifier ExplicitSpec,
+                               SourceLocation CloseParenLoc);
   bool setFunctionSpecNoreturn(SourceLocation Loc, const char *&PrevSpec,
                                unsigned &DiagID);
 
   bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
                      unsigned &DiagID);
   bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
                             unsigned &DiagID);
   bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,

cfe/trunk/include/clang/Sema/Overload.h

enum OverloadFailureKind {
     /// was not accessible from the caller's target (i.e. host->device,
     /// global->host, device->host).
     ovl_fail_bad_target,
 
     /// This candidate function was not viable because an enable_if
     /// attribute disabled it.
     ovl_fail_enable_if,
 
+    /// This candidate constructor or conversion fonction
+    /// is used implicitly but the explicit(bool) specifier
+    /// was resolved to true
+    ovl_fail_explicit_resolved,
+
     /// This candidate was not viable because its address could not be taken.
     ovl_fail_addr_not_available,
 
     /// This candidate was not viable because its OpenCL extension is disabled.
     ovl_fail_ext_disabled,
 
     /// This inherited constructor is not viable because it would slice the
     /// argument.

cfe/trunk/include/clang/Sema/Sema.h

public:
   ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
 
   /// Contexts in which a converted constant expression is required.
   enum CCEKind {
     CCEK_CaseValue,   ///< Expression in a case label.
     CCEK_Enumerator,  ///< Enumerator value with fixed underlying type.
     CCEK_TemplateArg, ///< Value of a non-type template parameter.
     CCEK_NewExpr,     ///< Constant expression in a noptr-new-declarator.
-    CCEK_ConstexprIf  ///< Condition in a constexpr if statement.
+    CCEK_ConstexprIf, ///< Condition in a constexpr if statement.
+    CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.
   };
   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
                                               llvm::APSInt &Value, CCEKind CCE);
   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
                                               APValue &Value, CCEKind CCE);
 
   /// Abstract base class used to perform a contextual implicit
   /// conversion from an expression to any type passing a filter.
public:
 
   using ADLCallKind = CallExpr::ADLCallKind;
 
   void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
                             ArrayRef<Expr *> Args,
                             OverloadCandidateSet &CandidateSet,
                             bool SuppressUserConversions = false,
                             bool PartialOverloading = false,
-                            bool AllowExplicit = false,
+                            bool AllowExplicit = true,
+                            bool AllowExplicitConversion = false,
                             ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
                             ConversionSequenceList EarlyConversions = None);
   void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
                       ArrayRef<Expr *> Args,
                       OverloadCandidateSet &CandidateSet,
                       TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
                       bool SuppressUserConversions = false,
                       bool PartialOverloading = false,
void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
                                   ArrayRef<Expr *> Args,
                                   OverloadCandidateSet& CandidateSet,
                                   bool SuppressUserConversions = false,
                                   bool PartialOverloading = false);
   void AddTemplateOverloadCandidate(
       FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
       TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
       OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,
-      bool PartialOverloading = false,
+      bool PartialOverloading = false, bool AllowExplicit = true,
       ADLCallKind IsADLCandidate = ADLCallKind::NotADL);
   bool CheckNonDependentConversions(FunctionTemplateDecl *FunctionTemplate,
                                     ArrayRef<QualType> ParamTypes,
                                     ArrayRef<Expr *> Args,
                                     OverloadCandidateSet &CandidateSet,
                                     ConversionSequenceList &Conversions,
                                     bool SuppressUserConversions,
                                     CXXRecordDecl *ActingContext = nullptr,
                                     QualType ObjectType = QualType(),
                                     Expr::Classification
                                         ObjectClassification = {});
-  void AddConversionCandidate(CXXConversionDecl *Conversion,
-                              DeclAccessPair FoundDecl,
-                              CXXRecordDecl *ActingContext,
-                              Expr *From, QualType ToType,
-                              OverloadCandidateSet& CandidateSet,
-                              bool AllowObjCConversionOnExplicit,
-                              bool AllowResultConversion = true);
-  void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
-                                      DeclAccessPair FoundDecl,
-                                      CXXRecordDecl *ActingContext,
-                                      Expr *From, QualType ToType,
-                                      OverloadCandidateSet &CandidateSet,
-                                      bool AllowObjCConversionOnExplicit,
-                                      bool AllowResultConversion = true);
+  void AddConversionCandidate(
+      CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
+      CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
+      OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
+      bool AllowExplicit, bool AllowResultConversion = true);
+  void AddTemplateConversionCandidate(
+      FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
+      CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
+      OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
+      bool AllowExplicit, bool AllowResultConversion = true);
   void AddSurrogateCandidate(CXXConversionDecl *Conversion,
                              DeclAccessPair FoundDecl,
                              CXXRecordDecl *ActingContext,
                              const FunctionProtoType *Proto,
                              Expr *Object, ArrayRef<Expr *> Args,
                              OverloadCandidateSet& CandidateSet);
   void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
                                    SourceLocation OpLoc, ArrayRef<Expr *> Args,

   /// decays, possibly changing the input variable.
   ///
   /// \param Loc - A location associated with the condition, e.g. the
   /// 'if' keyword.
   /// \return true iff there were any errors
   ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,
                                    bool IsConstexpr = false);
 
+  /// ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression
+  /// found in an explicit(bool) specifier.
+  ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E);
+
+  /// tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
+  /// Returns true if the explicit specifier is now resolved.
+  bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec);
+
   /// DiagnoseAssignmentAsCondition - Given that an expression is
   /// being used as a boolean condition, warn if it's an assignment.
   void DiagnoseAssignmentAsCondition(Expr *E);
 
   /// Redundant parentheses over an equality comparison can indicate
   /// that the user intended an assignment used as condition.
   void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
 

cfe/trunk/include/clang/Serialization/ASTBitCodes.h

enum DeclCode {
       DECL_CXX_DEDUCTION_GUIDE,
 
       /// A CXXMethodDecl record.
       DECL_CXX_METHOD,
 
       /// A CXXConstructorDecl record.
       DECL_CXX_CONSTRUCTOR,
 
-      /// A CXXConstructorDecl record for an inherited constructor.
-      DECL_CXX_INHERITED_CONSTRUCTOR,
-
       /// A CXXDestructorDecl record.
       DECL_CXX_DESTRUCTOR,
 
       /// A CXXConversionDecl record.
       DECL_CXX_CONVERSION,
 
       /// An AccessSpecDecl record.
       DECL_ACCESS_SPEC,

cfe/trunk/include/clang/Serialization/ASTReader.h

public:
 
   /// Read the record that describes the visible contents of a DC.
   bool readVisibleDeclContextStorage(uint64_t Offset,
                                      serialization::DeclID ID) {
     return Reader->ReadVisibleDeclContextStorage(*F, F->DeclsCursor, Offset,
                                                  ID);
   }
 
+  ExplicitSpecifier readExplicitSpec() {
+    uint64_t Kind = readInt();
+    bool HasExpr = Kind & 0x1;
+    Kind = Kind >> 1;
+    return ExplicitSpecifier(HasExpr ? readExpr() : nullptr,
+                             static_cast<ExplicitSpecKind>(Kind));
+  }
+
   void readExceptionSpec(SmallVectorImpl<QualType> &ExceptionStorage,
                          FunctionProtoType::ExceptionSpecInfo &ESI) {
     return Reader->readExceptionSpec(*F, ExceptionStorage, ESI, Record, Idx);
   }
 
   /// Get the global offset corresponding to a local offset.
   uint64_t getGlobalBitOffset(uint32_t LocalOffset) {
     return Reader->getGlobalBitOffset(*F, LocalOffset);

cfe/trunk/lib/AST/ASTImporter.cpp

if (Expected<ParmVarDecl *> ToPOrErr = import(P))
       Parameters.push_back(*ToPOrErr);
     else
       return ToPOrErr.takeError();
   }
 
   // Create the imported function.
   FunctionDecl *ToFunction = nullptr;
   if (auto *FromConstructor = dyn_cast<CXXConstructorDecl>(D)) {
+    Expr *ExplicitExpr = nullptr;
+    if (FromConstructor->getExplicitSpecifier().getExpr()) {
+      auto Imp = importSeq(FromConstructor->getExplicitSpecifier().getExpr());
+      if (!Imp)
+        return Imp.takeError();
+      std::tie(ExplicitExpr) = *Imp;
+    }
     if (GetImportedOrCreateDecl<CXXConstructorDecl>(
             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
             ToInnerLocStart, NameInfo, T, TInfo,
-        FromConstructor->isExplicit(),
+            ExplicitSpecifier(
+                ExplicitExpr,
+                FromConstructor->getExplicitSpecifier().getKind()),
             D->isInlineSpecified(), D->isImplicit(), D->isConstexpr()))
       return ToFunction;
   } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(D)) {
 
     auto Imp =
         importSeq(const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()),
                   FromDtor->getOperatorDeleteThisArg());
 
     if (!Imp)
if (GetImportedOrCreateDecl<CXXDestructorDecl>(
         D->isImplicit()))
       return ToFunction;
 
     CXXDestructorDecl *ToDtor = cast<CXXDestructorDecl>(ToFunction);
 
     ToDtor->setOperatorDelete(ToOperatorDelete, ToThisArg);
   } else if (CXXConversionDecl *FromConversion =
                  dyn_cast<CXXConversionDecl>(D)) {
+    Expr *ExplicitExpr = nullptr;
+    if (FromConversion->getExplicitSpecifier().getExpr()) {
+      auto Imp = importSeq(FromConversion->getExplicitSpecifier().getExpr());
+      if (!Imp)
+        return Imp.takeError();
+      std::tie(ExplicitExpr) = *Imp;
+    }
     if (GetImportedOrCreateDecl<CXXConversionDecl>(
             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
             ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
-            FromConversion->isExplicit(), D->isConstexpr(), SourceLocation()))
+            ExplicitSpecifier(ExplicitExpr,
+                              FromConversion->getExplicitSpecifier().getKind()),
+            D->isConstexpr(), SourceLocation()))
       return ToFunction;
   } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
     if (GetImportedOrCreateDecl<CXXMethodDecl>(
             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
             ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
             Method->isInlineSpecified(), D->isConstexpr(), SourceLocation()))
       return ToFunction;
   } else {

cfe/trunk/lib/AST/ASTStructuralEquivalence.cpp

bool PropertiesEqual =
       Method1->isDefaulted() == Method2->isDefaulted() &&
       Method1->isDeleted() == Method2->isDeleted();
   if (!PropertiesEqual)
     return false;
   // FIXME: Check for 'final'.
 
   if (auto *Constructor1 = dyn_cast<CXXConstructorDecl>(Method1)) {
     auto *Constructor2 = cast<CXXConstructorDecl>(Method2);
-    if (Constructor1->isExplicit() != Constructor2->isExplicit())
+    if (!Constructor1->getExplicitSpecifier().isEquivalent(
+            Constructor2->getExplicitSpecifier()))
       return false;
   }
 
   if (auto *Conversion1 = dyn_cast<CXXConversionDecl>(Method1)) {
     auto *Conversion2 = cast<CXXConversionDecl>(Method2);
-    if (Conversion1->isExplicit() != Conversion2->isExplicit())
+    if (!Conversion1->getExplicitSpecifier().isEquivalent(
+            Conversion2->getExplicitSpecifier()))
       return false;
     if (!IsStructurallyEquivalent(Context, Conversion1->getConversionType(),
                                   Conversion2->getConversionType()))
       return false;
   }
 
   const IdentifierInfo *Name1 = Method1->getIdentifier();
   const IdentifierInfo *Name2 = Method2->getIdentifier();

cfe/trunk/lib/AST/Decl.cpp

FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
     : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
                      StartLoc),
       DeclContext(DK), redeclarable_base(C), ODRHash(0),
       EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {
   assert(T.isNull() || T->isFunctionType());
   FunctionDeclBits.SClass = S;
   FunctionDeclBits.IsInline = isInlineSpecified;
   FunctionDeclBits.IsInlineSpecified = isInlineSpecified;
-  FunctionDeclBits.IsExplicitSpecified = false;
   FunctionDeclBits.IsVirtualAsWritten = false;
   FunctionDeclBits.IsPure = false;
   FunctionDeclBits.HasInheritedPrototype = false;
   FunctionDeclBits.HasWrittenPrototype = true;
   FunctionDeclBits.IsDeleted = false;
   FunctionDeclBits.IsTrivial = false;
   FunctionDeclBits.IsTrivialForCall = false;
   FunctionDeclBits.IsDefaulted = false;

cfe/trunk/lib/AST/DeclCXX.cpp

if (BaseDecl->isAbstract())
       return true;
   }
 
   return false;
 }
 
 void CXXDeductionGuideDecl::anchor() {}
 
+bool ExplicitSpecifier::isEquivalent(const ExplicitSpecifier Other) const {
+  if ((getKind() != Other.getKind() ||
+       getKind() == ExplicitSpecKind::Unresolved)) {
+    if (getKind() == ExplicitSpecKind::Unresolved &&
+        Other.getKind() == ExplicitSpecKind::Unresolved) {
+      ODRHash SelfHash, OtherHash;
+      SelfHash.AddStmt(getExpr());
+      OtherHash.AddStmt(Other.getExpr());
+      return SelfHash.CalculateHash() == OtherHash.CalculateHash();
+    } else
+      return false;
+  }
+  return true;
+}
+
+ExplicitSpecifier ExplicitSpecifier::getFromDecl(FunctionDecl *Function) {
+  switch (Function->getDeclKind()) {
+  case Decl::Kind::CXXConstructor:
+    return cast<CXXConstructorDecl>(Function)->getExplicitSpecifier();
+  case Decl::Kind::CXXConversion:
+    return cast<CXXConversionDecl>(Function)->getExplicitSpecifier();
+  case Decl::Kind::CXXDeductionGuide:
+    return cast<CXXDeductionGuideDecl>(Function)->getExplicitSpecifier();
+  default:
+    return {};
+  }
+}
+
 CXXDeductionGuideDecl *CXXDeductionGuideDecl::Create(
-    ASTContext &C, DeclContext *DC, SourceLocation StartLoc, bool IsExplicit,
-    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
-    SourceLocation EndLocation) {
-  return new (C, DC) CXXDeductionGuideDecl(C, DC, StartLoc, IsExplicit,
-                                           NameInfo, T, TInfo, EndLocation);
+    ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+    ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T,
+    TypeSourceInfo *TInfo, SourceLocation EndLocation) {
+  return new (C, DC) CXXDeductionGuideDecl(C, DC, StartLoc, ES, NameInfo, T,
+                                           TInfo, EndLocation);
 }
 
 CXXDeductionGuideDecl *CXXDeductionGuideDecl::CreateDeserialized(ASTContext &C,
                                                                  unsigned ID) {
-  return new (C, ID) CXXDeductionGuideDecl(C, nullptr, SourceLocation(), false,
-                                           DeclarationNameInfo(), QualType(),
-                                           nullptr, SourceLocation());
+  return new (C, ID) CXXDeductionGuideDecl(
+      C, nullptr, SourceLocation(), ExplicitSpecifier(), DeclarationNameInfo(),
+      QualType(), nullptr, SourceLocation());
 }
 
 void CXXMethodDecl::anchor() {}
 
 bool CXXMethodDecl::isStatic() const {
   const CXXMethodDecl *MD = getCanonicalDecl();
 
   if (MD->getStorageClass() == SC_Static)
SourceRange CXXCtorInitializer::getSourceRange() const {
   }
 
   return SourceRange(getSourceLocation(), getRParenLoc());
 }
 
 CXXConstructorDecl::CXXConstructorDecl(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
     const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
-    bool isExplicitSpecified, bool isInline, bool isImplicitlyDeclared,
+    ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared,
     bool isConstexpr, InheritedConstructor Inherited)
     : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
                     SC_None, isInline, isConstexpr, SourceLocation()) {
   setNumCtorInitializers(0);
   setInheritingConstructor(static_cast<bool>(Inherited));
   setImplicit(isImplicitlyDeclared);
+  CXXConstructorDeclBits.HasTrailingExplicitSpecifier = ES.getExpr() ? 1 : 0;
   if (Inherited)
     *getTrailingObjects<InheritedConstructor>() = Inherited;
-  setExplicitSpecified(isExplicitSpecified);
+  setExplicitSpecifier(ES);
 }
 
 void CXXConstructorDecl::anchor() {}
 
 CXXConstructorDecl *CXXConstructorDecl::CreateDeserialized(ASTContext &C,
                                                            unsigned ID,
-                                                           bool Inherited) {
-  unsigned Extra = additionalSizeToAlloc<InheritedConstructor>(Inherited);
+                                                           uint64_t AllocKind) {
+  bool hasTraillingExplicit = static_cast<bool>(AllocKind & TAKHasTailExplicit);
+  bool isInheritingConstructor =
+      static_cast<bool>(AllocKind & TAKInheritsConstructor);
+  unsigned Extra =
+      additionalSizeToAlloc<InheritedConstructor, ExplicitSpecifier>(
+          isInheritingConstructor, hasTraillingExplicit);
   auto *Result = new (C, ID, Extra) CXXConstructorDecl(
       C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
-      false, false, false, false, InheritedConstructor());
-  Result->setInheritingConstructor(Inherited);
+      ExplicitSpecifier(), false, false, false, InheritedConstructor());
+  Result->setInheritingConstructor(isInheritingConstructor);
+  Result->CXXConstructorDeclBits.HasTrailingExplicitSpecifier =
+      hasTraillingExplicit;
+  Result->setExplicitSpecifier(ExplicitSpecifier());
   return Result;
 }
 
-CXXConstructorDecl *
-CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
-                           SourceLocation StartLoc,
-                           const DeclarationNameInfo &NameInfo,
-                           QualType T, TypeSourceInfo *TInfo,
-                           bool isExplicit, bool isInline,
-                           bool isImplicitlyDeclared, bool isConstexpr,
-                           InheritedConstructor Inherited) {
+CXXConstructorDecl *CXXConstructorDecl::Create(
+    ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
+    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+    ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared,
+    bool isConstexpr, InheritedConstructor Inherited) {
   assert(NameInfo.getName().getNameKind()
          == DeclarationName::CXXConstructorName &&
          "Name must refer to a constructor");
   unsigned Extra =
-      additionalSizeToAlloc<InheritedConstructor>(Inherited ? 1 : 0);
-  return new (C, RD, Extra) CXXConstructorDecl(
-      C, RD, StartLoc, NameInfo, T, TInfo, isExplicit, isInline,
+      additionalSizeToAlloc<InheritedConstructor, ExplicitSpecifier>(
+          Inherited ? 1 : 0, ES.getExpr() ? 1 : 0);
+  return new (C, RD, Extra)
+      CXXConstructorDecl(C, RD, StartLoc, NameInfo, T, TInfo, ES, isInline,
                          isImplicitlyDeclared, isConstexpr, Inherited);
 }
 
 CXXConstructorDecl::init_const_iterator CXXConstructorDecl::init_begin() const {
   return CtorInitializers.get(getASTContext().getExternalSource());
 }
 
 CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const {
   assert(isDelegatingConstructor() && "Not a delegating constructor!");
if (auto *L = getASTMutationListener())
       L->ResolvedOperatorDelete(First, OD, ThisArg);
   }
 }
 
 void CXXConversionDecl::anchor() {}
 
 CXXConversionDecl *
 CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) CXXConversionDecl(C, nullptr, SourceLocation(),
-                                       DeclarationNameInfo(), QualType(),
-                                       nullptr, false, false, false,
-                                       SourceLocation());
+  return new (C, ID) CXXConversionDecl(
+      C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
+      false, ExplicitSpecifier(), false, SourceLocation());
 }
 
-CXXConversionDecl *
-CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
-                          SourceLocation StartLoc,
-                          const DeclarationNameInfo &NameInfo,
-                          QualType T, TypeSourceInfo *TInfo,
-                          bool isInline, bool isExplicit,
-                          bool isConstexpr, SourceLocation EndLocation) {
+CXXConversionDecl *CXXConversionDecl::Create(
+    ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
+    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+    bool isInline, ExplicitSpecifier ES, bool isConstexpr,
+    SourceLocation EndLocation) {
   assert(NameInfo.getName().getNameKind()
          == DeclarationName::CXXConversionFunctionName &&
          "Name must refer to a conversion function");
   return new (C, RD) CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo,
-                                       isInline, isExplicit, isConstexpr,
-                                       EndLocation);
+                                       isInline, ES, isConstexpr, EndLocation);
 }
 
 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
   return isImplicit() && getParent()->isLambda() &&
          getConversionType()->isBlockPointerType();
 }
 
 LinkageSpecDecl::LinkageSpecDecl(DeclContext *DC, SourceLocation ExternLoc,

cfe/trunk/lib/AST/DeclPrinter.cpp

void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) {
   Out << *D;
   prettyPrintAttributes(D);
   if (Expr *Init = D->getInitExpr()) {
     Out << " = ";
     Init->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
   }
 }
 
+static void printExplicitSpecifier(ExplicitSpecifier ES, llvm::raw_ostream &Out,
+                                   PrintingPolicy &Policy,
+                                   unsigned Indentation) {
+  std::string Proto = "explicit";
+  llvm::raw_string_ostream EOut(Proto);
+  if (ES.getExpr()) {
+    EOut << "(";
+    ES.getExpr()->printPretty(EOut, nullptr, Policy, Indentation);
+    EOut << ")";
+  }
+  EOut << " ";
+  EOut.flush();
+  Out << EOut.str();
+}
+
 void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
   if (!D->getDescribedFunctionTemplate() &&
       !D->isFunctionTemplateSpecialization())
     prettyPrintPragmas(D);
 
   if (D->isFunctionTemplateSpecialization())
     Out << "template<> ";
   else if (!D->getDescribedFunctionTemplate()) {
if (!Policy.SuppressSpecifiers) {
     case SC_Auto: case SC_Register:
       llvm_unreachable("invalid for functions");
     }
 
     if (D->isInlineSpecified())  Out << "inline ";
     if (D->isVirtualAsWritten()) Out << "virtual ";
     if (D->isModulePrivate())    Out << "__module_private__ ";
     if (D->isConstexpr() && !D->isExplicitlyDefaulted()) Out << "constexpr ";
-    if ((CDecl && CDecl->isExplicitSpecified()) ||
-        (ConversionDecl && ConversionDecl->isExplicitSpecified()) ||
-        (GuideDecl && GuideDecl->isExplicitSpecified()))
-      Out << "explicit ";
+    ExplicitSpecifier ExplicitSpec = ExplicitSpecifier::getFromDecl(D);
+    if (ExplicitSpec.isSpecified())
+      printExplicitSpecifier(ExplicitSpec, Out, Policy, Indentation);
   }
 
   PrintingPolicy SubPolicy(Policy);
   SubPolicy.SuppressSpecifiers = false;
   std::string Proto;
 
   if (Policy.FullyQualifiedName) {
     Proto += D->getQualifiedNameAsString();

cfe/trunk/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.CPlusPlus17) {
     Builder.defineMacro("__cpp_nontype_template_parameter_auto", "201606L");
   }
   if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)
     Builder.defineMacro("__cpp_aligned_new", "201606L");
   if (LangOpts.RelaxedTemplateTemplateArgs)
     Builder.defineMacro("__cpp_template_template_args", "201611L");
 
   // C++20 features.
+  if (LangOpts.CPlusPlus2a)
+    Builder.defineMacro("__cpp_conditional_explicit", "201806L");
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "201811L");
   Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
 
   // TS features.
   if (LangOpts.ConceptsTS)
     Builder.defineMacro("__cpp_experimental_concepts", "1L");
   if (LangOpts.Coroutines)

cfe/trunk/lib/Parse/ParseDecl.cpp

void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS,
   }
 
   // Issue diagnostic and remove function specifier if present.
   if (Specs & DeclSpec::PQ_FunctionSpecifier) {
     if (DS.isInlineSpecified())
       Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
     if (DS.isVirtualSpecified())
       Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
-    if (DS.isExplicitSpecified())
+    if (DS.hasExplicitSpecifier())
       Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
     DS.ClearFunctionSpecs();
   }
 
-  // Issue diagnostic and remove constexpr specfier if present.
+  // Issue diagnostic and remove constexpr specifier if present.
   if (DS.isConstexprSpecified() && DSC != DeclSpecContext::DSC_condition) {
     Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr);
     DS.ClearConstexprSpec();
   }
 }
 
 /// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
 /// specified token is valid after the identifier in a declarator which
bool EnteringContext = (DSContext == DeclSpecContext::DSC_class ||
                           DSContext == DeclSpecContext::DSC_top_level);
   bool AttrsLastTime = false;
   ParsedAttributesWithRange attrs(AttrFactory);
   // We use Sema's policy to get bool macros right.
   PrintingPolicy Policy = Actions.getPrintingPolicy();
   while (1) {
     bool isInvalid = false;
     bool isStorageClass = false;
+    bool isAlreadyConsumed = false;
     const char *PrevSpec = nullptr;
     unsigned DiagID = 0;
 
+    // This value need to be set when isAlreadyConsumed is set to true.
+    SourceLocation RangeEnd;
+
     // HACK: MSVC doesn't consider _Atomic to be a keyword and its STL
     // implementation for VS2013 uses _Atomic as an identifier for one of the
     // classes in <atomic>.
     //
     // A typedef declaration containing _Atomic<...> is among the places where
     // the class is used.  If we are currently parsing such a declaration, treat
     // the token as an identifier.
     if (getLangOpts().MSVCCompat && Tok.is(tok::kw__Atomic) &&
case tok::kw_virtual:
         DiagID = diag::err_openclcxx_virtual_function;
         PrevSpec = Tok.getIdentifierInfo()->getNameStart();
         isInvalid = true;
       }
       else {
         isInvalid = DS.setFunctionSpecVirtual(Loc, PrevSpec, DiagID);
       }
       break;
-    case tok::kw_explicit:
-      isInvalid = DS.setFunctionSpecExplicit(Loc, PrevSpec, DiagID);
+    case tok::kw_explicit: {
+      SourceLocation ExplicitLoc = Loc;
+      SourceLocation CloseParenLoc;
+      ExplicitSpecifier ExplicitSpec(nullptr, ExplicitSpecKind::ResolvedTrue);
+      isAlreadyConsumed = true;
+      RangeEnd = ExplicitLoc;
+      ConsumeToken(); // kw_explicit
+      if (Tok.is(tok::l_paren)) {
+        if (getLangOpts().CPlusPlus2a) {
+          ExprResult ExplicitExpr(static_cast<Expr *>(nullptr));
+          BalancedDelimiterTracker Tracker(*this, tok::l_paren);
+          Tracker.consumeOpen();
+          ExplicitExpr = ParseConstantExpression();
+          RangeEnd = Tok.getLocation();
+          if (ExplicitExpr.isUsable()) {
+            CloseParenLoc = Tok.getLocation();
+            Tracker.consumeClose();
+            ExplicitSpec =
+                Actions.ActOnExplicitBoolSpecifier(ExplicitExpr.get());
+          } else
+            Tracker.skipToEnd();
+        } else
+          Diag(Tok.getLocation(), diag::warn_cxx2a_compat_explicit_bool);
+      }
+      isInvalid = DS.setFunctionSpecExplicit(ExplicitLoc, PrevSpec, DiagID,
+                                             ExplicitSpec, CloseParenLoc);
       break;
+    }
     case tok::kw__Noreturn:
       if (!getLangOpts().C11)
         Diag(Loc, diag::ext_c11_noreturn);
       isInvalid = DS.setFunctionSpecNoreturn(Loc, PrevSpec, DiagID);
       break;
 
     // alignment-specifier
     case tok::kw__Alignas:
case tok::less:
       } else {
         DS.SetTypeSpecError();
       }
 
       // Need to support trailing type qualifiers (e.g. "id<p> const").
       // If a type specifier follows, it will be diagnosed elsewhere.
       continue;
     }
+
+    assert(!isAlreadyConsumed || RangeEnd != SourceLocation() &&
+                                     "both or neither of isAlreadyConsumed and "
+                                     "RangeEnd needs to be set");
+    DS.SetRangeEnd(isAlreadyConsumed ? RangeEnd : Tok.getLocation());
+
     // If the specifier wasn't legal, issue a diagnostic.
     if (isInvalid) {
       assert(PrevSpec && "Method did not return previous specifier!");
       assert(DiagID);
 
       if (DiagID == diag::ext_duplicate_declspec ||
-          DiagID == diag::ext_warn_duplicate_declspec)
-        Diag(Tok, DiagID)
-          << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation());
+          DiagID == diag::ext_warn_duplicate_declspec ||
+          DiagID == diag::err_duplicate_declspec)
+        Diag(Loc, DiagID) << PrevSpec
+                          << FixItHint::CreateRemoval(
+                                 SourceRange(Loc, DS.getEndLoc()));
       else if (DiagID == diag::err_opencl_unknown_type_specifier) {
-        Diag(Tok, DiagID) << getLangOpts().OpenCLCPlusPlus
+        Diag(Loc, DiagID) << getLangOpts().OpenCLCPlusPlus
                           << getLangOpts().getOpenCLVersionTuple().getAsString()
                           << PrevSpec << isStorageClass;
       } else
-        Diag(Tok, DiagID) << PrevSpec;
+        Diag(Loc, DiagID) << PrevSpec;
     }
 
-    DS.SetRangeEnd(Tok.getLocation());
-    if (DiagID != diag::err_bool_redeclaration)
+    if (DiagID != diag::err_bool_redeclaration && !isAlreadyConsumed)
       // After an error the next token can be an annotation token.
       ConsumeAnyToken();
 
     AttrsLastTime = false;
   }
 }
 
 /// ParseStructDeclaration - Parse a struct declaration without the terminating

cfe/trunk/lib/Sema/DeclSpec.cpp

if (StorageClassSpec != SCS_unspecified ||
     Res |= PQ_StorageClassSpecifier;
 
   if (TypeQualifiers != TQ_unspecified)
     Res |= PQ_TypeQualifier;
 
   if (hasTypeSpecifier())
     Res |= PQ_TypeSpecifier;
 
-  if (FS_inline_specified || FS_virtual_specified || FS_explicit_specified ||
+  if (FS_inline_specified || FS_virtual_specified || hasExplicitSpecifier() ||
       FS_noreturn_specified || FS_forceinline_specified)
     Res |= PQ_FunctionSpecifier;
   return Res;
 }
 
 template <class T> static bool BadSpecifier(T TNew, T TPrev,
                                             const char *&PrevSpec,
                                             unsigned &DiagID,
if (FS_virtual_specified) {
     return true;
   }
   FS_virtual_specified = true;
   FS_virtualLoc = Loc;
   return false;
 }
 
 bool DeclSpec::setFunctionSpecExplicit(SourceLocation Loc,
-                                       const char *&PrevSpec,
-                                       unsigned &DiagID) {
+                                       const char *&PrevSpec, unsigned &DiagID,
+                                       ExplicitSpecifier ExplicitSpec,
+                                       SourceLocation CloseParenLoc) {
+  assert((ExplicitSpec.getKind() == ExplicitSpecKind::ResolvedTrue ||
+          ExplicitSpec.getExpr()) &&
+         "invalid ExplicitSpecifier");
   // 'explicit explicit' is ok, but warn as this is likely not what the user
   // intended.
-  if (FS_explicit_specified) {
-    DiagID = diag::warn_duplicate_declspec;
+  if (hasExplicitSpecifier()) {
+    DiagID = (ExplicitSpec.getExpr() || FS_explicit_specifier.getExpr())
+                 ? diag::err_duplicate_declspec
+                 : diag::ext_warn_duplicate_declspec;
     PrevSpec = "explicit";
     return true;
   }
-  FS_explicit_specified = true;
+  FS_explicit_specifier = ExplicitSpec;
   FS_explicitLoc = Loc;
+  FS_explicitCloseParenLoc = CloseParenLoc;
   return false;
 }
 
 bool DeclSpec::setFunctionSpecNoreturn(SourceLocation Loc,
                                        const char *&PrevSpec,
                                        unsigned &DiagID) {
   // '_Noreturn _Noreturn' is ok, but warn as this is likely not what the user
   // intended.
void DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {
 
   // C++11 [dcl.fct.spec]p5:
   //   The virtual specifier shall be used only in the initial
   //   declaration of a non-static class member function;
   // C++11 [dcl.fct.spec]p6:
   //   The explicit specifier shall be used only in the declaration of
   //   a constructor or conversion function within its class
   //   definition;
-  if (isFriendSpecified() && (isVirtualSpecified() || isExplicitSpecified())) {
+  if (isFriendSpecified() && (isVirtualSpecified() || hasExplicitSpecifier())) {
     StringRef Keyword;
+    FixItHint Hint;
     SourceLocation SCLoc;
 
     if (isVirtualSpecified()) {
       Keyword = "virtual";
       SCLoc = getVirtualSpecLoc();
+      Hint = FixItHint::CreateRemoval(SCLoc);
     } else {
       Keyword = "explicit";
       SCLoc = getExplicitSpecLoc();
+      Hint = FixItHint::CreateRemoval(getExplicitSpecRange());
     }
 
-    FixItHint Hint = FixItHint::CreateRemoval(SCLoc);
     S.Diag(SCLoc, diag::err_friend_decl_spec)
       << Keyword << Hint;
 
-    FS_virtual_specified = FS_explicit_specified = false;
+    FS_virtual_specified = false;
+    FS_explicit_specifier = ExplicitSpecifier();
     FS_virtualLoc = FS_explicitLoc = SourceLocation();
   }
 
   assert(!TypeSpecOwned || isDeclRep((TST) TypeSpecType));
 
   // Okay, now we can infer the real type.
 
   // TODO: return "auto function" and other bad things based on the real type.

cfe/trunk/lib/Sema/SemaCodeComplete.cpp

QualType Sema::ProduceConstructorSignatureHelp(Scope *S, QualType Type,
 
   OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
 
   for (NamedDecl *C : LookupConstructors(RD)) {
     if (auto *FD = dyn_cast<FunctionDecl>(C)) {
       AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args,
                            CandidateSet,
                            /*SuppressUsedConversions=*/false,
-                           /*PartialOverloading=*/true);
+                           /*PartialOverloading=*/true,
+                           /*AllowExplicit*/ true);
     } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
       AddTemplateOverloadCandidate(
           FTD, DeclAccessPair::make(FTD, C->getAccess()),
           /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
           /*SuppressUsedConversions=*/false,
           /*PartialOverloading=*/true);
     }
   }

cfe/trunk/lib/Sema/SemaDecl.cpp

 /// does not identify a function.
 void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) {
   // FIXME: We should probably indicate the identifier in question to avoid
   // confusion for constructs like "virtual int a(), b;"
   if (DS.isVirtualSpecified())
     Diag(DS.getVirtualSpecLoc(),
          diag::err_virtual_non_function);
 
-  if (DS.isExplicitSpecified())
+  if (DS.hasExplicitSpecifier())
     Diag(DS.getExplicitSpecLoc(),
          diag::err_explicit_non_function);
 
   if (DS.isNoreturnSpecified())
     Diag(DS.getNoreturnSpecLoc(),
          diag::err_noreturn_non_function);
 }
 
if (!SemaRef.getLangOpts().CPlusPlus) {
     NewFD = FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), NameInfo,
                                  R, TInfo, SC, isInline, HasPrototype, false);
     if (D.isInvalidType())
       NewFD->setInvalidDecl();
 
     return NewFD;
   }
 
-  bool isExplicit = D.getDeclSpec().isExplicitSpecified();
+  ExplicitSpecifier ExplicitSpecifier = D.getDeclSpec().getExplicitSpecifier();
   bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
 
   // Check that the return type is not an abstract class type.
   // For record types, this is done by the AbstractClassUsageDiagnoser once
   // the class has been completely parsed.
   if (!DC->isRecord() &&
       SemaRef.RequireNonAbstractType(
           D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
           diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
     D.setInvalidType();
 
   if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
     // This is a C++ constructor declaration.
     assert(DC->isRecord() &&
            "Constructors can only be declared in a member context");
 
     R = SemaRef.CheckConstructorDeclarator(D, R, SC);
     return CXXConstructorDecl::Create(
         SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
-        TInfo, isExplicit, isInline,
+        TInfo, ExplicitSpecifier, isInline,
         /*isImplicitlyDeclared=*/false, isConstexpr);
 
   } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
     // This is a C++ destructor declaration.
     if (DC->isRecord()) {
       R = SemaRef.CheckDestructorDeclarator(D, R, SC);
       CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
       CXXDestructorDecl *NewDD =
if (!DC->isRecord()) {
            diag::err_conv_function_not_member);
       return nullptr;
     }
 
     SemaRef.CheckConversionDeclarator(D, R, SC);
     IsVirtualOkay = true;
     return CXXConversionDecl::Create(
         SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
-        TInfo, isInline, isExplicit, isConstexpr, SourceLocation());
+        TInfo, isInline, ExplicitSpecifier, isConstexpr, SourceLocation());
 
   } else if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
     SemaRef.CheckDeductionGuideDeclarator(D, R, SC);
 
     return CXXDeductionGuideDecl::Create(SemaRef.Context, DC, D.getBeginLoc(),
-                                         isExplicit, NameInfo, R, TInfo,
+                                         ExplicitSpecifier, NameInfo, R, TInfo,
                                          D.getEndLoc());
   } else if (DC->isRecord()) {
     // If the name of the function is the same as the name of the record,
     // then this must be an invalid constructor that has a return type.
     // (The parser checks for a return type and makes the declarator a
     // constructor if it has no return type).
     if (Name.getAsIdentifierInfo() &&
         Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   NewFD->setLexicalDeclContext(CurContext);
 
   if (IsLocalExternDecl)
     NewFD->setLocalExternDecl();
 
   if (getLangOpts().CPlusPlus) {
     bool isInline = D.getDeclSpec().isInlineSpecified();
     bool isVirtual = D.getDeclSpec().isVirtualSpecified();
-    bool isExplicit = D.getDeclSpec().isExplicitSpecified();
+    bool hasExplicit = D.getDeclSpec().hasExplicitSpecifier();
     bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
     isFriend = D.getDeclSpec().isFriendSpecified();
     if (isFriend && !isInline && D.isFunctionDefinition()) {
       // C++ [class.friend]p5
       //   A function can be defined in a friend declaration of a
       //   class . . . . Such a function is implicitly inline.
       NewFD->setImplicitlyInline();
     }
if (isInline && !NewFD->isInvalidDecl()) {
           << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
       }
     }
 
     // C++ [dcl.fct.spec]p6:
     //  The explicit specifier shall be used only in the declaration of a
     //  constructor or conversion function within its class definition;
     //  see 12.3.1 and 12.3.2.
-    if (isExplicit && !NewFD->isInvalidDecl() &&
+    if (hasExplicit && !NewFD->isInvalidDecl() &&
         !isa<CXXDeductionGuideDecl>(NewFD)) {
       if (!CurContext->isRecord()) {
         // 'explicit' was specified outside of the class.
         Diag(D.getDeclSpec().getExplicitSpecLoc(),
              diag::err_explicit_out_of_class)
-          << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
+            << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecRange());
       } else if (!isa<CXXConstructorDecl>(NewFD) &&
                  !isa<CXXConversionDecl>(NewFD)) {
         // 'explicit' was specified on a function that wasn't a constructor
         // or conversion function.
         Diag(D.getDeclSpec().getExplicitSpecLoc(),
              diag::err_explicit_non_ctor_or_conv_function)
-          << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
+            << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecRange());
       }
     }
 
     if (isConstexpr) {
       // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
       // are implicitly inline.
       NewFD->setImplicitlyInline();
 

cfe/trunk/lib/Sema/SemaDeclCXX.cpp

if (New->isConstexpr() != Old->isConstexpr()) {
     // C++11 [dcl.fcn.spec]p4:
     //   If the definition of a function appears in a translation unit before its
     //   first declaration as inline, the program is ill-formed.
     Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
     Diag(Def->getLocation(), diag::note_previous_definition);
     Invalid = true;
   }
 
-  // FIXME: It's not clear what should happen if multiple declarations of a
-  // deduction guide have different explicitness. For now at least we simply
-  // reject any case where the explicitness changes.
-  auto *NewGuide = dyn_cast<CXXDeductionGuideDecl>(New);
-  if (NewGuide && NewGuide->isExplicitSpecified() !=
-                      cast<CXXDeductionGuideDecl>(Old)->isExplicitSpecified()) {
-    Diag(New->getLocation(), diag::err_deduction_guide_explicit_mismatch)
-      << NewGuide->isExplicitSpecified();
+  // C++17 [temp.deduct.guide]p3:
+  //   Two deduction guide declarations in the same translation unit
+  //   for the same class template shall not have equivalent
+  //   parameter-declaration-clauses.
+  if (isa<CXXDeductionGuideDecl>(New) &&
+      !New->isFunctionTemplateSpecialization()) {
+    Diag(New->getLocation(), diag::err_deduction_guide_redeclared);
     Diag(Old->getLocation(), diag::note_previous_declaration);
   }
 
   // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
   // argument expression, that declaration shall be a definition and shall be
   // the only declaration of the function or function template in the
   // translation unit.
   if (Old->getFriendObjectKind() == Decl::FOK_Undeclared &&
void Sema::CheckConversionDeclarator(Declarator &D, QualType &R,
 
   // Rebuild the function type "R" without any parameters (in case any
   // of the errors above fired) and with the conversion type as the
   // return type.
   if (D.isInvalidType())
     R = Context.getFunctionType(ConvType, None, Proto->getExtProtoInfo());
 
   // C++0x explicit conversion operators.
-  if (DS.isExplicitSpecified())
+  if (DS.hasExplicitSpecifier() && !getLangOpts().CPlusPlus2a)
     Diag(DS.getExplicitSpecLoc(),
          getLangOpts().CPlusPlus11
              ? diag::warn_cxx98_compat_explicit_conversion_functions
              : diag::ext_explicit_conversion_functions)
-        << SourceRange(DS.getExplicitSpecLoc());
+        << SourceRange(DS.getExplicitSpecRange());
 }
 
 /// ActOnConversionDeclarator - Called by ActOnDeclarator to complete
 /// the declaration of the given C++ conversion function. This routine
 /// is responsible for recording the conversion function in the C++
 /// class, if possible.
 Decl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {
   assert(Conversion && "Expected to receive a conversion function declaration");
ComputingExceptionSpec(Sema &S, CXXMethodDecl *MD, SourceLocation Loc)
     S.pushCodeSynthesisContext(Ctx);
   }
   ~ComputingExceptionSpec() {
     S.popCodeSynthesisContext();
   }
 };
 }
 
+bool Sema::tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec) {
+  llvm::APSInt Result;
+  ExprResult Converted = CheckConvertedConstantExpression(
+      ExplicitSpec.getExpr(), Context.BoolTy, Result, CCEK_ExplicitBool);
+  ExplicitSpec.setExpr(Converted.get());
+  if (Converted.isUsable() && !Converted.get()->isValueDependent()) {
+    ExplicitSpec.setKind(Result.getBoolValue()
+                             ? ExplicitSpecKind::ResolvedTrue
+                             : ExplicitSpecKind::ResolvedFalse);
+    return true;
+  }
+  ExplicitSpec.setKind(ExplicitSpecKind::Unresolved);
+  return false;
+}
+
+ExplicitSpecifier Sema::ActOnExplicitBoolSpecifier(Expr *ExplicitExpr) {
+  ExplicitSpecifier ES(ExplicitExpr, ExplicitSpecKind::Unresolved);
+  if (!ExplicitExpr->isTypeDependent())
+    tryResolveExplicitSpecifier(ES);
+  return ES;
+}
+
 static Sema::ImplicitExceptionSpecification
 ComputeDefaultedSpecialMemberExceptionSpec(
     Sema &S, SourceLocation Loc, CXXMethodDecl *MD, Sema::CXXSpecialMember CSM,
     Sema::InheritedConstructorInfo *ICI) {
   ComputingExceptionSpec CES(S, MD, Loc);
 
   CXXRecordDecl *ClassDecl = MD->getParent();
 
CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
   // Create the actual constructor declaration.
   CanQualType ClassType
     = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationName Name
     = Context.DeclarationNames.getCXXConstructorName(ClassType);
   DeclarationNameInfo NameInfo(Name, ClassLoc);
   CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create(
-      Context, ClassDecl, ClassLoc, NameInfo, /*Type*/QualType(),
-      /*TInfo=*/nullptr, /*isExplicit=*/false, /*isInline=*/true,
-      /*isImplicitlyDeclared=*/true, Constexpr);
+      Context, ClassDecl, ClassLoc, NameInfo, /*Type*/ QualType(),
+      /*TInfo=*/nullptr, ExplicitSpecifier(),
+      /*isInline=*/true, /*isImplicitlyDeclared=*/true, Constexpr);
   DefaultCon->setAccess(AS_public);
   DefaultCon->setDefaulted();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDefaultConstructor,
                                             DefaultCon,
                                             /* ConstRHS */ false,
                                             /* Diagnose */ false);
Sema::findInheritingConstructor(SourceLocation Loc,
 
   bool Constexpr =
       BaseCtor->isConstexpr() &&
       defaultedSpecialMemberIsConstexpr(*this, Derived, CXXDefaultConstructor,
                                         false, BaseCtor, &ICI);
 
   CXXConstructorDecl *DerivedCtor = CXXConstructorDecl::Create(
       Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
-      BaseCtor->isExplicit(), /*Inline=*/true,
+      BaseCtor->getExplicitSpecifier(), /*Inline=*/true,
       /*ImplicitlyDeclared=*/true, Constexpr,
       InheritedConstructor(Shadow, BaseCtor));
   if (Shadow->isInvalidDecl())
     DerivedCtor->setInvalidDecl();
 
   // Build an unevaluated exception specification for this fake constructor.
   const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
   FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
= Context.DeclarationNames.getCXXConstructorName(
                                            Context.getCanonicalType(ClassType));
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
 
   //   An implicitly-declared copy constructor is an inline public
   //   member of its class.
   CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
       Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
-      /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
-      Constexpr);
+      ExplicitSpecifier(),
+      /*isInline=*/true,
+      /*isImplicitlyDeclared=*/true, Constexpr);
   CopyConstructor->setAccess(AS_public);
   CopyConstructor->setDefaulted();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
                                             CopyConstructor,
                                             /* ConstRHS */ Const,
                                             /* Diagnose */ false);
CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
 
   // C++11 [class.copy]p11:
   //   An implicitly-declared copy/move constructor is an inline public
   //   member of its class.
   CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create(
       Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
-      /*isExplicit=*/false, /*isInline=*/true, /*isImplicitlyDeclared=*/true,
-      Constexpr);
+      ExplicitSpecifier(),
+      /*isInline=*/true,
+      /*isImplicitlyDeclared=*/true, Constexpr);
   MoveConstructor->setAccess(AS_public);
   MoveConstructor->setDefaulted();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
                                             MoveConstructor,
                                             /* ConstRHS */ false,
                                             /* Diagnose */ false);

cfe/trunk/lib/Sema/SemaInit.cpp

for (NamedDecl *D : Ctors) {
     //     is to X or reference to (possibly cv-qualified X),
     //   user-defined conversion sequences are not considered.
     bool SuppressUserConversions =
         SecondStepOfCopyInit ||
         (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
          hasCopyOrMoveCtorParam(S.Context, Info));
 
     if (Info.ConstructorTmpl)
-      S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
-                                     /*ExplicitArgs*/ nullptr, Args,
-                                     CandidateSet, SuppressUserConversions);
+      S.AddTemplateOverloadCandidate(
+          Info.ConstructorTmpl, Info.FoundDecl,
+          /*ExplicitArgs*/ nullptr, Args, CandidateSet, SuppressUserConversions,
+          /*PartialOverloading=*/false, AllowExplicit);
     else {
       // C++ [over.match.copy]p1:
       //   - When initializing a temporary to be bound to the first parameter
       //     of a constructor [for type T] that takes a reference to possibly
       //     cv-qualified T as its first argument, called with a single
       //     argument in the context of direct-initialization, explicit
       //     conversion functions are also considered.
       // FIXME: What if a constructor template instantiates to such a signature?
       bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
                                Args.size() == 1 &&
                                hasCopyOrMoveCtorParam(S.Context, Info);
       S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, Args,
                              CandidateSet, SuppressUserConversions,
-                             /*PartialOverloading=*/false,
-                             /*AllowExplicit=*/AllowExplicitConv);
+                             /*PartialOverloading=*/false, AllowExplicit,
+                             AllowExplicitConv);
     }
   }
 
   // FIXME: Work around a bug in C++17 guaranteed copy elision.
   //
   // When initializing an object of class type T by constructor
   // ([over.match.ctor]) or by list-initialization ([over.match.list])
   // from a single expression of class type U, conversion functions of
if (SourceRD && S.isCompleteType(DeclLoc, Initializer->getType())) {
 
         FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
         CXXConversionDecl *Conv;
         if (ConvTemplate)
           Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
         else
           Conv = cast<CXXConversionDecl>(D);
 
-        if ((AllowExplicit && !CopyInitializing) || !Conv->isExplicit()) {
+        if (AllowExplicit || !Conv->isExplicit()) {
           if (ConvTemplate)
-            S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
-                                             ActingDC, Initializer, DestType,
-                                             CandidateSet, AllowExplicit,
-                                             /*AllowResultConversion*/false);
+            S.AddTemplateConversionCandidate(
+                ConvTemplate, I.getPair(), ActingDC, Initializer, DestType,
+                CandidateSet, AllowExplicit, AllowExplicit,
+                /*AllowResultConversion*/ false);
           else
             S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Initializer,
                                      DestType, CandidateSet, AllowExplicit,
-                                     /*AllowResultConversion*/false);
+                                     AllowExplicit,
+                                     /*AllowResultConversion*/ false);
         }
       }
     }
   }
 
   // Perform overload resolution and return the result.
   return CandidateSet.BestViableFunction(S, DeclLoc, Best);
 }
if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
     for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
       auto Info = getConstructorInfo(D);
       if (!Info.Constructor)
         continue;
 
       if (!Info.Constructor->isInvalidDecl() &&
           Info.Constructor->isConvertingConstructor(AllowExplicitCtors)) {
         if (Info.ConstructorTmpl)
-          S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
-                                         /*ExplicitArgs*/ nullptr,
-                                         Initializer, CandidateSet,
-                                         /*SuppressUserConversions=*/true);
-        else
-          S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
-                                 Initializer, CandidateSet,
-                                 /*SuppressUserConversions=*/true);
+          S.AddTemplateOverloadCandidate(
+              Info.ConstructorTmpl, Info.FoundDecl,
+              /*ExplicitArgs*/ nullptr, Initializer, CandidateSet,
+              /*SuppressUserConversions=*/true,
+              /*PartialOverloading*/ false, AllowExplicitCtors);
+        else
+          S.AddOverloadCandidate(
+              Info.Constructor, Info.FoundDecl, Initializer, CandidateSet,
+              /*SuppressUserConversions=*/true,
+              /*PartialOverloading*/ false, AllowExplicitCtors);
       }
     }
   }
   if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
     return OR_No_Viable_Function;
 
   const RecordType *T2RecordType = nullptr;
   if ((T2RecordType = T2->getAs<RecordType>()) &&
for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
 
       // If the conversion function doesn't return a reference type,
       // it can't be considered for this conversion unless we're allowed to
       // consider rvalues.
       // FIXME: Do we need to make sure that we only consider conversion
       // candidates with reference-compatible results? That might be needed to
       // break recursion.
       if ((AllowExplicitConvs || !Conv->isExplicit()) &&
-          (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
+          (AllowRValues ||
+           Conv->getConversionType()->isLValueReferenceType())) {
         if (ConvTemplate)
-          S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
-                                           ActingDC, Initializer,
-                                           DestType, CandidateSet,
-                                           /*AllowObjCConversionOnExplicit=*/
-                                             false);
-        else
-          S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
-                                   Initializer, DestType, CandidateSet,
-                                   /*AllowObjCConversionOnExplicit=*/false);
+          S.AddTemplateConversionCandidate(
+              ConvTemplate, I.getPair(), ActingDC, Initializer, DestType,
+              CandidateSet,
+              /*AllowObjCConversionOnExplicit=*/false, AllowExplicitConvs);
+        else
+          S.AddConversionCandidate(
+              Conv, I.getPair(), ActingDC, Initializer, DestType, CandidateSet,
+              /*AllowObjCConversionOnExplicit=*/false, AllowExplicitConvs);
       }
     }
   }
   if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
     return OR_No_Viable_Function;
 
   SourceLocation DeclLoc = Initializer->getBeginLoc();
 
if (S.isCompleteType(Kind.getLocation(), DestType)) {
       for (NamedDecl *D : S.LookupConstructors(DestRecordDecl)) {
         auto Info = getConstructorInfo(D);
         if (!Info.Constructor)
           continue;
 
         if (!Info.Constructor->isInvalidDecl() &&
             Info.Constructor->isConvertingConstructor(AllowExplicit)) {
           if (Info.ConstructorTmpl)
-            S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
-                                           /*ExplicitArgs*/ nullptr,
-                                           Initializer, CandidateSet,
-                                           /*SuppressUserConversions=*/true);
+            S.AddTemplateOverloadCandidate(
+                Info.ConstructorTmpl, Info.FoundDecl,
+                /*ExplicitArgs*/ nullptr, Initializer, CandidateSet,
+                /*SuppressUserConversions=*/true,
+                /*PartialOverloading*/ false, AllowExplicit);
           else
             S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
                                    Initializer, CandidateSet,
-                                   /*SuppressUserConversions=*/true);
+                                   /*SuppressUserConversions=*/true,
+                                   /*PartialOverloading*/ false, AllowExplicit);
         }
       }
     }
   }
 
   SourceLocation DeclLoc = Initializer->getBeginLoc();
 
   if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
if (S.isCompleteType(DeclLoc, SourceType)) {
         CXXConversionDecl *Conv;
         if (ConvTemplate)
           Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
         else
           Conv = cast<CXXConversionDecl>(D);
 
         if (AllowExplicit || !Conv->isExplicit()) {
           if (ConvTemplate)
-            S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
-                                             ActingDC, Initializer, DestType,
-                                             CandidateSet, AllowExplicit);
+            S.AddTemplateConversionCandidate(
+                ConvTemplate, I.getPair(), ActingDC, Initializer, DestType,
+                CandidateSet, AllowExplicit, AllowExplicit);
           else
-            S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
-                                     Initializer, DestType, CandidateSet,
+            S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Initializer,
+                                     DestType, CandidateSet, AllowExplicit,
                                      AllowExplicit);
         }
       }
     }
   }
 
   // Perform overload resolution. If it fails, return the failed result.
   OverloadCandidateSet::iterator Best;
QualType Sema::DeduceTemplateSpecializationFromInitializer(
   //
   // Since we know we're initializing a class type of a type unrelated to that
   // of the initializer, this reduces to something fairly reasonable.
   OverloadCandidateSet Candidates(Kind.getLocation(),
                                   OverloadCandidateSet::CSK_Normal);
   OverloadCandidateSet::iterator Best;
 
   bool HasAnyDeductionGuide = false;
+  bool AllowExplicit = !Kind.isCopyInit() || ListInit;
 
   auto tryToResolveOverload =
       [&](bool OnlyListConstructors) -> OverloadingResult {
     Candidates.clear(OverloadCandidateSet::CSK_Normal);
     HasAnyDeductionGuide = false;
 
     for (auto I = Guides.begin(), E = Guides.end(); I != E; ++I) {
       NamedDecl *D = (*I)->getUnderlyingDecl();
for (auto I = Guides.begin(), E = Guides.end(); I != E; ++I) {
       if (!GD->isImplicit())
         HasAnyDeductionGuide = true;
 
       // C++ [over.match.ctor]p1: (non-list copy-initialization from non-class)
       //   For copy-initialization, the candidate functions are all the
       //   converting constructors (12.3.1) of that class.
       // C++ [over.match.copy]p1: (non-list copy-initialization from class)
       //   The converting constructors of T are candidate functions.
-      if (Kind.isCopyInit() && !ListInit) {
+      if (!AllowExplicit) {
         // Only consider converting constructors.
         if (GD->isExplicit())
           continue;
 
         // When looking for a converting constructor, deduction guides that
         // could never be called with one argument are not interesting to
         // check or note.
         if (GD->getMinRequiredArguments() > 1 ||
for (auto I = Guides.begin(), E = Guides.end(); I != E; ++I) {
       //    - [over.match.copy] (in all cases)
       // FIXME: The "second phase of [over.match.list] case can also
       // theoretically happen here, but it's not clear whether we can
       // ever have a parameter of the right type.
       bool SuppressUserConversions = Kind.isCopyInit();
 
       if (TD)
         AddTemplateOverloadCandidate(TD, I.getPair(), /*ExplicitArgs*/ nullptr,
-                                     Inits, Candidates,
-                                     SuppressUserConversions);
+                                     Inits, Candidates, SuppressUserConversions,
+                                     /*PartialOverloading*/ false,
+                                     AllowExplicit);
       else
         AddOverloadCandidate(GD, I.getPair(), Inits, Candidates,
-                             SuppressUserConversions);
+                             SuppressUserConversions,
+                             /*PartialOverloading*/ false, AllowExplicit);
     }
     return Candidates.BestViableFunction(*this, Kind.getLocation(), Best);
   };
 
   OverloadingResult Result = OR_No_Viable_Function;
 
   // C++11 [over.match.list]p1, per DR1467: for list-initialization, first
   // try initializer-list constructors.

cfe/trunk/lib/Sema/SemaLambda.cpp

InvokerParams.push_back(ParmVarDecl::Create(
         /*DefaultArg=*/nullptr));
     CallOpConvTL.setParam(I, From);
     CallOpConvNameTL.setParam(I, From);
   }
 
   CXXConversionDecl *Conversion = CXXConversionDecl::Create(
       S.Context, Class, Loc,
       DeclarationNameInfo(ConversionName, Loc, ConvNameLoc), ConvTy, ConvTSI,
-      /*isInline=*/true, /*isExplicit=*/false,
+      /*isInline=*/true, ExplicitSpecifier(),
       /*isConstexpr=*/S.getLangOpts().CPlusPlus17,
       CallOperator->getBody()->getEndLoc());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
 
   if (Class->isGenericLambda()) {
     // Create a template version of the conversion operator, using the template
     // parameter list of the function call operator.
static void addBlockPointerConversion(Sema &S,
   DeclarationName Name
     = S.Context.DeclarationNames.getCXXConversionFunctionName(
         S.Context.getCanonicalType(BlockPtrTy));
   DeclarationNameLoc NameLoc;
   NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc);
   CXXConversionDecl *Conversion = CXXConversionDecl::Create(
       S.Context, Class, Loc, DeclarationNameInfo(Name, Loc, NameLoc), ConvTy,
       S.Context.getTrivialTypeSourceInfo(ConvTy, Loc),
-      /*isInline=*/true, /*isExplicit=*/false,
+      /*isInline=*/true, ExplicitSpecifier(),
       /*isConstexpr=*/false, CallOperator->getBody()->getEndLoc());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
   Class->addDecl(Conversion);
 }
 
 static ExprResult performLambdaVarCaptureInitialization(
     Sema &S, const Capture &Capture, FieldDecl *Field,

cfe/trunk/lib/Sema/SemaLookup.cpp

for (NamedDecl *CandDecl : Candidates) {
     DeclAccessPair Cand = DeclAccessPair::make(CandDecl, AS_public);
     auto CtorInfo = getConstructorInfo(Cand);
     if (CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(Cand->getUnderlyingDecl())) {
       if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
         AddMethodCandidate(M, Cand, RD, ThisTy, Classification,
                            llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
       else if (CtorInfo)
         AddOverloadCandidate(CtorInfo.Constructor, CtorInfo.FoundDecl,
-                             llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
+                             llvm::makeArrayRef(&Arg, NumArgs), OCS,
+                             /*SuppressUserConversions*/ true);
       else
         AddOverloadCandidate(M, Cand, llvm::makeArrayRef(&Arg, NumArgs), OCS,
-                             true);
+                             /*SuppressUserConversions*/ true);
     } else if (FunctionTemplateDecl *Tmpl =
                  dyn_cast<FunctionTemplateDecl>(Cand->getUnderlyingDecl())) {
       if (SM == CXXCopyAssignment || SM == CXXMoveAssignment)
         AddMethodTemplateCandidate(
             Tmpl, Cand, RD, nullptr, ThisTy, Classification,
             llvm::makeArrayRef(&Arg, NumArgs), OCS, true);
       else if (CtorInfo)
         AddTemplateOverloadCandidate(

cfe/trunk/lib/Sema/SemaOverload.cpp

for (auto *D : S.LookupConstructors(To)) {
     if (Usable) {
       // If the first argument is (a reference to) the target type,
       // suppress conversions.
       bool SuppressUserConversions = isFirstArgumentCompatibleWithType(
           S.Context, Info.Constructor, ToType);
       if (Info.ConstructorTmpl)
         S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
                                        /*ExplicitArgs*/ nullptr, From,
-                                       CandidateSet, SuppressUserConversions);
+                                       CandidateSet, SuppressUserConversions,
+                                       /*PartialOverloading*/ false,
+                                       AllowExplicit);
       else
         S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
-                               CandidateSet, SuppressUserConversions);
+                               CandidateSet, SuppressUserConversions,
+                               /*PartialOverloading*/ false, AllowExplicit);
     }
   }
 
   bool HadMultipleCandidates = (CandidateSet.size() > 1);
 
   OverloadCandidateSet::iterator Best;
   switch (auto Result =
               CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
if (!S.isCompleteType(From->getExprLoc(), ToType)) {
               SuppressUserConversions = isFirstArgumentCompatibleWithType(
                   S.Context, Info.Constructor, ToType);
             }
           }
           if (Info.ConstructorTmpl)
             S.AddTemplateOverloadCandidate(
                 Info.ConstructorTmpl, Info.FoundDecl,
                 /*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs),
-                CandidateSet, SuppressUserConversions);
+                CandidateSet, SuppressUserConversions,
+                /*PartialOverloading*/ false, AllowExplicit);
           else
             // Allow one user-defined conversion when user specifies a
             // From->ToType conversion via an static cast (c-style, etc).
             S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
                                    llvm::makeArrayRef(Args, NumArgs),
-                                   CandidateSet, SuppressUserConversions);
+                                   CandidateSet, SuppressUserConversions,
+                                   /*PartialOverloading*/ false, AllowExplicit);
         }
       }
     }
   }
 
   // Enumerate conversion functions, if we're allowed to.
   if (ConstructorsOnly || isa<InitListExpr>(From)) {
   } else if (!S.isCompleteType(From->getBeginLoc(), From->getType())) {
if (CXXRecordDecl *FromRecordDecl
         FunctionTemplateDecl *ConvTemplate;
         if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
           Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
         else
           Conv = cast<CXXConversionDecl>(D);
 
         if (AllowExplicit || !Conv->isExplicit()) {
           if (ConvTemplate)
-            S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl,
-                                             ActingContext, From, ToType,
-                                             CandidateSet,
-                                             AllowObjCConversionOnExplicit);
-          else
-            S.AddConversionCandidate(Conv, FoundDecl, ActingContext,
-                                     From, ToType, CandidateSet,
-                                     AllowObjCConversionOnExplicit);
+            S.AddTemplateConversionCandidate(
+                ConvTemplate, FoundDecl, ActingContext, From, ToType,
+                CandidateSet, AllowObjCConversionOnExplicit, AllowExplicit);
+          else
+            S.AddConversionCandidate(
+                Conv, FoundDecl, ActingContext, From, ToType, CandidateSet,
+                AllowObjCConversionOnExplicit, AllowExplicit);
         }
       }
     }
   }
 
   bool HadMultipleCandidates = (CandidateSet.size() > 1);
 
   OverloadCandidateSet::iterator Best;
if (AllowRvalues) {
         Conv->getConversionType()->getAs<ReferenceType>();
       if (!RefType ||
           (!RefType->isLValueReferenceType() &&
            !RefType->getPointeeType()->isFunctionType()))
         continue;
     }
 
     if (ConvTemplate)
-      S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC,
-                                       Init, DeclType, CandidateSet,
-                                       /*AllowObjCConversionOnExplicit=*/false);
-    else
-      S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init,
-                               DeclType, CandidateSet,
-                               /*AllowObjCConversionOnExplicit=*/false);
+      S.AddTemplateConversionCandidate(
+          ConvTemplate, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
+          /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
+    else
+      S.AddConversionCandidate(
+          Conv, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
+          /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
   }
 
   bool HadMultipleCandidates = (CandidateSet.size() > 1);
 
   OverloadCandidateSet::iterator Best;
   switch (CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
   case OR_Success:
     // C++ [over.ics.ref]p1:
static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
   //  implicitly converted to type T, where the converted
   //  expression is a constant expression and the implicit conversion
   //  sequence contains only [... list of conversions ...].
   // C++1z [stmt.if]p2:
   //  If the if statement is of the form if constexpr, the value of the
   //  condition shall be a contextually converted constant expression of type
   //  bool.
   ImplicitConversionSequence ICS =
-      CCE == Sema::CCEK_ConstexprIf
+      CCE == Sema::CCEK_ConstexprIf || CCE == Sema::CCEK_ExplicitBool
           ? TryContextuallyConvertToBool(S, From)
           : TryCopyInitialization(S, From, T,
                                   /*SuppressUserConversions=*/false,
                                   /*InOverloadResolution=*/false,
                                   /*AllowObjcWritebackConversion=*/false,
                                   /*AllowExplicit=*/false);
   StandardConversionSequence *SCS = nullptr;
   switch (ICS.getKind()) {
for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
     FunctionTemplateDecl *ConvTemplate;
     if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
       Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
     else
       Conv = cast<CXXConversionDecl>(D);
 
     if (ConvTemplate)
       SemaRef.AddTemplateConversionCandidate(
           ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
-        /*AllowObjCConversionOnExplicit=*/false);
+          /*AllowObjCConversionOnExplicit=*/false, /*AllowExplicit*/ true);
     else
       SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From,
                                      ToType, CandidateSet,
-                                     /*AllowObjCConversionOnExplicit=*/false);
+                                     /*AllowObjCConversionOnExplicit=*/false,
+                                     /*AllowExplicit*/ true);
   }
 }
 
 /// Attempt to convert the given expression to a type which is accepted
 /// by the given converter.
 ///
 /// This routine will attempt to convert an expression of class type to a
 /// type accepted by the specified converter. In C++11 and before, the class

 /// AddOverloadCandidate - Adds the given function to the set of
 /// candidate functions, using the given function call arguments.  If
 /// @p SuppressUserConversions, then don't allow user-defined
 /// conversions via constructors or conversion operators.
 ///
 /// \param PartialOverloading true if we are performing "partial" overloading
 /// based on an incomplete set of function arguments. This feature is used by
 /// code completion.
-void Sema::AddOverloadCandidate(FunctionDecl *Function,
-                                DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
-                                OverloadCandidateSet &CandidateSet,
-                                bool SuppressUserConversions,
-                                bool PartialOverloading, bool AllowExplicit,
-                                ADLCallKind IsADLCandidate,
-                                ConversionSequenceList EarlyConversions) {
+void Sema::AddOverloadCandidate(
+    FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
+    OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+    bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
+    ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions) {
   const FunctionProtoType *Proto
     = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
   assert(Proto && "Functions without a prototype cannot be overloaded");
   assert(!Function->getDescribedFunctionTemplate() &&
          "Use AddTemplateOverloadCandidate for function templates");
 
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
     if (!isa<CXXConstructorDecl>(Method)) {
if (Candidate.Conversions[ArgIdx].isInitialized()) {
       // We already formed a conversion sequence for this parameter during
       // template argument deduction.
     } else if (ArgIdx < NumParams) {
       // (C++ 13.3.2p3): for F to be a viable function, there shall
       // exist for each argument an implicit conversion sequence
       // (13.3.3.1) that converts that argument to the corresponding
       // parameter of F.
       QualType ParamType = Proto->getParamType(ArgIdx);
-      Candidate.Conversions[ArgIdx]
-        = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
-                                SuppressUserConversions,
-                                /*InOverloadResolution=*/true,
-                                /*AllowObjCWritebackConversion=*/
-                                  getLangOpts().ObjCAutoRefCount,
-                                AllowExplicit);
+      Candidate.Conversions[ArgIdx] = TryCopyInitialization(
+          *this, Args[ArgIdx], ParamType, SuppressUserConversions,
+          getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
       if (Candidate.Conversions[ArgIdx].isBad()) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_conversion;
         return;
       }
     } else {
       // (C++ 13.3.2p2): For the purposes of overload resolution, any
       // argument for which there is no corresponding parameter is
       // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
       Candidate.Conversions[ArgIdx].setEllipsis();
     }
   }
 
+  if (!AllowExplicit) {
+    ExplicitSpecifier ES = ExplicitSpecifier::getFromDecl(Function);
+    if (ES.getKind() != ExplicitSpecKind::ResolvedFalse) {
+      Candidate.Viable = false;
+      Candidate.FailureKind = ovl_fail_explicit_resolved;
+      return;
+    }
+  }
+
   if (EnableIfAttr *FailedAttr = CheckEnableIf(Function, Args)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
     Candidate.DeductionFailure.Data = FailedAttr;
     return;
   }
 
   if (LangOpts.OpenCL && isOpenCLDisabledDecl(Function)) {

 
 /// Add a C++ function template specialization as a candidate
 /// in the candidate set, using template argument deduction to produce
 /// an appropriate function template specialization.
 void Sema::AddTemplateOverloadCandidate(
     FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
     TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
     OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
-    bool PartialOverloading, ADLCallKind IsADLCandidate) {
+    bool PartialOverloading, bool AllowExplicit, ADLCallKind IsADLCandidate) {
   if (!CandidateSet.isNewCandidate(FunctionTemplate))
     return;
 
   // C++ [over.match.funcs]p7:
   //   In each case where a candidate is a function template, candidate
   //   function template specializations are generated using template argument
   //   deduction (14.8.3, 14.8.2). Those candidates are then handled as
   //   candidate functions in the usual way.113) A given name can refer to one
else {
                                                             Info);
     }
     return;
   }
 
   // Add the function template specialization produced by template argument
   // deduction as a candidate.
   assert(Specialization && "Missing function template specialization?");
-  AddOverloadCandidate(Specialization, FoundDecl, Args, CandidateSet,
-                       SuppressUserConversions, PartialOverloading,
-                       /*AllowExplicit*/ false, IsADLCandidate, Conversions);
+  AddOverloadCandidate(
+      Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
+      PartialOverloading, AllowExplicit,
+      /*AllowExplicitConversions*/ false, IsADLCandidate, Conversions);
 }
 
 /// Check that implicit conversion sequences can be formed for each argument
 /// whose corresponding parameter has a non-dependent type, per DR1391's
 /// [temp.deduct.call]p10.
 bool Sema::CheckNonDependentConversions(
     FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
     ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,

 }
 
 /// AddConversionCandidate - Add a C++ conversion function as a
 /// candidate in the candidate set (C++ [over.match.conv],
 /// C++ [over.match.copy]). From is the expression we're converting from,
 /// and ToType is the type that we're eventually trying to convert to
 /// (which may or may not be the same type as the type that the
 /// conversion function produces).
-void
-Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
-                             DeclAccessPair FoundDecl,
-                             CXXRecordDecl *ActingContext,
-                             Expr *From, QualType ToType,
-                             OverloadCandidateSet& CandidateSet,
-                             bool AllowObjCConversionOnExplicit,
-                             bool AllowResultConversion) {
+void Sema::AddConversionCandidate(
+    CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
+    CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
+    OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
+    bool AllowExplicit, bool AllowResultConversion) {
   assert(!Conversion->getDescribedFunctionTemplate() &&
          "Conversion function templates use AddTemplateConversionCandidate");
   QualType ConvType = Conversion->getConversionType().getNonReferenceType();
   if (!CandidateSet.isNewCandidate(Conversion))
     return;
 
   // If the conversion function has an undeduced return type, trigger its
   // deduction now.
case ImplicitConversionSequence::BadConversion:
     Candidate.FailureKind = ovl_fail_bad_final_conversion;
     return;
 
   default:
     llvm_unreachable(
            "Can only end up with a standard conversion sequence or failure");
   }
 
+  if (!AllowExplicit && Conversion->getExplicitSpecifier().getKind() !=
+                            ExplicitSpecKind::ResolvedFalse) {
+    Candidate.Viable = false;
+    Candidate.FailureKind = ovl_fail_explicit_resolved;
+    return;
+  }
+
   if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
     Candidate.DeductionFailure.Data = FailedAttr;
     return;
   }
 
   if (Conversion->isMultiVersion() && Conversion->hasAttr<TargetAttr>() &&
       !Conversion->getAttr<TargetAttr>()->isDefaultVersion()) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_non_default_multiversion_function;
   }
 }
 
 /// Adds a conversion function template specialization
 /// candidate to the overload set, using template argument deduction
 /// to deduce the template arguments of the conversion function
 /// template from the type that we are converting to (C++
 /// [temp.deduct.conv]).
-void
-Sema::AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
-                                     DeclAccessPair FoundDecl,
-                                     CXXRecordDecl *ActingDC,
-                                     Expr *From, QualType ToType,
-                                     OverloadCandidateSet &CandidateSet,
-                                     bool AllowObjCConversionOnExplicit,
-                                     bool AllowResultConversion) {
+void Sema::AddTemplateConversionCandidate(
+    FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
+    CXXRecordDecl *ActingDC, Expr *From, QualType ToType,
+    OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
+    bool AllowExplicit, bool AllowResultConversion) {
   assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
          "Only conversion function templates permitted here");
 
   if (!CandidateSet.isNewCandidate(FunctionTemplate))
     return;
 
   TemplateDeductionInfo Info(CandidateSet.getLocation());
   CXXConversionDecl *Specialization = nullptr;
if (TemplateDeductionResult Result
     return;
   }
 
   // Add the conversion function template specialization produced by
   // template argument deduction as a candidate.
   assert(Specialization && "Missing function template specialization?");
   AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
                          CandidateSet, AllowObjCConversionOnExplicit,
-                         AllowResultConversion);
+                         AllowExplicit, AllowResultConversion);
 }
 
 /// AddSurrogateCandidate - Adds a "surrogate" candidate function that
 /// converts the given @c Object to a function pointer via the
 /// conversion function @c Conversion, and then attempts to call it
 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
 /// the type of function that we'll eventually be calling.
 void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
     DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none);
 
     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
       if (ExplicitTemplateArgs)
         continue;
 
       AddOverloadCandidate(FD, FoundDecl, Args, CandidateSet,
                            /*SupressUserConversions=*/false, PartialOverloading,
-                           /*AllowExplicit=*/false, ADLCallKind::UsesADL);
+                           /*AllowExplicitConversions*/ false,
+                           /*AllowExplicit*/ true, ADLCallKind::UsesADL);
     } else {
-      AddTemplateOverloadCandidate(cast<FunctionTemplateDecl>(*I), FoundDecl,
-                                   ExplicitTemplateArgs, Args, CandidateSet,
-                                   /*SupressUserConversions=*/false,
-                                   PartialOverloading, ADLCallKind::UsesADL);
+      AddTemplateOverloadCandidate(
+          cast<FunctionTemplateDecl>(*I), FoundDecl, ExplicitTemplateArgs, Args,
+          CandidateSet,
+          /*SuppressUserConversions=*/false, PartialOverloading,
+          /*AllowExplicit*/true, ADLCallKind::UsesADL);
     }
   }
 }
 
 namespace {
 enum class Comparison { Equal, Better, Worse };
 }
 
static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) {
   FunctionDecl *Callee = Cand->Function;
   EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
 
   S.Diag(Callee->getLocation(),
          diag::note_ovl_candidate_disabled_by_function_cond_attr)
       << Attr->getCond()->getSourceRange() << Attr->getMessage();
 }
 
+static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand) {
+  ExplicitSpecifier ES;
+  const char *DeclName;
+  switch (Cand->Function->getDeclKind()) {
+  case Decl::Kind::CXXConstructor:
+    ES = cast<CXXConstructorDecl>(Cand->Function)->getExplicitSpecifier();
+    DeclName = "constructor";
+    break;
+  case Decl::Kind::CXXConversion:
+    ES = cast<CXXConversionDecl>(Cand->Function)->getExplicitSpecifier();
+    DeclName = "conversion operator";
+    break;
+  case Decl::Kind::CXXDeductionGuide:
+    ES = cast<CXXDeductionGuideDecl>(Cand->Function)->getExplicitSpecifier();
+    DeclName = "deductiong guide";
+    break;
+  default:
+    llvm_unreachable("invalid Decl");
+  }
+  assert(ES.getExpr() && "null expression should be handled before");
+  S.Diag(Cand->Function->getLocation(),
+         diag::note_ovl_candidate_explicit_forbidden)
+      << DeclName;
+  S.Diag(ES.getExpr()->getBeginLoc(),
+         diag::note_explicit_bool_resolved_to_true);
+}
+
 static void DiagnoseOpenCLExtensionDisabled(Sema &S, OverloadCandidate *Cand) {
   FunctionDecl *Callee = Cand->Function;
 
   S.Diag(Callee->getLocation(),
          diag::note_ovl_candidate_disabled_by_extension)
     << S.getOpenCLExtensionsFromDeclExtMap(Callee);
 }
 
static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
   }
 
   case ovl_fail_bad_target:
     return DiagnoseBadTarget(S, Cand);
 
   case ovl_fail_enable_if:
     return DiagnoseFailedEnableIfAttr(S, Cand);
 
+  case ovl_fail_explicit_resolved:
+    return DiagnoseFailedExplicitSpec(S, Cand);
+
   case ovl_fail_ext_disabled:
     return DiagnoseOpenCLExtensionDisabled(S, Cand);
 
   case ovl_fail_inhctor_slice:
     // It's generally not interesting to note copy/move constructors here.
     if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
       return;
     S.Diag(Fn->getLocation(),
for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
       NamedDecl *Func = *I;
       CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
       if (isa<UsingShadowDecl>(Func))
         Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
 
 
       // Microsoft supports direct constructor calls.
       if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
-        AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(),
-                             Args, CandidateSet);
+        AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(), Args,
+                             CandidateSet,
+                             /*SuppressUserConversions*/ false);
       } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
         // If explicit template arguments were provided, we can't call a
         // non-template member function.
         if (TemplateArgs)
           continue;
 
         AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType,
                            ObjectClassification, Args, CandidateSet,

cfe/trunk/lib/Sema/SemaTemplate.cpp

if (DS.isConstexprSpecified())
       EmitDiag(DS.getConstexprSpecLoc());
 
     // [dcl.fct.spec]p1:
     //   Function-specifiers can be used only in function declarations.
 
     if (DS.isVirtualSpecified())
       EmitDiag(DS.getVirtualSpecLoc());
 
-    if (DS.isExplicitSpecified())
+    if (DS.hasExplicitSpecifier())
       EmitDiag(DS.getExplicitSpecLoc());
 
     if (DS.isNoreturnSpecified())
       EmitDiag(DS.getNoreturnSpecLoc());
   };
 
   CheckValidDeclSpecifiers();
 
NamedDecl *transformConstructor(FunctionTemplateDecl *FTD,
     // new ones.
     TypeLocBuilder TLB;
     SmallVector<ParmVarDecl*, 8> Params;
     QualType NewType = transformFunctionProtoType(TLB, FPTL, Params, Args);
     if (NewType.isNull())
       return nullptr;
     TypeSourceInfo *NewTInfo = TLB.getTypeSourceInfo(SemaRef.Context, NewType);
 
-    return buildDeductionGuide(TemplateParams, CD->isExplicit(), NewTInfo,
-                               CD->getBeginLoc(), CD->getLocation(),
+    return buildDeductionGuide(TemplateParams, CD->getExplicitSpecifier(),
+                               NewTInfo, CD->getBeginLoc(), CD->getLocation(),
                                CD->getEndLoc());
   }
 
   /// Build a deduction guide with the specified parameter types.
   NamedDecl *buildSimpleDeductionGuide(MutableArrayRef<QualType> ParamTypes) {
     SourceLocation Loc = Template->getLocation();
 
     // Build the requested type.
for (auto T : ParamTypes) {
       ParmVarDecl *NewParam = ParmVarDecl::Create(
           SemaRef.Context, DC, Loc, Loc, nullptr, T,
           SemaRef.Context.getTrivialTypeSourceInfo(T, Loc), SC_None, nullptr);
       NewParam->setScopeInfo(0, Params.size());
       FPTL.setParam(Params.size(), NewParam);
       Params.push_back(NewParam);
     }
 
-    return buildDeductionGuide(Template->getTemplateParameters(), false, TSI,
-                               Loc, Loc, Loc);
+    return buildDeductionGuide(Template->getTemplateParameters(),
+                               ExplicitSpecifier(), TSI, Loc, Loc, Loc);
   }
 
 private:
   /// Transform a constructor template parameter into a deduction guide template
   /// parameter, rebuilding any internal references to earlier parameters and
   /// renumbering as we go.
   NamedDecl *transformTemplateParameter(NamedDecl *TemplateParam,
                                         MultiLevelTemplateArgumentList &Args) {
ParmVarDecl *NewParam = ParmVarDecl::Create(SemaRef.Context, DC,
                                                 NewDefArg.get());
     NewParam->setScopeInfo(OldParam->getFunctionScopeDepth(),
                            OldParam->getFunctionScopeIndex());
     SemaRef.CurrentInstantiationScope->InstantiatedLocal(OldParam, NewParam);
     return NewParam;
   }
 
   NamedDecl *buildDeductionGuide(TemplateParameterList *TemplateParams,
-                                 bool Explicit, TypeSourceInfo *TInfo,
+                                 ExplicitSpecifier ES, TypeSourceInfo *TInfo,
                                  SourceLocation LocStart, SourceLocation Loc,
                                  SourceLocation LocEnd) {
     DeclarationNameInfo Name(DeductionGuideName, Loc);
     ArrayRef<ParmVarDecl *> Params =
         TInfo->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams();
 
     // Build the implicit deduction guide template.
     auto *Guide =
-        CXXDeductionGuideDecl::Create(SemaRef.Context, DC, LocStart, Explicit,
-                                      Name, TInfo->getType(), TInfo, LocEnd);
+        CXXDeductionGuideDecl::Create(SemaRef.Context, DC, LocStart, ES, Name,
+                                      TInfo->getType(), TInfo, LocEnd);
     Guide->setImplicit();
     Guide->setParams(Params);
 
     for (auto *Param : Params)
       Param->setDeclContext(Guide);
 
     auto *GuideTemplate = FunctionTemplateDecl::Create(
         SemaRef.Context, DC, Loc, DeductionGuideName, TemplateParams, Guide);

cfe/trunk/lib/Sema/SemaTemplateInstantiateDecl.cpp

static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr(
   if (Result.isInvalid())
     return;
   Expr *MaxExpr = Result.getAs<Expr>();
 
   S.addAMDGPUFlatWorkGroupSizeAttr(Attr.getLocation(), New, MinExpr, MaxExpr,
                                    Attr.getSpellingListIndex());
 }
 
+static ExplicitSpecifier
+instantiateExplicitSpecifier(Sema &S,
+                             const MultiLevelTemplateArgumentList &TemplateArgs,
+                             ExplicitSpecifier ES, FunctionDecl *New) {
+  if (!ES.getExpr())
+    return ES;
+  Expr *OldCond = ES.getExpr();
+  Expr *Cond = nullptr;
+  {
+    EnterExpressionEvaluationContext Unevaluated(
+        S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
+    ExprResult SubstResult = S.SubstExpr(OldCond, TemplateArgs);
+    if (SubstResult.isInvalid()) {
+      return ExplicitSpecifier::Invalid();
+    }
+    Cond = SubstResult.get();
+  }
+  ExplicitSpecifier Result(Cond, ES.getKind());
+  if (!Cond->isTypeDependent())
+    S.tryResolveExplicitSpecifier(Result);
+  return Result;
+}
+
 static void instantiateDependentAMDGPUWavesPerEUAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
     const AMDGPUWavesPerEUAttr &Attr, Decl *New) {
   // Both min and max expression are constant expressions.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
 
   ExprResult Result = S.SubstExpr(Attr.getMin(), TemplateArgs);
else
     isFriend = (D->getFriendObjectKind() != Decl::FOK_None);
 
   bool MergeWithParentScope = (TemplateParams != nullptr) ||
     Owner->isFunctionOrMethod() ||
     !(isa<Decl>(Owner) &&
       cast<Decl>(Owner)->isDefinedOutsideFunctionOrMethod());
   LocalInstantiationScope Scope(SemaRef, MergeWithParentScope);
 
+  ExplicitSpecifier InstantiatedExplicitSpecifier;
+  if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
+    InstantiatedExplicitSpecifier = instantiateExplicitSpecifier(
+        SemaRef, TemplateArgs, DGuide->getExplicitSpecifier(), DGuide);
+    if (InstantiatedExplicitSpecifier.isInvalid())
+      return nullptr;
+  }
+
   SmallVector<ParmVarDecl *, 4> Params;
   TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
   if (!TInfo)
     return nullptr;
   QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
 
   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
   if (QualifierLoc) {
Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
   }
 
   DeclarationNameInfo NameInfo
     = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
 
   FunctionDecl *Function;
   if (auto *DGuide = dyn_cast<CXXDeductionGuideDecl>(D)) {
     Function = CXXDeductionGuideDecl::Create(
-      SemaRef.Context, DC, D->getInnerLocStart(), DGuide->isExplicit(),
-      NameInfo, T, TInfo, D->getSourceRange().getEnd());
+        SemaRef.Context, DC, D->getInnerLocStart(),
+        InstantiatedExplicitSpecifier, NameInfo, T, TInfo,
+        D->getSourceRange().getEnd());
     if (DGuide->isCopyDeductionCandidate())
       cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
     Function->setAccess(D->getAccess());
   } else {
     Function = FunctionDecl::Create(
         SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
         D->getCanonicalDecl()->getStorageClass(), D->isInlineSpecified(),
         D->hasWrittenPrototype(), D->isConstexpr());
for (unsigned I = 0; I != NumTempParamLists; ++I) {
       TemplateParameterList *TempParams = D->getTemplateParameterList(I);
       TemplateParameterList *InstParams = SubstTemplateParams(TempParams);
       if (!InstParams)
         return nullptr;
       TempParamLists[I] = InstParams;
     }
   }
 
+  ExplicitSpecifier InstantiatedExplicitSpecifier =
+      instantiateExplicitSpecifier(SemaRef, TemplateArgs,
+                                   ExplicitSpecifier::getFromDecl(D), D);
+  if (InstantiatedExplicitSpecifier.isInvalid())
+    return nullptr;
+
   SmallVector<ParmVarDecl *, 4> Params;
   TypeSourceInfo *TInfo = SubstFunctionType(D, Params);
   if (!TInfo)
     return nullptr;
   QualType T = adjustFunctionTypeForInstantiation(SemaRef.Context, D, TInfo);
 
   NestedNameSpecifierLoc QualifierLoc = D->getQualifierLoc();
   if (QualifierLoc) {
Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
   // Build the instantiated method declaration.
   CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
   CXXMethodDecl *Method = nullptr;
 
   SourceLocation StartLoc = D->getInnerLocStart();
   DeclarationNameInfo NameInfo
     = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
-    Method = CXXConstructorDecl::Create(SemaRef.Context, Record,
-                                        StartLoc, NameInfo, T, TInfo,
-                                        Constructor->isExplicit(),
-                                        Constructor->isInlineSpecified(),
-                                        false, Constructor->isConstexpr());
+    Method = CXXConstructorDecl::Create(
+        SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
+        InstantiatedExplicitSpecifier, Constructor->isInlineSpecified(), false,
+        Constructor->isConstexpr());
     Method->setRangeEnd(Constructor->getEndLoc());
   } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
     Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
                                        StartLoc, NameInfo, T, TInfo,
                                        Destructor->isInlineSpecified(),
                                        false);
     Method->setRangeEnd(Destructor->getEndLoc());
   } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
     Method = CXXConversionDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
-        Conversion->isInlineSpecified(), Conversion->isExplicit(),
+        Conversion->isInlineSpecified(), InstantiatedExplicitSpecifier,
         Conversion->isConstexpr(), Conversion->getEndLoc());
   } else {
     StorageClass SC = D->isStatic() ? SC_Static : SC_None;
     Method = CXXMethodDecl::Create(SemaRef.Context, Record, StartLoc, NameInfo,
                                    T, TInfo, SC, D->isInlineSpecified(),
                                    D->isConstexpr(), D->getEndLoc());
   }
 

cfe/trunk/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   FD->IdentifierNamespace = Record.readInt();
 
   // FunctionDecl's body is handled last at ASTDeclReader::Visit,
   // after everything else is read.
 
   FD->setStorageClass(static_cast<StorageClass>(Record.readInt()));
   FD->setInlineSpecified(Record.readInt());
   FD->setImplicitlyInline(Record.readInt());
-  FD->setExplicitSpecified(Record.readInt());
   FD->setVirtualAsWritten(Record.readInt());
   FD->setPure(Record.readInt());
   FD->setHasInheritedPrototype(Record.readInt());
   FD->setHasWrittenPrototype(Record.readInt());
   FD->setDeletedAsWritten(Record.readInt());
   FD->setTrivial(Record.readInt());
   FD->setTrivialForCall(Record.readInt());
   FD->setDefaulted(Record.readInt());
if (KeyFn && D->isCompleteDefinition())
       // record or similar for that case.
       C.KeyFunctions[D] = KeyFn;
   }
 
   return Redecl;
 }
 
 void ASTDeclReader::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
+  D->setExplicitSpecifier(Record.readExplicitSpec());
   VisitFunctionDecl(D);
   D->setIsCopyDeductionCandidate(Record.readInt());
 }
 
 void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
   VisitFunctionDecl(D);
 
   unsigned NumOverridenMethods = Record.readInt();
if (D->isCanonicalDecl()) {
     // the relevant information from the canonical declaration.
     Record.skipInts(NumOverridenMethods);
   }
 }
 
 void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
   // We need the inherited constructor information to merge the declaration,
   // so we have to read it before we call VisitCXXMethodDecl.
+  D->setExplicitSpecifier(Record.readExplicitSpec());
   if (D->isInheritingConstructor()) {
     auto *Shadow = ReadDeclAs<ConstructorUsingShadowDecl>();
     auto *Ctor = ReadDeclAs<CXXConstructorDecl>();
     *D->getTrailingObjects<InheritedConstructor>() =
         InheritedConstructor(Shadow, Ctor);
   }
 
   VisitCXXMethodDecl(D);
if (auto *OperatorDelete = ReadDeclAs<FunctionDecl>()) {
     if (!Canon->OperatorDelete) {
       Canon->OperatorDelete = OperatorDelete;
       Canon->OperatorDeleteThisArg = ThisArg;
     }
   }
 }
 
 void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
+  D->setExplicitSpecifier(Record.readExplicitSpec());
   VisitCXXMethodDecl(D);
 }
 
 void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
   VisitDecl(D);
   D->ImportedAndComplete.setPointer(readModule());
   D->ImportedAndComplete.setInt(Record.readInt());
   auto *StoredLocs = D->getTrailingObjects<SourceLocation>();
case DECL_CXX_RECORD:
     break;
   case DECL_CXX_DEDUCTION_GUIDE:
     D = CXXDeductionGuideDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_CXX_METHOD:
     D = CXXMethodDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_CXX_CONSTRUCTOR:
-    D = CXXConstructorDecl::CreateDeserialized(Context, ID, false);
-    break;
-  case DECL_CXX_INHERITED_CONSTRUCTOR:
-    D = CXXConstructorDecl::CreateDeserialized(Context, ID, true);
+    D = CXXConstructorDecl::CreateDeserialized(Context, ID, Record.readInt());
     break;
   case DECL_CXX_DESTRUCTOR:
     D = CXXDestructorDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_CXX_CONVERSION:
     D = CXXConversionDecl::CreateDeserialized(Context, ID);
     break;
   case DECL_ACCESS_SPEC:

cfe/trunk/lib/Serialization/ASTWriter.cpp

#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(DECL_USING_SHADOW);
   RECORD(DECL_USING_DIRECTIVE);
   RECORD(DECL_UNRESOLVED_USING_VALUE);
   RECORD(DECL_UNRESOLVED_USING_TYPENAME);
   RECORD(DECL_LINKAGE_SPEC);
   RECORD(DECL_CXX_RECORD);
   RECORD(DECL_CXX_METHOD);
   RECORD(DECL_CXX_CONSTRUCTOR);
-  RECORD(DECL_CXX_INHERITED_CONSTRUCTOR);
   RECORD(DECL_CXX_DESTRUCTOR);
   RECORD(DECL_CXX_CONVERSION);
   RECORD(DECL_ACCESS_SPEC);
   RECORD(DECL_FRIEND);
   RECORD(DECL_FRIEND_TEMPLATE);
   RECORD(DECL_CLASS_TEMPLATE);
   RECORD(DECL_CLASS_TEMPLATE_SPECIALIZATION);
   RECORD(DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION);

cfe/trunk/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
   Record.push_back(D->getIdentifierNamespace());
 
   // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
   // after everything else is written.
   Record.push_back(static_cast<int>(D->getStorageClass())); // FIXME: stable encoding
   Record.push_back(D->isInlineSpecified());
   Record.push_back(D->isInlined());
-  Record.push_back(D->isExplicitSpecified());
   Record.push_back(D->isVirtualAsWritten());
   Record.push_back(D->isPure());
   Record.push_back(D->hasInheritedPrototype());
   Record.push_back(D->hasWrittenPrototype());
   Record.push_back(D->isDeletedBit());
   Record.push_back(D->isTrivial());
   Record.push_back(D->isTrivialForCall());
   Record.push_back(D->isDefaulted());
void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   }
 
   Record.push_back(D->param_size());
   for (auto P : D->parameters())
     Record.AddDeclRef(P);
   Code = serialization::DECL_FUNCTION;
 }
 
+static void addExplicitSpecifier(ExplicitSpecifier ES,
+                                 ASTRecordWriter &Record) {
+  uint64_t Kind = static_cast<uint64_t>(ES.getKind());
+  Kind = Kind << 1 | static_cast<bool>(ES.getExpr());
+  Record.push_back(Kind);
+  if (ES.getExpr()) {
+    Record.AddStmt(ES.getExpr());
+  }
+}
+
 void ASTDeclWriter::VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D) {
+  addExplicitSpecifier(D->getExplicitSpecifier(), Record);
   VisitFunctionDecl(D);
   Record.push_back(D->isCopyDeductionCandidate());
   Code = serialization::DECL_CXX_DEDUCTION_GUIDE;
 }
 
 void ASTDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) {
   VisitNamedDecl(D);
   // FIXME: convert to LazyStmtPtr?
if (D->getDeclContext() == D->getLexicalDeclContext() &&
       !D->hasInheritedPrototype() &&
       D->hasWrittenPrototype())
     AbbrevToUse = Writer.getDeclCXXMethodAbbrev();
 
   Code = serialization::DECL_CXX_METHOD;
 }
 
 void ASTDeclWriter::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
+  Record.push_back(D->getTraillingAllocKind());
+  addExplicitSpecifier(D->getExplicitSpecifier(), Record);
   if (auto Inherited = D->getInheritedConstructor()) {
     Record.AddDeclRef(Inherited.getShadowDecl());
     Record.AddDeclRef(Inherited.getConstructor());
-    Code = serialization::DECL_CXX_INHERITED_CONSTRUCTOR;
-  } else {
-    Code = serialization::DECL_CXX_CONSTRUCTOR;
   }
 
   VisitCXXMethodDecl(D);
-
-  Code = D->isInheritingConstructor()
-             ? serialization::DECL_CXX_INHERITED_CONSTRUCTOR
-             : serialization::DECL_CXX_CONSTRUCTOR;
+  Code = serialization::DECL_CXX_CONSTRUCTOR;
 }
 
 void ASTDeclWriter::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
   VisitCXXMethodDecl(D);
 
   Record.AddDeclRef(D->getOperatorDelete());
   if (D->getOperatorDelete())
     Record.AddStmt(D->getOperatorDeleteThisArg());
 
   Code = serialization::DECL_CXX_DESTRUCTOR;
 }
 
 void ASTDeclWriter::VisitCXXConversionDecl(CXXConversionDecl *D) {
+  addExplicitSpecifier(D->getExplicitSpecifier(), Record);
   VisitCXXMethodDecl(D);
   Code = serialization::DECL_CXX_CONVERSION;
 }
 
 void ASTDeclWriter::VisitImportDecl(ImportDecl *D) {
   VisitDecl(D);
   Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
   ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // InnerLocStart
   Abv->Add(BitCodeAbbrevOp(0));                         // HasExtInfo
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // TSIType
   // FunctionDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // StorageClass
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Inline
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InlineSpecified
-  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitSpecified
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // VirtualAsWritten
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Pure
   Abv->Add(BitCodeAbbrevOp(0));                         // HasInheritedProto
   Abv->Add(BitCodeAbbrevOp(1));                         // HasWrittenProto
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // TrivialForCall
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted

cfe/trunk/test/CXX/temp/temp.deduct.guide/p1.cpp

 extern A(int(&)[26]) -> A<int>;
 #ifdef CLASS
 // expected-error@-2 {{storage class specified for a member}}
 #else
 // expected-error@-4 {{deduction guide cannot be declared 'extern'}}
 #endif
 mutable A(int(&)[27]) -> A<int>; // expected-error-re {{{{'mutable' cannot be applied to|illegal storage class on}} function}}
 virtual A(int(&)[28]) -> A<int>; // expected-error {{'virtual' can only appear on non-static member functions}}
-const A(int(&)[28]) -> A<int>; // expected-error {{deduction guide cannot be declared 'const'}}
+const A(int(&)[31]) -> A<int>; // expected-error {{deduction guide cannot be declared 'const'}}
 
 const volatile static constexpr inline A(int(&)[29]) -> A<int>; // expected-error {{deduction guide cannot be declared 'static inline constexpr const volatile'}}
 
 A(int(&)[30]) const -> A<int>; // expected-error {{deduction guide cannot have 'const' qualifier}}
 
 // No definition is allowed.
 A(int(&)[40]) -> A<int> {} // expected-error {{deduction guide cannot have a function definition}}
 A(int(&)[41]) -> A<int> = default; // expected-error {{deduction guide cannot have a function definition}} expected-error {{only special member functions may be defaulted}}

cfe/trunk/test/CXX/temp/temp.deduct.guide/p3.cpp

 // RUN: %clang_cc1 -std=c++1z %s -verify
 
 // The same restrictions apply to the parameter-declaration-clause of a
 // deduction guide as in a function declaration.
 template<typename T> struct A {};
-A(void) -> A<int>; // ok
+A(void) -> A<int>; // expected-note {{previous}}
 A(void, int) -> A<int>; // expected-error {{'void' must be the first and only parameter if specified}}
 
-// We interpret this as also extending to the validity of redeclarations. It's
-// a bit of a stretch (OK, a lot of a stretch) but it gives desirable answers.
-A() -> A<int>; // ok, redeclaration
+A() -> A<int>; // expected-error {{redeclaration of deduction guide}}
+// expected-note@-1 {{previous}}
 
 A() -> A<int>; // expected-note {{previous}}
+// expected-error@-1 {{redeclaration of deduction guide}}
 A() -> A<float>; // FIXME: "functions" is a poor term. expected-error {{functions that differ only in their return type cannot be overloaded}}
 
 template<typename T> A(T) -> A<typename T::foo>;
 template<typename T> A(T) -> A<typename T::bar>; // ok, can overload on return type (SFINAE applies)
 
 A(long) -> A<int>;
 template<typename T = int> A(long) -> A<char>; // ok, non-template beats template as usual
 

cfe/trunk/test/PCH/cxx-explicit-specifier.cpp

+// RUN: %clang_cc1 -std=c++2a -emit-pch %s -o %t-cxx2a
+// RUN: %clang_cc1 -std=c++2a -DUSE_PCH -include-pch %t-cxx2a %s -ast-print -verify | FileCheck %s
+
+#ifndef USE_PCH
+namespace inheriting_constructor {
+  struct S {};
+
+  template<typename X, typename Y> struct T {
+    template<typename A>
+    explicit((Y{}, true)) T(A &&a) {}
+  };
+
+  template<typename X, typename Y> struct U : T<X, Y> {
+    using T<X, Y>::T;
+  };
+
+  U<S, char> foo(char ch) {
+    return U<S, char>(ch);
+  }
+}
+#else
+namespace inheriting_constructor {
+U<S, char> a = foo('0');
+}
+
+//CHECK: explicit((char{} , true))
+
+#endif
+
+namespace basic {
+#ifndef USE_PCH
+
+struct B {};
+
+struct A {
+  explicit A(int);
+  explicit(false) operator bool();
+  explicit(true) operator B();
+};
+#else
+//expected-note@-6+ {{candidate constructor}}
+//expected-note@-9+ {{candidate constructor}}
+//expected-note@-6+ {{candidate function}}
+
+//CHECK: explicit{{ +}}A(
+//CHECK-NEXT: explicit(false){{ +}}operator
+//CHECK-NEXT: explicit(true){{ +}}operator
+A a = 0; //expected-error {{no viable conversion}}
+A a1(0);
+
+bool b = a1;
+B b1 = a1; //expected-error {{no viable conversion}}
+
+#endif
+}
+
+
+namespace templ {
+#ifndef USE_PCH
+
+template<bool b>
+struct B {
+  static constexpr bool value = b;
+};
+
+template<bool b>
+struct A {
+  explicit(b) A(B<b>) {}
+  template<typename T>
+  explicit(b ^ T::value) operator T();
+};
+B<true> b_true;
+B<false> b_false;
+#else
+//expected-note@-8 {{candidate template ignored}}
+//expected-note@-8+ {{explicit constructor}}
+//expected-note@-15+ {{candidate constructor}}
+//expected-note@-8+ {{candidate conversion operator ignored}}
+//expected-note@-9+ {{explicit(bool) specifier resolved to true}}
+//expected-note@-12 {{explicit(bool) specifier resolved to true}}
+//expected-note@-13+ {{candidate deductiong guide ignored}}
+
+//CHECK: explicit(b){{ +}}A
+//CHECK: explicit(b{{ +}}^{{ +}}T::value){{ +}}operator
+
+A a = { b_true }; //expected-error {{class template argument deduction}}
+A a0 = b_true; //expected-error {{no viable constructor or deduction guide}}
+A a_true(b_true);
+A a_false = b_false;
+
+B<true> b = a_true;
+B<true> b1 = a_false; //expected-error {{no viable conversion}}
+B<false> b2(a_true);
+
+#endif
+
+}
+
+namespace guide {
+
+#ifndef USE_PCH
+
+template<typename T>
+struct A {
+  A(T);
+};
+
+template<typename T>
+explicit(true) A(T) -> A<T>;
+
+explicit(false) A(int) -> A<int>;
+
+#else
+//expected-note@-5 {{explicit deduction guide}}
+
+//CHECK: explicit(true){{ +}}A(
+//CHECK: explicit(false){{ +}}A(
+
+A a = { 0.0 }; //expected-error {{explicit deduction guide}}
+A a1 = { 0 };
+
+#endif
+
+}

cfe/trunk/test/SemaCXX/builtin-is-constant-evaluated.cpp

 int y;
 int &r = __builtin_is_constant_evaluated() ? x : y;
 static_assert(&r == &x);
 
 } // namespace test_ref_initialization
 
 #if defined(__cpp_conditional_explicit)
 struct TestConditionalExplicit {
-  explicit(__builtin_is_constant_evaluated()) TestConditionalExplicit(int) {}
+  explicit(!__builtin_is_constant_evaluated()) TestConditionalExplicit(int) {}
 };
 TestConditionalExplicit e = 42;
 #endif

cfe/trunk/test/SemaCXX/cxx2a-compat.cpp

 // expected-warning@-4 {{type of UTF-8 string literal will change}} expected-note@-4 {{remove 'u8' prefix}}
 // expected-warning@-4 {{type of UTF-8 string literal will change}} expected-note@-4 {{remove 'u8' prefix}}
 // expected-warning@-4 {{type of UTF-8 string literal will change}} expected-note@-4 {{remove 'u8' prefix}}
 #else
 // expected-error@-8 {{ISO C++20 does not permit initialization of char array with UTF-8 string literal}}
 // expected-error@-8 {{cannot initialize a variable of type 'const char *' with an lvalue of type 'const char8_t [6]'}}
 // expected-error@-8 {{no viable conversion from 'const char8_t [9]' to 'string'}}
 #endif
+
+template<bool b>
+struct C {
+  explicit(C)(int);
+};
+#if __cplusplus <= 201703L
+// expected-warning@-3 {{this expression will be parsed as explicit(bool) in C++2a}}
+#if defined(__cpp_conditional_explicit)
+#error "the feature test macro __cpp_conditional_explicit isn't correct"
+#endif
+#else
+// expected-error@-8 {{does not refer to a value}}
+// expected-error@-9 {{expected member name or ';'}}
+// expected-error@-10 {{expected ')'}}
+// expected-note@-12 {{declared here}}
+// expected-note@-12 {{to match this '('}}
+#if !defined(__cpp_conditional_explicit) || __cpp_conditional_explicit != 201806L
+#error "the feature test macro __cpp_conditional_explicit isn't correct"
+#endif
+#endif
 No newline at end of file

cfe/trunk/test/SemaCXX/cxx2a-explicit-bool.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+
+template <bool b, auto val> struct enable_ifv {};
+
+template <auto val> struct enable_ifv<true, val> {
+  static constexpr auto value = val;
+};
+
+template <typename T1, typename T2> struct is_same {
+  static constexpr bool value = false;
+};
+
+template <typename T> struct is_same<T, T> {
+  static constexpr bool value = true;
+};
+
+namespace special_cases
+{
+
+template<int a>
+struct A {
+// expected-note@-1+ {{candidate constructor}}
+  explicit(1 << a)
+// expected-note@-1 {{negative shift count -1}}
+// expected-error@-2 {{explicit specifier argument is not a constant expression}}
+  A(int);
+};
+
+A<-1> a(0);
+// expected-error@-1 {{no matching constructor}}
+// expected-note@-2 {{in instantiation of template class}}
+
+template<int a>
+struct B {
+  explicit(b)
+  // expected-error@-1 {{use of undeclared identifier}}
+  B(int);
+};
+
+template<int a>
+struct B1 {
+  explicit(a +)
+  // expected-error@-1 {{expected expression}}
+  B1(int);
+};
+
+struct B2 {
+  explicit(false) explicit
+  B2(int);
+  // expected-error@-2 {{duplicate 'explicit' declaration specifier}}
+};
+
+template<int a>
+  struct C {
+  // expected-note@-1 {{candidate constructor}} expected-note@-1 {{candidate constructor}}
+  // expected-note@-2 {{candidate constructor}} expected-note@-2 {{candidate constructor}}
+  explicit(a == 0)
+C(int),
+C(double);
+};
+
+C<0> c0 = 0.0; // expected-error {{no viable conversion}}
+C<0> c1 = 0; // expected-error {{no viable conversion}}
+C<1> c2 = 0.0;
+C<1> c3 = 0;
+
+explicit(false) void f(int);// expected-error {{'explicit' can only be specified inside the class definition}}
+
+struct D {
+  explicit(false) void f(int);// expected-error {{'explicit' can only be applied to a constructor or conversion function}}
+};
+
+template <typename T> struct E {
+  // expected-note@-1+ {{candidate constructor}}
+  explicit((T{}, false))
+  // expected-error@-1 {{illegal initializer type 'void'}}
+  E(int);
+};
+
+E<void> e = 1;
+// expected-error@-1 {{no viable conversion}}
+// expected-note@-2 {{in instantiation of}}
+
+}
+
+namespace trailling_object {
+
+template<bool b>
+struct B {
+  explicit(b) B(int) {}
+};
+
+template<bool b>
+struct A : B<b> {
+  explicit(b) A(int) : B<b>(0) {}
+};
+
+A<true> a(0);
+
+}
+
+namespace constructor1 {
+
+template<bool b>
+  struct A {
+    // expected-note@-1+ {{candidate constructor}}
+    // expected-note@-2+ {{candidate function}}
+    explicit(b) A(int, int = 0);
+  // expected-note@-1+ {{explicit constructor declared here}}
+};
+
+template<bool b>
+A<b>::A(int, int) {}
+
+void f()
+{
+A<true> a0 = 0; // expected-error {{no viable conversion}}
+A<true> a1( 0);
+A<true> && a2 = 0;// expected-error {{could not bind}}
+A<true> && a3( 0);// expected-error {{could not bind}}
+A<true> a4{ 0};
+A<true> && a5 = { 0};// expected-error {{chosen constructor is explicit}}
+A<true> && a6{ 0};
+A<true> a7 = { 0}; // expected-error {{chosen constructor is explicit in copy-initialization}}
+
+a0 = 0;
+a1 = { 0}; // expected-error {{no viable overloaded '='}}
+a2 = A<true>( 0);
+a3 = A<true>{ 0};
+
+A<false> c0 =  ((short)0);
+A<false> c1( ((short)0));
+A<false> && c2 =  ((short)0);
+A<false> && c3( ((short)0));
+A<false> c4{ ((short)0)};
+A<false> && c5 = { ((short)0)};
+A<false> && c6{ ((short)0)};
+
+A<true> d1( 0, 0);
+A<true> d2{ 0, 0};
+A<true> d3 = { 0, 0}; // expected-error {{chosen constructor is explicit in copy-initialization}}
+
+d1 = { 0, 0}; // expected-error {{no viable overloaded '='}}
+d2 = A<true>( 0, 0);
+d3 = A<true>{ 0, 0};
+}
+}
+
+namespace constructor2 {
+
+template<bool a, typename T1>
+struct A {
+  // expected-note@-1 {{candidate constructor}} expected-note@-1 {{candidate constructor}}
+  // expected-note@-2 {{candidate constructor}} expected-note@-2 {{candidate constructor}}
+  template<typename T2>
+  explicit(a ^ is_same<T1, T2>::value)
+  // expected-note@-1+ {{explicit(bool) specifier resolved to true}}
+  A(T2) {}
+  // expected-note@-1+ {{explicit constructor declared here}}
+  // expected-note@-2+ {{candidate constructor ignored}}
+};
+
+A<true, int> a0 = 0.0; // expected-error {{no viable conversion}}
+A<true, int> a1( 0.0);
+A<true, int> && a2 = 0.0;// expected-error {{could not bind}}
+A<true, int> && a3( 0.0);// expected-error {{could not bind}}
+A<true, int> a4{ 0.0};
+A<true, int> && a5 = { 0.0};// expected-error {{chosen constructor is explicit}}
+A<true, int> && a6{ 0.0};
+A<true, int> a7 = { 0.0}; // expected-error {{chosen constructor is explicit in copy-initialization}}
+
+A<true, int> b0 = 0;
+A<true, int> b1( 0);
+A<true, int> && b2 = 0;
+A<true, int> && b3( 0);
+A<true, int> b4{ 0};
+A<true, int> && b5 = { 0};
+A<true, int> && b6{ 0};
+A<true, int> b7 = { 0};
+
+A<true, double> c0 = 0; // expected-error {{no viable conversion}}
+A<true, double> c1( 0);
+A<true, double> && c2 = 0;// expected-error {{could not bind}}
+A<true, double> && c3( 0);// expected-error {{could not bind}}
+A<true, double> c4{ 0};
+A<true, double> && c5 = { 0};// expected-error {{chosen constructor is explicit}}
+A<true, double> && c6{ 0};
+A<true, double> c7 = { 0}; // expected-error {{chosen constructor is explicit in copy-initialization}}
+
+}
+
+namespace constructor_sfinae {
+
+template<bool a>
+struct A {
+  // expected-note@-1+ {{candidate constructor}}
+  template<typename T>
+  explicit(enable_ifv<is_same<int, T>::value, a>::value)
+  //expected-note@-1 {{explicit(bool) specifier resolved to true}}
+  A(T) {}
+  // expected-note@-1+ {{substitution failure}}
+  // expected-note@-2 {{candidate constructor ignored}}
+  // expected-note@-3 {{explicit constructor declared here}}
+  template<typename T, bool c = true>
+  explicit(enable_ifv<is_same<bool, T>::value, a>::value)
+  //expected-note@-1 {{explicit(bool) specifier resolved to true}}
+  A(T) {}
+  // expected-note@-1+ {{substitution failure}}
+  // expected-note@-2 {{candidate constructor ignored}}
+  // expected-note@-3 {{explicit constructor declared here}}
+};
+
+A<true> a0 = 0.0; // expected-error {{no viable conversion}}
+A<true> a1( 0.0); // expected-error {{no matching constructor}}
+A<true> a4{ 0.0}; // expected-error {{no matching constructor}}
+A<true> a7 = { 0.0}; // expected-error {{no matching constructor}}
+
+A<true> b0 = 0; // expected-error {{no viable conversion}}
+A<true> b1( 0);
+A<true> b4{ 0};
+A<true> b7 = { 0}; // expected-error {{chosen constructor is explicit}}
+
+A<false> c0 = 0;
+A<false> c1( 0);
+A<false> c4{ 0};
+A<false> c7 = { 0};
+
+A<true> d0 = true; // expected-error {{no viable conversion}}
+A<true> d1( true);
+A<true> d4{ true};
+A<true> d7 = { true}; // expected-error {{chosen constructor is explicit}}
+
+}
+
+namespace conversion {
+
+template<bool a>
+struct A {
+  explicit(a) operator int ();
+};
+
+template<bool a>
+A<a>::operator int() {
+  return 0;
+}
+
+A<true> A_true;
+A<false> A_false;
+
+int ai0 = A<true>(); // expected-error {{no viable conversion}}
+const int& ai1 = A<true>(); // expected-error {{no viable conversion}}
+int&& ai3 = A<true>(); // expected-error {{no viable conversion}}
+int ai4 = A_true; // expected-error {{no viable conversion}}
+const int& ai5 = A_true; // expected-error {{no viable conversion}}
+
+int ai01 = {A<true>()}; // expected-error {{no viable conversion}}
+const int& ai11 = {A<true>()}; // expected-error {{no viable conversion}}
+int&& ai31 = {A<true>()}; // expected-error {{no viable conversion}}
+int ai41 = {A_true}; // expected-error {{no viable conversion}}
+const int& ai51 = {A_true}; // expected-error {{no viable conversion}}
+
+int ae0(A<true>());
+const int& ae1(A<true>());
+int&& ae3(A<true>());
+int ae4(A_true);
+const int& ae5(A_true);
+
+int bi0 = A<false>();
+const int& bi1 = A<false>();
+int&& bi3 = A<false>();
+int bi4 = A_false;
+const int& bi5 = A_false;
+
+int bi01 = {A<false>()};
+const int& bi11 = {A<false>()};
+int&& bi31 = {A<false>()};
+int bi41 = {A_false};
+const int& bi51 = {A_false};
+
+int be0(A<true>());
+const int& be1(A<true>());
+int&& be3(A<true>());
+int be4(A_true);
+const int& be5(A_true);
+
+}
+
+namespace conversion2 {
+
+struct B {};
+// expected-note@-1+ {{candidate constructor}}
+template<bool a>
+struct A {
+  template<typename T2>
+  explicit(enable_ifv<is_same<B, T2>::value, a>::value)
+  // expected-note@-1+ {{explicit(bool) specifier resolved to true}}
+  operator T2() { return T2(); };
+  // expected-note@-1+ {{substitution failure}}
+  // expected-note@-2+ {{candidate conversion}}
+};
+
+A<false> A_false;
+A<true> A_true;
+
+int ai0 = A<true>(); // expected-error {{no viable conversion}}
+const int& ai1 = A<true>(); // expected-error {{no viable conversion}}
+int&& ai3 = A<true>(); // expected-error {{no viable conversion}}
+int ai4 = A_false; // expected-error {{no viable conversion}}
+const int& ai5 = A_false; // expected-error {{no viable conversion}}
+
+int ae0{A<true>()};  // expected-error {{no viable conversion}}
+const int& ae1{A<true>()};  // expected-error {{no viable conversion}}
+int&& ae3{A<true>()};  // expected-error {{no viable conversion}}
+int ae4{A_true};  // expected-error {{no viable conversion}}
+const int& ae5{A_true};  // expected-error {{no viable conversion}}
+
+int ap0((A<true>()));  // expected-error {{no viable conversion}}
+const int& ap1((A<true>()));  // expected-error {{no viable conversion}}
+int&& ap3((A<true>()));  // expected-error {{no viable conversion}}
+int ap4(A_true);  // expected-error {{no viable conversion}}
+const int& ap5(A_true);  // expected-error {{no viable conversion}}
+
+B b0 = A<true>(); // expected-error {{no viable conversion}}
+const B & b1 = A<true>(); // expected-error {{no viable conversion}}
+B && b3 = A<true>(); // expected-error {{no viable conversion}}
+B b4 = A_true; // expected-error {{no viable conversion}}
+const B & b5 = A_true; // expected-error {{no viable conversion}}
+
+B be0(A<true>());
+const B& be1(A<true>());
+B&& be3(A<true>());
+B be4(A_true);
+const B& be5(A_true);
+
+B c0 = A<false>();
+const B & c1 = A<false>();
+B && c3 = A<false>();
+B c4 = A_false;
+const B & c5 = A_false;
+
+}
+
+namespace parameter_pack {
+
+template<typename T>
+struct A {
+  // expected-note@-1+ {{candidate constructor}}
+  // expected-note@-2+ {{candidate function}}
+  template<typename ... Ts>
+  explicit((is_same<T, Ts>::value && ...))
+  // expected-note@-1 {{explicit(bool) specifier resolved to true}}
+  A(Ts...);
+  // expected-note@-1 {{candidate constructor}}
+  // expected-note@-2 {{explicit constructor}}
+};
+
+template<typename T>
+template<typename ... Ts>
+A<T>::A(Ts ...) {}
+
+void f() {
+
+A<int> a0 = 0; // expected-error {{no viable conversion}}
+A<int> a1( 0, 1);
+A<int> a2{ 0, 1};
+A<int> a3 = { 0, 1}; // expected-error {{chosen constructor is explicit}}
+
+a1 = 0; // expected-error {{no viable overloaded '='}}
+a2 = { 0, 1}; // expected-error {{no viable overloaded '='}}
+
+A<double> b0 = 0;
+A<double> b1( 0, 1);
+A<double> b2{ 0, 1};
+A<double> b3 = { 0, 1};
+
+b1 = 0;
+b2 = { 0, 1};
+
+}
+
+}
+
+namespace deduction_guide {
+
+template<bool b>
+struct B {};
+
+B<true> b_true;
+B<false> b_false;
+
+template<typename T>
+struct nondeduced
+{
+using type = T;
+};
+
+template<typename T1, typename T2, bool b>
+struct A {
+  // expected-note@-1+ {{candidate function}}
+  explicit(false)
+  A(typename nondeduced<T1>::type, typename nondeduced<T2>::type, typename nondeduced<B<b>>::type) {}
+  // expected-note@-1+ {{candidate template ignored}}
+};
+
+template<typename T1, typename T2, bool b>
+explicit(enable_ifv<is_same<T1, T2>::value, b>::value)
+A(T1, T2, B<b>) -> A<T1, T2, b>;
+// expected-note@-1+ {{explicit deduction guide declared here}}
+// expected-note@-2+ {{candidate template ignored}}
+void f() {
+
+A a0( 0.0, 1, b_true); // expected-error {{no viable constructor or deduction guide}}
+A a1{ 0.0, 1, b_true}; // expected-error {{no viable constructor or deduction guide}}
+A a2 = { 0.0, 1, b_true}; // expected-error {{no viable constructor or deduction guide}}
+auto a4 = A( 0.0, 1, b_true); // expected-error {{no viable constructor or deduction guide}}
+auto a5 = A{ 0.0, 1, b_true}; // expected-error {{no viable constructor or deduction guide}}
+
+A b0( 0, 1, b_true);
+A b1{ 0, 1, b_true};
+A b2 = { 0, 1, b_true}; // expected-error {{explicit deduction guide for copy-list-initialization}}
+auto b4 = A( 0, 1, b_true);
+auto b5 = A{ 0, 1, b_true};
+b0 = { 0, 1, b_false}; // expected-error {{no viable overloaded '='}}
+
+A c0( 0, 1, b_false);
+A c1{ 0, 1, b_false};
+A c2 = { 0, 1, b_false};
+auto c4 = A( 0, 1, b_false);
+auto c5 = A{ 0, 1, b_false};
+c2 = { 0, 1, b_false};
+
+}
+
+}
+
+namespace test8 {
+
+template<bool b>
+struct A {
+  //expected-note@-1+ {{candidate function}}
+  template<typename T1, typename T2>
+  explicit(b)
+  A(T1, T2) {}
+  //expected-note@-1 {{explicit constructor declared here}}
+};
+
+template<typename T1, typename T2>
+explicit(!is_same<T1, int>::value)
+A(T1, T2) -> A<!is_same<int, T2>::value>;
+// expected-note@-1+ {{explicit deduction guide declared here}}
+
+template<bool b>
+A<b> v();
+
+void f() {
+
+A a0( 0, 1);
+A a1{ 0, 1};
+A a2 = { 0, 1};
+auto a4 = A( 0, 1);
+auto a5 = A{ 0, 1};
+auto a6(v<false>());
+a6 = { 0, 1};
+
+A b0( 0.0, 1);
+A b1{ 0.0, 1};
+A b2 = { 0.0, 1}; // expected-error {{explicit deduction guide for copy-list-initialization}}
+auto b4 = A( 0.0, 1);
+auto b5 = A{ 0.0, 1};
+
+A c0( 0, 1.0);
+A c1{ 0, 1.0};
+A c2 = { 0, 1.0}; // expected-error {{chosen constructor is explicit}}
+auto c4 = A( 0, 1.0);
+auto c5 = A{ 0, 1.0};
+auto c6(v<true>());
+c0 = { 0, 1.0}; // expected-error {{no viable overloaded '='}}
+
+A d0( 0.0, 1.0);
+A d1{ 0.0, 1.0};
+A d2 = { 0.0, 1.0};  // expected-error {{explicit deduction guide for copy-list-initialization}}
+auto d4 = A( 0.0, 1.0);
+auto d5 = A{ 0.0, 1.0};
+
+}
+
+}
+
+namespace conversion3 {
+
+template<bool b>
+struct A {
+  explicit(!b) operator int();
+  explicit(b) operator bool();
+};
+
+template<bool b>
+A<b>::operator bool() { return false; }
+
+struct B {
+  void f(int);
+  void f(bool);
+};
+
+void f(A<true> a, B b) {
+  b.f(a);
+}
+
+void f1(A<false> a, B b) {
+  b.f(a);
+}
+
+// Taken from 12.3.2p2
+class X { X(); };
+class Y { }; // expected-note+ {{candidate constructor (the implicit}}
+
+template<bool b>
+struct Z {
+  explicit(b) operator X() const;
+  explicit(b) operator Y() const;
+  explicit(b) operator int() const;
+};
+
+void testExplicit()
+{
+Z<true> z;
+// 13.3.1.4p1 & 8.5p16:
+Y y2 = z; // expected-error {{no viable conversion}}
+Y y2b(z);
+Y y3 = (Y)z;
+Y y4 = Y(z);
+Y y5 = static_cast<Y>(z);
+// 13.3.1.5p1 & 8.5p16:
+int i1 = (int)z;
+int i2 = int(z);
+int i3 = static_cast<int>(z);
+int i4(z);
+// 13.3.1.6p1 & 8.5.3p5:
+const Y& y6 = z; // expected-error {{no viable conversion}}
+const int& y7 = z; // expected-error {{no viable conversion}}
+const Y& y8(z);
+const int& y9(z);
+
+// Y is an aggregate, so aggregate-initialization is performed and the
+// conversion function is not considered.
+const Y y10{z}; // expected-error {{excess elements}}
+const Y& y11{z}; // expected-error {{excess elements}} expected-note {{in initialization of temporary}}
+const int& y12{z};
+
+// X is not an aggregate, so constructors are considered,
+// per 13.3.3.1/4 & DR1467.
+const X x1{z};
+const X& x2{z};
+}
+
+struct tmp {};
+
+template<typename T1>
+struct C {
+  template<typename T>
+  explicit(!is_same<T1, T>::value)
+  // expected-note@-1+ {{explicit(bool) specifier resolved to true}}
+  operator T();
+  // expected-note@-1+ {{candidate conversion operator ignored}}
+};
+
+using Bool = C<bool>;
+using Integral = C<int>;
+using Unrelated = C<tmp>;
+
+void testBool() {
+Bool    b;
+Integral n;
+Unrelated u;
+
+(void) (1 + b); // expected-error {{invalid operands to binary expression}}
+(void) (1 + n);
+(void) (1 + u); // expected-error {{invalid operands to binary expression}}
+
+// 5.3.1p9:
+(void) (!b);
+(void) (!n);
+(void) (!u);
+
+// 5.14p1:
+(void) (b && true);
+(void) (n && true);
+(void) (u && true);
+
+// 5.15p1:
+(void) (b || true);
+(void) (n || true);
+(void) (u || true);
+
+// 5.16p1:
+(void) (b ? 0 : 1);
+(void) (n ? 0: 1);
+(void) (u ? 0: 1);
+
+// // 5.19p5:
+// // TODO: After constexpr has been implemented
+
+// 6.4p4:
+if (b) {}
+if (n) {}
+if (u) {}
+
+// 6.4.2p2:
+switch (b) {} // expected-error {{statement requires expression of integer type}}
+switch (n) {} // expected-error {{statement requires expression of integer type}}
+switch (u) {} // expected-error {{statement requires expression of integer type}}
+
+// 6.5.1:
+while (b) {}
+while (n) {}
+while (u) {}
+
+// 6.5.2p1:
+do {} while (b);
+do {} while (n);
+do {} while (u);
+
+// 6.5.3:
+for (;b;) {}
+for (;n;) {}
+for (;u;) {}
+
+// 13.3.1.5p1:
+bool db1(b);
+bool db2(n);
+bool db3(u);
+int di1(b);
+int di2(n);
+int di3(n);
+const bool &direct_cr1(b);
+const bool &direct_cr2(n);
+const bool &direct_cr3(n);
+const int &direct_cr4(b);
+const int &direct_cr5(n);
+const int &direct_cr6(n);
+bool directList1{b};
+bool directList2{n};
+bool directList3{n};
+int directList4{b};
+int directList5{n};
+int directList6{n};
+const bool &directList_cr1{b};
+const bool &directList_cr2{n};
+const bool &directList_cr3{n};
+const int &directList_cr4{b};
+const int &directList_cr5{n};
+const int &directList_cr6{n};
+bool copy1 = b;
+bool copy2 = n;// expected-error {{no viable conversion}}
+bool copyu2 = u;// expected-error {{no viable conversion}}
+int copy3 = b;// expected-error {{no viable conversion}}
+int copy4 = n;
+int copyu4 = u;// expected-error {{no viable conversion}}
+const bool &copy5 = b;
+const bool &copy6 = n;// expected-error {{no viable conversion}}
+const bool &copyu6 = u;// expected-error {{no viable conversion}}
+const int &copy7 = b;// expected-error {{no viable conversion}}
+const int &copy8 = n;
+const int &copyu8 = u;// expected-error {{no viable conversion}}
+bool copyList1 = {b};
+bool copyList2 = {n};// expected-error {{no viable conversion}}
+bool copyListu2 = {u};// expected-error {{no viable conversion}}
+int copyList3 = {b};// expected-error {{no viable conversion}}
+int copyList4 = {n};
+int copyListu4 = {u};// expected-error {{no viable conversion}}
+const bool &copyList5 = {b};
+const bool &copyList6 = {n};// expected-error {{no viable conversion}}
+const bool &copyListu6 = {u};// expected-error {{no viable conversion}}
+const int &copyList7 = {b};// expected-error {{no viable conversion}}
+const int &copyList8 = {n};
+const int &copyListu8 = {u};// expected-error {{no viable conversion}}
+}
+
+}
+
+namespace deduction_guide2 {
+
+template<typename T1 = int, typename T2 = int>
+struct A {
+  // expected-note@-1+ {{candidate template ignored}}
+  explicit(!is_same<T1, T2>::value)
+  // expected-note@-1+ {{explicit(bool) specifier resolved to true}}
+  A(T1 = 0, T2 = 0) {}
+  // expected-note@-1 {{explicit constructor}}
+  // expected-note@-2+ {{candidate deductiong guide ignored}}
+};
+
+A a0 = 0;
+A a1(0, 0);
+A a2{0, 0};
+A a3 = {0, 0};
+
+A b0 = 0.0; // expected-error {{no viable constructor or deduction guide}}
+A b1(0.0, 0.0);
+A b2{0.0, 0.0};
+A b3 = {0.0, 0.0};
+
+A b4 = {0.0, 0}; // expected-error {{explicit constructor}}
+
+template<typename T1, typename T2>
+explicit A(T1, T2) -> A<T1, T2>;
+// expected-note@-1+ {{explicit deduction guide}}
+
+A c0 = 0;
+A c1(0, 0);
+A c2{0, 0};
+A c3 = {0, 0};// expected-error {{explicit deduction guide}}
+
+A d0 = 0.0; // expected-error {{no viable constructor or deduction guide}}
+A d1(0, 0);
+A d2{0, 0};
+A d3 = {0.0, 0.0};// expected-error {{explicit deduction guide}}
+
+}

cfe/trunk/test/SemaCXX/explicit.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2a %s
+
 namespace Constructor {
 struct A {
   A(int);
 };
 
 struct B { // expected-note+ {{candidate}}
   explicit B(int);
 };

 
 B b0 = 0; // expected-error {{no viable conversion}}
 B b1(0);
 B &&b2 = 0; // expected-error {{could not bind}}
 B &&b3(0); // expected-error {{could not bind}}
 B b4{0};
 B &&b5 = {0}; // expected-error {{chosen constructor is explicit}}
 B &&b6{0};
+
+struct S {
+  template <bool b = true>
+  explicit S();
+};
+
+struct T : S {
+  //  T();
+};
+
+struct U : T {
+  U();
+};
+U::U() {}
+
 }
 
 namespace Conversion {
   struct A {
     operator int();
     explicit operator bool();
   };
 
void testBool() {
     bool copyList2 = {n}; // expected-error {{no viable conversion}}
     int copyList3 = {b};
     int copyList4 = {n}; // expected-error {{no viable conversion}}
     const bool &copyList5 = {b};
     const bool &copyList6 = {n}; // expected-error {{no viable conversion}}
     const int &copyList7 = {b};
     const int &copyList8 = {n}; // expected-error {{no viable conversion}}
   }
-  
+#if __cplusplus < 201707L
   void testNew()
   {
     // 5.3.4p6:
     struct Int {
       operator int();
     };
     struct NotInt {
       explicit operator int(); // expected-note {{conversion to integral type 'int' declared here}}
     };
     
     Int    i;
     NotInt ni;
     
     new int[i];
     new int[ni]; // expected-error {{array size expression of type 'NotInt' requires explicit conversion to type 'int'}}
   }
-  
+#endif
   void testDelete()
   {
     // 5.3.5pp2:
     struct Ptr {
       operator int*();
     };
     struct NotPtr {
       explicit operator int*(); // expected-note {{conversion}}

cfe/trunk/unittests/AST/Language.h

 typedef std::vector<std::string> ArgVector;
 
 enum Language {
     Lang_C,
     Lang_C89,
     Lang_CXX,
     Lang_CXX11,
     Lang_CXX14,
+    Lang_CXX2a,
     Lang_OpenCL,
     Lang_OBJCXX
 };
 
 ArgVector getBasicRunOptionsForLanguage(Language Lang);
 
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif

cfe/trunk/unittests/AST/Language.cpp

case Lang_CXX:
     BasicArgs = {"-std=c++98", "-frtti"};
     break;
   case Lang_CXX11:
     BasicArgs = {"-std=c++11", "-frtti"};
     break;
   case Lang_CXX14:
     BasicArgs = {"-std=c++14", "-frtti"};
     break;
+  case Lang_CXX2a:
+    BasicArgs = {"-std=c++2a", "-frtti"};
+    break;
   case Lang_OpenCL:
   case Lang_OBJCXX:
     llvm_unreachable("Not implemented yet!");
   }
   return BasicArgs;
 }
 
 } // end namespace ast_matchers
 } // end namespace clang

cfe/trunk/unittests/AST/MatchVerifier.h

testing::AssertionResult MatchVerifier<NodeType>::match(
   case Lang_CXX11:
     Args.push_back("-std=c++11");
     FileName = "input.cc";
     break;
   case Lang_CXX14:
     Args.push_back("-std=c++14");
     FileName = "input.cc";
     break;
+  case Lang_CXX2a:
+    Args.push_back("-std=c++2a");
+    FileName = "input.cc";
+    break;
   case Lang_OpenCL:
     FileName = "input.cl";
     break;
   case Lang_OBJCXX:
     FileName = "input.mm";
     break;
   }
 

cfe/trunk/unittests/AST/StructuralEquivalenceTest.cpp

 TEST_F(StructuralEquivalenceTest, CompareSameDeclWithMultiple) {
   auto t = makeNamedDecls(
       "struct A{ }; struct B{ }; void foo(A a, A b);",
       "struct A{ }; struct B{ }; void foo(A a, B b);",
       Lang_CXX);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
+TEST_F(StructuralEquivalenceTest, ExplicitBoolDifferent) {
+  auto Decls = makeNamedDecls("struct foo {explicit(false) foo(int);};",
+                              "struct foo {explicit(true) foo(int);};", Lang_CXX2a);
+  CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
+      get<0>(Decls), cxxConstructorDecl(hasName("foo")));
+  CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
+      get<1>(Decls), cxxConstructorDecl(hasName("foo")));
+  EXPECT_FALSE(testStructuralMatch(First, Second));
+}
+
+TEST_F(StructuralEquivalenceTest, ExplicitBoolSame) {
+  auto Decls = makeNamedDecls("struct foo {explicit(true) foo(int);};",
+                              "struct foo {explicit(true) foo(int);};", Lang_CXX2a);
+  CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
+      get<0>(Decls), cxxConstructorDecl(hasName("foo")));
+  CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
+      get<1>(Decls), cxxConstructorDecl(hasName("foo")));
+  EXPECT_TRUE(testStructuralMatch(First, Second));
+}
+
 struct StructuralEquivalenceEnumTest : StructuralEquivalenceTest {};
 
 TEST_F(StructuralEquivalenceEnumTest, FwdDeclEnumShouldBeEqualWithFwdDeclEnum) {
   auto t = makeNamedDecls("enum class foo;", "enum class foo;", Lang_CXX11);
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceEnumTest,

 }
 
 TEST_F(StructuralEquivalenceTemplateTest, DifferentTemplateArgKind) {
   auto t = makeNamedDecls("template <class T> struct foo;",
                           "template <int T> struct foo;", Lang_CXX);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
+TEST_F(StructuralEquivalenceTemplateTest, ExplicitBoolSame) {
+  auto Decls = makeNamedDecls("template <bool b> struct foo {explicit(b) foo(int);};",
+                              "template <bool b> struct foo {explicit(b) foo(int);};", Lang_CXX2a);
+  CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
+      get<0>(Decls), cxxConstructorDecl(hasName("foo<b>")));
+  CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
+      get<1>(Decls), cxxConstructorDecl(hasName("foo<b>")));
+  EXPECT_TRUE(testStructuralMatch(First, Second));
+}
+
+TEST_F(StructuralEquivalenceTemplateTest, ExplicitBoolDifference) {
+  auto Decls = makeNamedDecls("template <bool b> struct foo {explicit(b) foo(int);};",
+                              "template <bool b> struct foo {explicit(!b) foo(int);};", Lang_CXX2a);
+  CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
+      get<0>(Decls), cxxConstructorDecl(hasName("foo<b>")));
+  CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
+      get<1>(Decls), cxxConstructorDecl(hasName("foo<b>")));
+  EXPECT_FALSE(testStructuralMatch(First, Second));
+}
+
 } // end namespace ast_matchers
 } // end namespace clang

cfe/trunk/www/cxx_status.html

</tr>
     <tr>
       <td>Feature test macros</td>
       <td><a href="http://wg21.link/p0941r2">P0941R2</a></td>
       <td class="full" align="center"><a href="#sd6">(see below)</a></td>
     </tr>
     <tr>
       <td><tt>explicit(bool)</tt></td>
       <td><a href="http://wg21.link/p0892r2">P0892R2</a></td>
-      <td class="none" align="center">No</td>
+      <td class="svn" align="center">SVN</td>
     </tr>
     <!-- San Diego papers -->
     <tr>
       <td>Signed integers are two's complement</td>
       <td><a href="http://wg21.link/p1236r1">P1236R1</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>