Remove LLVM 8.0.1 files.

1 files changed, 0 insertions, 2000 deletions

diff --git a/gnu/llvm/tools/clang/lib/Parse/ParseTentative.cpp b/gnu/llvm/tools/clang/lib/Parse/ParseTentative.cpp
deleted file mode 100644
index de39e0675fd..00000000000
--- a/gnu/llvm/tools/clang/lib/Parse/ParseTentative.cpp
+++ /dev/null
@@ -1,2000 +0,0 @@
-//===--- ParseTentative.cpp - Ambiguity Resolution Parsing ----------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file implements the tentative parsing portions of the Parser
-//  interfaces, for ambiguity resolution.
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/Parse/Parser.h"
-#include "clang/Parse/ParseDiagnostic.h"
-#include "clang/Sema/ParsedTemplate.h"
-using namespace clang;
-
-/// isCXXDeclarationStatement - C++-specialized function that disambiguates
-/// between a declaration or an expression statement, when parsing function
-/// bodies. Returns true for declaration, false for expression.
-///
-///         declaration-statement:
-///           block-declaration
-///
-///         block-declaration:
-///           simple-declaration
-///           asm-definition
-///           namespace-alias-definition
-///           using-declaration
-///           using-directive
-/// [C++0x]   static_assert-declaration
-///
-///         asm-definition:
-///           'asm' '(' string-literal ')' ';'
-///
-///         namespace-alias-definition:
-///           'namespace' identifier = qualified-namespace-specifier ';'
-///
-///         using-declaration:
-///           'using' typename[opt] '::'[opt] nested-name-specifier
-///                 unqualified-id ';'
-///           'using' '::' unqualified-id ;
-///
-///         using-directive:
-///           'using' 'namespace' '::'[opt] nested-name-specifier[opt]
-///                 namespace-name ';'
-///
-bool Parser::isCXXDeclarationStatement() {
-  switch (Tok.getKind()) {
-    // asm-definition
-  case tok::kw_asm:
-    // namespace-alias-definition
-  case tok::kw_namespace:
-    // using-declaration
-    // using-directive
-  case tok::kw_using:
-    // static_assert-declaration
-  case tok::kw_static_assert:
-  case tok::kw__Static_assert:
-    return true;
-    // simple-declaration
-  default:
-    return isCXXSimpleDeclaration(/*AllowForRangeDecl=*/false);
-  }
-}
-
-/// isCXXSimpleDeclaration - C++-specialized function that disambiguates
-/// between a simple-declaration or an expression-statement.
-/// If during the disambiguation process a parsing error is encountered,
-/// the function returns true to let the declaration parsing code handle it.
-/// Returns false if the statement is disambiguated as expression.
-///
-/// simple-declaration:
-///   decl-specifier-seq init-declarator-list[opt] ';'
-///   decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
-///                      brace-or-equal-initializer ';'    [C++17]
-///
-/// (if AllowForRangeDecl specified)
-/// for ( for-range-declaration : for-range-initializer ) statement
-///
-/// for-range-declaration:
-///    decl-specifier-seq declarator
-///    decl-specifier-seq ref-qualifier[opt] '[' identifier-list ']'
-///
-/// In any of the above cases there can be a preceding attribute-specifier-seq,
-/// but the caller is expected to handle that.
-bool Parser::isCXXSimpleDeclaration(bool AllowForRangeDecl) {
-  // C++ 6.8p1:
-  // There is an ambiguity in the grammar involving expression-statements and
-  // declarations: An expression-statement with a function-style explicit type
-  // conversion (5.2.3) as its leftmost subexpression can be indistinguishable
-  // from a declaration where the first declarator starts with a '('. In those
-  // cases the statement is a declaration. [Note: To disambiguate, the whole
-  // statement might have to be examined to determine if it is an
-  // expression-statement or a declaration].
-
-  // C++ 6.8p3:
-  // The disambiguation is purely syntactic; that is, the meaning of the names
-  // occurring in such a statement, beyond whether they are type-names or not,
-  // is not generally used in or changed by the disambiguation. Class
-  // templates are instantiated as necessary to determine if a qualified name
-  // is a type-name. Disambiguation precedes parsing, and a statement
-  // disambiguated as a declaration may be an ill-formed declaration.
-
-  // We don't have to parse all of the decl-specifier-seq part. There's only
-  // an ambiguity if the first decl-specifier is
-  // simple-type-specifier/typename-specifier followed by a '(', which may
-  // indicate a function-style cast expression.
-  // isCXXDeclarationSpecifier will return TPResult::Ambiguous only in such
-  // a case.
-
-  bool InvalidAsDeclaration = false;
-  TPResult TPR = isCXXDeclarationSpecifier(TPResult::False,
-                                           &InvalidAsDeclaration);
-  if (TPR != TPResult::Ambiguous)
-    return TPR != TPResult::False; // Returns true for TPResult::True or
-                                   // TPResult::Error.
-
-  // FIXME: TryParseSimpleDeclaration doesn't look past the first initializer,
-  // and so gets some cases wrong. We can't carry on if we've already seen
-  // something which makes this statement invalid as a declaration in this case,
-  // since it can cause us to misparse valid code. Revisit this once
-  // TryParseInitDeclaratorList is fixed.
-  if (InvalidAsDeclaration)
-    return false;
-
-  // FIXME: Add statistics about the number of ambiguous statements encountered
-  // and how they were resolved (number of declarations+number of expressions).
-
-  // Ok, we have a simple-type-specifier/typename-specifier followed by a '(',
-  // or an identifier which doesn't resolve as anything. We need tentative
-  // parsing...
-
-  {
-    RevertingTentativeParsingAction PA(*this);
-    TPR = TryParseSimpleDeclaration(AllowForRangeDecl);
-  }
-
-  // In case of an error, let the declaration parsing code handle it.
-  if (TPR == TPResult::Error)
-    return true;
-
-  // Declarations take precedence over expressions.
-  if (TPR == TPResult::Ambiguous)
-    TPR = TPResult::True;
-
-  assert(TPR == TPResult::True || TPR == TPResult::False);
-  return TPR == TPResult::True;
-}
-
-/// Try to consume a token sequence that we've already identified as
-/// (potentially) starting a decl-specifier.
-Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
-  switch (Tok.getKind()) {
-  case tok::kw__Atomic:
-    if (NextToken().isNot(tok::l_paren)) {
-      ConsumeToken();
-      break;
-    }
-    LLVM_FALLTHROUGH;
-  case tok::kw_typeof:
-  case tok::kw___attribute:
-  case tok::kw___underlying_type: {
-    ConsumeToken();
-    if (Tok.isNot(tok::l_paren))
-      return TPResult::Error;
-    ConsumeParen();
-    if (!SkipUntil(tok::r_paren))
-      return TPResult::Error;
-    break;
-  }
-
-  case tok::kw_class:
-  case tok::kw_struct:
-  case tok::kw_union:
-  case tok::kw___interface:
-  case tok::kw_enum:
-    // elaborated-type-specifier:
-    //     class-key attribute-specifier-seq[opt]
-    //         nested-name-specifier[opt] identifier
-    //     class-key nested-name-specifier[opt] template[opt] simple-template-id
-    //     enum nested-name-specifier[opt] identifier
-    //
-    // FIXME: We don't support class-specifiers nor enum-specifiers here.
-    ConsumeToken();
-
-    // Skip attributes.
-    while (Tok.isOneOf(tok::l_square, tok::kw___attribute, tok::kw___declspec,
-                       tok::kw_alignas)) {
-      if (Tok.is(tok::l_square)) {
-        ConsumeBracket();
-        if (!SkipUntil(tok::r_square))
-          return TPResult::Error;
-      } else {
-        ConsumeToken();
-        if (Tok.isNot(tok::l_paren))
-          return TPResult::Error;
-        ConsumeParen();
-        if (!SkipUntil(tok::r_paren))
-          return TPResult::Error;
-      }
-    }
-
-    if (Tok.isOneOf(tok::identifier, tok::coloncolon, tok::kw_decltype,
-                    tok::annot_template_id) &&
-        TryAnnotateCXXScopeToken())
-      return TPResult::Error;
-    if (Tok.is(tok::annot_cxxscope))
-      ConsumeAnnotationToken();
-    if (Tok.is(tok::identifier))
-      ConsumeToken();
-    else if (Tok.is(tok::annot_template_id))
-      ConsumeAnnotationToken();
-    else
-      return TPResult::Error;
-    break;
-
-  case tok::annot_cxxscope:
-    ConsumeAnnotationToken();
-    LLVM_FALLTHROUGH;
-  default:
-    ConsumeAnyToken();
-
-    if (getLangOpts().ObjC && Tok.is(tok::less))
-      return TryParseProtocolQualifiers();
-    break;
-  }
-
-  return TPResult::Ambiguous;
-}
-
-/// simple-declaration:
-///   decl-specifier-seq init-declarator-list[opt] ';'
-///
-/// (if AllowForRangeDecl specified)
-/// for ( for-range-declaration : for-range-initializer ) statement
-/// for-range-declaration:
-///    attribute-specifier-seqopt type-specifier-seq declarator
-///
-Parser::TPResult Parser::TryParseSimpleDeclaration(bool AllowForRangeDecl) {
-  if (TryConsumeDeclarationSpecifier() == TPResult::Error)
-    return TPResult::Error;
-
-  // Two decl-specifiers in a row conclusively disambiguate this as being a
-  // simple-declaration. Don't bother calling isCXXDeclarationSpecifier in the
-  // overwhelmingly common case that the next token is a '('.
-  if (Tok.isNot(tok::l_paren)) {
-    TPResult TPR = isCXXDeclarationSpecifier();
-    if (TPR == TPResult::Ambiguous)
-      return TPResult::True;
-    if (TPR == TPResult::True || TPR == TPResult::Error)
-      return TPR;
-    assert(TPR == TPResult::False);
-  }
-
-  TPResult TPR = TryParseInitDeclaratorList();
-  if (TPR != TPResult::Ambiguous)
-    return TPR;
-
-  if (Tok.isNot(tok::semi) && (!AllowForRangeDecl || Tok.isNot(tok::colon)))
-    return TPResult::False;
-
-  return TPResult::Ambiguous;
-}
-
-/// Tentatively parse an init-declarator-list in order to disambiguate it from
-/// an expression.
-///
-///       init-declarator-list:
-///         init-declarator
-///         init-declarator-list ',' init-declarator
-///
-///       init-declarator:
-///         declarator initializer[opt]
-/// [GNU]   declarator simple-asm-expr[opt] attributes[opt] initializer[opt]
-///
-///       initializer:
-///         brace-or-equal-initializer
-///         '(' expression-list ')'
-///
-///       brace-or-equal-initializer:
-///         '=' initializer-clause
-/// [C++11] braced-init-list
-///
-///       initializer-clause:
-///         assignment-expression
-///         braced-init-list
-///
-///       braced-init-list:
-///         '{' initializer-list ','[opt] '}'
-///         '{' '}'
-///
-Parser::TPResult Parser::TryParseInitDeclaratorList() {
-  while (1) {
-    // declarator
-    TPResult TPR = TryParseDeclarator(false/*mayBeAbstract*/);
-    if (TPR != TPResult::Ambiguous)
-      return TPR;
-
-    // [GNU] simple-asm-expr[opt] attributes[opt]
-    if (Tok.isOneOf(tok::kw_asm, tok::kw___attribute))
-      return TPResult::True;
-
-    // initializer[opt]
-    if (Tok.is(tok::l_paren)) {
-      // Parse through the parens.
-      ConsumeParen();
-      if (!SkipUntil(tok::r_paren, StopAtSemi))
-        return TPResult::Error;
-    } else if (Tok.is(tok::l_brace)) {
-      // A left-brace here is sufficient to disambiguate the parse; an
-      // expression can never be followed directly by a braced-init-list.
-      return TPResult::True;
-    } else if (Tok.is(tok::equal) || isTokIdentifier_in()) {
-      // MSVC and g++ won't examine the rest of declarators if '=' is
-      // encountered; they just conclude that we have a declaration.
-      // EDG parses the initializer completely, which is the proper behavior
-      // for this case.
-      //
-      // At present, Clang follows MSVC and g++, since the parser does not have
-      // the ability to parse an expression fully without recording the
-      // results of that parse.
-      // FIXME: Handle this case correctly.
-      //
-      // Also allow 'in' after an Objective-C declaration as in:
-      // for (int (^b)(void) in array). Ideally this should be done in the
-      // context of parsing for-init-statement of a foreach statement only. But,
-      // in any other context 'in' is invalid after a declaration and parser
-      // issues the error regardless of outcome of this decision.
-      // FIXME: Change if above assumption does not hold.
-      return TPResult::True;
-    }
-
-    if (!TryConsumeToken(tok::comma))
-      break;
-  }
-
-  return TPResult::Ambiguous;
-}
-
-struct Parser::ConditionDeclarationOrInitStatementState {
-  Parser &P;
-  bool CanBeExpression = true;
-  bool CanBeCondition = true;
-  bool CanBeInitStatement;
-  bool CanBeForRangeDecl;
-
-  ConditionDeclarationOrInitStatementState(Parser &P, bool CanBeInitStatement,
-                                           bool CanBeForRangeDecl)
-      : P(P), CanBeInitStatement(CanBeInitStatement),
-        CanBeForRangeDecl(CanBeForRangeDecl) {}
-
-  bool resolved() {
-    return CanBeExpression + CanBeCondition + CanBeInitStatement +
-               CanBeForRangeDecl < 2;
-  }
-
-  void markNotExpression() {
-    CanBeExpression = false;
-
-    if (!resolved()) {
-      // FIXME: Unify the parsing codepaths for condition variables and
-      // simple-declarations so that we don't need to eagerly figure out which
-      // kind we have here. (Just parse init-declarators until we reach a
-      // semicolon or right paren.)
-      RevertingTentativeParsingAction PA(P);
-      if (CanBeForRangeDecl) {
-        // Skip until we hit a ')', ';', or a ':' with no matching '?'.
-        // The final case is a for range declaration, the rest are not.
-        while (true) {
-          unsigned QuestionColonDepth = 0;
-          P.SkipUntil({tok::r_paren, tok::semi, tok::question, tok::colon},
-                      StopBeforeMatch);
-          if (P.Tok.is(tok::question))
-            ++QuestionColonDepth;
-          else if (P.Tok.is(tok::colon)) {
-            if (QuestionColonDepth)
-              --QuestionColonDepth;
-            else {
-              CanBeCondition = CanBeInitStatement = false;
-              return;
-            }
-          } else {
-            CanBeForRangeDecl = false;
-            break;
-          }
-          P.ConsumeToken();
-        }
-      } else {
-        // Just skip until we hit a ')' or ';'.
-        P.SkipUntil(tok::r_paren, tok::semi, StopBeforeMatch);
-      }
-      if (P.Tok.isNot(tok::r_paren))
-        CanBeCondition = CanBeForRangeDecl = false;
-      if (P.Tok.isNot(tok::semi))
-        CanBeInitStatement = false;
-    }
-  }
-
-  bool markNotCondition() {
-    CanBeCondition = false;
-    return resolved();
-  }
-
-  bool markNotForRangeDecl() {
-    CanBeForRangeDecl = false;
-    return resolved();
-  }
-
-  bool update(TPResult IsDecl) {
-    switch (IsDecl) {
-    case TPResult::True:
-      markNotExpression();
-      assert(resolved() && "can't continue after tentative parsing bails out");
-      break;
-    case TPResult::False:
-      CanBeCondition = CanBeInitStatement = CanBeForRangeDecl = false;
-      break;
-    case TPResult::Ambiguous:
-      break;
-    case TPResult::Error:
-      CanBeExpression = CanBeCondition = CanBeInitStatement =
-          CanBeForRangeDecl = false;
-      break;
-    }
-    return resolved();
-  }
-
-  ConditionOrInitStatement result() const {
-    assert(CanBeExpression + CanBeCondition + CanBeInitStatement +
-                   CanBeForRangeDecl < 2 &&
-           "result called but not yet resolved");
-    if (CanBeExpression)
-      return ConditionOrInitStatement::Expression;
-    if (CanBeCondition)
-      return ConditionOrInitStatement::ConditionDecl;
-    if (CanBeInitStatement)
-      return ConditionOrInitStatement::InitStmtDecl;
-    if (CanBeForRangeDecl)
-      return ConditionOrInitStatement::ForRangeDecl;
-    return ConditionOrInitStatement::Error;
-  }
-};
-
-/// Disambiguates between a declaration in a condition, a
-/// simple-declaration in an init-statement, and an expression for
-/// a condition of a if/switch statement.
-///
-///       condition:
-///         expression
-///         type-specifier-seq declarator '=' assignment-expression
-/// [C++11] type-specifier-seq declarator '=' initializer-clause
-/// [C++11] type-specifier-seq declarator braced-init-list
-/// [GNU]   type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]
-///             '=' assignment-expression
-///       simple-declaration:
-///         decl-specifier-seq init-declarator-list[opt] ';'
-///
-/// Note that, unlike isCXXSimpleDeclaration, we must disambiguate all the way
-/// to the ';' to disambiguate cases like 'int(x))' (an expression) from
-/// 'int(x);' (a simple-declaration in an init-statement).
-Parser::ConditionOrInitStatement
-Parser::isCXXConditionDeclarationOrInitStatement(bool CanBeInitStatement,
-                                                 bool CanBeForRangeDecl) {
-  ConditionDeclarationOrInitStatementState State(*this, CanBeInitStatement,
-                                                 CanBeForRangeDecl);
-
-  if (State.update(isCXXDeclarationSpecifier()))
-    return State.result();
-
-  // It might be a declaration; we need tentative parsing.
-  RevertingTentativeParsingAction PA(*this);
-
-  // FIXME: A tag definition unambiguously tells us this is an init-statement.
-  if (State.update(TryConsumeDeclarationSpecifier()))
-    return State.result();
-  assert(Tok.is(tok::l_paren) && "Expected '('");
-
-  while (true) {
-    // Consume a declarator.
-    if (State.update(TryParseDeclarator(false/*mayBeAbstract*/)))
-      return State.result();
-
-    // Attributes, asm label, or an initializer imply this is not an expression.
-    // FIXME: Disambiguate properly after an = instead of assuming that it's a
-    // valid declaration.
-    if (Tok.isOneOf(tok::equal, tok::kw_asm, tok::kw___attribute) ||
-        (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace))) {
-      State.markNotExpression();
-      return State.result();
-    }
-
-    // A colon here identifies a for-range declaration.
-    if (State.CanBeForRangeDecl && Tok.is(tok::colon))
-      return ConditionOrInitStatement::ForRangeDecl;
-
-    // At this point, it can't be a condition any more, because a condition
-    // must have a brace-or-equal-initializer.
-    if (State.markNotCondition())
-      return State.result();
-
-    // Likewise, it can't be a for-range declaration any more.
-    if (State.markNotForRangeDecl())
-      return State.result();
-
-    // A parenthesized initializer could be part of an expression or a
-    // simple-declaration.
-    if (Tok.is(tok::l_paren)) {
-      ConsumeParen();
-      SkipUntil(tok::r_paren, StopAtSemi);
-    }
-
-    if (!TryConsumeToken(tok::comma))
-      break;
-  }
-
-  // We reached the end. If it can now be some kind of decl, then it is.
-  if (State.CanBeCondition && Tok.is(tok::r_paren))
-    return ConditionOrInitStatement::ConditionDecl;
-  else if (State.CanBeInitStatement && Tok.is(tok::semi))
-    return ConditionOrInitStatement::InitStmtDecl;
-  else
-    return ConditionOrInitStatement::Expression;
-}
-
-  /// Determine whether the next set of tokens contains a type-id.
-  ///
-  /// The context parameter states what context we're parsing right
-  /// now, which affects how this routine copes with the token
-  /// following the type-id. If the context is TypeIdInParens, we have
-  /// already parsed the '(' and we will cease lookahead when we hit
-  /// the corresponding ')'. If the context is
-  /// TypeIdAsTemplateArgument, we've already parsed the '<' or ','
-  /// before this template argument, and will cease lookahead when we
-  /// hit a '>', '>>' (in C++0x), or ','; or, in C++0x, an ellipsis immediately
-  /// preceding such. Returns true for a type-id and false for an expression.
-  /// If during the disambiguation process a parsing error is encountered,
-  /// the function returns true to let the declaration parsing code handle it.
-  ///
-  /// type-id:
-  ///   type-specifier-seq abstract-declarator[opt]
-  ///
-bool Parser::isCXXTypeId(TentativeCXXTypeIdContext Context, bool &isAmbiguous) {
-
-  isAmbiguous = false;
-
-  // C++ 8.2p2:
-  // The ambiguity arising from the similarity between a function-style cast and
-  // a type-id can occur in different contexts. The ambiguity appears as a
-  // choice between a function-style cast expression and a declaration of a
-  // type. The resolution is that any construct that could possibly be a type-id
-  // in its syntactic context shall be considered a type-id.
-
-  TPResult TPR = isCXXDeclarationSpecifier();
-  if (TPR != TPResult::Ambiguous)
-    return TPR != TPResult::False; // Returns true for TPResult::True or
-                                     // TPResult::Error.
-
-  // FIXME: Add statistics about the number of ambiguous statements encountered
-  // and how they were resolved (number of declarations+number of expressions).
-
-  // Ok, we have a simple-type-specifier/typename-specifier followed by a '('.
-  // We need tentative parsing...
-
-  RevertingTentativeParsingAction PA(*this);
-
-  // type-specifier-seq
-  TryConsumeDeclarationSpecifier();
-  assert(Tok.is(tok::l_paren) && "Expected '('");
-
-  // declarator
-  TPR = TryParseDeclarator(true/*mayBeAbstract*/, false/*mayHaveIdentifier*/);
-
-  // In case of an error, let the declaration parsing code handle it.
-  if (TPR == TPResult::Error)
-    TPR = TPResult::True;
-
-  if (TPR == TPResult::Ambiguous) {
-    // We are supposed to be inside parens, so if after the abstract declarator
-    // we encounter a ')' this is a type-id, otherwise it's an expression.
-    if (Context == TypeIdInParens && Tok.is(tok::r_paren)) {
-      TPR = TPResult::True;
-      isAmbiguous = true;
-
-    // We are supposed to be inside a template argument, so if after
-    // the abstract declarator we encounter a '>', '>>' (in C++0x), or
-    // ','; or, in C++0x, an ellipsis immediately preceding such, this
-    // is a type-id. Otherwise, it's an expression.
-    } else if (Context == TypeIdAsTemplateArgument &&
-               (Tok.isOneOf(tok::greater, tok::comma) ||
-                (getLangOpts().CPlusPlus11 &&
-                 (Tok.is(tok::greatergreater) ||
-                  (Tok.is(tok::ellipsis) &&
-                   NextToken().isOneOf(tok::greater, tok::greatergreater,
-                                       tok::comma)))))) {
-      TPR = TPResult::True;
-      isAmbiguous = true;
-
-    } else
-      TPR = TPResult::False;
-  }
-
-  assert(TPR == TPResult::True || TPR == TPResult::False);
-  return TPR == TPResult::True;
-}
-
-/// Returns true if this is a C++11 attribute-specifier. Per
-/// C++11 [dcl.attr.grammar]p6, two consecutive left square bracket tokens
-/// always introduce an attribute. In Objective-C++11, this rule does not
-/// apply if either '[' begins a message-send.
-///
-/// If Disambiguate is true, we try harder to determine whether a '[[' starts
-/// an attribute-specifier, and return CAK_InvalidAttributeSpecifier if not.
-///
-/// If OuterMightBeMessageSend is true, we assume the outer '[' is either an
-/// Obj-C message send or the start of an attribute. Otherwise, we assume it
-/// is not an Obj-C message send.
-///
-/// C++11 [dcl.attr.grammar]:
-///
-///     attribute-specifier:
-///         '[' '[' attribute-list ']' ']'
-///         alignment-specifier
-///
-///     attribute-list:
-///         attribute[opt]
-///         attribute-list ',' attribute[opt]
-///         attribute '...'
-///         attribute-list ',' attribute '...'
-///
-///     attribute:
-///         attribute-token attribute-argument-clause[opt]
-///
-///     attribute-token:
-///         identifier
-///         identifier '::' identifier
-///
-///     attribute-argument-clause:
-///         '(' balanced-token-seq ')'
-Parser::CXX11AttributeKind
-Parser::isCXX11AttributeSpecifier(bool Disambiguate,
-                                  bool OuterMightBeMessageSend) {
-  if (Tok.is(tok::kw_alignas))
-    return CAK_AttributeSpecifier;
-
-  if (Tok.isNot(tok::l_square) || NextToken().isNot(tok::l_square))
-    return CAK_NotAttributeSpecifier;
-
-  // No tentative parsing if we don't need to look for ']]' or a lambda.
-  if (!Disambiguate && !getLangOpts().ObjC)
-    return CAK_AttributeSpecifier;
-
-  RevertingTentativeParsingAction PA(*this);
-
-  // Opening brackets were checked for above.
-  ConsumeBracket();
-
-  // Outside Obj-C++11, treat anything with a matching ']]' as an attribute.
-  if (!getLangOpts().ObjC) {
-    ConsumeBracket();
-
-    bool IsAttribute = SkipUntil(tok::r_square);
-    IsAttribute &= Tok.is(tok::r_square);
-
-    return IsAttribute ? CAK_AttributeSpecifier : CAK_InvalidAttributeSpecifier;
-  }
-
-  // In Obj-C++11, we need to distinguish four situations:
-  //  1a) int x[[attr]];                     C++11 attribute.
-  //  1b) [[attr]];                          C++11 statement attribute.
-  //   2) int x[[obj](){ return 1; }()];     Lambda in array size/index.
-  //  3a) int x[[obj get]];                  Message send in array size/index.
-  //  3b) [[Class alloc] init];              Message send in message send.
-  //   4) [[obj]{ return self; }() doStuff]; Lambda in message send.
-  // (1) is an attribute, (2) is ill-formed, and (3) and (4) are accepted.
-
-  // If we have a lambda-introducer, then this is definitely not a message send.
-  // FIXME: If this disambiguation is too slow, fold the tentative lambda parse
-  // into the tentative attribute parse below.
-  LambdaIntroducer Intro;
-  if (!TryParseLambdaIntroducer(Intro)) {
-    // A lambda cannot end with ']]', and an attribute must.
-    bool IsAttribute = Tok.is(tok::r_square);
-
-    if (IsAttribute)
-      // Case 1: C++11 attribute.
-      return CAK_AttributeSpecifier;
-
-    if (OuterMightBeMessageSend)
-      // Case 4: Lambda in message send.
-      return CAK_NotAttributeSpecifier;
-
-    // Case 2: Lambda in array size / index.
-    return CAK_InvalidAttributeSpecifier;
-  }
-
-  ConsumeBracket();
-
-  // If we don't have a lambda-introducer, then we have an attribute or a
-  // message-send.
-  bool IsAttribute = true;
-  while (Tok.isNot(tok::r_square)) {
-    if (Tok.is(tok::comma)) {
-      // Case 1: Stray commas can only occur in attributes.
-      return CAK_AttributeSpecifier;
-    }
-
-    // Parse the attribute-token, if present.
-    // C++11 [dcl.attr.grammar]:
-    //   If a keyword or an alternative token that satisfies the syntactic
-    //   requirements of an identifier is contained in an attribute-token,
-    //   it is considered an identifier.
-    SourceLocation Loc;
-    if (!TryParseCXX11AttributeIdentifier(Loc)) {
-      IsAttribute = false;
-      break;
-    }
-    if (Tok.is(tok::coloncolon)) {
-      ConsumeToken();
-      if (!TryParseCXX11AttributeIdentifier(Loc)) {
-        IsAttribute = false;
-        break;
-      }
-    }
-
-    // Parse the attribute-argument-clause, if present.
-    if (Tok.is(tok::l_paren)) {
-      ConsumeParen();
-      if (!SkipUntil(tok::r_paren)) {
-        IsAttribute = false;
-        break;
-      }
-    }
-
-    TryConsumeToken(tok::ellipsis);
-
-    if (!TryConsumeToken(tok::comma))
-      break;
-  }
-
-  // An attribute must end ']]'.
-  if (IsAttribute) {
-    if (Tok.is(tok::r_square)) {
-      ConsumeBracket();
-      IsAttribute = Tok.is(tok::r_square);
-    } else {
-      IsAttribute = false;
-    }
-  }
-
-  if (IsAttribute)
-    // Case 1: C++11 statement attribute.
-    return CAK_AttributeSpecifier;
-
-  // Case 3: Message send.
-  return CAK_NotAttributeSpecifier;
-}
-
-Parser::TPResult Parser::TryParsePtrOperatorSeq() {
-  while (true) {
-    if (Tok.isOneOf(tok::coloncolon, tok::identifier))
-      if (TryAnnotateCXXScopeToken(true))
-        return TPResult::Error;
-
-    if (Tok.isOneOf(tok::star, tok::amp, tok::caret, tok::ampamp) ||
-        (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::star))) {
-      // ptr-operator
-      ConsumeAnyToken();
-      while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw_restrict,
-                         tok::kw__Nonnull, tok::kw__Nullable,
-                         tok::kw__Null_unspecified))
-        ConsumeToken();
-    } else {
-      return TPResult::True;
-    }
-  }
-}
-
-///         operator-function-id:
-///           'operator' operator
-///
-///         operator: one of
-///           new  delete  new[]  delete[]  +  -  *  /  %  ^  [...]
-///
-///         conversion-function-id:
-///           'operator' conversion-type-id
-///
-///         conversion-type-id:
-///           type-specifier-seq conversion-declarator[opt]
-///
-///         conversion-declarator:
-///           ptr-operator conversion-declarator[opt]
-///
-///         literal-operator-id:
-///           'operator' string-literal identifier
-///           'operator' user-defined-string-literal
-Parser::TPResult Parser::TryParseOperatorId() {
-  assert(Tok.is(tok::kw_operator));
-  ConsumeToken();
-
-  // Maybe this is an operator-function-id.
-  switch (Tok.getKind()) {
-  case tok::kw_new: case tok::kw_delete:
-    ConsumeToken();
-    if (Tok.is(tok::l_square) && NextToken().is(tok::r_square)) {
-      ConsumeBracket();
-      ConsumeBracket();
-    }
-    return TPResult::True;
-
-#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemOnly) \
-  case tok::Token:
-#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemOnly)
-#include "clang/Basic/OperatorKinds.def"
-    ConsumeToken();
-    return TPResult::True;
-
-  case tok::l_square:
-    if (NextToken().is(tok::r_square)) {
-      ConsumeBracket();
-      ConsumeBracket();
-      return TPResult::True;
-    }
-    break;
-
-  case tok::l_paren:
-    if (NextToken().is(tok::r_paren)) {
-      ConsumeParen();
-      ConsumeParen();
-      return TPResult::True;
-    }
-    break;
-
-  default:
-    break;
-  }
-
-  // Maybe this is a literal-operator-id.
-  if (getLangOpts().CPlusPlus11 && isTokenStringLiteral()) {
-    bool FoundUDSuffix = false;
-    do {
-      FoundUDSuffix |= Tok.hasUDSuffix();
-      ConsumeStringToken();
-    } while (isTokenStringLiteral());
-
-    if (!FoundUDSuffix) {
-      if (Tok.is(tok::identifier))
-        ConsumeToken();
-      else
-        return TPResult::Error;
-    }
-    return TPResult::True;
-  }
-
-  // Maybe this is a conversion-function-id.
-  bool AnyDeclSpecifiers = false;
-  while (true) {
-    TPResult TPR = isCXXDeclarationSpecifier();
-    if (TPR == TPResult::Error)
-      return TPR;
-    if (TPR == TPResult::False) {
-      if (!AnyDeclSpecifiers)
-        return TPResult::Error;
-      break;
-    }
-    if (TryConsumeDeclarationSpecifier() == TPResult::Error)
-      return TPResult::Error;
-    AnyDeclSpecifiers = true;
-  }
-  return TryParsePtrOperatorSeq();
-}
-
-///         declarator:
-///           direct-declarator
-///           ptr-operator declarator
-///
-///         direct-declarator:
-///           declarator-id
-///           direct-declarator '(' parameter-declaration-clause ')'
-///                 cv-qualifier-seq[opt] exception-specification[opt]
-///           direct-declarator '[' constant-expression[opt] ']'
-///           '(' declarator ')'
-/// [GNU]     '(' attributes declarator ')'
-///
-///         abstract-declarator:
-///           ptr-operator abstract-declarator[opt]
-///           direct-abstract-declarator
-///
-///         direct-abstract-declarator:
-///           direct-abstract-declarator[opt]
-///                 '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
-///                 exception-specification[opt]
-///           direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
-///           '(' abstract-declarator ')'
-/// [C++0x]   ...
-///
-///         ptr-operator:
-///           '*' cv-qualifier-seq[opt]
-///           '&'
-/// [C++0x]   '&&'                                                        [TODO]
-///           '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
-///
-///         cv-qualifier-seq:
-///           cv-qualifier cv-qualifier-seq[opt]
-///
-///         cv-qualifier:
-///           'const'
-///           'volatile'
-///
-///         declarator-id:
-///           '...'[opt] id-expression
-///
-///         id-expression:
-///           unqualified-id
-///           qualified-id                                                [TODO]
-///
-///         unqualified-id:
-///           identifier
-///           operator-function-id
-///           conversion-function-id
-///           literal-operator-id
-///           '~' class-name                                              [TODO]
-///           '~' decltype-specifier                                      [TODO]
-///           template-id                                                 [TODO]
-///
-Parser::TPResult Parser::TryParseDeclarator(bool mayBeAbstract,
-                                            bool mayHaveIdentifier,
-                                            bool mayHaveDirectInit) {
-  // declarator:
-  //   direct-declarator
-  //   ptr-operator declarator
-  if (TryParsePtrOperatorSeq() == TPResult::Error)
-    return TPResult::Error;
-
-  // direct-declarator:
-  // direct-abstract-declarator:
-  if (Tok.is(tok::ellipsis))
-    ConsumeToken();
-
-  if ((Tok.isOneOf(tok::identifier, tok::kw_operator) ||
-       (Tok.is(tok::annot_cxxscope) && (NextToken().is(tok::identifier) ||
-                                        NextToken().is(tok::kw_operator)))) &&
-      mayHaveIdentifier) {
-    // declarator-id
-    if (Tok.is(tok::annot_cxxscope))
-      ConsumeAnnotationToken();
-    else if (Tok.is(tok::identifier))
-      TentativelyDeclaredIdentifiers.push_back(Tok.getIdentifierInfo());
-    if (Tok.is(tok::kw_operator)) {
-      if (TryParseOperatorId() == TPResult::Error)
-        return TPResult::Error;
-    } else
-      ConsumeToken();
-  } else if (Tok.is(tok::l_paren)) {
-    ConsumeParen();
-    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();
-      if (TPR != TPResult::Ambiguous)
-        return TPR;
-    } else {
-      // '(' declarator ')'
-      // '(' attributes declarator ')'
-      // '(' abstract-declarator ')'
-      if (Tok.isOneOf(tok::kw___attribute, tok::kw___declspec, tok::kw___cdecl,
-                      tok::kw___stdcall, tok::kw___fastcall, tok::kw___thiscall,
-                      tok::kw___regcall, tok::kw___vectorcall))
-        return TPResult::True; // attributes indicate declaration
-      TPResult TPR = TryParseDeclarator(mayBeAbstract, mayHaveIdentifier);
-      if (TPR != TPResult::Ambiguous)
-        return TPR;
-      if (Tok.isNot(tok::r_paren))
-        return TPResult::False;
-      ConsumeParen();
-    }
-  } else if (!mayBeAbstract) {
-    return TPResult::False;
-  }
-
-  if (mayHaveDirectInit)
-    return TPResult::Ambiguous;
-
-  while (1) {
-    TPResult TPR(TPResult::Ambiguous);
-
-    if (Tok.is(tok::l_paren)) {
-      // Check whether we have a function declarator or a possible ctor-style
-      // initializer that follows the declarator. Note that ctor-style
-      // initializers are not possible in contexts where abstract declarators
-      // are allowed.
-      if (!mayBeAbstract && !isCXXFunctionDeclarator())
-        break;
-
-      // direct-declarator '(' parameter-declaration-clause ')'
-      //        cv-qualifier-seq[opt] exception-specification[opt]
-      ConsumeParen();
-      TPR = TryParseFunctionDeclarator();
-    } else if (Tok.is(tok::l_square)) {
-      // direct-declarator '[' constant-expression[opt] ']'
-      // direct-abstract-declarator[opt] '[' constant-expression[opt] ']'
-      TPR = TryParseBracketDeclarator();
-    } else {
-      break;
-    }
-
-    if (TPR != TPResult::Ambiguous)
-      return TPR;
-  }
-
-  return TPResult::Ambiguous;
-}
-
-Parser::TPResult
-Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) {
-  switch (Kind) {
-  // Obviously starts an expression.
-  case tok::numeric_constant:
-  case tok::char_constant:
-  case tok::wide_char_constant:
-  case tok::utf8_char_constant:
-  case tok::utf16_char_constant:
-  case tok::utf32_char_constant:
-  case tok::string_literal:
-  case tok::wide_string_literal:
-  case tok::utf8_string_literal:
-  case tok::utf16_string_literal:
-  case tok::utf32_string_literal:
-  case tok::l_square:
-  case tok::l_paren:
-  case tok::amp:
-  case tok::ampamp:
-  case tok::star:
-  case tok::plus:
-  case tok::plusplus:
-  case tok::minus:
-  case tok::minusminus:
-  case tok::tilde:
-  case tok::exclaim:
-  case tok::kw_sizeof:
-  case tok::kw___func__:
-  case tok::kw_const_cast:
-  case tok::kw_delete:
-  case tok::kw_dynamic_cast:
-  case tok::kw_false:
-  case tok::kw_new:
-  case tok::kw_operator:
-  case tok::kw_reinterpret_cast:
-  case tok::kw_static_cast:
-  case tok::kw_this:
-  case tok::kw_throw:
-  case tok::kw_true:
-  case tok::kw_typeid:
-  case tok::kw_alignof:
-  case tok::kw_noexcept:
-  case tok::kw_nullptr:
-  case tok::kw__Alignof:
-  case tok::kw___null:
-  case tok::kw___alignof:
-  case tok::kw___builtin_choose_expr:
-  case tok::kw___builtin_offsetof:
-  case tok::kw___builtin_va_arg:
-  case tok::kw___imag:
-  case tok::kw___real:
-  case tok::kw___FUNCTION__:
-  case tok::kw___FUNCDNAME__:
-  case tok::kw___FUNCSIG__:
-  case tok::kw_L__FUNCTION__:
-  case tok::kw_L__FUNCSIG__:
-  case tok::kw___PRETTY_FUNCTION__:
-  case tok::kw___uuidof:
-#define TYPE_TRAIT(N,Spelling,K) \
-  case tok::kw_##Spelling:
-#include "clang/Basic/TokenKinds.def"
-    return TPResult::True;
-
-  // Obviously starts a type-specifier-seq:
-  case tok::kw_char:
-  case tok::kw_const:
-  case tok::kw_double:
-  case tok::kw__Float16:
-  case tok::kw___float128:
-  case tok::kw_enum:
-  case tok::kw_half:
-  case tok::kw_float:
-  case tok::kw_int:
-  case tok::kw_long:
-  case tok::kw___int64:
-  case tok::kw___int128:
-  case tok::kw_restrict:
-  case tok::kw_short:
-  case tok::kw_signed:
-  case tok::kw_struct:
-  case tok::kw_union:
-  case tok::kw_unsigned:
-  case tok::kw_void:
-  case tok::kw_volatile:
-  case tok::kw__Bool:
-  case tok::kw__Complex:
-  case tok::kw_class:
-  case tok::kw_typename:
-  case tok::kw_wchar_t:
-  case tok::kw_char8_t:
-  case tok::kw_char16_t:
-  case tok::kw_char32_t:
-  case tok::kw__Decimal32:
-  case tok::kw__Decimal64:
-  case tok::kw__Decimal128:
-  case tok::kw___interface:
-  case tok::kw___thread:
-  case tok::kw_thread_local:
-  case tok::kw__Thread_local:
-  case tok::kw_typeof:
-  case tok::kw___underlying_type:
-  case tok::kw___cdecl:
-  case tok::kw___stdcall:
-  case tok::kw___fastcall:
-  case tok::kw___thiscall:
-  case tok::kw___regcall:
-  case tok::kw___vectorcall:
-  case tok::kw___unaligned:
-  case tok::kw___vector:
-  case tok::kw___pixel:
-  case tok::kw___bool:
-  case tok::kw__Atomic:
-#define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
-#include "clang/Basic/OpenCLImageTypes.def"
-  case tok::kw___unknown_anytype:
-    return TPResult::False;
-
-  default:
-    break;
-  }
-
-  return TPResult::Ambiguous;
-}
-
-bool Parser::isTentativelyDeclared(IdentifierInfo *II) {
-  return std::find(TentativelyDeclaredIdentifiers.begin(),
-                   TentativelyDeclaredIdentifiers.end(), II)
-      != TentativelyDeclaredIdentifiers.end();
-}
-
-namespace {
-class TentativeParseCCC : public CorrectionCandidateCallback {
-public:
-  TentativeParseCCC(const Token &Next) {
-    WantRemainingKeywords = false;
-    WantTypeSpecifiers = Next.isOneOf(tok::l_paren, tok::r_paren, tok::greater,
-                                      tok::l_brace, tok::identifier);
-  }
-
-  bool ValidateCandidate(const TypoCorrection &Candidate) override {
-    // Reject any candidate that only resolves to instance members since they
-    // aren't viable as standalone identifiers instead of member references.
-    if (Candidate.isResolved() && !Candidate.isKeyword() &&
-        llvm::all_of(Candidate,
-                     [](NamedDecl *ND) { return ND->isCXXInstanceMember(); }))
-      return false;
-
-    return CorrectionCandidateCallback::ValidateCandidate(Candidate);
-  }
-};
-}
-/// isCXXDeclarationSpecifier - Returns TPResult::True if it is a 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 found and reported.
-///
-/// If HasMissingTypename is provided, a name with a dependent scope specifier
-/// will be treated as ambiguous if the 'typename' keyword is missing. If this
-/// happens, *HasMissingTypename will be set to 'true'. This will also be used
-/// as an indicator that undeclared identifiers (which will trigger a later
-/// parse error) should be treated as types. Returns TPResult::Ambiguous in
-/// such cases.
-///
-///         decl-specifier:
-///           storage-class-specifier
-///           type-specifier
-///           function-specifier
-///           'friend'
-///           'typedef'
-/// [C++11]   'constexpr'
-/// [GNU]     attributes declaration-specifiers[opt]
-///
-///         storage-class-specifier:
-///           'register'
-///           'static'
-///           'extern'
-///           'mutable'
-///           'auto'
-/// [GNU]     '__thread'
-/// [C++11]   'thread_local'
-/// [C11]     '_Thread_local'
-///
-///         function-specifier:
-///           'inline'
-///           'virtual'
-///           'explicit'
-///
-///         typedef-name:
-///           identifier
-///
-///         type-specifier:
-///           simple-type-specifier
-///           class-specifier
-///           enum-specifier
-///           elaborated-type-specifier
-///           typename-specifier
-///           cv-qualifier
-///
-///         simple-type-specifier:
-///           '::'[opt] nested-name-specifier[opt] type-name
-///           '::'[opt] nested-name-specifier 'template'
-///                 simple-template-id                              [TODO]
-///           'char'
-///           'wchar_t'
-///           'bool'
-///           'short'
-///           'int'
-///           'long'
-///           'signed'
-///           'unsigned'
-///           'float'
-///           'double'
-///           'void'
-/// [GNU]     typeof-specifier
-/// [GNU]     '_Complex'
-/// [C++11]   'auto'
-/// [GNU]     '__auto_type'
-/// [C++11]   'decltype' ( expression )
-/// [C++1y]   'decltype' ( 'auto' )
-///
-///         type-name:
-///           class-name
-///           enum-name
-///           typedef-name
-///
-///         elaborated-type-specifier:
-///           class-key '::'[opt] nested-name-specifier[opt] identifier
-///           class-key '::'[opt] nested-name-specifier[opt] 'template'[opt]
-///               simple-template-id
-///           'enum' '::'[opt] nested-name-specifier[opt] identifier
-///
-///         enum-name:
-///           identifier
-///
-///         enum-specifier:
-///           'enum' identifier[opt] '{' enumerator-list[opt] '}'
-///           'enum' identifier[opt] '{' enumerator-list ',' '}'
-///
-///         class-specifier:
-///           class-head '{' member-specification[opt] '}'
-///
-///         class-head:
-///           class-key identifier[opt] base-clause[opt]
-///           class-key nested-name-specifier identifier base-clause[opt]
-///           class-key nested-name-specifier[opt] simple-template-id
-///               base-clause[opt]
-///
-///         class-key:
-///           'class'
-///           'struct'
-///           'union'
-///
-///         cv-qualifier:
-///           'const'
-///           'volatile'
-/// [GNU]     restrict
-///
-Parser::TPResult
-Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
-                                  bool *HasMissingTypename) {
-  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();
-    // In 'foo bar', 'foo' is always a type name outside of Objective-C.
-    if (!getLangOpts().ObjC && Next.is(tok::identifier))
-      return TPResult::True;
-
-    if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
-      // Determine whether this is a valid expression. If not, we will hit
-      // a parse error one way or another. In that case, tell the caller that
-      // this is ambiguous. Typo-correct to type and expression keywords and
-      // to types and identifiers, in order to try to recover from errors.
-      switch (TryAnnotateName(false /* no nested name specifier */,
-                              llvm::make_unique<TentativeParseCCC>(Next))) {
-      case ANK_Error:
-        return TPResult::Error;
-      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())
-            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())
-        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())
-      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())
-      return TPResult::Error;
-    return isCXXDeclarationSpecifier(BracedCastResult, HasMissingTypename);
-
-    // decl-specifier:
-    //   storage-class-specifier
-    //   type-specifier
-    //   function-specifier
-    //   'friend'
-    //   'typedef'
-    //   'constexpr'
-  case tok::kw_friend:
-  case tok::kw_typedef:
-  case tok::kw_constexpr:
-    // storage-class-specifier
-  case tok::kw_register:
-  case tok::kw_static:
-  case tok::kw_extern:
-  case tok::kw_mutable:
-  case tok::kw_auto:
-  case tok::kw___thread:
-  case tok::kw_thread_local:
-  case tok::kw__Thread_local:
-    // function-specifier
-  case tok::kw_inline:
-  case tok::kw_virtual:
-  case tok::kw_explicit:
-
-    // Modules
-  case tok::kw___module_private__:
-
-    // Debugger support
-  case tok::kw___unknown_anytype:
-
-    // type-specifier:
-    //   simple-type-specifier
-    //   class-specifier
-    //   enum-specifier
-    //   elaborated-type-specifier
-    //   typename-specifier
-    //   cv-qualifier
-
-    // class-specifier
-    // elaborated-type-specifier
-  case tok::kw_class:
-  case tok::kw_struct:
-  case tok::kw_union:
-  case tok::kw___interface:
-    // enum-specifier
-  case tok::kw_enum:
-    // cv-qualifier
-  case tok::kw_const:
-  case tok::kw_volatile:
-  case tok::kw___private:
-  case tok::kw___local:
-  case tok::kw___global:
-  case tok::kw___constant:
-  case tok::kw___generic:
-
-    // GNU
-  case tok::kw_restrict:
-  case tok::kw__Complex:
-  case tok::kw___attribute:
-  case tok::kw___auto_type:
-    return TPResult::True;
-
-    // Microsoft
-  case tok::kw___declspec:
-  case tok::kw___cdecl:
-  case tok::kw___stdcall:
-  case tok::kw___fastcall:
-  case tok::kw___thiscall:
-  case tok::kw___regcall:
-  case tok::kw___vectorcall:
-  case tok::kw___w64:
-  case tok::kw___sptr:
-  case tok::kw___uptr:
-  case tok::kw___ptr64:
-  case tok::kw___ptr32:
-  case tok::kw___forceinline:
-  case tok::kw___unaligned:
-  case tok::kw__Nonnull:
-  case tok::kw__Nullable:
-  case tok::kw__Null_unspecified:
-  case tok::kw___kindof:
-    return TPResult::True;
-
-    // Borland
-  case tok::kw___pascal:
-    return TPResult::True;
-
-    // AltiVec
-  case tok::kw___vector:
-    return TPResult::True;
-
-  case tok::annot_template_id: {
-    TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
-    if (TemplateId->Kind != TNK_Type_template)
-      return TPResult::False;
-    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())
-      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(),
-                                                     SS);
-        if (SS.getScopeRep() && SS.getScopeRep()->isDependent()) {
-          RevertingTentativeParsingAction PA(*this);
-          ConsumeAnnotationToken();
-          ConsumeToken();
-          bool isIdentifier = Tok.is(tok::identifier);
-          TPResult TPR = TPResult::False;
-          if (!isIdentifier)
-            TPR = isCXXDeclarationSpecifier(BracedCastResult,
-                                            HasMissingTypename);
-
-          if (isIdentifier ||
-              TPR == TPResult::True || TPR == TPResult::Error)
-            return TPResult::Error;
-
-          if (HasMissingTypename) {
-            // We can't tell whether this is a missing 'typename' or a valid
-            // expression.
-            *HasMissingTypename = true;
-            return TPResult::Ambiguous;
-          }
-        } else {
-          // Try to resolve the name. If it doesn't exist, assume it was
-          // intended to name a type and keep disambiguating.
-          switch (TryAnnotateName(false /* SS is not dependent */)) {
-          case ANK_Error:
-            return TPResult::Error;
-          case ANK_TentativeDecl:
-            return TPResult::False;
-          case ANK_TemplateName:
-            // In C++17, this could be a type template for class template
-            // argument deduction.
-            if (getLangOpts().CPlusPlus17) {
-              if (TryAnnotateTypeOrScopeToken())
-                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.
-            // In C++17, this could be class template argument deduction.
-            return (getLangOpts().CPlusPlus17 || GreaterThanIsOperator)
-                       ? TPResult::True
-                       : TPResult::False;
-          case ANK_Unresolved:
-            return HasMissingTypename ? TPResult::Ambiguous
-                                      : TPResult::False;
-          case ANK_Success:
-            break;
-          }
-
-          // Annotated it, check again.
-          assert(Tok.isNot(tok::annot_cxxscope) ||
-                 NextToken().isNot(tok::identifier));
-          return isCXXDeclarationSpecifier(BracedCastResult,
-                                           HasMissingTypename);
-        }
-      }
-      return TPResult::False;
-    }
-    // If that succeeded, fallthrough into the generic simple-type-id case.
-    LLVM_FALLTHROUGH;
-
-    // The ambiguity resides in a simple-type-specifier/typename-specifier
-    // followed by a '('. The '(' could either be the start of:
-    //
-    //   direct-declarator:
-    //     '(' declarator ')'
-    //
-    //   direct-abstract-declarator:
-    //     '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
-    //              exception-specification[opt]
-    //     '(' abstract-declarator ')'
-    //
-    // or part of a function-style cast expression:
-    //
-    //     simple-type-specifier '(' expression-list[opt] ')'
-    //
-
-    // simple-type-specifier:
-
-  case tok::annot_typename:
-  case_typename:
-    // In Objective-C, we might have a protocol-qualified type.
-    if (getLangOpts().ObjC && NextToken().is(tok::less)) {
-      // Tentatively parse the protocol qualifiers.
-      RevertingTentativeParsingAction PA(*this);
-      ConsumeAnyToken(); // The type token
-
-      TPResult TPR = TryParseProtocolQualifiers();
-      bool isFollowedByParen = Tok.is(tok::l_paren);
-      bool isFollowedByBrace = Tok.is(tok::l_brace);
-
-      if (TPR == TPResult::Error)
-        return TPResult::Error;
-
-      if (isFollowedByParen)
-        return TPResult::Ambiguous;
-
-      if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
-        return BracedCastResult;
-
-      return TPResult::True;
-    }
-    LLVM_FALLTHROUGH;
-
-  case tok::kw_char:
-  case tok::kw_wchar_t:
-  case tok::kw_char8_t:
-  case tok::kw_char16_t:
-  case tok::kw_char32_t:
-  case tok::kw_bool:
-  case tok::kw_short:
-  case tok::kw_int:
-  case tok::kw_long:
-  case tok::kw___int64:
-  case tok::kw___int128:
-  case tok::kw_signed:
-  case tok::kw_unsigned:
-  case tok::kw_half:
-  case tok::kw_float:
-  case tok::kw_double:
-  case tok::kw__Float16:
-  case tok::kw___float128:
-  case tok::kw_void:
-  case tok::annot_decltype:
-    if (NextToken().is(tok::l_paren))
-      return TPResult::Ambiguous;
-
-    // This is a function-style cast in all cases we disambiguate other than
-    // one:
-    //   struct S {
-    //     enum E : int { a = 4 }; // enum
-    //     enum E : int { 4 };     // bit-field
-    //   };
-    if (getLangOpts().CPlusPlus11 && NextToken().is(tok::l_brace))
-      return BracedCastResult;
-
-    if (isStartOfObjCClassMessageMissingOpenBracket())
-      return TPResult::False;
-
-    return TPResult::True;
-
-  // GNU typeof support.
-  case tok::kw_typeof: {
-    if (NextToken().isNot(tok::l_paren))
-      return TPResult::True;
-
-    RevertingTentativeParsingAction PA(*this);
-
-    TPResult TPR = TryParseTypeofSpecifier();
-    bool isFollowedByParen = Tok.is(tok::l_paren);
-    bool isFollowedByBrace = Tok.is(tok::l_brace);
-
-    if (TPR == TPResult::Error)
-      return TPResult::Error;
-
-    if (isFollowedByParen)
-      return TPResult::Ambiguous;
-
-    if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
-      return BracedCastResult;
-
-    return TPResult::True;
-  }
-
-  // C++0x type traits support
-  case tok::kw___underlying_type:
-    return TPResult::True;
-
-  // C11 _Atomic
-  case tok::kw__Atomic:
-    return TPResult::True;
-
-  default:
-    return TPResult::False;
-  }
-}
-
-bool Parser::isCXXDeclarationSpecifierAType() {
-  switch (Tok.getKind()) {
-    // typename-specifier
-  case tok::annot_decltype:
-  case tok::annot_template_id:
-  case tok::annot_typename:
-  case tok::kw_typeof:
-  case tok::kw___underlying_type:
-    return true;
-
-    // elaborated-type-specifier
-  case tok::kw_class:
-  case tok::kw_struct:
-  case tok::kw_union:
-  case tok::kw___interface:
-  case tok::kw_enum:
-    return true;
-
-    // simple-type-specifier
-  case tok::kw_char:
-  case tok::kw_wchar_t:
-  case tok::kw_char8_t:
-  case tok::kw_char16_t:
-  case tok::kw_char32_t:
-  case tok::kw_bool:
-  case tok::kw_short:
-  case tok::kw_int:
-  case tok::kw_long:
-  case tok::kw___int64:
-  case tok::kw___int128:
-  case tok::kw_signed:
-  case tok::kw_unsigned:
-  case tok::kw_half:
-  case tok::kw_float:
-  case tok::kw_double:
-  case tok::kw__Float16:
-  case tok::kw___float128:
-  case tok::kw_void:
-  case tok::kw___unknown_anytype:
-  case tok::kw___auto_type:
-    return true;
-
-  case tok::kw_auto:
-    return getLangOpts().CPlusPlus11;
-
-  case tok::kw__Atomic:
-    // "_Atomic foo"
-    return NextToken().is(tok::l_paren);
-
-  default:
-    return false;
-  }
-}
-
-/// [GNU] typeof-specifier:
-///         'typeof' '(' expressions ')'
-///         'typeof' '(' type-name ')'
-///
-Parser::TPResult Parser::TryParseTypeofSpecifier() {
-  assert(Tok.is(tok::kw_typeof) && "Expected 'typeof'!");
-  ConsumeToken();
-
-  assert(Tok.is(tok::l_paren) && "Expected '('");
-  // Parse through the parens after 'typeof'.
-  ConsumeParen();
-  if (!SkipUntil(tok::r_paren, StopAtSemi))
-    return TPResult::Error;
-
-  return TPResult::Ambiguous;
-}
-
-/// [ObjC] protocol-qualifiers:
-////         '<' identifier-list '>'
-Parser::TPResult Parser::TryParseProtocolQualifiers() {
-  assert(Tok.is(tok::less) && "Expected '<' for qualifier list");
-  ConsumeToken();
-  do {
-    if (Tok.isNot(tok::identifier))
-      return TPResult::Error;
-    ConsumeToken();
-
-    if (Tok.is(tok::comma)) {
-      ConsumeToken();
-      continue;
-    }
-
-    if (Tok.is(tok::greater)) {
-      ConsumeToken();
-      return TPResult::Ambiguous;
-    }
-  } while (false);
-
-  return TPResult::Error;
-}
-
-/// 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.
-/// 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) {
-
-  // 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);
-  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]
-///   parameter-declaration-list ',' '...'
-///
-/// parameter-declaration-list:
-///   parameter-declaration
-///   parameter-declaration-list ',' parameter-declaration
-///
-/// parameter-declaration:
-///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[opt]
-///   attribute-specifier-seq[opt] decl-specifier-seq declarator attributes[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) {
-
-  if (Tok.is(tok::r_paren))
-    return TPResult::Ambiguous;
-
-  //   parameter-declaration-list[opt] '...'[opt]
-  //   parameter-declaration-list ',' '...'
-  //
-  // parameter-declaration-list:
-  //   parameter-declaration
-  //   parameter-declaration-list ',' parameter-declaration
-  //
-  while (1) {
-    // '...'[opt]
-    if (Tok.is(tok::ellipsis)) {
-      ConsumeToken();
-      if (Tok.is(tok::r_paren))
-        return TPResult::True; // '...)' is a sign of a function declarator.
-      else
-        return TPResult::False;
-    }
-
-    // An attribute-specifier-seq here is a sign of a function declarator.
-    if (isCXX11AttributeSpecifier(/*Disambiguate*/false,
-                                  /*OuterMightBeMessageSend*/true))
-      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);
-
-    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)
-          return TPResult::Error;
-
-        // If we see a parameter name, this can't be a template argument.
-        if (SeenType && Tok.is(tok::identifier))
-          return TPResult::True;
-
-        TPR = isCXXDeclarationSpecifier(TPResult::False,
-                                        InvalidAsDeclaration);
-        if (TPR == TPResult::Error)
-          return TPR;
-      } while (TPR != TPResult::False);
-    } else if (TPR == TPResult::Ambiguous) {
-      // Disambiguate what follows the decl-specifier.
-      if (TryConsumeDeclarationSpecifier() == TPResult::Error)
-        return TPResult::Error;
-    } else
-      return TPR;
-
-    // declarator
-    // abstract-declarator[opt]
-    TPR = TryParseDeclarator(true/*mayBeAbstract*/);
-    if (TPR != TPResult::Ambiguous)
-      return TPR;
-
-    // [GNU] attributes[opt]
-    if (Tok.is(tok::kw___attribute))
-      return TPResult::True;
-
-    // If we're disambiguating a template argument in a default argument in
-    // a class definition versus a parameter declaration, an '=' here
-    // disambiguates the parse one way or the other.
-    // If this is a parameter, it must have a default argument because
-    //   (a) the previous parameter did, and
-    //   (b) this must be the first declaration of the function, so we can't
-    //       inherit any default arguments from elsewhere.
-    // If we see an ')', then we've reached the end of a
-    // parameter-declaration-clause, and the last param is missing its default
-    // argument.
-    if (VersusTemplateArgument)
-      return Tok.isOneOf(tok::equal, tok::r_paren) ? TPResult::True
-                                                   : TPResult::False;
-
-    if (Tok.is(tok::equal)) {
-      // '=' assignment-expression
-      // Parse through assignment-expression.
-      // FIXME: assignment-expression may contain an unparenthesized comma.
-      if (!SkipUntil(tok::comma, tok::r_paren, StopAtSemi | StopBeforeMatch))
-        return TPResult::Error;
-    }
-
-    if (Tok.is(tok::ellipsis)) {
-      ConsumeToken();
-      if (Tok.is(tok::r_paren))
-        return TPResult::True; // '...)' is a sign of a function declarator.
-      else
-        return TPResult::False;
-    }
-
-    if (!TryConsumeToken(tok::comma))
-      break;
-  }
-
-  return TPResult::Ambiguous;
-}
-
-/// 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, otherwise it will return either False() or
-/// Error().
-///
-/// '(' parameter-declaration-clause ')' cv-qualifier-seq[opt]
-///         exception-specification[opt]
-///
-/// exception-specification:
-///   'throw' '(' type-id-list[opt] ')'
-///
-Parser::TPResult Parser::TryParseFunctionDeclarator() {
-
-  // The '(' is already parsed.
-
-  TPResult TPR = TryParseParameterDeclarationClause();
-  if (TPR == TPResult::Ambiguous && Tok.isNot(tok::r_paren))
-    TPR = TPResult::False;
-
-  if (TPR == TPResult::False || TPR == TPResult::Error)
-    return TPR;
-
-  // Parse through the parens.
-  if (!SkipUntil(tok::r_paren, StopAtSemi))
-    return TPResult::Error;
-
-  // cv-qualifier-seq
-  while (Tok.isOneOf(tok::kw_const, tok::kw_volatile, tok::kw___unaligned,
-                     tok::kw_restrict))
-    ConsumeToken();
-
-  // ref-qualifier[opt]
-  if (Tok.isOneOf(tok::amp, tok::ampamp))
-    ConsumeToken();
-
-  // exception-specification
-  if (Tok.is(tok::kw_throw)) {
-    ConsumeToken();
-    if (Tok.isNot(tok::l_paren))
-      return TPResult::Error;
-
-    // Parse through the parens after 'throw'.
-    ConsumeParen();
-    if (!SkipUntil(tok::r_paren, StopAtSemi))
-      return TPResult::Error;
-  }
-  if (Tok.is(tok::kw_noexcept)) {
-    ConsumeToken();
-    // Possibly an expression as well.
-    if (Tok.is(tok::l_paren)) {
-      // Find the matching rparen.
-      ConsumeParen();
-      if (!SkipUntil(tok::r_paren, StopAtSemi))
-        return TPResult::Error;
-    }
-  }
-
-  return TPResult::Ambiguous;
-}
-
-/// '[' constant-expression[opt] ']'
-///
-Parser::TPResult Parser::TryParseBracketDeclarator() {
-  ConsumeBracket();
-  if (!SkipUntil(tok::r_square, StopAtSemi))
-    return TPResult::Error;
-
-  return TPResult::Ambiguous;
-}