[NFC] Refactor name parsing into Parser::parseDeclNameRef()

beccadax · beccadax · commit c5747c3d9633 · 2019-12-15T23:46:42.000-08:00
Gives this functionality a more self-documenting interface.
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -1412,6 +1412,44 @@ class Parser {
   /// \param loc The location of the label (empty if it doesn't exist)
   void parseOptionalArgumentLabel(Identifier &name, SourceLoc &loc);
 
+  enum class DeclNameFlag : uint8_t {
+    /// If passed, operator basenames are allowed.
+    AllowOperators = 1 << 0,
+
+    /// If passed, names that coincide with keywords are allowed. Used after a
+    /// dot to enable things like '.init' and '.default'.
+    AllowKeywords = 1 << 1,
+
+    /// If passed, 'deinit' and 'subscript' should be parsed as special names,
+    /// not ordinary identifiers.
+    UseSpecialNamesForDeinitAndSubscript = AllowKeywords | 1 << 2,
+
+    /// If passed, compound names with argument lists are allowed, unless they
+    /// have empty argument lists.
+    AllowCompoundNames = 1 << 4,
+
+    /// If passed, compound names with empty argument lists are allowed.
+    AllowZeroArgCompoundNames = AllowCompoundNames | 1 << 5,
+  };
+  using DeclNameOptions = OptionSet<DeclNameFlag>;
+
+  friend DeclNameOptions operator|(DeclNameFlag flag1, DeclNameFlag flag2) {
+    return DeclNameOptions(flag1) | flag2;
+  }
+
+  /// Without \c DeclNameFlag::AllowCompoundNames, parse an
+  /// unqualified-decl-base-name.
+  ///
+  ///   unqualified-decl-base-name: identifier
+  ///
+  /// With \c DeclNameFlag::AllowCompoundNames, parse an unqualified-base-name.
+  ///
+  ///   unqualified-decl-name:
+  ///     unqualified-decl-base-name
+  ///     unqualified-decl-base-name '(' ((identifier | '_') ':') + ')'
+  DeclNameRef parseDeclNameRef(DeclNameLoc &loc, const Diagnostic &diag,
+                               DeclNameOptions flags);
+
   /// Parse an unqualified-decl-base-name.
   ///
   ///   unqualified-decl-name:
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
@@ -2078,12 +2078,87 @@ void Parser::parseOptionalArgumentLabel(Identifier &name, SourceLoc &loc) {
   }
 }
 
-DeclNameRef Parser::parseUnqualifiedDeclBaseName(
-                                                 bool afterDot,
-                                                 DeclNameLoc &loc,
-                                                 const Diagnostic &diag,
-                                                 bool allowOperators,
-                                                 bool allowDeinitAndSubscript) {
+static bool tryParseArgLabelList(Parser &P, Parser::DeclNameOptions flags,
+                                 SourceLoc &lparenLoc,
+                                 SmallVectorImpl<Identifier> &argumentLabels,
+                                 SmallVectorImpl<SourceLoc> &argumentLabelLocs,
+                                 SourceLoc &rparenLoc) {
+  if (!flags.contains(Parser::DeclNameFlag::AllowCompoundNames))
+    return false;
+
+  // Is the current token a left paren?
+  if (!P.Tok.isFollowingLParen())
+    return false;
+
+  // Okay, let's look ahead and see if the next token is something that could
+  // be in an arg label list...
+  const Token &next = P.peekToken();
+
+  // A close parenthesis, if empty lists are allowed.
+  bool nextIsRParen =
+      flags.contains(Parser::DeclNameFlag::AllowZeroArgCompoundNames) &&
+      next.is(tok::r_paren);
+  // An argument label.
+  bool nextIsArgLabel = next.canBeArgumentLabel() || next.is(tok::colon);
+  // An editor placeholder.
+  bool nextIsPlaceholder = Identifier::isEditorPlaceholder(next.getText());
+
+  if (!(nextIsRParen || nextIsArgLabel || nextIsPlaceholder))
+    return false;
+
+  // Try to parse a compound name.
+  SyntaxParsingContext ArgsCtxt(P.SyntaxContext, SyntaxKind::DeclNameArguments);
+  Parser::BacktrackingScope backtrack(P);
+
+  lparenLoc = P.consumeToken(tok::l_paren);
+  while (P.Tok.isNot(tok::r_paren)) {
+    SyntaxParsingContext ArgCtxt(P.SyntaxContext, SyntaxKind::DeclNameArgument);
+
+    // If we see a ':', the user forgot the '_';
+    if (P.Tok.is(tok::colon)) {
+      P.diagnose(P.Tok, diag::empty_arg_label_underscore)
+          .fixItInsert(P.Tok.getLoc(), "_");
+      argumentLabels.push_back(Identifier());
+      argumentLabelLocs.push_back(P.consumeToken(tok::colon));
+    }
+
+    Identifier argName;
+    SourceLoc argLoc;
+    P.parseOptionalArgumentLabel(argName, argLoc);
+    if (argLoc.isValid()) {
+      argumentLabels.push_back(argName);
+      argumentLabelLocs.push_back(argLoc);
+      continue;
+    }
+
+    // This is not a compound name.
+    // FIXME: Could recover better if we "know" it's a compound name.
+    ArgCtxt.setBackTracking();
+    ArgsCtxt.setBackTracking();
+
+    return false;
+  }
+
+  // We have a compound name. Cancel backtracking and build that name.
+  backtrack.cancelBacktrack();
+
+  if (argumentLabels.empty() && P.SyntaxContext->isEnabled())
+    P.SyntaxContext->addSyntax(
+        ParsedSyntaxRecorder::makeBlankDeclNameArgumentList(
+            P.leadingTriviaLoc(), *P.SyntaxContext));
+  else
+    ArgsCtxt.collectNodesInPlace(SyntaxKind::DeclNameArgumentList);
+
+  rparenLoc = P.consumeToken(tok::r_paren);
+
+  assert(argumentLabels.size() == argumentLabelLocs.size());
+
+  return true;
+}
+
+DeclNameRef Parser::parseDeclNameRef(DeclNameLoc &loc,
+                                     const Diagnostic &diag,
+                                     DeclNameOptions flags) {
   // Consume the base name.
   DeclBaseName baseName;
   SourceLoc baseNameLoc;
@@ -2092,17 +2167,21 @@ DeclNameRef Parser::parseUnqualifiedDeclBaseName(
     baseNameLoc = consumeIdentifier(
         &baseNameId, /*allowDollarIdentifier=*/true);
     baseName = baseNameId;
-  } else if (allowOperators && Tok.isAnyOperator()) {
+  } else if (flags.contains(DeclNameFlag::AllowOperators) &&
+             Tok.isAnyOperator()) {
     baseName = Context.getIdentifier(Tok.getText());
     baseNameLoc = consumeToken();
-  } else if (afterDot && Tok.isKeyword()) {
+  } else if (flags.contains(DeclNameFlag::AllowKeywords) && Tok.isKeyword()) {
+    bool specialDeinitAndSubscript =
+        flags.contains(DeclNameFlag::UseSpecialNamesForDeinitAndSubscript);
+
     // Syntax highlighting should treat this token as an identifier and
     // not as a keyword.
     if (Tok.is(tok::kw_init))
       baseName = DeclBaseName::createConstructor();
-    else if (allowDeinitAndSubscript &&Tok.is(tok::kw_deinit))
+    else if (specialDeinitAndSubscript && Tok.is(tok::kw_deinit))
       baseName = DeclBaseName::createDestructor();
-    else if (allowDeinitAndSubscript &&Tok.is(tok::kw_subscript))
+    else if (specialDeinitAndSubscript && Tok.is(tok::kw_subscript))
       baseName = DeclBaseName::createSubscript();
     else
       baseName = Context.getIdentifier(Tok.getText());
@@ -2115,95 +2194,67 @@ DeclNameRef Parser::parseUnqualifiedDeclBaseName(
     return DeclNameRef();
   }
 
-  loc = DeclNameLoc(baseNameLoc);
-  return DeclNameRef(baseName);
-}
-
-
-DeclNameRef Parser::parseUnqualifiedDeclName(bool afterDot,
-                                             DeclNameLoc &loc,
-                                             const Diagnostic &diag,
-                                             bool allowOperators,
-                                             bool allowZeroArgCompoundNames,
-                                             bool allowDeinitAndSubscript) {
-  // Consume the base name.
-  auto baseName = parseUnqualifiedDeclBaseName(afterDot, loc, diag,
-                                               allowOperators,
-                                               allowDeinitAndSubscript);
-
-  // If the next token isn't a following '(', we don't have a compound name.
-  if (!baseName || !Tok.isFollowingLParen())
-    return baseName;
-
-  // If the next token is a ')' then we have a 0-arg compound name. This is
-  // explicitly differentiated from "simple" (non-compound) name in DeclName.
-  // Unfortunately only some places in the grammar are ok with accepting this
-  // kind of name; in other places it's ambiguous with trailing calls.
-  if (allowZeroArgCompoundNames && peekToken().is(tok::r_paren)) {
-    SyntaxParsingContext ArgsCtxt(SyntaxContext, SyntaxKind::DeclNameArguments);
-    consumeToken(tok::l_paren);
-    if (SyntaxContext->isEnabled())
-      SyntaxContext->addSyntax(
-          ParsedSyntaxRecorder::makeBlankDeclNameArgumentList(
-              leadingTriviaLoc(), *SyntaxContext));
-    consumeToken(tok::r_paren);
-    SmallVector<Identifier, 2> argumentLabels;
-    return baseName.withArgumentLabels(Context, argumentLabels);
-  }
-
-  // If the token after that isn't an argument label or ':', we don't have a
-  // compound name.
-  if ((!peekToken().canBeArgumentLabel() && !peekToken().is(tok::colon)) ||
-      Identifier::isEditorPlaceholder(peekToken().getText())) {
-    return baseName;
-  }
-
-  // Try to parse a compound name.
-  SyntaxParsingContext ArgsCtxt(SyntaxContext, SyntaxKind::DeclNameArguments);
-  BacktrackingScope backtrack(*this);
-
+  // Parse an argument list, if the flags allow it and it's present.
   SmallVector<Identifier, 2> argumentLabels;
   SmallVector<SourceLoc, 2> argumentLabelLocs;
-  SourceLoc lparenLoc = consumeToken(tok::l_paren);
+  SourceLoc lparenLoc;
   SourceLoc rparenLoc;
-  while (Tok.isNot(tok::r_paren)) {
-    SyntaxParsingContext ArgCtxt(SyntaxContext, SyntaxKind::DeclNameArgument);
 
-    // If we see a ':', the user forgot the '_';
-    if (Tok.is(tok::colon)) {
-      diagnose(Tok, diag::empty_arg_label_underscore)
-          .fixItInsert(Tok.getLoc(), "_");
-      argumentLabels.push_back(Identifier());
-      argumentLabelLocs.push_back(consumeToken(tok::colon));
-    }
+  bool hadArgList = tryParseArgLabelList(*this, flags, lparenLoc,
+                                         argumentLabels, argumentLabelLocs,
+                                         rparenLoc);
 
-    Identifier argName;
-    SourceLoc argLoc;
-    parseOptionalArgumentLabel(argName, argLoc);
-    if (argLoc.isValid()) {
-      argumentLabels.push_back(argName);
-      argumentLabelLocs.push_back(argLoc);
-      continue;
-    }
+  if (argumentLabelLocs.empty() || !hadArgList)
+    loc = DeclNameLoc(baseNameLoc);
+  else
+    loc = DeclNameLoc(Context, baseNameLoc, lparenLoc, argumentLabelLocs,
+                      rparenLoc);
 
-    // This is not a compound name.
-    // FIXME: Could recover better if we "know" it's a compound name.
-    ArgCtxt.setBackTracking();
-    ArgsCtxt.setBackTracking();
-    return baseName;
+  if (!hadArgList)
+    return DeclNameRef(baseName);
+
+  return DeclNameRef({ Context, baseName, argumentLabels });
+}
+
+DeclNameRef Parser::parseUnqualifiedDeclBaseName(
+                                                 bool afterDot,
+                                                 DeclNameLoc &loc,
+                                                 const Diagnostic &diag,
+                                                 bool allowOperators,
+                                                 bool allowDeinitAndSubscript) {
+  DeclNameOptions flags = {};
+  if (afterDot)
+    flags |= DeclNameFlag::AllowKeywords;
+  if (allowOperators)
+    flags |= DeclNameFlag::AllowOperators;
+  if (allowDeinitAndSubscript) {
+    assert(afterDot);
+    flags |= DeclNameFlag::UseSpecialNamesForDeinitAndSubscript;
   }
-  // We have a compound name. Cancel backtracking and build that name.
-  backtrack.cancelBacktrack();
 
-  ArgsCtxt.collectNodesInPlace(SyntaxKind::DeclNameArgumentList);
-  rparenLoc = consumeToken(tok::r_paren);
+  return parseDeclNameRef(loc, diag, flags);
+}
 
-  assert(!argumentLabels.empty() && "Logic above should prevent this");
-  assert(argumentLabels.size() == argumentLabelLocs.size());
 
-  loc = DeclNameLoc(Context, loc.getBaseNameLoc(), lparenLoc, argumentLabelLocs,
-                    rparenLoc);
-  return baseName.withArgumentLabels(Context, argumentLabels);
+DeclNameRef Parser::parseUnqualifiedDeclName(bool afterDot,
+                                             DeclNameLoc &loc,
+                                             const Diagnostic &diag,
+                                             bool allowOperators,
+                                             bool allowZeroArgCompoundNames,
+                                             bool allowDeinitAndSubscript) {
+  DeclNameOptions flags = DeclNameFlag::AllowCompoundNames;
+  if (afterDot)
+    flags |= DeclNameFlag::AllowKeywords;
+  if (allowOperators)
+    flags |= DeclNameFlag::AllowOperators;
+  if (allowDeinitAndSubscript) {
+    assert(afterDot);
+    flags |= DeclNameFlag::UseSpecialNamesForDeinitAndSubscript;
+  }
+  if (allowZeroArgCompoundNames)
+    flags |= DeclNameFlag::AllowZeroArgCompoundNames;
+
+  return parseDeclNameRef(loc, diag, flags);
 }
 
 ///   expr-identifier:
