================
@@ -1779,6 +1779,42 @@ void Parser::checkPotentialAngleBracket(ExprResult
&PotentialTemplateName) {
Priority);
}
+bool Parser::isMissingTemplateKeywordBeforeScope(bool AnnotateInvalid) {
+ assert(Tok.is(tok::coloncolon));
+ Sema::DisableTypoCorrectionRAII DTC(Actions);
+ ColonProtectionRAIIObject ColonProtection(*this);
+
+ SourceLocation StartLoc = Tok.getLocation();
+ if (TryAnnotateTypeOrScopeToken())
+ return true;
+ if (Tok.isSimpleTypeSpecifier(getLangOpts()))
+ return false;
+ CXXScopeSpec SS;
+ ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
+ /*ObjectHasErrors=*/false,
+ /*EnteringContext=*/false);
+ ExprResult Result = tryParseCXXIdExpression(SS,
/*isAddressOfOperand=*/false);
----------------
sdkrystian wrote:
> Parsing the same expression twice could also be problematic in some cases --
> for example, if it contains a lambda, we might assign it the wrong mangling
> number. Can we arrange things such that for a valid program, we only parse
> the expression once?
@zygoloid That already is the case:
```cpp
template<int I>
struct A
{
constexpr static int x = 0;
template<typename T>
using B = A;
};
template<typename T>
struct B
{
constexpr static int x = 0;
};
template<typename T>
void f(T t)
{
t.A<0>::template B<decltype([]() { })>::x; // ok, interpreted as '((t.A) <
0) > ::template B<decltype([]() { })>::x'
// lambda expression is only parsed once
t.A<0>::template C<decltype([]() { })>::x; // warning: use 'template'
keyword to treat 'A' as a dependent template name
// lambda expression is parsed
twice
}
```
https://github.com/llvm/llvm-project/pull/100425
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
