Revert "Improve declaration / expression disambiguation around ptr-operators, and use"

This seems to break mixing function-style and c-style casts, and is
breaking bootstrapping llvm.

This reverts r230261.

llvm-svn: 230274

6 files changed, 28 insertions, 67 deletions

diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index 2cfc5e23dd7..fd120aef294 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -1941,12 +1941,11 @@ private:
   TPResult TryParsePtrOperatorSeq();
   TPResult TryParseOperatorId();
   TPResult TryParseInitDeclaratorList();
-  TPResult TryParseDeclarator(bool MayBeAbstract, bool MayHaveIdentifier = true,
-                              bool VersusExpression = true);
+  TPResult TryParseDeclarator(bool mayBeAbstract, bool mayHaveIdentifier=true);
   TPResult
   TryParseParameterDeclarationClause(bool *InvalidAsDeclaration = nullptr,
                                      bool VersusTemplateArg = false);
-  TPResult TryParseFunctionDeclarator(bool VersusExpression = true);
+  TPResult TryParseFunctionDeclarator();
   TPResult TryParseBracketDeclarator();
   TPResult TryConsumeDeclarationSpecifier();
 
diff --git a/clang/lib/Parse/ParseTentative.cpp b/clang/lib/Parse/ParseTentative.cpp
index 29ee467b6ad..abf16fa6222 100644
--- a/clang/lib/Parse/ParseTentative.cpp
+++ b/clang/lib/Parse/ParseTentative.cpp
@@ -284,7 +284,7 @@ Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
 Parser::TPResult Parser::TryParseInitDeclaratorList() {
   while (1) {
     // declarator
-    TPResult TPR = TryParseDeclarator(false/*MayBeAbstract*/);
+    TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
     if (TPR != TPResult::Ambiguous)
       return TPR;
 
@@ -361,7 +361,7 @@ bool Parser::isCXXConditionDeclaration() {
   assert(Tok.is(tok::l_paren) && "Expected '('");
 
   // declarator
-  TPR = TryParseDeclarator(false/*MayBeAbstract*/);
+  TPR = TryParseDeclarator(false/*mayBeAbstract*/);
 
   // In case of an error, let the declaration parsing code handle it.
   if (TPR == TPResult::Error)
@@ -431,7 +431,7 @@ bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
   assert(Tok.is(tok::l_paren) && "Expected '('");
 
   // declarator
-  TPR = TryParseDeclarator(/*MayBeAbstract*/true, /*MayHaveIdentifier*/false);
+  TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
 
   // In case of an error, let the declaration parsing code handle it.
   if (TPR == TPResult::Error)
@@ -623,7 +623,6 @@ Parser::isCXX11AttributeSpecifier(bool Disambiguate,
 }
 
 Parser::TPResult Parser::TryParsePtrOperatorSeq() {
-  bool ConsumedAny = false;
   while (true) {
     if (Tok.is(tok::coloncolon) || Tok.is(tok::identifier))
       if (TryAnnotateCXXScopeToken(true))
@@ -638,9 +637,8 @@ Parser::TPResult Parser::TryParsePtrOperatorSeq() {
              Tok.is(tok::kw_volatile) ||
              Tok.is(tok::kw_restrict))
         ConsumeToken();
-      ConsumedAny = true;
     } else {
-      return ConsumedAny ? TPResult::True : TPResult::False;
+      return TPResult::True;
     }
   }
 }
@@ -736,8 +734,7 @@ Parser::TPResult Parser::TryParseOperatorId() {
       return TPResult::Error;
     AnyDeclSpecifiers = true;
   }
-  return TryParsePtrOperatorSeq() == TPResult::Error ? TPResult::Error
-                                                     : TPResult::True;
+  return TryParsePtrOperatorSeq();
 }
 
 ///         declarator:
@@ -793,23 +790,13 @@ Parser::TPResult Parser::TryParseOperatorId() {
 ///           '~' decltype-specifier                                      [TODO]
 ///           template-id                                                 [TODO]
 ///
-Parser::TPResult Parser::TryParseDeclarator(bool MayBeAbstract,
-                                            bool MayHaveIdentifier,
-                                            bool VersusExpression) {
+Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
+                                            bool mayHaveIdentifier) {
   // declarator:
   //   direct-declarator
   //   ptr-operator declarator
-  {
-    TPResult TPR = TryParsePtrOperatorSeq();
-    if (TPR == TPResult::Error)
-      return TPResult::Error;
-    // After a ptr-operator, any of ')', ',', ';', and '...' indicates
-    // that this cannot be an expression.
-    if (VersusExpression && TPR == TPResult::True &&
-        (Tok.is(tok::r_paren) || Tok.is(tok::comma) || Tok.is(tok::ellipsis) ||
-         Tok.is(tok::semi)))
-      return TPResult::True;
-  }
+  if (TryParsePtrOperatorSeq() == TPResult::Error)
+    return TPResult::Error;
 
   // direct-declarator:
   // direct-abstract-declarator:
@@ -819,7 +806,7 @@ Parser::TPResult Parser::TryParseDeclarator(bool MayBeAbstract,
   if ((Tok.is(tok::identifier) || Tok.is(tok::kw_operator) ||
        (Tok.is(tok::annot_cxxscope) && (NextToken().is(tok::identifier) ||
                                         NextToken().is(tok::kw_operator)))) &&
-      MayHaveIdentifier) {
+      mayHaveIdentifier) {
     // declarator-id
     if (Tok.is(tok::annot_cxxscope))
       ConsumeToken();
@@ -832,14 +819,14 @@ Parser::TPResult Parser::TryParseDeclarator(bool MayBeAbstract,
       ConsumeToken();
   } else if (Tok.is(tok::l_paren)) {
     ConsumeParen();
-    if (MayBeAbstract &&
+    if (mayBeAbstract &&
         (Tok.is(tok::r_paren) ||       // 'int()' is a function.
          // 'int(...)' is a function.
          (Tok.is(tok::ellipsis) && NextToken().is(tok::r_paren)) ||
          isDeclarationSpecifier())) {   // 'int(int)' is a function.
       // '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
       //        exception-specification[opt]
-      TPResult TPR = TryParseFunctionDeclarator(VersusExpression);
+      TPResult TPR = TryParseFunctionDeclarator();
       if (TPR != TPResult::Ambiguous)
         return TPR;
     } else {
@@ -855,15 +842,14 @@ Parser::TPResult Parser::TryParseDeclarator(bool MayBeAbstract,
           Tok.is(tok::kw___vectorcall) ||
           Tok.is(tok::kw___unaligned))
         return TPResult::True; // attributes indicate declaration
-      TPResult TPR = TryParseDeclarator(MayBeAbstract, MayHaveIdentifier,
-                                        VersusExpression);
+      TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
       if (TPR != TPResult::Ambiguous)
         return TPR;
       if (Tok.isNot(tok::r_paren))
         return TPResult::False;
       ConsumeParen();
     }
-  } else if (!MayBeAbstract) {
+  } else if (!mayBeAbstract) {
     return TPResult::False;
   }
 
@@ -879,13 +865,13 @@ Parser::TPResult Parser::TryParseDeclarator(bool MayBeAbstract,
       // initializer that follows the declarator. Note that ctor-style
       // initializers are not possible in contexts where abstract declarators
       // are allowed.
-      if (!MayBeAbstract && !isCXXFunctionDeclarator())
+      if (!mayBeAbstract && !isCXXFunctionDeclarator())
         break;
 
       // direct-declarator '(' parameter-declaration-clause ')'
       //        cv-qualifier-seq[opt] exception-specification[opt]
       ConsumeParen();
-      TPR = TryParseFunctionDeclarator(VersusExpression);
+      TPR = TryParseFunctionDeclarator();
     } else if (Tok.is(tok::l_square)) {
       // direct-declarator '[' constant-expression[opt] ']'
       // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
@@ -1724,8 +1710,7 @@ Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
 
     // declarator
     // abstract-declarator[opt]
-    TPR = TryParseDeclarator(/*MayBeAbstract*/true, /*MayHaveIdentifier*/true,
-                             /*VersusExpression*/!VersusTemplateArgument);
+    TPR = TryParseDeclarator(true/*mayBeAbstract*/);
     if (TPR != TPResult::Ambiguous)
       return TPR;
 
@@ -1772,15 +1757,9 @@ Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
 
 /// TryParseFunctionDeclarator - We parsed a '(' and we want to try to continue
 /// parsing as a function declarator.
-///
 /// If TryParseFunctionDeclarator fully parsed the function declarator, it will
-/// return TPResult::Ambiguous.
-///
-/// If \p VersusExpression is true and this cannot be a function-style
-/// cast expression, returns TPResult::True.
-///
-/// Otherwise, returns TPResult::False if this can't be a function declarator
-/// and TPResult::Error if it can't be anything.
+/// return TPResult::Ambiguous, otherwise it will return either False() or
+/// Error().
 ///
 /// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
 ///         exception-specification[opt]
@@ -1788,7 +1767,7 @@ Parser::TryParseParameterDeclarationClause(bool *InvalidAsDeclaration,
 /// exception-specification:
 ///   'throw' '(' type-id-list[opt] ')'
 ///
-Parser::TPResult Parser::TryParseFunctionDeclarator(bool VersusExpression) {
+Parser::TPResult Parser::TryParseFunctionDeclarator() {
 
   // The '(' is already parsed.
 
@@ -1796,9 +1775,8 @@ Parser::TPResult Parser::TryParseFunctionDeclarator(bool VersusExpression) {
   if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
     TPR = TPResult::False;
 
-  if (TPR != TPResult::Ambiguous)
-    if (VersusExpression || TPR != TPResult::True)
-      return TPR;
+  if (TPR == TPResult::False || TPR == TPResult::Error)
+    return TPR;
 
   // Parse through the parens.
   if (!SkipUntil(tok::r_paren, StopAtSemi))
diff --git a/clang/test/Parser/cxx-ambig-init-templ.cpp b/clang/test/Parser/cxx-ambig-init-templ.cpp
index 584262c9be4..1f692664137 100644
--- a/clang/test/Parser/cxx-ambig-init-templ.cpp
+++ b/clang/test/Parser/cxx-ambig-init-templ.cpp
@@ -170,15 +170,6 @@ namespace ElaboratedTypeSpecifiers {
   };
 }
 
-namespace AbstractPtrOperatorDeclarator {
-  template <int, typename> struct X {
-    operator int();
-  };
-  struct Y {
-    void f(int a = X<0, int (*)()>());
-  };
-}
-
 namespace PR20459 {
   template <typename EncTraits> struct A {
      void foo(int = EncTraits::template TypeEnc<int, int>::val); // ok
diff --git a/clang/test/Parser/cxx-variadic-func.cpp b/clang/test/Parser/cxx-variadic-func.cpp
index c0fad95e468..98a34d3e1bf 100644
--- a/clang/test/Parser/cxx-variadic-func.cpp
+++ b/clang/test/Parser/cxx-variadic-func.cpp
@@ -1,7 +1,8 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 void f(...) {
-  int g(int(...)); // no warning, unambiguously a function declaration
+  // FIXME: There's no disambiguation here; this is unambiguous.
+  int g(int(...)); // expected-warning {{disambiguated}} expected-note {{paren}}
 }
 
 void h(int n..., int m); // expected-error {{expected ')'}} expected-note {{to match}}
diff --git a/clang/test/Parser/recovery.cpp b/clang/test/Parser/recovery.cpp
index f099473e04b..2d5b518c691 100644
--- a/clang/test/Parser/recovery.cpp
+++ b/clang/test/Parser/recovery.cpp
@@ -203,14 +203,6 @@ namespace pr15133 {
   };
 }
 
-namespace AbstractPtrOperator {
-  // A ptr-operator and no name means we have a declaration and not an
-  // expression.
-  template<typename T> int f(int*, T::type); // expected-error {{missing 'typename'}}
-  template<typename T> int f(int (T::*), T::type); // expected-error {{missing 'typename'}}
-  template<typename T> int f(int (*)(), T::type); // expected-error {{missing 'typename'}}
-}
-
 namespace InvalidEmptyNames {
 // These shouldn't crash, the diagnostics aren't important.
 struct ::, struct ::; // expected-error 2 {{expected identifier}} expected-error 2 {{declaration of anonymous struct must be a definition}} expected-warning {{declaration does not declare anything}}
diff --git a/clang/test/SemaTemplate/rdar9173693.cpp b/clang/test/SemaTemplate/rdar9173693.cpp
index 1e999cba670..86b49545a30 100644
--- a/clang/test/SemaTemplate/rdar9173693.cpp
+++ b/clang/test/SemaTemplate/rdar9173693.cpp
@@ -2,5 +2,5 @@
 
 // <rdar://problem/9173693>
 template< bool C > struct assert { };
-template< bool > struct assert_arg_pred_impl { }; // expected-note 2 {{declared here}}
-template< typename Pred > assert<false> assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type ); // expected-error 3 {{}}
+template< bool > struct assert_arg_pred_impl { }; // expected-note 3 {{declared here}}
+template< typename Pred > assert<false> assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type ); // expected-error 5 {{}}