Parser: Tweak parseTypeIdentifier to better suit its only remaining client

Author: AnthonyLatsis

include/swift/Parse/Parser.h

@@ -1296,22 +1296,25 @@ class Parser {
                                      SourceLoc &LAngleLoc,
                                      SourceLoc &RAngleLoc);
 
-  /// Parses a type identifier (e.g. 'Foo' or 'Foo.Bar.Baz').
+  /// Parses and returns the base type for a qualified declaration name,
+  /// positioning the parser at the '.' before the final declaration name. This
+  /// position is important for parsing final declaration names like '.init' via
+  /// `parseUnqualifiedDeclName`. For example, 'Foo.Bar.f' parses as 'Foo.Bar'
+  /// and the parser is positioned at '.f'. If there is no base type qualifier
+  /// (e.g. when parsing just 'f'), returns an empty parser error.
   ///
-  /// When `isParsingQualifiedDeclBaseType` is true:
-  /// - Parses and returns the base type for a qualified declaration name,
-  ///   positioning the parser at the '.' before the final declaration name.
-  //    This position is important for parsing final declaration names like
-  //    '.init' via `parseUnqualifiedDeclName`.
-  /// - For example, 'Foo.Bar.f' parses as 'Foo.Bar' and the parser is
-  ///   positioned at '.f'.
-  /// - If there is no base type qualifier (e.g. when parsing just 'f'), returns
-  ///   an empty parser error.
-  ParserResult<TypeRepr> parseTypeIdentifier(
-      bool isParsingQualifiedDeclBaseType = false);
+  /// \verbatim
+  ///   qualified-decl-name-base-type:
+  ///     identifier generic-args? ('.' identifier generic-args?)*
+  /// \endverbatim
+  ParserResult<TypeRepr> parseQualifiedDeclNameBaseType();
 
   /// Parse an identifier type, e.g 'Foo' or 'Bar<Int>'.
-  ParserResult<IdentTypeRepr> parseSimpleTypeIdentifier();
+  ///
+  /// \verbatim
+  /// type-identifier: identifier generic-args?
+  /// \endverbatim
+  ParserResult<IdentTypeRepr> parseTypeIdentifier();
 
   /// Parse a dotted type, e.g. 'Foo<X>.Y.Z', 'P.Type', '[X].Y'.
   ParserResult<TypeRepr> parseTypeDotted(ParserResult<TypeRepr> Base);
@@ -1575,10 +1578,6 @@ class Parser {
   bool canParseTypedPattern();
 
   /// Returns true if a qualified declaration name base type can be parsed.
-  ///
-  /// \verbatim
-  ///   qualified-decl-name-base-type: simple-type-identifier '.'
-  /// \endverbatim
   bool canParseBaseTypeForQualifiedDeclName();
 
   /// Returns true if the current token is '->' or effects specifiers followed

lib/Parse/ParseDecl.cpp

@@ -1423,7 +1423,7 @@ static Optional<AccessorKind> isAccessorLabel(const Token &token) {
   return None;
 }
 
-/// Helper function that parses 'type-identifier' for `parseQualifiedDeclName`.
+/// Helper function that parses a base type for `parseQualifiedDeclName`.
 /// Returns true on error. Sets `baseType` to the parsed base type if present,
 /// or to `nullptr` if not. A missing base type is not considered an error.
 static bool parseBaseTypeForQualifiedDeclName(Parser &P, TypeRepr *&baseType) {
@@ -1434,15 +1434,15 @@ static bool parseBaseTypeForQualifiedDeclName(Parser &P, TypeRepr *&baseType) {
   if (!P.canParseBaseTypeForQualifiedDeclName())
     return false;
 
-  auto result = P.parseTypeIdentifier(/*isParsingQualifiedDeclName*/ true);
+  auto result = P.parseQualifiedDeclNameBaseType();
   // If base type should be parseable but the actual base type result is null,
   // return true (error).
   if (result.isNull())
     return true;
 
   // Consume the leading period before the final declaration name component.
-  // `parseTypeIdentifier(/*isParsingQualifiedDeclName*/ true)` leaves the
-  // leading period unparsed to avoid syntax verification errors.
+  // `parseQualifiedDeclNameBaseType` leaves the leading period unparsed to
+  // avoid syntax verification errors.
   assert(P.startsWithSymbol(P.Tok, '.') && "false");
 
   // Check if this is a reference to a property or subscript accessor.
@@ -1478,9 +1478,7 @@ static bool parseBaseTypeForQualifiedDeclName(Parser &P, TypeRepr *&baseType) {
 ///
 /// \verbatim
 ///   qualified-decl-name:
-///     type-identifier? unqualified-decl-name
-///   type-identifier:
-///     identifier generic-args? ('.' identifier generic-args?)*
+///     qualified-decl-name-base-type? unqualified-decl-name
 /// \endverbatim
 ///
 // TODO(TF-1066): Use module qualified name syntax/parsing instead of custom

lib/Parse/ParseType.cpp

@@ -204,7 +204,7 @@ ParserResult<TypeRepr> Parser::parseTypeSimple(
           status, PackTypeRepr::create(Context, keywordLoc,
                                        SourceRange(lbLoc, rbLoc), elements));
     } else {
-      ty = parseSimpleTypeIdentifier();
+      ty = parseTypeIdentifier();
       if (auto *ITR = cast_or_null<IdentTypeRepr>(ty.getPtrOrNull())) {
         if (Tok.is(tok::code_complete) && !Tok.isAtStartOfLine()) {
           if (IDECallbacks)
@@ -716,16 +716,8 @@ ParserStatus Parser::parseGenericArguments(SmallVectorImpl<TypeRepr *> &Args,
   return makeParserSuccess();
 }
 
-/// parseTypeIdentifier
-///   
-///   type-identifier:
-///     identifier generic-args? ('.' identifier generic-args?)*
-///
-ParserResult<TypeRepr>
-Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
-  // If parsing a qualified declaration name, return error if base type cannot
-  // be parsed.
-  if (isParsingQualifiedDeclBaseType && !canParseBaseTypeForQualifiedDeclName())
+ParserResult<TypeRepr> Parser::parseQualifiedDeclNameBaseType() {
+  if (!canParseBaseTypeForQualifiedDeclName())
     return makeParserError();
 
   if (Tok.isNot(tok::identifier) && Tok.isNot(tok::kw_Self)) {
@@ -750,38 +742,11 @@ Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
     return nullptr;
   }
 
-  // In SIL files (not just when parsing SIL types), accept the
-  // Pack{} syntax for spelling variadic type packs.
-  if (SIL && Tok.isContextualKeyword("Pack") &&
-      peekToken().is(tok::l_brace)) {
-    TokReceiver->registerTokenKindChange(Tok.getLoc(), tok::contextual_keyword);
-    SourceLoc keywordLoc = consumeToken(tok::identifier);
-    SourceLoc lbLoc = consumeToken(tok::l_brace);
-    SourceLoc rbLoc;
-    SmallVector<TypeRepr*, 8> elements;
-    auto status = parseList(tok::r_brace, lbLoc, rbLoc,
-                            /*AllowSepAfterLast=*/false,
-                            diag::expected_rbrace_pack_type_list,
-                            [&] () -> ParserStatus {
-      auto element = parseType(diag::expected_type);
-      if (element.hasCodeCompletion())
-        return makeParserCodeCompletionStatus();
-      if (element.isNull())
-        return makeParserError();
-      elements.push_back(element.get());
-      return makeParserSuccess();
-    });
-
-    return makeParserResult(status,
-        PackTypeRepr::create(Context, keywordLoc, SourceRange(lbLoc, rbLoc),
-                             elements));
-  }
-
   ParserStatus Status;
   SmallVector<IdentTypeRepr *, 4> ComponentsR;
   SourceLoc EndLoc;
   while (true) {
-    auto IdentResult = parseSimpleTypeIdentifier();
+    auto IdentResult = parseTypeIdentifier();
     if (IdentResult.isParseErrorOrHasCompletion())
       return IdentResult;
 
@@ -797,9 +762,10 @@ Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
       if (peekToken().isContextualKeyword("Type") ||
           peekToken().isContextualKeyword("Protocol"))
         break;
-      // If parsing a qualified declaration name, break before parsing the
-      // period before the final declaration name component.
-      if (isParsingQualifiedDeclBaseType) {
+
+      // Break before parsing the period before the final declaration
+      // name component.
+      {
         // If qualified name base type cannot be parsed from the current
         // point (i.e. the next type identifier is not followed by a '.'),
         // then the next identifier is the final declaration name component.
@@ -839,7 +805,7 @@ Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
   return makeParserResult(Status, DeclRefTR);
 }
 
-ParserResult<IdentTypeRepr> Parser::parseSimpleTypeIdentifier() {
+ParserResult<IdentTypeRepr> Parser::parseTypeIdentifier() {
   // FIXME: We should parse e.g. 'X.var'. Almost any keyword is a valid member
   // component.
   DeclNameLoc Loc;
@@ -901,7 +867,7 @@ ParserResult<TypeRepr> Parser::parseTypeDotted(ParserResult<TypeRepr> Base) {
       continue;
     }
 
-    auto IdentResult = parseSimpleTypeIdentifier();
+    auto IdentResult = parseTypeIdentifier();
     if (IdentResult.isParseErrorOrHasCompletion())
       return IdentResult | ParserStatus(Base);