Remove support for '^ splice-expression' production.

Author: katzdm

clang/lib/Parse/ParseReflect.cpp

@@ -26,51 +26,14 @@ ExprResult Parser::ParseCXXReflectExpression() {
   EnterExpressionEvaluationContext EvalContext(
         Actions, Sema::ExpressionEvaluationContext::ReflectionContext);
 
-  // ^ template [:splice-specifier:]
-  //
-  SourceLocation TemplateKWLoc;
-  if (Tok.is(tok::kw_template)) {
-    TemplateKWLoc = ConsumeToken();
-
-    if (!Tok.is(tok::l_splice)) {
-      Diag(TemplateKWLoc, diag::err_unexpected_template_in_unqualified_id);
-      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
-      return ExprError();
-    }
-
-    if (ParseCXXSpliceSpecifier(TemplateKWLoc)) {
-      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
-      return ExprError();
-    }
-
-    if (!NextToken().is(tok::less)) {
-      Token Splice = Tok;
-      TemplateTy Template = ParseCXXSpliceAsTemplate();
-      if (Template)
-        return Actions.BuildCXXReflectExpr(OpLoc, Splice.getLocation(),
-                                           Template.get());
-      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
-      return ExprError();
-    }
-
-    if (ParseTemplateAnnotationFromSplice(SourceLocation(), false, false,
-                                                 /*Complain=*/true)) {
-      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
-      return ExprError();
-    }
-  }
-
-
   // Parse a leading nested-name-specifier, e.g.,
   //
   CXXScopeSpec SS;
-  if (TemplateKWLoc.isInvalid()) {
-    if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
-                                       /*ObjectHasErrors=*/false,
-                                       /*EnteringContext=*/false)) {
-      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
-      return ExprError();
-    }
+  if (ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
+                                     /*ObjectHasErrors=*/false,
+                                     /*EnteringContext=*/false)) {
+    SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
+    return ExprError();
   }
 
   // Start the tentative parse: This will be reverted if the operand is found
@@ -79,24 +42,6 @@ ExprResult Parser::ParseCXXReflectExpression() {
   //
   TentativeParsingAction TentativeAction(*this);
 
-  // ^ [:splice-specifier:]
-  //
-  if (!SS.isSet() && Tok.is(tok::annot_splice)) {
-    assert(TemplateKWLoc.isInvalid());
-
-    ExprResult ER = getExprAnnotation(Tok);
-    assert(!ER.isInvalid());
-    ER = ParseCXXSpliceAsExpr(true);
-    if (ER.isInvalid()) {
-      TentativeAction.Commit();
-      SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
-      return ExprError();
-    }
-
-    TentativeAction.Commit();
-    return Actions.ActOnCXXReflectExpr(OpLoc, cast<CXXSpliceExpr>(ER.get()));
-  }
-
   // Next, check for an unqualified-id.
   if (Tok.isOneOf(tok::identifier, tok::kw_operator, tok::kw_template,
                   tok::tilde, tok::annot_template_id)) {

clang/test/Reflection/reflection-of-splice.cpp

@@ -36,22 +36,12 @@ struct S {
   template <typename T> static constexpr int TMemVar = 0;
 };
 
-static_assert(^template [:^TCls:] == ^TCls);
-static_assert(^typename [:^TCls:]<int> == ^TCls<int>);
-static_assert(^template [:^TCls:]<int> == ^typename [:^TCls:]<int>);
 static_assert(is_same_v<typename [:^TCls:]<int>, TCls<int>>);
-static_assert(^typename [:^TAlias:]<int> == ^TAlias<int>);
 static_assert(is_same_v<typename [:^TAlias:]<int>, TCls<int>>);
-static_assert(^template [:^TFn:] == ^TFn);
-static_assert(^template [:^TFn:]<int> == ^TFn<int>);
 static_assert(&template [:^TFn:]<int> == &TFn<int>);
-static_assert(^template [:^TVar:]<int> == ^TVar<int>);
 static_assert(&template [:^TVar:]<int> == &TVar<int>);
-static_assert(^template [:^S::TInner:]<int> == ^S::TInner<int>);
 static_assert(is_same_v<typename [:^S::TInner:]<int>, S::TInner<int>>);
-static_assert(^template [:^S::TFn:]<int> == ^S::TFn<int>);
 static_assert(&template [:^S::TFn:]<int> == &S::TFn<int>);
-static_assert(^template [:^S::TMemVar:]<int> == ^S::TMemVar<int>);
 static_assert(&template [:^S::TMemVar:]<int> == &S::TMemVar<int>);
 }  // namespace idempotency