[C++2a] P0634r3: Down with typename!

[ayzhao]

Summary

This patch implements P0634r3 that removes the need for 'typename' in certain contexts.

For example,

template <typename T>
using foo = T::type; // ok

This is also allowed in previous language versions as an extension, because I think it's pretty useful. :)

[rsmith]

clang/lib/Sema/SemaTemplate.cpp

3377–3379 ↗

(On Diff #200440)

This FIXME is concerning. Is this a problem with this patch? (Is the FIXME wrong now?)

clang/test/CXX/drs/dr5xx.cpp

485 ↗

(On Diff #200440)

A comment here explaining that A and B stop being aggregates in C++20 would be nice. (Nicer would be changing the testcase so it still tests the relevant rule in C++20 mode, if that's possible...)

clang/test/CXX/temp/temp.res/p5.cpp

1 ↗

(On Diff #200440)

Please add tests for enum-base and conversion-type-id:

template<typename T> struct A {
  enum E : T::type {};
  operator T::type() {}
  void f() { this->operator T::type(); }
};

... which should currently be rejected.

[Rakete1111]

• rebased
• addressed review comments

clang/lib/Parse/ParseDecl.cpp

4321 ↗

(On Diff #200440)

Do you know why this isn't allowed in operator ids?

5100–5101 ↗

(On Diff #200440)

Yeah it does the break the second. Would just checking whether a friend is there be good enough? clang doesn't seem to actively propose to add a friend if there's one missing, so if we add a IsFriend parameter and then check if it is set than always return false, it should work. Is that acceptable? It would break the nice error message you get if you write friend C(int);, but if we restrict it when isDeclarationSpecifier return false (with Never) would that be better (that's what I'm doing right now)?

Another solution would be to tentatively parse the whole thing, but that can be pretty expensive I believe.

clang/lib/Sema/SemaTemplate.cpp

3377–3379 ↗

(On Diff #200440)

Yes you're right, I believe it not longer applies due to the change in ParseDecl.cpp in ParseDeclarationSpecifiers.

[Rakete1111]

clang/lib/Sema/SemaTemplate.cpp

3377–3379 ↗

(On Diff #200440)

Although I'm not that sure I fully understand what that comments alludes to.

[rsmith]

clang/lib/Parse/ParseDecl.cpp

4321 ↗

(On Diff #200440)

There's already been discussion of that on the core reflector, and people seem to agree it's an oversight in the wording. If you want to accept that here, I think that's fine, under the assumption that this will be fixed by DR. (If you want to follow the wording-as-moved, that's fine too.)

5100–5101 ↗

(On Diff #200440)

This seems a little fragile against future grammar changes, but I think the IsFriend check is correct -- I *think* the only way we can see a qualified-id here in a valid non-constructor, non-nested-name-specifier case is in a friend declaration.

clang/lib/Sema/SemaTemplate.cpp

3377–3379 ↗

(On Diff #200440)

The example would be something like this:

template<typename T> struct X {
  template<typename U> struct Y { Y(); using V = int; };
  template<typename U> typename Y<U>::V f();
};
template<typename T> template<typename U>
X<T>::Y<U>::V X<T>::f() {}

Clang trunk today points out that the typename keyword is missing on the final line, but fails to point out that the template keyword is also missing. The reason is that in the case where that construct is valid:

template<typename T> template<typename U>
X<T>::Y<U>::Y() {}

... we are "entering the context" of the nested-name-specifier, which means we don't need a template keyword.

If the FIXME is fixed, then we should diagnose the missing template in the above program.

Also, because we don't rebuild the nested-name-specifier as a dependent nested name specifier in this case, we fail to match it against the declaration in the class, so in my example above, we also produce an "out-of-line definition does not match" error.

A closely-related issue can be seen in an example such as:

template<typename T> struct X {
  template<typename U> struct Y { Y(); typedef void V; }; 
  template<typename U> typename Y<U>::V::W f();
};
template<typename T> template<typename U>
X<T>::template Y<U>::V::W X<T>::f() { return 0; }

Here, we produce a completely bogus error:

<stdin>:6:13: error: 'X::Y::V' (aka 'void') is not a class, namespace, or enumeration
X<T>::template Y<U>::V::W X<T>::f() { return 0; } 
            ^

... because we parse this in "entering context" mode and so resolve X<T>::Y<U>::V to the type in the primary template (that is, void). That's wrong: we should defer resolving this name to a type until we know what T and U are, or until we know that we're *actually* entering the context. Specifically, the above program can be extended as follows:

template<> template<> struct X<int>::Y<int> {
  struct V { using W = int; };
};
void call(X<int> x) { x.f<int>(); } // OK, f returns int

The above program should be accepted by this patch, if the FIXME is indeed now fixed. Please add it as a testcase :)

[Rakete1111]

clang/lib/Sema/SemaTemplate.cpp

3377–3379 ↗

(On Diff #200440)

Oh ok, got it thanks. So no, the program is still not accepted in clang, and a pretty dumb side effect of it is that

template<typename T> struct X {
  template<typename U> struct Y { Y(); using V = int; };
  template<typename U> typename Y<U>::V f();
};
template<typename T> template<typename U>
X<T>::Y<U>::V X<T>::f() {}

is accepted without the diagnostic for the missing template. :(

[vivekvpandya]

Minor suggestion, you may want to update http://clang.llvm.org/cxx_status.html page for "typename optional in more contexts" with in this change.

[cjdb]

What's the status of this patch?

[erichkeane]

In D53847#3252460, @cjdb wrote:

What's the status of this patch?

It appears to me that the 'delta' right now is a couple of cases where this patch doesn't properly diagnose/warn (see the convo in SemaTemplate.cpp )

[ilya-biryukov]

Hey! Also wondering what's the status of this.
@Rakete1111 do you plan to finish the patch? Or would it be ok if someone takes it over?

[erichkeane]

In D53847#3706965, @ilya-biryukov wrote:

Hey! Also wondering what's the status of this.
@Rakete1111 do you plan to finish the patch? Or would it be ok if someone takes it over?

Note that this would also let us mark P2324 as complete as well. @ilya-biryukov : Since there is no response, I suspect the answer here is someone should take this over. Were you going to?

[ilya-biryukov]

In D53847#3735704, @erichkeane wrote:

Note that this would also let us mark P2324 as complete as well. @ilya-biryukov : Since there is no response, I suspect the answer here is someone should take this over. Were you going to?

I could, but also busy with other things and happy to give this one away.
Would you be interested to take it over instead?

[erichkeane]

In D53847#3735738, @ilya-biryukov wrote:

In D53847#3735704, @erichkeane wrote:

Note that this would also let us mark P2324 as complete as well. @ilya-biryukov : Since there is no response, I suspect the answer here is someone should take this over. Were you going to?

I could, but also busy with other things and happy to give this one away.
Would you be interested to take it over instead?

Also very busy with other things, but was sorta looking into closing the partial P2324. I haven't dug into this one much in a while, but I was sort of wondering if this is a candidate for being 'split up' into smaller patches/handle 1 case at a time. If i have time next week, I might just start looking into making this work for single-examples, rather than everything.

[erichkeane]

In D53847#3735758, @erichkeane wrote:

In D53847#3735738, @ilya-biryukov wrote:

In D53847#3735704, @erichkeane wrote:

Note that this would also let us mark P2324 as complete as well. @ilya-biryukov : Since there is no response, I suspect the answer here is someone should take this over. Were you going to?

I could, but also busy with other things and happy to give this one away.
Would you be interested to take it over instead?

Also very busy with other things, but was sorta looking into closing the partial P2324. I haven't dug into this one much in a while, but I was sort of wondering if this is a candidate for being 'split up' into smaller patches/handle 1 case at a time. If i have time next week, I might just start looking into making this work for single-examples, rather than everything.

Welp, spoke too soon, my concepts stuff got reverted again, so I'll be workingon that for a while now, so I wont' have time to jump on this today.

[royjacobson]

I looked at this a bit about a week ago and got it down to 3-4 tests failing, but I'm not sure how much time I'll have to continue working on it. If one of you wants to take over I'll be happy to send you what I've currently got. @erichkeane @ilya-biryukov

Also, do you know if having posted this patch is agreement for licensing this code? Or do we need to get explicit agreement from the original author before committing a version of this?

[erichkeane]

In D53847#3745415, @royjacobson wrote:

I looked at this a bit about a week ago and got it down to 3-4 tests failing, but I'm not sure how much time I'll have to continue working on it. If one of you wants to take over I'll be happy to send you what I've currently got. @erichkeane @ilya-biryukov

Also, do you know if having posted this patch is agreement for licensing this code? Or do we need to get explicit agreement from the original author before committing a version of this?

I've never seen that be an issue before, and I don't see enough in https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents to be clear about the answer to that. @tstellar could perhaps answer.

[ayzhao]

In D53847#3745415, @royjacobson wrote:

I looked at this a bit about a week ago and got it down to 3-4 tests failing, but I'm not sure how much time I'll have to continue working on it. If one of you wants to take over I'll be happy to send you what I've currently got. @erichkeane @ilya-biryukov

Also, do you know if having posted this patch is agreement for licensing this code? Or do we need to get explicit agreement from the original author before committing a version of this?

I'm currently looking at this patch; please do send me what you have.

[ayzhao]

Update commit with contributions from @royjacobson

[jyknight]

Also, do you know if having posted this patch is agreement for licensing this code? Or do we need to get explicit agreement from the original author before committing a version of this?

I've never seen that be an issue before, and I don't see enough in https://llvm.org/docs/DeveloperPolicy.html#copyright-license-and-patents to be clear about the answer to that. @tstellar could perhaps answer.

Contributing the patch to phab was agreement to contribute to llvm under the llvm license, you do not need further permission to take over and finish and commit a patch from phab. Per the standard apache2 terms in the llvm license, "Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions."

[shafik]

First set of comments.

clang/include/clang/Parse/Parser.h

2418 ↗

(On Diff #458329)

Why don't we just have isImplicitTypenameContext(...) return an ImplicitTypenameContext?

clang/include/clang/Sema/DeclSpec.h

1809 ↗

(On Diff #458329)

Since you use Yes for the positive option how about No for the negative option? Yes/Never feel like an odd pair.

clang/lib/Parse/ParseDecl.cpp

3608 ↗

(On Diff #458329)

3609 ↗

(On Diff #458329)

clang/lib/Parse/ParseDeclCXX.cpp

1248 ↗

(On Diff #458329)

1290 ↗

(On Diff #458329)

1311 ↗

(On Diff #458329)

clang/lib/Parse/ParseTentative.cpp

446 ↗

(On Diff #458329)

clang/lib/Parse/Parser.cpp

2035 ↗

(On Diff #458329)

2036 ↗

(On Diff #458329)

clang/lib/Sema/DeclSpec.cpp

27 ↗

(On Diff #458329)

Duplicate include.

1474 ↗

(On Diff #458329)

Dead code?

[ayzhao]

address code review comments from shafik@

[ayzhao]

clang/lib/Parse/ParseDecl.cpp

5100–5101 ↗

(On Diff #200440)

I _think_ the first comment in this chain can be marked as done given that the test cases are now in p5.cpp and Clang compiles them without errors with the help of the IsFriend check.

[shafik]

Maybe I missed it but I don't see a test that covers temp.res p5 e.g.:

template <class T> void f(int i) {
  T::x * i;  // This will be assumed to be the expression
             //   T::x multiplied by i
             // Not a declaration of variable i of 
             //   type pointer to T::x?
}

struct Foo {
 typedef int x;
};

struct Bar {
  static int const x = 5;
};

int main() {
  f<Bar>(1);          // OK
  f<Foo>(1);          // error: Foo::x is a type
}

clang/include/clang/Sema/DeclSpec.h

1918 ↗

(On Diff #458580)

Why do we need this one shot previous lookup result? I am struggling to see the connection between isDeclaratorFunctionLike(...) and where we check hasPrevLookupResult(...) and why it matter.

clang/lib/Parse/ParseDecl.cpp

6479 ↗

(On Diff #458580)

Looks like there are a few of these left over as debugging lines, the should removed.

clang/lib/Sema/DeclSpec.cpp

1502–1504 ↗

(On Diff #458580)

clang/test/CXX/temp/temp.res/p5.cpp

1 ↗

(On Diff #458580)

It looks like this is temp.res p4 now

[ayzhao]

Fix failing test in p5.cpp where typename should be required for enum-base

(N.B. due to https://github.com/llvm/llvm-project/commit/c90e198107431f64b73686bdce31c293e3380ac7, the correct error should now be missing 'typename' rather than forbidden enum forward references)

[ayzhao]

remove obsolete FIXME

[ayzhao]

clang/lib/Parse/ParseDecl.cpp

4321 ↗

(On Diff #200440)

It seems like a wording oversight that we don't assume typename in an enum-base. Probably would be good to raise this on the core reflector.

Marking this as done for now; this patch currently returns an error if typename is assumed in an enum-base.

[ayzhao]

p5.cpp -> p4.cpp, removed debug statements

haven't yet fully grokked this patch. still looking into fixing test failures and PrevLookupResult.

[ayzhao]

Fix typename-specifier-3.cpp test

Things done:

• the warning should also include a check that C++20 is required
• the warning should only show up for precxx17, as %std_cxx17- translates to -std=c++2b

[ayzhao]

clang/lib/Sema/SemaDecl.cpp

362 ↗

(On Diff #459205)

Status update:

This line is currently causing p2-2.cpp to fail with the following error:

FAIL: Clang :: CXX/module/module.interface/p2-2.cpp (2 of 17555)
******************** TEST 'Clang :: CXX/module/module.interface/p2-2.cpp' FAILED ********************
Script:
--
: 'RUN: at line 3';   /dev/shm/ayzhao_llvm/llvm-project/build/bin/clang -cc1 -internal-isystem /dev/shm/ayzhao_llvm/llvm-project/build/lib/clang/16.0.0/include -nostdsysteminc -std=c++20 /dev/shm/ayzhao_llvm/llvm-project/clang/test/CXX/module/module.interface/p2-2.cpp -verify
--
Exit Code: 1
 
Command Output (stderr):
--
error: 'error' diagnostics expected but not seen:
  File /dev/shm/ayzhao_llvm/llvm-project/clang/test/CXX/module/module.interface/p2-2.cpp Line 17: cannot export 'iterator' as it is not at namespace scope
  File /dev/shm/ayzhao_llvm/llvm-project/clang/test/CXX/module/module.interface/p2-2.cpp Line 35: cannot export 'iterator' as it is not at namespace scope
error: 'error' diagnostics seen but not expected:
  File /dev/shm/ayzhao_llvm/llvm-project/clang/test/CXX/module/module.interface/p2-2.cpp Line 17: declaration does not declare anything
  File /dev/shm/ayzhao_llvm/llvm-project/clang/test/CXX/module/module.interface/p2-2.cpp Line 35: declaration does not declare anything
4 errors generated.
 
--
 
********************

A reduced repro is here:

export module X;

export template <typename T>
struct X {
  struct iterator {
    T node;
  };
};

export template <typename T> X<T>::iterator;

Sema::getTypeName(...) is called from these lines, with the result being that TypeRep is null in main but not null in this patch.

I'm still in the process of trying to figure out how to resolve this, but any suggestions/insights would be very welcome.

[cor3ntin]

Maybe @ChuanqiXu Can help as it seems module related

[ayzhao]

clang/lib/Sema/SemaDecl.cpp

362 ↗

(On Diff #459205)

I fixed this with the following diff:

diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 1375431d8998..dacba4d18021 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -362,6 +362,11 @@ ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
         if (AllowImplicitTypename == ImplicitTypenameContext::No &&
             !isClassName && !IsCtorOrDtorName)
           return nullptr;
+        // FIXME: This hack is required in order to make the test
+        // CXX/module/module.interface/p2-2.cpp pass. Can we get this working
+        // with this method returning a non-null ParsedType?
+        if (isa<ExportDecl>(CurContext))
+          return nullptr;
         bool IsImplicitTypename = !isClassName && !IsCtorOrDtorName;
         if (IsImplicitTypename) {
           SourceLocation QualifiedLoc = SS->getRange().getBegin();

It's very hacky, but it works (for now)

[ayzhao]

hacky fix for the test CXX/module/module.interface/p2-2.cpp

If anyone has a better idea on how to fix this test, feedback is very welcome.

[ayzhao]

clang/lib/Sema/SemaTemplate.cpp

3377–3379 ↗

(On Diff #200440)

Currently looking into this.

It is interesting to note that for the following example in one of the parent comments:

template<typename T> struct X {
  template<typename U> struct Y { Y(); typedef void V; }; 
  template<typename U> typename Y<U>::V::W f();
};
template<typename T> template<typename U>
X<T>::template Y<U>::V::W X<T>::f() { return 0; }

GCC doesn't like the fact that the template keyword is on the final line if compiled with -pedantic [0]:

<source>:6:16: warning: keyword 'template' not allowed in declarator-id [-Wpedantic]
    6 | X<T>::template Y<U>::V::W X<T>::f() { return 0; }
      |                ^~~~
Compiler returned: 0

[0]: https://godbolt.org/z/dYddW3ErY

[ayzhao]

fix typo

[ayzhao]

remove extra blank line

[ayzhao]

clang/lib/Sema/SemaTemplate.cpp

3377–3379 ↗

(On Diff #200440)

This is starting to feel like a separate issue. I filed https://github.com/llvm/llvm-project/issues/57853 to track it.

[ayzhao]

rebase + clang-format

[ayzhao]

remove PrevLookupResult + put Declarator(...) and ~Declarator() definitions back in the header files to reduce the diff since we're no longer overloading the constructor.

[ayzhao]

clang/include/clang/Sema/DeclSpec.h

1918 ↗

(On Diff #458580)

Removed

clang/lib/Sema/DeclSpec.cpp

1502–1504 ↗

(On Diff #458580)

Ended up removing PrevLookupResult per my other comment.

[ayzhao]

rebase + upload; also friendly ping!

[shafik]

I made mostly small comments but I think @aaron.ballman and/or @erichkeane should take a look as well.

clang/lib/Parse/ParseDecl.cpp

3434–3435 ↗

(On Diff #462032)

5592 ↗

(On Diff #462032)

Instead of adding yet another bool flag maybe we can consider using something like enum isFriend : bool {No, Yes}.

I am sure @aaron.ballman will want to chime in here as well.

clang/lib/Parse/ParseTemplate.cpp

20 ↗

(On Diff #462032)

Do we still need this?

1450 ↗

(On Diff #462032)

clang/lib/Sema/Sema.cpp

51 ↗

(On Diff #462032)

Do we need this?

[erichkeane]

I think this is on the right track, but would like to see more work done on that fixme before we commit (or at least better understand what is causing this). I'm afraid of what else can get us into that situation besides the export-decl.

clang/lib/Sema/SemaDecl.cpp

367 ↗

(On Diff #462032)

Hmm... this scares me quite a bit, I don't really know what other fallout results from this, or other code that would hit here.

We should probably spend more time making sure we understand this better.

[ayzhao]

address some review comments

[aaron.ballman]

clang/include/clang/Parse/Parser.h

2343 ↗

(On Diff #462222)

Starting with is implies contextual conversion to bool (generally), so I'd suggest renaming.

clang/include/clang/Sema/DeclSpec.h

1806 ↗

(On Diff #462222)

Not opposed to this construct, but I am worried about how well it will scale. I don't know that we want to add a bunch of named enums that all boil down to a bool. (If someone thinks they have good ideas here, that'd be a good RFC topic for Discourse because we have a ton of interfaces that take a bunch of bools.)

clang/lib/Parse/ParseDecl.cpp

5592 ↗

(On Diff #462032)

Heh, so this is where I get worried about the scalability of using enums for these. We really want to use three different enums here, but do we really want to *add* three different enums? I'm unconvinced.

However, if we can come up with some template magic to allow for named bool parameters as a generic interface, that would be valuable to use.

[erichkeane]

clang/lib/Parse/ParseDecl.cpp

5592 ↗

(On Diff #462032)

I prefer enums over bools TBH, even if we end up with a million of then somewhere.

That said, what about:

https://godbolt.org/z/Kz6jdjobj

template<typename SpecificThing>
class Is {
    Is(bool v) : value(v){}
  public:
  bool value;
  static const Is Yes() { return Is{true};}
  static const Is No() { return Is{false};}

  operator bool() { return value; }
};

class Friend{}; // #1
 
void foo(Is<Friend> f) {
    if (f) {
        ///...
    }
}

void baz() {
    foo(Is<Friend>::Yes());
}

Adding a 'new' thing is as simple as just adding #1 for anything we care about. We might want to put them in a namespace of some sort, but perhaps not awful?

[aaron.ballman]

clang/lib/Parse/ParseDecl.cpp

5592 ↗

(On Diff #462032)

Yeah, this is along the lines of what I was thinking of! However, I'm still concerned about that approach because it involves adding a new type for every situation we have a bool. Empty classes to use as a tag definitely works, but I was hoping we could use a string literal rather than a tag type so that we don't have the extra compile time overhead of adding hundreds of new empty classes. e.g.,

void foo(Is<"Friend"> f) {
  if (f) {
     // ...
  }
}

void baz() {
  foo(Is<"Friend">::Yes); // Yay
  foo(Is<"Enemy">::Yes); // Error for type mismatch with Is<"Friend">
}

However, that might require compiling with C++20 (I don't recall), so it may not be a viable idea.

[ayzhao]

address some comments

[ayzhao]

clang/include/clang/Sema/DeclSpec.h

1806 ↗

(On Diff #462222)

Ack. IIRC this enum was created as a result of this comment by @rsmith expressing concern over adding an additional bool parameter to a function with a lot of preexisting bool args.

[erichkeane]

clang/lib/Parse/ParseDecl.cpp

5592 ↗

(On Diff #462032)

Yeah, referring to stringliterals is troublesome in C++17. However, we COULD do that like:

void foo(Is<"Friend"_Is> f) {
  if (f) {
     // ...
  }
}

void baz() {
  foo(Is<"Friend"_Is>::Yes); // Yay
  foo(Is<"Enemy"_Is>::Yes); // Error for type mismatch with Is<"Friend">
}

by making operator _Is return an integer_sequence.

[aaron.ballman]

clang/include/clang/Sema/DeclSpec.h

1806 ↗

(On Diff #462222)

Ack. IIRC this enum was created as a result of this comment by @rsmith expressing concern over adding an additional bool parameter to a function with a lot of preexisting bool args.

Yeah, I spotted his suggestion (and am totally fine with implementing it here as you've done). I was mostly thinking about the future when someone tries to do this for every set of 2 or more bool parameters. :-D

clang/lib/Parse/ParseDecl.cpp

5592 ↗

(On Diff #462032)

That's a really neat idea! If you want to work it up into something that could be plausible to add to ADT, I think it's worth an RFC to add the interface. I'm guessing the diagnostic behavior of that would be kind of gross, but once we move to C++20 we'd be able to use string literal template arguments directly and get better diagnostic behavior. The critical part is that the code is readable and we get diagnostics when passing an argument to the wrong parameter.

[ayzhao]

Add FriendSpecified enum

[ayzhao]

fix spacing

[ayzhao]

clang/lib/Parse/ParseDecl.cpp

5592 ↗

(On Diff #462032)

I added a FriendSpecified enum for now.

I'm going to mark the comment chain as done so that they don't unnecessarily block the review.

I agree with the idea of a generic type to represent boolean arguments, but I think it would be out of scope of this patch and that Discourse would be a more appropriate place to discuss this.

[ayzhao]

address some more review comments + rebase

[ayzhao]

clang/lib/Sema/SemaDecl.cpp

367 ↗

(On Diff #462032)

Following up with my previous comment about the failing test that this hack was supposed to fix:

I added the typename keyword to the export template statement and lo and behold, Clang emits the same "declaration does not declare anything" diagnostic instead of the namespace scope diagnostic [0].

To me, this feels like that the original test case was wrong:

1. There should've been a typename keyword in the export statement. Perhaps the author of the test wasn't aware that the typename keyword was required, or perhaps the author already assumed that P0634r3 was already implemented in clang.
2. The test currently passing (with Clang emitting the namespace diagnostic instead of the declaration diagnostic) seems to be a freak coincidence.

I'm not familiar at all with C++ modules - is this a bug with exporting types?

[0]: https://godbolt.org/z/PYvh68Tq7

[ayzhao]

clang/lib/Sema/SemaDecl.cpp

367 ↗

(On Diff #462032)

small fix: I linked to the wrong line when referencing the original test case. The link should be https://github.com/llvm/llvm-project/blob/a707675dbba9ca3ec6e668f86fea2240a85ca171/clang/test/CXX/module/module.interface/p2-2.cpp#L17

[ayzhao]

remove the hack for the test p2-2.cpp and patch in patch in D134578 which fixes the test

[ayzhao]

clang/lib/Sema/SemaDecl.cpp

367 ↗

(On Diff #462032)

So my belief now is that the test p2-2.cpp is broken. I've removed the FIXME hack, and I created D134578 to fix the test. To keep the bots happy, I also cherry-picked D134578 into this patch.

[ayzhao]

In D53847#3809072, @erichkeane wrote:

I think this is on the right track, but would like to see more work done on that fixme before we commit (or at least better understand what is causing this). I'm afraid of what else can get us into that situation besides the export-decl.

The FIXME has been removed; the problem seems to be that the test is broken. See https://reviews.llvm.org/D53847?id=462032#inline-1297092

[erichkeane]

Thanks for looking into it. I think you're right that it is a mistake that we accepted that without the 'struct' keyword after a quick look, so I think I am OK with this. Please give @aaron.ballman a day or so to take a look if he wishes.

[ayzhao]

clang-format + rebase

[cor3ntin]

It's great to see this make progress.
Can you update cxx_status.html and ReleaseNotes.txt?

[ayzhao]

update cxx_status.html and ReleaseNotes.rst + rebase

[ayzhao]

In D53847#3817376, @cor3ntin wrote:

It's great to see this make progress.
Can you update cxx_status.html and ReleaseNotes.txt?

Done.

I also saw that P2092R0 was marked as partially supported in cxx_status.html due to missing support for P0634R3, but I'm not familiar enough with P2092R0 to update that entry.

[cor3ntin]

Good catch

template<typename T>
concept K = requires (typename T::Type X) { // (3)
X.next();
}

That typename should be optional. Can you add a test for that? If it works you can mark P2092 as fully supported.

[ayzhao]

In D53847#3819200, @cor3ntin wrote:

Good catch

template<typename T>
concept K = requires (typename T::Type X) { // (3)
X.next();
}

That typename should be optional. Can you add a test for that? If it works you can mark P2092 as fully supported.

Done.

The test originally failed, but it was a simple fix to get it to work.

[ayzhao]

add test and fix for P2092

[cor3ntin]

In D53847#3819344, @ayzhao wrote:

add test and fix for P2092

These changes look good to me, thanks

include/clang/Basic/DiagnosticSemaKinds.td

 def warn_cxx98_compat_typename_outside_of_template : Warning<
   "use of 'typename' outside of a template is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_typename_refers_to_using_value_decl : Error<
   "typename specifier refers to a dependent using declaration for a value "
   "%0 in %1">;
 def note_using_value_decl_missing_typename : Note<
   "add 'typename' to treat this using declaration as a type">;
+def warn_cxx17_compat_implicit_typename : Warning<"use of implicit 'typename' is "
+  "incompatible with C++ standards before C++2a">, InGroup<CXX2aCompat>,
+  DefaultIgnore;
+def ext_implicit_typename : ExtWarn<"missing 'typename' prior to dependent "
+  "type name %0%1; implicit 'typename' is a C++2a extension">,
+  InGroup<CXX2a>;
 
 def err_template_kw_refers_to_non_template : Error<
   "%0 following the 'template' keyword does not refer to a template">;
 def note_template_kw_refers_to_non_template : Note<
   "declared as a non-template here">;
 def err_template_kw_refers_to_class_template : Error<
   "'%0%1' instantiated to a class template, not a function template">;
 def note_referenced_class_template : Note<

include/clang/Parse/Parser.h

private:
   /// token.
   static void setExprAnnotation(Token &Tok, ExprResult ER) {
     Tok.setAnnotationValue(ER.getAsOpaquePointer());
   }
 
 public:
   // If NeedType is true, then TryAnnotateTypeOrScopeToken will try harder to
   // find a type name by attempting typo correction.
-  bool TryAnnotateTypeOrScopeToken();
+  bool TryAnnotateTypeOrScopeToken(bool AllowImplicitTypename = false);
   bool TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS,
-                                                 bool IsNewScope);
+                                                 bool IsNewScope,
+                                                 bool AllowImplicitTypename);
   bool TryAnnotateCXXScopeToken(bool EnteringContext = false);
 
 private:
   enum AnnotatedNameKind {
     /// Annotation has failed and emitted an error.
     ANK_Error,
     /// The identifier is a tentatively-declared name.
     ANK_TentativeDecl,
private:
   enum class DeclSpecContext {
     DSC_normal, // normal context
     DSC_class,  // class context, enables 'friend'
     DSC_type_specifier, // C++ type-specifier-seq or C specifier-qualifier-list
     DSC_trailing, // C++11 trailing-type-specifier in a trailing return type
     DSC_alias_declaration, // C++11 type-specifier-seq in an alias-declaration
     DSC_top_level, // top-level/namespace declaration context
     DSC_template_param, // template parameter context
+    DSC_template_arg, // template argument context
     DSC_template_type_arg, // template type argument context
     DSC_objc_method_result, // ObjC method result context, enables 'instancetype'
     DSC_condition // condition declaration context
   };
 
   /// Is this a context in which we are parsing just a type-specifier (or
   /// trailing-type-specifier)?
   static bool isTypeSpecifier(DeclSpecContext DSC) {
     switch (DSC) {
     case DeclSpecContext::DSC_normal:
     case DeclSpecContext::DSC_template_param:
+    case DeclSpecContext::DSC_template_arg:
     case DeclSpecContext::DSC_class:
     case DeclSpecContext::DSC_top_level:
     case DeclSpecContext::DSC_objc_method_result:
     case DeclSpecContext::DSC_condition:
       return false;
 
     case DeclSpecContext::DSC_template_type_arg:
     case DeclSpecContext::DSC_type_specifier:
     case DeclSpecContext::DSC_trailing:
     case DeclSpecContext::DSC_alias_declaration:
       return true;
     }
     llvm_unreachable("Missing DeclSpecContext case");
   }
 
   /// Is this a context in which we can perform class template argument
   /// deduction?
   static bool isClassTemplateDeductionContext(DeclSpecContext DSC) {
     switch (DSC) {
     case DeclSpecContext::DSC_normal:
     case DeclSpecContext::DSC_template_param:
+    case DeclSpecContext::DSC_template_arg:
     case DeclSpecContext::DSC_class:
     case DeclSpecContext::DSC_top_level:
     case DeclSpecContext::DSC_condition:
     case DeclSpecContext::DSC_type_specifier:
       return true;
 
     case DeclSpecContext::DSC_objc_method_result:
     case DeclSpecContext::DSC_template_type_arg:
     case DeclSpecContext::DSC_trailing:
     case DeclSpecContext::DSC_alias_declaration:
       return false;
     }
     llvm_unreachable("Missing DeclSpecContext case");
   }
 
+  // Is this a context in which an implicit 'typename' is allowed?
+  static bool isImplicitTypenameContext(DeclSpecContext DSC) {
+    switch (DSC) {
+    case DeclSpecContext::DSC_class:
+    case DeclSpecContext::DSC_top_level:
+    case DeclSpecContext::DSC_type_specifier:
+    case DeclSpecContext::DSC_template_type_arg:
+    case DeclSpecContext::DSC_trailing:
+    case DeclSpecContext::DSC_alias_declaration:
+    case DeclSpecContext::DSC_template_param:
+      return true;
+
+    case DeclSpecContext::DSC_normal:
+    case DeclSpecContext::DSC_objc_method_result:
+    case DeclSpecContext::DSC_condition:
+    case DeclSpecContext::DSC_template_arg:
+      return false;
+    }
+    llvm_unreachable("Missing DeclSpecContext case");
+  }
+
   /// Information on a C++0x for-range-initializer found while parsing a
   /// declaration which turns out to be a for-range-declaration.
   struct ForRangeInit {
     SourceLocation ColonLoc;
     ExprResult RangeExpr;
 
     bool ParsedForRangeDecl() { return !ColonLoc.isInvalid(); }
   };
bool ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
                         ParsedAttributesWithRange &Attrs);
   DeclSpecContext
   getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context);
   void ParseDeclarationSpecifiers(
       DeclSpec &DS,
       const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
       AccessSpecifier AS = AS_none,
       DeclSpecContext DSC = DeclSpecContext::DSC_normal,
-      LateParsedAttrList *LateAttrs = nullptr);
+      LateParsedAttrList *LateAttrs = nullptr) {
+    return ParseDeclarationSpecifiers(DS, TemplateInfo, AS, DSC, LateAttrs,
+                                      isImplicitTypenameContext(DSC));
+  }
+  void ParseDeclarationSpecifiers(
+      DeclSpec &DS,
+      const ParsedTemplateInfo &TemplateInfo,
+      AccessSpecifier AS,
+      DeclSpecContext DSC,
+      LateParsedAttrList *LateAttrs,
+      bool AllowImplicitTypename);
+
   bool DiagnoseMissingSemiAfterTagDefinition(
       DeclSpec &DS, AccessSpecifier AS, DeclSpecContext DSContext,
       LateParsedAttrList *LateAttrs = nullptr);
 
   void ParseSpecifierQualifierList(
       DeclSpec &DS, AccessSpecifier AS = AS_none,
       DeclSpecContext DSC = DeclSpecContext::DSC_normal);
 
private:
 
   /// isCXXFunctionDeclarator - Disambiguates between a function declarator or
   /// a constructor-style initializer, when parsing declaration statements.
   /// Returns true for function declarator and false for constructor-style
   /// initializer. Sets 'IsAmbiguous' to true to indicate that this declaration
   /// might be a constructor-style initializer.
   /// If during the disambiguation process a parsing error is encountered,
   /// the function returns true to let the declaration parsing code handle it.
-  bool isCXXFunctionDeclarator(bool *IsAmbiguous = nullptr);
+  bool isCXXFunctionDeclarator(bool *IsAmbiguous = nullptr,
+                               bool AllowImplicitTypename = false);
 
   struct ConditionDeclarationOrInitStatementState;
   enum class ConditionOrInitStatement {
     Expression,    ///< Disambiguated as an expression (either kind).
     ConditionDecl, ///< Disambiguated as the declaration form of condition.
     InitStmtDecl,  ///< Disambiguated as a simple-declaration init-statement.
     ForRangeDecl,  ///< Disambiguated as a for-range declaration.
     Error          ///< Can't be any of the above!
private:
   /// declaration specifier, TPResult::False if it is not,
   /// TPResult::Ambiguous if it could be either a decl-specifier or a
   /// function-style cast, and TPResult::Error if a parsing error was
   /// encountered. If it could be a braced C++11 function-style cast, returns
   /// BracedCastResult.
   /// Doesn't consume tokens.
   TPResult
   isCXXDeclarationSpecifier(TPResult BracedCastResult = TPResult::False,
-                            bool *HasMissingTypename = nullptr);
+                            bool *HasMissingTypename = nullptr,
+                            bool AllowImplicitTypename = false);
 
   /// Given that isCXXDeclarationSpecifier returns \c TPResult::True or
   /// \c TPResult::Ambiguous, determine whether the decl-specifier would be
   /// a type-specifier other than a cv-qualifier.
   bool isCXXDeclarationSpecifierAType();
 
   /// Determine whether an identifier has been tentatively declared as a
   /// non-type. Such tentative declarations should not be found to name a type
private:
   TPResult TryParseProtocolQualifiers();
   TPResult TryParsePtrOperatorSeq();
   TPResult TryParseOperatorId();
   TPResult TryParseInitDeclaratorList();
   TPResult TryParseDeclarator(bool mayBeAbstract, bool mayHaveIdentifier = true,
                               bool mayHaveDirectInit = false);
   TPResult
   TryParseParameterDeclarationClause(bool *InvalidAsDeclaration = nullptr,
-                                     bool VersusTemplateArg = false);
+                                     bool VersusTemplateArg = false,
+                                     bool AllowImplicitTypename = false);
   TPResult TryParseFunctionDeclarator();
   TPResult TryParseBracketDeclarator();
   TPResult TryConsumeDeclarationSpecifier();
 
 public:
   TypeResult ParseTypeName(SourceRange *Range = nullptr,
                            DeclaratorContext Context
                              = DeclaratorContext::TypeNameContext,

include/clang/Sema/DeclSpec.h

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace clang {
   class ASTContext;
   class CXXRecordDecl;
   class TypeLoc;
   class LangOptions;
+  class LookupResult;
   class IdentifierInfo;
   class NamespaceAliasDecl;
   class NamespaceDecl;
   class ObjCDeclSpec;
   class Sema;
   class Declarator;
   struct TemplateIdAnnotation;
 
#endif
   /// If this is the second or subsequent declarator in this declaration,
   /// the location of the comma before this declarator.
   SourceLocation CommaLoc;
 
   /// If provided, the source location of the ellipsis used to describe
   /// this declarator as a parameter pack.
   SourceLocation EllipsisLoc;
 
+  /// Lookup result of declarator, if any.
+  LookupResult *PrevLookupResult;
+
   friend struct DeclaratorChunk;
 
 public:
   Declarator(const DeclSpec &ds, DeclaratorContext C)
       : DS(ds), Range(ds.getSourceRange()), Context(C),
         InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
         GroupingParens(false), FunctionDefinition(FDK_Declaration),
         Redeclaration(false), Extension(false), ObjCIvar(false),
         ObjCWeakProperty(false), InlineStorageUsed(false),
-        Attrs(ds.getAttributePool().getFactory()), AsmLabel(nullptr) {}
+        Attrs(ds.getAttributePool().getFactory()), AsmLabel(nullptr),
+        PrevLookupResult(nullptr) {}
 
   ~Declarator() {
     clear();
   }
   /// getDeclSpec - Return the declaration-specifier that this declarator was
   /// declared with.
   const DeclSpec &getDeclSpec() const { return DS; }
 
public:
   /// redeclaration time if the decl is static.
   bool isStaticMember();
 
   /// Returns true if this declares a constructor or a destructor.
   bool isCtorOrDtor();
 
   void setRedeclaration(bool Val) { Redeclaration = Val; }
   bool isRedeclaration() const { return Redeclaration; }
+
+  void setPrevLookupResult(LookupResult *LR) { PrevLookupResult = LR; }
+  LookupResult &getPrevLookupResult() {
+    assert(PrevLookupResult);
+    return *PrevLookupResult;
+  }
+  const LookupResult &getPrevLookupResult() const {
+    assert(PrevLookupResult);
+    return *PrevLookupResult;
+  }
+  bool hasPrevLookupResult() const { return PrevLookupResult; }
 };
 
 /// This little struct is used to capture information about
 /// structure field declarators, which is basically just a bitfield size.
 struct FieldDeclarator {
   Declarator D;
   Expr *BitfieldSize;
   explicit FieldDeclarator(const DeclSpec &DS)

include/clang/Sema/Sema.h

public:
 
   ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
                          Scope *S, CXXScopeSpec *SS = nullptr,
                          bool isClassName = false, bool HasTrailingDot = false,
                          ParsedType ObjectType = nullptr,
                          bool IsCtorOrDtorName = false,
                          bool WantNontrivialTypeSourceInfo = false,
                          bool IsClassTemplateDeductionContext = true,
+                         bool AllowImplicitTypename = false,
                          IdentifierInfo **CorrectedII = nullptr);
   TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
   bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
   void DiagnoseUnknownTypeName(IdentifierInfo *&II,
                                SourceLocation IILoc,
                                Scope *S,
                                CXXScopeSpec *SS,
                                ParsedType &SuggestedType,
public:
   /// definition, assuming we don't care about analyzing its body or emitting
   /// code for that function.
   ///
   /// This will be \c false only if we may need the body of the function in
   /// order to parse the rest of the program (for instance, if it is
   /// \c constexpr in C++11 or has an 'auto' return type in C++14).
   bool canSkipFunctionBody(Decl *D);
 
+  /// Determine whether \param D is function like (function or function
+  /// template) for parsing.
+  bool isDeclaratorFunctionLike(Declarator &D);
+
   void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
   Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
   Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
   Decl *ActOnSkippedFunctionBody(Decl *Decl);
   void ActOnFinishInlineFunctionDef(FunctionDecl *D);
 
   /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
   /// attribute for which parsing is delayed.

   /// Called when the parser has parsed a C++ typename
   /// specifier, e.g., "typename T::type".
   ///
   /// \param S The scope in which this typename type occurs.
   /// \param TypenameLoc the location of the 'typename' keyword
   /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
   /// \param II the identifier we're retrieving (e.g., 'type' in the example).
   /// \param IdLoc the location of the identifier.
-  TypeResult
-  ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
+  TypeResult ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
                                const CXXScopeSpec &SS, const IdentifierInfo &II,
-                    SourceLocation IdLoc);
+                               SourceLocation IdLoc,
+                               bool IsImplicitTypename = false);
 
   /// Called when the parser has parsed a C++ typename
   /// specifier that ends in a template-id, e.g.,
   /// "typename MetaFun::template apply<T1, T2>".
   ///
   /// \param S The scope in which this typename type occurs.
   /// \param TypenameLoc the location of the 'typename' keyword
   /// \param SS the nested-name-specifier following the typename (e.g., 'T::').

lib/Parse/ParseDecl.cpp

if (!isTypeSpecifier(DSC) && (!SS || DSC == DeclSpecContext::DSC_top_level ||
     case tok::comma:
     case tok::equal:
     case tok::kw_asm:
     case tok::l_brace:
     case tok::l_square:
     case tok::semi:
       // This looks like a variable or function declaration. The type is
       // probably missing. We're done parsing decl-specifiers.
+      // But only if we are not in a function prototype scope.
+      if (getCurScope()->isFunctionPrototypeScope())
+        break;
       if (SS)
         AnnotateScopeToken(*SS, /*IsNewAnnotation*/false);
       return false;
 
     default:
       // This is probably supposed to be a type. This includes cases like:
       //   int f(itn);
       //   struct S { unsinged : 4; };
bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS,
   return false;
 }
 
 /// Determine the declaration specifier context from the declarator
 /// context.
 ///
 /// \param Context the declarator context, which is one of the
 /// DeclaratorContext enumerator values.
 Parser::DeclSpecContext
 Parser::getDeclSpecContextFromDeclaratorContext(DeclaratorContext Context) {
-  if (Context == DeclaratorContext::MemberContext)
+  switch (Context) {
+  case DeclaratorContext::MemberContext:
     return DeclSpecContext::DSC_class;
-  if (Context == DeclaratorContext::FileContext)
+  case DeclaratorContext::FileContext:
     return DeclSpecContext::DSC_top_level;
-  if (Context == DeclaratorContext::TemplateParamContext)
+  case DeclaratorContext::TemplateParamContext:
     return DeclSpecContext::DSC_template_param;
-  if (Context == DeclaratorContext::TemplateArgContext ||
-      Context == DeclaratorContext::TemplateTypeArgContext)
+  case DeclaratorContext::TemplateArgContext:
+    return DeclSpecContext::DSC_template_arg;
+  case DeclaratorContext::TemplateTypeArgContext:
     return DeclSpecContext::DSC_template_type_arg;
-  if (Context == DeclaratorContext::TrailingReturnContext ||
-      Context == DeclaratorContext::TrailingReturnVarContext)
+  case DeclaratorContext::TrailingReturnContext:
+  case DeclaratorContext::TrailingReturnVarContext:
     return DeclSpecContext::DSC_trailing;
-  if (Context == DeclaratorContext::AliasDeclContext ||
-      Context == DeclaratorContext::AliasTemplateContext)
+  case DeclaratorContext::AliasDeclContext:
+  case DeclaratorContext::AliasTemplateContext:
     return DeclSpecContext::DSC_alias_declaration;
+  case DeclaratorContext::TypeNameContext:
+    return DeclSpecContext::DSC_type_specifier;
+  case DeclaratorContext::ConditionContext:
+    return DeclSpecContext::DSC_condition;
+  case DeclaratorContext::PrototypeContext:
+  case DeclaratorContext::ObjCResultContext:
+  case DeclaratorContext::ObjCParameterContext:
+  case DeclaratorContext::KNRTypeListContext:
+  case DeclaratorContext::FunctionalCastContext:
+  case DeclaratorContext::BlockContext:
+  case DeclaratorContext::ForContext:
+  case DeclaratorContext::InitStmtContext:
+  case DeclaratorContext::CXXNewContext:
+  case DeclaratorContext::CXXCatchContext:
+  case DeclaratorContext::ObjCCatchContext:
+  case DeclaratorContext::BlockLiteralContext:
+  case DeclaratorContext::LambdaExprContext:
+  case DeclaratorContext::LambdaExprParameterContext:
+  case DeclaratorContext::ConversionIdContext:
     return DeclSpecContext::DSC_normal;
   }
 
+  llvm_unreachable("Missing DeclaratorContext case");
+}
+
 /// ParseAlignArgument - Parse the argument to an alignment-specifier.
 ///
 /// FIXME: Simply returns an alignof() expression if the argument is a
 /// type. Ideally, the type should be propagated directly into Sema.
 ///
 /// [C11]   type-id
 /// [C11]   constant-expression
 /// [C++0x] type-id ...[opt]

 /// [C++]   'explicit'
 /// [OpenCL] '__kernel'
 ///       'friend': [C++ dcl.friend]
 ///       'constexpr': [C++0x dcl.constexpr]
 void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
                                         const ParsedTemplateInfo &TemplateInfo,
                                         AccessSpecifier AS,
                                         DeclSpecContext DSContext,
-                                        LateParsedAttrList *LateAttrs) {
+                                        LateParsedAttrList *LateAttrs,
+                                        bool AllowImplicitTypename) {
   if (DS.getSourceRange().isInvalid()) {
     // Start the range at the current token but make the end of the range
     // invalid.  This will make the entire range invalid unless we successfully
     // consume a token.
     DS.SetRangeStart(Tok.getLocation());
     DS.SetRangeEnd(SourceLocation());
   }
 
case tok::annot_cxxscope: {
       // shape of a constructor declaration, process it as one.
       if ((DSContext == DeclSpecContext::DSC_top_level ||
            DSContext == DeclSpecContext::DSC_class) &&
           Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(),
                                      &SS) &&
           isConstructorDeclarator(/*Unqualified*/ false))
         goto DoneWithDeclSpec;
 
-      ParsedType TypeRep =
-          Actions.getTypeName(*Next.getIdentifierInfo(), Next.getLocation(),
-                              getCurScope(), &SS, false, false, nullptr,
-                              /*IsCtorOrDtorName=*/false,
-                              /*WantNonTrivialSourceInfo=*/true,
-                              isClassTemplateDeductionContext(DSContext));
+      ParsedType TypeRep = Actions.getTypeName(
+          *Next.getIdentifierInfo(), Next.getLocation(), getCurScope(), &SS,
+          false, false, nullptr,
+          isClassTemplateDeductionContext(DSContext),
+          AllowImplicitTypename);
 
       // If the referenced identifier is not a type, then this declspec is
       // erroneous: We already checked about that it has no type specifier, and
       // C++ doesn't have implicit int.  Diagnose it as a typo w.r.t. to the
       // typename.
       if (!TypeRep) {
         // Eat the scope spec so the identifier is current.
         ConsumeAnnotationToken();
if (getLangOpts().ObjC && NextToken().is(tok::period))
       return false;
     if (TryAltiVecVectorToken())
       return true;
     LLVM_FALLTHROUGH;
   case tok::kw_decltype: // decltype(T())::type
   case tok::kw_typename: // typename T::type
     // Annotate typenames and C++ scope specifiers.  If we get one, just
     // recurse to handle whatever we get.
-    if (TryAnnotateTypeOrScopeToken())
+    if (TryAnnotateTypeOrScopeToken(/*AllowImplicitTypename=*/true))
       return true;
     if (Tok.is(tok::identifier))
       return false;
 
     // If we're in Objective-C and we have an Objective-C class type followed
     // by an identifier and then either ':' or ']', in a place where an
     // expression is permitted, then this is probably a class message send
     // missing the initial '['. In this case, we won't consider this to be
if (Tok.is(tok::l_paren)) {
                                 (D.isFunctionDeclaratorAFunctionDeclaration()
                                    ? Scope::FunctionDeclarationScope : 0));
 
       // The paren may be part of a C++ direct initializer, eg. "int x(1);".
       // In such a case, check if we actually have a function declarator; if it
       // is not, the declarator has been fully parsed.
       bool IsAmbiguous = false;
       if (getLangOpts().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
+        bool AllowImplicitTypename = false;
+        if (D.getCXXScopeSpec().isSet())
+          AllowImplicitTypename = Actions.isDeclaratorFunctionLike(D);
+        else if (D.getContext() == DeclaratorContext::MemberContext)
+          AllowImplicitTypename = true;
+
         // The name of the declarator, if any, is tentatively declared within
         // a possible direct initializer.
         TentativelyDeclaredIdentifiers.push_back(D.getIdentifier());
-        bool IsFunctionDecl = isCXXFunctionDeclarator(&IsAmbiguous);
+        bool IsFunctionDecl =
+            isCXXFunctionDeclarator(&IsAmbiguous, AllowImplicitTypename);
         TentativelyDeclaredIdentifiers.pop_back();
         if (!IsFunctionDecl)
           break;
       }
       ParsedAttributes attrs(AttrFactory);
       BalancedDelimiterTracker T(*this, tok::l_paren);
       T.consumeOpen();
       ParseFunctionDeclarator(D, attrs, T, IsAmbiguous);
       PrototypeScope.Exit();
     } else if (Tok.is(tok::l_square)) {
       ParseBracketDeclarator(D);
     } else {
       break;
     }
   }
 }
 
 void Parser::ParseDecompositionDeclarator(Declarator &D) {
   assert(Tok.is(tok::l_square));
 
   // If this doesn't look like a structured binding, maybe it's a misplaced
   // array declarator.
   // FIXME: Consume the l_square first so we don't need extra lookahead for
   // this.
   if (!(NextToken().is(tok::identifier) &&
         GetLookAheadToken(2).isOneOf(tok::comma, tok::r_square)) &&
       !(NextToken().is(tok::r_square) &&

 /// [GNU]   declaration-specifiers abstract-declarator[opt] attributes
 /// [C++11] attribute-specifier-seq parameter-declaration
 ///
 void Parser::ParseParameterDeclarationClause(
        Declarator &D,
        ParsedAttributes &FirstArgAttrs,
        SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
        SourceLocation &EllipsisLoc) {
+
+  bool AllowImplicitTypename;
+  if (D.getContext() == DeclaratorContext::MemberContext ||
+      D.getContext() == DeclaratorContext::LambdaExprContext)
+    AllowImplicitTypename = true;
+  else
+    AllowImplicitTypename = D.getCXXScopeSpec().isSet() &&
+                            D.isFunctionDeclaratorAFunctionDeclaration();
+
   do {
     // FIXME: Issue a diagnostic if we parsed an attribute-specifier-seq
     // before deciding this was a parameter-declaration-clause.
     if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
       break;
 
     // Parse the declaration-specifiers.
     // Just use the ParsingDeclaration "scope" of the declarator.
     DeclSpec DS(AttrFactory);
 
     // Parse any C++11 attributes.
     MaybeParseCXX11Attributes(DS.getAttributes());
 
     // Skip any Microsoft attributes before a param.
     MaybeParseMicrosoftAttributes(DS.getAttributes());
 
     SourceLocation DSStart = Tok.getLocation();
 
     // If the caller parsed attributes for the first argument, add them now.
     // Take them so that we only apply the attributes to the first parameter.
     // FIXME: If we can leave the attributes in the token stream somehow, we can
     // get rid of a parameter (FirstArgAttrs) and this statement. It might be
     // too much hassle.
     DS.takeAttributesFrom(FirstArgAttrs);
 
-    ParseDeclarationSpecifiers(DS);
-
+    ParseDeclarationSpecifiers(DS, /*TemplateInfo=*/ParsedTemplateInfo(),
+                               AS_none, DeclSpecContext::DSC_normal,
+                               /*LateAttrs=*/nullptr, AllowImplicitTypename);
 
     // Parse the declarator.  This is "PrototypeContext" or
     // "LambdaExprParameterContext", because we must accept either
     // 'declarator' or 'abstract-declarator' here.
     Declarator ParmDeclarator(
         DS, D.getContext() == DeclaratorContext::LambdaExprContext
                 ? DeclaratorContext::LambdaExprParameterContext
                 : DeclaratorContext::PrototypeContext);
     ParseDeclarator(ParmDeclarator);
 
     // Parse GNU attributes, if present.

lib/Parse/ParseDeclCXX.cpp

TypeResult Parser::ParseBaseTypeSpecifier(SourceLocation &BaseLoc,
   }
 
   // We have an identifier; check whether it is actually a type.
   IdentifierInfo *CorrectedII = nullptr;
   ParsedType Type = Actions.getTypeName(
       *Id, IdLoc, getCurScope(), &SS, /*IsClassName=*/true, false, nullptr,
       /*IsCtorOrDtorName=*/false,
       /*NonTrivialTypeSourceInfo=*/true,
-      /*IsClassTemplateDeductionContext*/ false, &CorrectedII);
+      /*IsClassTemplateDeductionContext*/ false,
+      /*AllowImplicitTypename=*/false, &CorrectedII);
   if (!Type) {
     Diag(IdLoc, diag::err_expected_class_name);
     return true;
   }
 
   // Consume the identifier.
   EndLocation = IdLoc;
 

lib/Parse/ParseExprCXX.cpp

if (Next.is(tok::colon) && areTokensAdjacent(Tok, Next))
       FixDigraph(*this, PP, Tok, Next, Kind, /*AtDigraph*/true);
   }
 
   if (ExpectAndConsume(tok::less, diag::err_expected_less_after, CastName))
     return ExprError();
 
   // Parse the common declaration-specifiers piece.
   DeclSpec DS(AttrFactory);
-  ParseSpecifierQualifierList(DS);
+  ParseSpecifierQualifierList(DS, /*AccessSpecifier=*/AS_none,
+                              DeclSpecContext::DSC_type_specifier);
 
   // Parse the abstract-declarator, if present.
   Declarator DeclaratorInfo(DS, DeclaratorContext::TypeNameContext);
   ParseDeclarator(DeclaratorInfo);
 
   SourceLocation RAngleBracketLoc = Tok.getLocation();
 
   if (ExpectAndConsume(tok::greater))

lib/Parse/ParseTemplate.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
+#include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 using namespace clang;
 
 /// Parse a template declaration, explicit instantiation, or
 /// explicit specialization.
 Decl *Parser::ParseDeclarationStartingWithTemplate(
     DeclaratorContext Context, SourceLocation &DeclEnd,

lib/Parse/ParseTentative.cpp

 ///
 ///         cv-qualifier:
 ///           'const'
 ///           'volatile'
 /// [GNU]     restrict
 ///
 Parser::TPResult
 Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
-                                  bool *HasMissingTypename) {
+                                  bool *HasMissingTypename,
+                                  bool AllowImplicitTypename) {
+  const bool NoImplicitTypename = !HasMissingTypename || !AllowImplicitTypename;
+
   switch (Tok.getKind()) {
   case tok::identifier: {
     // Check for need to substitute AltiVec __vector keyword
     // for "vector" identifier.
     if (TryAltiVecVectorToken())
       return TPResult::True;
 
     const Token &Next = NextToken();
if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
       case ANK_TentativeDecl:
         return TPResult::False;
       case ANK_TemplateName:
         // In C++17, this could be a type template for class template argument
         // deduction. Try to form a type annotation for it. If we're in a
         // template template argument, we'll undo this when checking the
         // validity of the argument.
         if (getLangOpts().CPlusPlus17) {
-          if (TryAnnotateTypeOrScopeToken())
+          if (TryAnnotateTypeOrScopeToken(NoImplicitTypename))
             return TPResult::Error;
           if (Tok.isNot(tok::identifier))
             break;
         }
 
         // A bare type template-name which can't be a template template
         // argument is an error, and was probably intended to be a type.
         return GreaterThanIsOperator ? TPResult::True : TPResult::False;
       case ANK_Unresolved:
         return HasMissingTypename ? TPResult::Ambiguous : TPResult::False;
       case ANK_Success:
         break;
       }
       assert(Tok.isNot(tok::identifier) &&
              "TryAnnotateName succeeded without producing an annotation");
     } else {
       // This might possibly be a type with a dependent scope specifier and
       // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
       // since it will annotate as a primary expression, and we want to use the
       // "missing 'typename'" logic.
-      if (TryAnnotateTypeOrScopeToken())
+      if (TryAnnotateTypeOrScopeToken(!NoImplicitTypename))
         return TPResult::Error;
       // If annotation failed, assume it's a non-type.
       // FIXME: If this happens due to an undeclared identifier, treat it as
       // ambiguous.
       if (Tok.is(tok::identifier))
         return TPResult::False;
     }
 
     // We annotated this token as something. Recurse to handle whatever we got.
     return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
   }
 
   case tok::kw_typename:  // typename T::type
     // Annotate typenames and C++ scope specifiers.  If we get one, just
     // recurse to handle whatever we get.
-    if (TryAnnotateTypeOrScopeToken())
+    if (TryAnnotateTypeOrScopeToken(/*AllowImplicitTypename=*/true))
       return TPResult::Error;
     return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
 
   case tok::coloncolon: {    // ::foo::bar
     const Token &Next = NextToken();
     if (Next.isOneOf(tok::kw_new,       // ::new
                      tok::kw_delete))   // ::delete
       return TPResult::False;
     LLVM_FALLTHROUGH;
   }
   case tok::kw___super:
   case tok::kw_decltype:
     // Annotate typenames and C++ scope specifiers.  If we get one, just
     // recurse to handle whatever we get.
-    if (TryAnnotateTypeOrScopeToken())
+    if (TryAnnotateTypeOrScopeToken(!NoImplicitTypename))
       return TPResult::Error;
     return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
 
     // decl-specifier:
     //   storage-class-specifier
     //   type-specifier
     //   function-specifier
     //   'friend'
case tok::annot_template_id: {
     CXXScopeSpec SS;
     AnnotateTemplateIdTokenAsType();
     assert(Tok.is(tok::annot_typename));
     goto case_typename;
   }
 
   case tok::annot_cxxscope: // foo::bar or ::foo::bar, but already parsed
     // We've already annotated a scope; try to annotate a type.
-    if (TryAnnotateTypeOrScopeToken())
+    if (TryAnnotateTypeOrScopeToken(!NoImplicitTypename))
       return TPResult::Error;
     if (!Tok.is(tok::annot_typename)) {
       // If the next token is an identifier or a type qualifier, then this
       // can't possibly be a valid expression either.
       if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
         CXXScopeSpec SS;
         Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(),
                                                      Tok.getAnnotationRange(),

 /// Returns true for function declarator and false for constructor-style
 /// initializer.
 /// If during the disambiguation process a parsing error is encountered,
 /// the function returns true to let the declaration parsing code handle it.
 ///
 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
 ///         exception-specification[opt]
 ///
-bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous) {
+bool Parser::isCXXFunctionDeclarator(bool *IsAmbiguous,
+                                     bool AllowImplicitTypename) {
 
   // C++ 8.2p1:
   // The ambiguity arising from the similarity between a function-style cast and
   // a declaration mentioned in 6.8 can also occur in the context of a
   // declaration. In that context, the choice is between a function declaration
   // with a redundant set of parentheses around a parameter name and an object
   // declaration with a function-style cast as the initializer. Just as for the
   // ambiguities mentioned in 6.8, the resolution is to consider any construct
   // that could possibly be a declaration a declaration.
 
   RevertingTentativeParsingAction PA(*this);
 
   ConsumeParen();
   bool InvalidAsDeclaration = false;
-  TPResult TPR = TryParseParameterDeclarationClause(&InvalidAsDeclaration);
+  TPResult TPR = TryParseParameterDeclarationClause(
+      &InvalidAsDeclaration, /*VersusTemplateArgument=*/false,
+      AllowImplicitTypename);
   if (TPR == TPResult::Ambiguous) {
     if (Tok.isNot(tok::r_paren))
       TPR = TPResult::False;
     else {
       const Token &Next = NextToken();
       if (Next.isOneOf(tok::amp, tok::ampamp, tok::kw_const, tok::kw_volatile,
                        tok::kw_throw, tok::kw_noexcept, tok::l_square,
                        tok::l_brace, tok::kw_try, tok::equal, tok::arrow) ||
           isCXX11VirtSpecifier(Next))
         // The next token cannot appear after a constructor-style initializer,
         // and can appear next in a function definition. This must be a function
         // declarator.
         TPR = TPResult::True;
       else if (InvalidAsDeclaration)
         // Use the absence of 'typename' as a tie-breaker.
         TPR = TPResult::False;
     }
   }
 
   if (IsAmbiguous && TPR == TPResult::Ambiguous)
     *IsAmbiguous = true;
 
   // In case of an error, let the declaration parsing code handle it.
   return TPR != TPResult::False;
 }
 
 /// parameter-declaration-clause:
 ///   parameter-declaration-list[opt] '...'[opt]

 ///     '=' assignment-expression
 ///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
 ///     attributes[opt]
 ///   attribute-specifier-seq[opt] decl-specifier-seq abstract-declarator[opt]
 ///     attributes[opt] '=' assignment-expression
 ///
 Parser::TPResult
 Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
-                                           bool VersusTemplateArgument) {
+                                           bool VersusTemplateArgument,
+                                           bool AllowImplicitTypename) {
 
   if (Tok.is(tok::r_paren))
     return TPResult::Ambiguous;
 
   //   parameter-declaration-list[opt] '...'[opt]
   //   parameter-declaration-list ',' '...'
   //
   // parameter-declaration-list:
if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
       return TPResult::True;
 
     ParsedAttributes attrs(AttrFactory);
     MaybeParseMicrosoftAttributes(attrs);
 
     // decl-specifier-seq
     // A parameter-declaration's initializer must be preceded by an '=', so
     // decl-specifier-seq '{' is not a parameter in C++11.
-    TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
-                                             InvalidAsDeclaration);
+    TPResult TPR = isCXXDeclarationSpecifier(
+        TPResult::False, InvalidAsDeclaration, AllowImplicitTypename);
 
     if (VersusTemplateArgument && TPR == TPResult::True) {
       // Consume the decl-specifier-seq. We have to look past it, since a
       // type-id might appear here in a template argument.
       bool SeenType = false;
       do {
         SeenType |= isCXXDeclarationSpecifierAType();
         if (TryConsumeDeclarationSpecifier() == TPResult::Error)

lib/Parse/Parser.cpp

Parser::TryAnnotateName(bool IsAddressOfOperand,
   const bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope);
 
   CXXScopeSpec SS;
   if (getLangOpts().CPlusPlus &&
       ParseOptionalCXXScopeSpecifier(SS, nullptr, EnteringContext))
     return ANK_Error;
 
   if (Tok.isNot(tok::identifier) || SS.isInvalid()) {
-    if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation))
+    if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(
+            SS, !WasScopeAnnotation, /*AllowImplicitTypename=*/false))
       return ANK_Error;
     return ANK_Unresolved;
   }
 
   IdentifierInfo *Name = Tok.getIdentifierInfo();
   SourceLocation NameLoc = Tok.getLocation();
 
   // FIXME: Move the tentative declaration logic into ClassifyName so we can
   // typo-correct to tentatively-declared identifiers.
-  if (isTentativelyDeclared(Name)) {
+  if (isTentativelyDeclared(Name) && SS.isEmpty()) {
     // Identifier has been tentatively declared, and thus cannot be resolved as
     // an expression. Fall back to annotating it as a type.
-    if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation))
+    if (TryAnnotateTypeOrScopeTokenAfterScopeSpec(
+            SS, !WasScopeAnnotation, /*AllowImplicitTypename=*/false))
       return ANK_Error;
     return Tok.is(tok::annot_typename) ? ANK_Success : ANK_TentativeDecl;
   }
 
   Token Next = NextToken();
 
   // Look up and classify the identifier. We don't perform any typo-correction
   // after a scope specifier, because in general we can't recover from typos

 /// will not be called twice, once to check whether we have a declaration
 /// specifier, and another one to get the actual type inside
 /// ParseDeclarationSpecifiers).
 ///
 /// This returns true if an error occurred.
 ///
 /// Note that this routine emits an error if you call it with ::new or ::delete
 /// as the current tokens, so only call it in contexts where these are invalid.
-bool Parser::TryAnnotateTypeOrScopeToken() {
+bool Parser::TryAnnotateTypeOrScopeToken(bool AllowImplicitTypename) {
   assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon) ||
           Tok.is(tok::kw_typename) || Tok.is(tok::annot_cxxscope) ||
           Tok.is(tok::kw_decltype) || Tok.is(tok::annot_template_id) ||
           Tok.is(tok::kw___super)) &&
          "Cannot be a type or scope token!");
 
   if (Tok.is(tok::kw_typename)) {
     // MSVC lets you do stuff like:
     //   typename typedef T_::D D;
     //
     // We will consume the typedef token here and put it back after we have
     // parsed the first identifier, transforming it into something more like:
     //   typename T_::D typedef D;
     if (getLangOpts().MSVCCompat && NextToken().is(tok::kw_typedef)) {
       Token TypedefToken;
       PP.Lex(TypedefToken);
-      bool Result = TryAnnotateTypeOrScopeToken();
+      bool Result = TryAnnotateTypeOrScopeToken(AllowImplicitTypename);
       PP.EnterToken(Tok);
       Tok = TypedefToken;
       if (!Result)
         Diag(Tok.getLocation(), diag::warn_expected_qualified_after_typename);
       return Result;
     }
 
     // Parse a C++ typename-specifier, e.g., "typename T::type".
     //
     //   typename-specifier:
     //     'typename' '::' [opt] nested-name-specifier identifier
     //     'typename' '::' [opt] nested-name-specifier template [opt]
     //            simple-template-id
     SourceLocation TypenameLoc = ConsumeToken();
     CXXScopeSpec SS;
     if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
                                        /*EnteringContext=*/false, nullptr,
                                        /*IsTypename*/ true))
       return true;
     if (!SS.isSet()) {
       if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id) ||
           Tok.is(tok::annot_decltype)) {
         // Attempt to recover by skipping the invalid 'typename'
         if (Tok.is(tok::annot_decltype) ||
-            (!TryAnnotateTypeOrScopeToken() && Tok.isAnnotation())) {
+            (!TryAnnotateTypeOrScopeToken(AllowImplicitTypename) &&
+             Tok.isAnnotation())) {
           unsigned DiagID = diag::err_expected_qualified_after_typename;
           // MS compatibility: MSVC permits using known types with typename.
           // e.g. "typedef typename T* pointer_type"
           if (getLangOpts().MicrosoftExt)
             DiagID = diag::warn_expected_qualified_after_typename;
           Diag(Tok.getLocation(), DiagID);
           return false;
         }
bool Parser::TryAnnotateTypeOrScopeToken(bool AllowImplicitTypename) {
   // Remembers whether the token was originally a scope annotation.
   bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope);
 
   CXXScopeSpec SS;
   if (getLangOpts().CPlusPlus)
     if (ParseOptionalCXXScopeSpecifier(SS, nullptr, /*EnteringContext*/false))
       return true;
 
-  return TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation);
+  return TryAnnotateTypeOrScopeTokenAfterScopeSpec(SS, !WasScopeAnnotation,
+                                                   AllowImplicitTypename);
 }
 
 /// Try to annotate a type or scope token, having already parsed an
 /// optional scope specifier. \p IsNewScope should be \c true unless the scope
 /// specifier was extracted from an existing tok::annot_cxxscope annotation.
-bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(CXXScopeSpec &SS,
-                                                       bool IsNewScope) {
+bool Parser::TryAnnotateTypeOrScopeTokenAfterScopeSpec(
+    CXXScopeSpec &SS, bool IsNewScope, bool AllowImplicitTypename) {
   if (Tok.is(tok::identifier)) {
     // Determine whether the identifier is a type name.
     if (ParsedType Ty = Actions.getTypeName(
             *Tok.getIdentifierInfo(), Tok.getLocation(), getCurScope(), &SS,
             false, NextToken().is(tok::period), nullptr,
             /*IsCtorOrDtorName=*/false,
-            /*NonTrivialTypeSourceInfo*/true,
-            /*IsClassTemplateDeductionContext*/true)) {
+            /*NonTrivialTypeSourceInfo*/ true,
+            /*IsClassTemplateDeductionContext*/ true, AllowImplicitTypename)) {
       SourceLocation BeginLoc = Tok.getLocation();
       if (SS.isNotEmpty()) // it was a C++ qualified type name.
         BeginLoc = SS.getBeginLoc();
 
       /// An Objective-C object type followed by '<' is a specialization of
       /// a parameterized class type or a protocol-qualified type.
       if (getLangOpts().ObjC && NextToken().is(tok::less) &&
           (Ty.get()->isObjCObjectType() ||
            Ty.get()->isObjCObjectPointerType())) {
         // Consume the name.

lib/Sema/DeclSpec.cpp

 #include "clang/Sema/DeclSpec.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include <cstring>
 using namespace clang;
 

lib/Sema/Sema.cpp

return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
                                        QT, OpenCLTypeExtMap);
 }
 
 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
   IdentifierInfo *FnName = D.getIdentifier();
   return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
                                        OpenCLDeclExtMap, 1, D.getSourceRange());
 }
+
+bool Sema::isDeclaratorFunctionLike(Declarator &D) {
+  assert(D.getCXXScopeSpec().isSet() &&
+         "can only be called for qualified names");
+  LookupResult LR(*this, D.getIdentifier(), D.getBeginLoc(), LookupOrdinaryName,
+                  forRedeclarationInCurContext());
+  DeclContext *DC = computeDeclContext(D.getCXXScopeSpec(),
+                                       !D.getDeclSpec().isFriendSpecified());
+  if (!DC)
+    return false;
+
+  LookupQualifiedName(LR, DC);
+  bool Result = std::all_of(LR.begin(), LR.end(), [](Decl *Dcl) {
+    if (NamedDecl *ND = dyn_cast<NamedDecl>(Dcl)) {
+      ND = ND->getUnderlyingDecl();
+      return isa<FunctionDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
+             isa<UsingDecl>(ND);
+    }
+    return false;
+  });
+
+  
+  D.setPrevLookupResult(new LookupResult(std::move(LR)));
+  return Result;
+}

lib/Sema/SemaDecl.cpp

 /// type. Otherwise, returns NULL.
 ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
                              Scope *S, CXXScopeSpec *SS,
                              bool isClassName, bool HasTrailingDot,
                              ParsedType ObjectTypePtr,
                              bool IsCtorOrDtorName,
                              bool WantNontrivialTypeSourceInfo,
                              bool IsClassTemplateDeductionContext,
+                             bool AllowImplicitTypename,
                              IdentifierInfo **CorrectedII) {
   // FIXME: Consider allowing this outside C++1z mode as an extension.
   bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
                               getLangOpts().CPlusPlus17 && !IsCtorOrDtorName &&
                               !isClassName && !HasTrailingDot;
 
   // Determine where we will perform name lookup.
   DeclContext *LookupCtx = nullptr;
if (!LookupCtx) {
         //   A qualified-id that refers to a type and in which the
         //   nested-name-specifier depends on a template-parameter (14.6.2)
         //   shall be prefixed by the keyword typename to indicate that the
         //   qualified-id denotes a type, forming an
         //   elaborated-type-specifier (7.1.5.3).
         //
         // We therefore do not perform any name lookup if the result would
         // refer to a member of an unknown specialization.
-        if (!isClassName && !IsCtorOrDtorName)
+        // In C++2a, in several contexts a 'typename' is not required. Also
+        // allow this as an extension.
+        if (!AllowImplicitTypename && !isClassName && !IsCtorOrDtorName)
           return nullptr;
+        bool IsImplicitTypename = !isClassName && !IsCtorOrDtorName;
+        if (IsImplicitTypename) {
+          SourceLocation QualifiedLoc = SS->getRange().getBegin();
+          if (getLangOpts().CPlusPlus2a)
+            Diag(QualifiedLoc, diag::warn_cxx17_compat_implicit_typename);
+          else
+            Diag(QualifiedLoc, diag::ext_implicit_typename)
+                << SS->getScopeRep() << II.getName()
+                << FixItHint::CreateInsertion(QualifiedLoc, "typename ");
+        }
 
         // We know from the grammar that this name refers to a type,
         // so build a dependent node to describe the type.
         if (WantNontrivialTypeSourceInfo)
-          return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
+          return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc,
+                                   IsImplicitTypename)
+              .get();
 
         NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context);
-        QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
-                                       II, NameLoc);
+        QualType T =
+            CheckTypenameType(IsImplicitTypename ? ETK_Typename : ETK_None,
+                              SourceLocation(), QualifierLoc, II, NameLoc);
         return ParsedType::make(T);
       }
 
       return nullptr;
     }
 
     if (!LookupCtx->isDependentContext() &&
         RequireCompleteDeclContext(*SS, LookupCtx))
if (!D.getCXXScopeSpec().isSet()) {
 
     if (IsLinkageLookup) {
       Previous.clear(LookupRedeclarationWithLinkage);
       Previous.setRedeclarationKind(ForExternalRedeclaration);
     }
 
     LookupName(Previous, S, CreateBuiltins);
   } else { // Something like "int foo::x;"
+    if (D.hasPrevLookupResult()) {
+      Previous = std::move(D.getPrevLookupResult());
+      D.setPrevLookupResult(nullptr);
+    }
+    else
       LookupQualifiedName(Previous, DC);
 
     // C++ [dcl.meaning]p1:
     //   When the declarator-id is qualified, the declaration shall refer to a
     //  previously declared member of the class or namespace to which the
     //  qualifier refers (or, in the case of a namespace, of an element of the
     //  inline namespace set of that namespace (7.3.1)) or to a specialization
     //  thereof; [...]
     //

lib/Sema/SemaTemplate.cpp

Sema::ActOnDependentTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
   TypeLocBuilder TLB;
   DependentNameTypeLoc TL = TLB.push<DependentNameTypeLoc>(Result);
   TL.setElaboratedKeywordLoc(TagLoc);
   TL.setQualifierLoc(SS.getWithLocInContext(Context));
   TL.setNameLoc(NameLoc);
   return CreateParsedType(Result, TLB.getTypeSourceInfo(Context, Result));
 }
 
-TypeResult
-Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
-                        const CXXScopeSpec &SS, const IdentifierInfo &II,
-                        SourceLocation IdLoc) {
+TypeResult Sema::ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
+                                   const CXXScopeSpec &SS,
+                                   const IdentifierInfo &II,
+                                   SourceLocation IdLoc,
+                                   bool IsImplicitTypename) {
   if (SS.isInvalid())
     return true;
 
   if (TypenameLoc.isValid() && S && !S->getTemplateParamParent())
     Diag(TypenameLoc,
          getLangOpts().CPlusPlus11 ?
            diag::warn_cxx98_compat_typename_outside_of_template :
            diag::ext_typename_outside_of_template)
       << FixItHint::CreateRemoval(TypenameLoc);
 
   NestedNameSpecifierLoc QualifierLoc = SS.getWithLocInContext(Context);
-  QualType T = CheckTypenameType(TypenameLoc.isValid()? ETK_Typename : ETK_None,
-                                 TypenameLoc, QualifierLoc, II, IdLoc);
+  QualType T = CheckTypenameType(
+      TypenameLoc.isValid() || IsImplicitTypename ? ETK_Typename : ETK_None,
   if (T.isNull())
     return true;
 
   TypeSourceInfo *TSI = Context.CreateTypeSourceInfo(T);
   if (isa<DependentNameType>(T)) {
     DependentNameTypeLoc TL = TSI->getTypeLoc().castAs<DependentNameTypeLoc>();
     TL.setElaboratedKeywordLoc(TypenameLoc);
     TL.setQualifierLoc(QualifierLoc);

test/CXX/drs/dr1xx.cpp

 namespace dr107 { // dr107: yes
   struct S {};
   extern "C" S operator+(S, S) { return S(); }
 }
 
 namespace dr108 { // dr108: yes
   template<typename T> struct A {
     struct B { typedef int X; };
-    B::X x; // expected-error {{missing 'typename'}}
+    B::X x; // expected-error {{implicit 'typename' is a C++2a extension}}
     struct C : B { X x; }; // expected-error {{unknown type name}}
   };
   template<> struct A<int>::B { int X; };
 }
 
 namespace dr109 { // dr109: yes
   struct A { template<typename T> void f(T); };
   template<typename T> struct B : T {

test/CXX/drs/dr2xx.cpp

 // dr223: na
 
 namespace dr224 { // dr224: no
   namespace example1 {
     template <class T> class A {
       typedef int type;
       A::type a;
       A<T>::type b;
-      A<T*>::type c; // expected-error {{missing 'typename'}}
+      A<T*>::type c; // expected-error {{implicit 'typename' is a C++2a extension}}
       ::dr224::example1::A<T>::type d;
 
       class B {
         typedef int type;
 
         A::type a;
         A<T>::type b;
-        A<T*>::type c; // expected-error {{missing 'typename'}}
+        A<T*>::type c; // expected-error {{implicit 'typename' is a C++2a extension}}
         ::dr224::example1::A<T>::type d;
 
         B::type e;
         A<T>::B::type f;
-        A<T*>::B::type g; // expected-error {{missing 'typename'}}
+        A<T*>::B::type g; // expected-error {{implicit 'typename' is a C++2a extension}}
         typename A<T*>::B::type h;
       };
     };
 
     template <class T> class A<T*> {
       typedef int type;
       A<T*>::type a;
-      A<T>::type b; // expected-error {{missing 'typename'}}
+      A<T>::type b; // expected-error {{implicit 'typename' is a C++2a extension}}
     };
 
     template <class T1, class T2, int I> struct B {
       typedef int type;
       B<T1, T2, I>::type b1;
-      B<T2, T1, I>::type b2; // expected-error {{missing 'typename'}}
+      B<T2, T1, I>::type b2; // expected-error {{implicit 'typename' is a C++2a extension}}
 
       typedef T1 my_T1;
       static const int my_I = I;
       static const int my_I2 = I+0;
       static const int my_I3 = my_I;
-      B<my_T1, T2, my_I>::type b3; // FIXME: expected-error {{missing 'typename'}}
-      B<my_T1, T2, my_I2>::type b4; // expected-error {{missing 'typename'}}
-      B<my_T1, T2, my_I3>::type b5; // FIXME: expected-error {{missing 'typename'}}
+      B<my_T1, T2, my_I>::type b3; // FIXME: expected-error {{implicit 'typename' is a C++2a extension}}
+      B<my_T1, T2, my_I2>::type b4; // expected-error {{implicit 'typename' is a C++2a extension}}
+      B<my_T1, T2, my_I3>::type b5; // FIXME: expected-error {{implicit 'typename' is a C++2a extension}}
     };
   }
 
   namespace example2 {
     template <int, typename T> struct X { typedef T type; };
     template <class T> class A {
       static const int i = 5;
-      X<i, int>::type w; // FIXME: expected-error {{missing 'typename'}}
-      X<A::i, char>::type x; // FIXME: expected-error {{missing 'typename'}}
-      X<A<T>::i, double>::type y; // FIXME: expected-error {{missing 'typename'}}
-      X<A<T*>::i, long>::type z; // expected-error {{missing 'typename'}}
+      X<i, int>::type w; // FIXME: expected-error {{implicit 'typename' is a C++2a extension}}
+      X<A::i, char>::type x; // FIXME: expected-error {{implicit 'typename' is a C++2a extension}}
+      X<A<T>::i, double>::type y; // FIXME: expected-error {{implicit 'typename' is a C++2a extension}}
+      X<A<T*>::i, long>::type z; // expected-error {{implicit 'typename' is a C++2a extension}}
       int f();
     };
     template <class T> int A<T>::f() {
       return i;
     }
   }
 }
 

test/CXX/drs/dr4xx.cpp

 }
 
 namespace dr409 { // dr409: yes
   template<typename T> struct A {
     typedef int B;
     B b1;
     A::B b2;
     A<T>::B b3;
-    A<T*>::B b4; // expected-error {{missing 'typename'}}
+    A<T*>::B b4; // expected-error {{implicit 'typename' is a C++2a extension}}
   };
 }
 
 namespace dr410 { // dr410: no
   template<class T> void f(T);
   void g(int);
   namespace M {
     template<class T> void h(T);

test/CXX/drs/dr5xx.cpp

void test(int (&a)[3], S<3> s) {
     g1(a);
     g2(a); // expected-error {{no matching}}
     g3(a); // expected-error {{no matching}}
   }
 
   template<int N> struct X {
     typedef int type;
     X<N>::type v1;
-    X<(N)>::type v2; // expected-error {{missing 'typename'}}
-    X<+N>::type v3; // expected-error {{missing 'typename'}}
+    X<(N)>::type v2; // expected-error {{implicit 'typename' is a C++2a extension}}
+    X<+N>::type v3; // expected-error {{implicit 'typename' is a C++2a extension}}
   };
 }
 
 namespace dr527 { // dr527: na
   // This DR is meaningless. It removes a required diagnostic from the case
   // where a not-externally-visible object is odr-used but not defined, which
   // requires a diagnostic for a different reason.
   extern struct { int x; } a; // FIXME: We should reject this, per dr389.

test/CXX/temp/temp.res/temp.dep/temp.dep.type/p1.cpp

namespace Example1 {
 
   template<class T> struct A<A<T>> {
     struct C {};
     B<B<T>>::C bc; // ok, B<B<T>> is the current instantiation.
   };
 
   template<class T> struct A<A<A<T>>> {
     struct C {};
-    B<B<T>>::C bc; // expected-error {{missing 'typename'}}
+    B<B<T>>::C bc; // expected-warning {{implicit 'typename' is a C++2a extension}}
   };
 }
 
 namespace Example2 {
   template<class T> struct A {
     void g();
   };
   template<class T> using B = A<T>;
   template<class T> void B<T>::g() {} // ok.
 }

test/FixIt/fixit.cpp

public:
   friend void f(MoreAccidentalCommas) {}
   int k2, // expected-error {{expected ';' at end of declaration}}
   virtual void g(), // expected-error {{expected ';' at end of declaration}}
 };
 
 template<class T> struct Mystery;
 template<class T> typedef Mystery<T>::type getMysteriousThing() { // \
   expected-error {{function definition declared 'typedef'}} \
-  expected-error {{missing 'typename' prior to dependent}}
+  expected-warning {{implicit 'typename' is a C++2a extension}}
   return Mystery<T>::get();
 }
 
 template<template<typename> Foo, // expected-error {{template template parameter requires 'class' after the parameter list}}
          template<typename> typename Bar, // expected-warning {{template template parameter using 'typename' is a C++17 extension}}
          template<typename> struct Baz> // expected-error {{template template parameter requires 'class' after the parameter list}}
 void func();
 

test/Parser/cxx-member-initializers.cpp

class G {
   void g(int x = C<int, ::D>().f()) {}
   void h(int x = C<int, N::E>().f()) {}
   void i(int x = C<int, ::N::E>().f()) {}
   void j(int x = C<int, decltype(N::E())::F>().f()) {}
   void k(int x = C<int, C<int, int>>().f()) {}
   void l(int x = C<int, C<int, int>::C1>().f()) {}
 
   // This isn't, but it shouldn't crash. The diagnostics don't matter much.
-  void m(int x = C<int, union int>().f()) {} // expected-error {{declaration of anonymous union must be a definition}} expected-error {{expected a type}}
+  void m(int x = C<int, union int>().f()) {} // expected-error {{declaration of anonymous union must be a definition}} expected-error {{type name requires a specifier or qualifier}}
 };

test/Parser/editor-placeholder-recovery.cpp

 #endif
             break;
 
         default:
             break;
     }
 }
 
-void Struct::method(<#Struct &x#>, noSupressionHere) { // expected-error {{unknown type name 'noSupressionHere'}} expected-error {{C++ requires a type specifier for all declarations}}
+void Struct::method(<#Struct &x#>, noSupressionHere) { // expected-error {{unknown type name 'noSupressionHere'}}
 #ifndef SUPPRESS
   // expected-error@-2 {{editor placeholder in source file}}
 #endif
 }
 
 void handleTrigraph() {
   <??=placeholder#> // expected-error {{expected expression}} expected-error {{expected expression}} expected-warning {{trigraph converted to '#' character}}
 }

test/SemaCXX/MicrosoftCompatibility.cpp

 
 template<class T, class U>
 class C : private A<T>, public B<U> {
 public:
    typedef A<T> Base1;
    typedef B<U> Base2;
    typedef A<U> Base3;
 
-   A<T>::TYPE a1; // expected-warning {{missing 'typename' prior to dependent type name}}
-   Base1::TYPE a2; // expected-warning {{missing 'typename' prior to dependent type name}}
+   A<T>::TYPE a1; // expected-warning {{implicit 'typename' is a C++2a extension}}
+   Base1::TYPE a2; // expected-warning {{implicit 'typename' is a C++2a extension}}
 
-   B<U>::TYPE a3; // expected-warning {{missing 'typename' prior to dependent type name}}
-   Base2::TYPE a4; // expected-warning {{missing 'typename' prior to dependent type name}}
+   B<U>::TYPE a3; // expected-warning {{implicit 'typename' is a C++2a extension}}
+   Base2::TYPE a4; // expected-warning {{implicit 'typename' is a C++2a extension}}
 
-   A<U>::TYPE a5; // expected-error {{missing 'typename' prior to dependent type name}}
-   Base3::TYPE a6; // expected-error {{missing 'typename' prior to dependent type name}}
+   A<U>::TYPE a5; // expected-warning {{implicit 'typename' is a C++2a extension}}
+   Base3::TYPE a6; // expected-warning {{implicit 'typename' is a C++2a extension}}
  };
 
 class D {
 public:
     typedef int Type;
 };
 
 template <class T>
-void function_missing_typename(const T::Type param)// expected-warning {{missing 'typename' prior to dependent type name}}
+void function_missing_typename(const T::Type param)// expected-warning {{missing 'typename'}}
 {
-    const T::Type var = 2; // expected-warning {{missing 'typename' prior to dependent type name}}
+    const T::Type var = 2; // expected-warning {{missing 'typename'}}
 }
 
 template void function_missing_typename<D>(const D::Type param);
 
 }
 
 //MSVC allows forward enum declaration
 enum ENUM; // expected-warning {{forward references to 'enum' types are a Microsoft extension}}

test/SemaCXX/MicrosoftExtensions.cpp

 
 // Check that __unaligned is not recognized if MS extensions are not enabled
 typedef char __unaligned *aligned_type; // expected-error {{expected ';' after top level declarator}}
 
 #elif TEST3
 
 namespace PR32750 {
 template<typename T> struct A {};
-template<typename T> struct B : A<A<T>> { A<T>::C::D d; }; // expected-error {{missing 'typename' prior to dependent type name 'A<T>::C::D'}}
+template<typename T> struct B : A<A<T>> { A<T>::C::D d; }; // expected-warning {{implicit 'typename' is a C++2a extension}}
 }
 
 #else
 
 #error Unknown test mode
 
 #endif
 

test/SemaCXX/MicrosoftSuper.cpp

struct DerivedFromKnownSpecialization : BaseTemplate<int> {
   }
 };
 
 template <typename T>
 struct DerivedFromDependentBase : BaseTemplate<T> {
   typename __super::XXX a;
   typedef typename __super::XXX b;
 
-  __super::XXX c;         // expected-error {{missing 'typename'}}
-  typedef __super::XXX d; // expected-error {{missing 'typename'}}
+  __super::XXX c;         // expected-warning {{implicit 'typename' is a C++2a extension}}
+  typedef __super::XXX d; // expected-warning {{implicit 'typename' is a C++2a extension}}
 
   void foo() {
     typename __super::XXX e;
     typedef typename __super::XXX f;
 
     __super::XXX g;         // expected-error {{missing 'typename'}}
     typedef __super::XXX h; // expected-error {{missing 'typename'}}
 
     int x = __super::foo();
   }
 };
 
 template <typename T>
 struct DerivedFromTemplateParameter : T {
   typename __super::XXX a;
   typedef typename __super::XXX b;
 
-  __super::XXX c;         // expected-error {{missing 'typename'}}
-  typedef __super::XXX d; // expected-error {{missing 'typename'}}
+  __super::XXX c;         // expected-warning {{implicit 'typename' is a C++2a extension}}
+  typedef __super::XXX d; // expected-warning {{implicit 'typename' is a C++2a extension}}
 
   void foo() {
     typename __super::XXX e;
     typedef typename __super::XXX f;
 
     __super::XXX g;         // expected-error {{missing 'typename'}}
     typedef __super::XXX h; // expected-error {{missing 'typename'}}
 

test/SemaCXX/unknown-type-name.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // PR3990
 namespace N {
   struct Wibble {
   };
 
   typedef Wibble foo;
 
struct A {
   typedef T type;
 
   type f();
 
   type g();
 
   static int n;
   static type m;
-  static int h(T::type, int); // expected-error{{missing 'typename'}}
-  static int h(T::type x, char); // expected-error{{missing 'typename'}}
+  static int h(T::type, int); // expected-warning{{implicit 'typename' is a C++2a extension}}
+  static int h(T::type x, char); // expected-warning{{implicit 'typename' is a C++2a extension}}
 };
 
 template<typename T>
-A<T>::type g(T t) { return t; } // expected-error{{missing 'typename'}}
+A<T>::type g(T t) { return t; } // expected-warning{{implicit 'typename' is a C++2a extension}}
 
 template<typename T>
-A<T>::type A<T>::f() { return type(); } // expected-error{{missing 'typename'}}
+A<T>::type A<T>::f() { return type(); } // expected-warning{{implicit 'typename' is a C++2a extension}}
 
 template<typename T>
 void f(T::type) { } // expected-error{{missing 'typename'}}
 
 template<typename T>
 void g(T::type x) { } // expected-error{{missing 'typename'}}
 
 template<typename T>
 void f(T::type, int) { } // expected-error{{missing 'typename'}}
 
 template<typename T>
 void f(T::type x, char) { } // expected-error{{missing 'typename'}}
 
 template<typename T>
 void f(int, T::type) { } // expected-error{{missing 'typename'}}
 
 template<typename T>
 void f(char, T::type x) { } // expected-error{{missing 'typename'}}
 
 template<typename T>
 void f(int, T::type, int) { } // expected-error{{missing 'typename'}}
 
 template<typename T>
 void f(int, T::type x, char) { } // expected-error{{missing 'typename'}}
 
 int *p;
 
-// FIXME: We should assume that 'undeclared' is a type, not a parameter name
-//        here, and produce an 'unknown type name' diagnostic instead.
-int f1(undeclared, int); // expected-error{{requires a type specifier}}
+int f1(undeclared, int); // expected-error{{unknown type name 'undeclared'}}
 
 int f2(undeclared, 0); // expected-error{{undeclared identifier}}
 
 int f3(undeclared *p, int); // expected-error{{unknown type name 'undeclared'}}
 
 int f4(undeclared *p, 0); // expected-error{{undeclared identifier}}
 
 int *test(UnknownType *fool) { return 0; } // expected-error{{unknown type name 'UnknownType'}}
 
 template<typename T> int A<T>::n(T::value); // ok
 template<typename T>
-A<T>::type // expected-error{{missing 'typename'}}
+A<T>::type // expected-warning {{implicit 'typename' is a C++2a extension}}
 A<T>::m(T::value, 0); // ok
 
-template<typename T> int A<T>::h(T::type, int) {} // expected-error{{missing 'typename'}}
-template<typename T> int A<T>::h(T::type x, char) {} // expected-error{{missing 'typename'}}
+template<typename T> int A<T>::h(T::type, int) {} // expected-warning{{implicit 'typename' is a C++2a extension}}
+template<typename T> int A<T>::h(T::type x, char) {} // expected-warning{{implicit 'typename' is a C++2a extension}}
 
 template<typename T> int h(T::type, int); // expected-error{{missing 'typename'}}
 template<typename T> int h(T::type x, char); // expected-error{{missing 'typename'}}
 
 template<typename T> int junk1(T::junk);
 #if __cplusplus <= 201103L
 // expected-warning@-2 {{variable templates are a C++14 extension}}
 #endif
 template<typename T> int junk2(T::junk) throw(); // expected-error{{missing 'typename'}}
 template<typename T> int junk3(T::junk) = delete; // expected-error{{missing 'typename'}}
 #if __cplusplus <= 199711L
 //expected-warning@-2 {{deleted function definitions are a C++11 extension}}
 #endif
 
 template<typename T> int junk4(T::junk j); // expected-error{{missing 'typename'}}
 
 // FIXME: We can tell this was intended to be a function because it does not
 //        have a dependent nested name specifier.
 template<typename T> int i(T::type, int());
 #if __cplusplus <= 201103L
 // expected-warning@-2 {{variable templates are a C++14 extension}}
 #endif
 
 
 // FIXME: We know which type specifier should have been specified here. Provide
 //        a fix-it to add 'typename A<T>::type'
 template<typename T>
-A<T>::g() { } // expected-error{{requires a type specifier}}
+A<T>::g() { } // expected-error{{expected unqualified-id}}
+// expected-warning@-1{{implicit 'typename' is a C++2a extension}}