[NFC] Switch uses over to parseDeclNameRef()

Author: beccadax

lib/Parse/ParseDecl.cpp

@@ -768,11 +768,10 @@ Parser::parseImplementsAttribute(SourceLoc AtLoc, SourceLoc Loc) {
     }
 
     if (!Status.shouldStopParsing()) {
-      MemberName =
-          parseUnqualifiedDeclName(/*afterDot=*/false, MemberNameLoc,
-                                   diag::attr_implements_expected_member_name,
-                                   /*allowOperators=*/true,
-                                   /*allowZeroArgCompoundNames=*/true);
+      MemberName = parseDeclNameRef(MemberNameLoc,
+          diag::attr_implements_expected_member_name,
+          DeclNameFlag::AllowZeroArgCompoundNames |
+          DeclNameFlag::AllowOperators);
       if (!MemberName) {
         Status.setIsParseError();
       }
@@ -1022,10 +1021,8 @@ bool Parser::parseDifferentiableAttributeArguments(
          SyntaxContext, SyntaxKind::FunctionDeclName);
     Diagnostic funcDiag(diag::attr_differentiable_expected_function_name.ID,
                         { label });
-    result.Name =
-        parseUnqualifiedDeclName(/*afterDot=*/false, result.Loc,
-                                 funcDiag, /*allowOperators=*/true,
-                                 /*allowZeroArgCompoundNames=*/true);
+    result.Name = parseDeclNameRef(result.Loc, funcDiag,
+        DeclNameFlag::AllowZeroArgCompoundNames | DeclNameFlag::AllowOperators);
     // If no trailing comma or 'where' clause, terminate parsing arguments.
     if (Tok.isNot(tok::comma, tok::kw_where))
       terminateParsingArgs = true;
@@ -1129,10 +1126,11 @@ ParserResult<DerivativeAttr> Parser::parseDerivativeAttribute(SourceLoc atLoc,
                                                SyntaxKind::FunctionDeclName);
       // NOTE: Use `afterDot = true` and `allowDeinitAndSubscript = true` to
       // enable, e.g. `@derivative(of: init)` and `@derivative(of: subscript)`.
-      original.Name = parseUnqualifiedDeclName(
-          /*afterDot*/ true, original.Loc,
-          diag::attr_derivative_expected_original_name, /*allowOperators*/ true,
-          /*allowZeroArgCompoundNames*/ true, /*allowDeinitAndSubscript*/ true);
+      original.Name = parseDeclNameRef(original.Loc,
+          diag::attr_derivative_expected_original_name,
+          DeclNameFlag::AllowZeroArgCompoundNames |
+          DeclNameFlag::AllowKeywords | DeclNameFlag::AllowOperators |
+          DeclNameFlag::UseSpecialNamesForDeinitAndSubscript);
     }
     if (consumeIfTrailingComma())
       return makeParserError();
@@ -2060,10 +2058,11 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
                                             SyntaxKind::DeclName);
 
         DeclNameLoc loc;
-        replacedFunction = parseUnqualifiedDeclName(
-            true, loc, diag::attr_dynamic_replacement_expected_function,
-            /*allowOperators*/ true, /*allowZeroArgCompoundNames*/ true,
-            /*allowDeinitAndSubscript*/ true);
+        replacedFunction = parseDeclNameRef(loc,
+            diag::attr_dynamic_replacement_expected_function,
+            DeclNameFlag::AllowZeroArgCompoundNames |
+            DeclNameFlag::AllowKeywords | DeclNameFlag::AllowOperators |
+            DeclNameFlag::UseSpecialNamesForDeinitAndSubscript);
       }
     }
 
@@ -2572,11 +2571,9 @@ bool Parser::parseConventionAttributeInternal(
       return true;
     }
 
-    DeclNameLoc unusedWitnessMethodProtocolLoc;
-    convention.WitnessMethodProtocol = parseUnqualifiedDeclBaseName(
-        /*afterDot=*/false, unusedWitnessMethodProtocolLoc,
-       diag::convention_attribute_witness_method_expected_protocol
-    );
+    DeclNameLoc unusedLoc;
+    convention.WitnessMethodProtocol = parseDeclNameRef(unusedLoc,
+        diag::convention_attribute_witness_method_expected_protocol, {});
   }
 
   // Parse the ')'.  We can't use parseMatchingToken if we're in

lib/Parse/ParseExpr.cpp

@@ -644,6 +644,7 @@ ParserResult<Expr> Parser::parseExprKeyPathObjC() {
   // Parse the sequence of unqualified-names.
   ParserStatus status;
   SourceLoc LastDotLoc;
+  DeclNameOptions flags = DeclNameFlag::AllowCompoundNames;
   while (true) {
     SyntaxParsingContext NamePieceCtx(SyntaxContext, SyntaxKind::ObjcNamePiece);
     // Handle code completion.
@@ -652,10 +653,8 @@ ParserResult<Expr> Parser::parseExprKeyPathObjC() {
 
     // Parse the next name.
     DeclNameLoc nameLoc;
-    bool afterDot = !components.empty();
-    auto name = parseUnqualifiedDeclName(
-                  afterDot, nameLoc, 
-                  diag::expr_keypath_expected_property_or_type);
+    DeclNameRef name = parseDeclNameRef(nameLoc,
+        diag::expr_keypath_expected_property_or_type, flags);
     if (!name) {
       status.setIsParseError();
       break;
@@ -666,6 +665,9 @@ ParserResult<Expr> Parser::parseExprKeyPathObjC() {
                                                       nameLoc.getBaseNameLoc());
     components.push_back(component);
 
+    // After the first component, we can start parsing keywords.
+    flags |= DeclNameFlag::AllowKeywords;
+
     // Handle code completion.
     if (Tok.is(tok::code_complete))
       return handleCodeCompletion(SourceLoc());
@@ -1130,7 +1132,8 @@ Parser::parseExprPostfixSuffix(ParserResult<Expr> Result, bool isExprBasic,
       Diag<> D = isa<SuperRefExpr>(Result.get())
                      ? diag::expected_identifier_after_super_dot_expr
                      : diag::expected_member_name;
-      DeclNameRef Name = parseUnqualifiedDeclName(/*afterDot=*/true, NameLoc, D);
+      auto Name = parseDeclNameRef(NameLoc, D,
+          DeclNameFlag::AllowKeywords | DeclNameFlag::AllowCompoundNames);
       if (!Name)
         return nullptr;
       SyntaxContext->createNodeInPlace(SyntaxKind::MemberAccessExpr);
@@ -1580,8 +1583,8 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
       return Result;
     }
 
-    Name = parseUnqualifiedDeclName(/*afterDot=*/true, NameLoc,
-                                    diag::expected_identifier_after_dot_expr);
+    Name = parseDeclNameRef(NameLoc, diag::expected_identifier_after_dot_expr,
+        DeclNameFlag::AllowKeywords | DeclNameFlag::AllowCompoundNames);
     if (!Name) return nullptr;
     SyntaxContext->createNodeInPlace(SyntaxKind::MemberAccessExpr);
 
@@ -2267,8 +2270,8 @@ Expr *Parser::parseExprIdentifier() {
 
   // Parse the unqualified-decl-name.
   DeclNameLoc loc;
-  DeclNameRef name = parseUnqualifiedDeclName(/*afterDot=*/false, loc,
-                                              diag::expected_expr);
+  DeclNameRef name = parseDeclNameRef(loc, diag::expected_expr,
+                                      DeclNameFlag::AllowCompoundNames);
 
   SmallVector<TypeRepr*, 8> args;
   SourceLoc LAngleLoc, RAngleLoc;
@@ -3082,9 +3085,8 @@ ParserStatus Parser::parseExprList(tok leftTok, tok rightTok,
       SyntaxParsingContext operatorContext(SyntaxContext,
                                            SyntaxKind::IdentifierExpr);
       DeclNameLoc Loc;
-      auto OperName = parseUnqualifiedDeclBaseName(/*afterDot=*/false, Loc,
-                                                   diag::expected_operator_ref,
-                                                   /*allowOperators=*/true);
+      auto OperName = parseDeclNameRef(Loc, diag::expected_operator_ref,
+                                       DeclNameFlag::AllowOperators);
       if (!OperName) {
         return makeParserError();
       }

lib/Parse/ParseType.cpp

@@ -667,9 +667,8 @@ ParserResult<TypeRepr> Parser::parseTypeIdentifier() {
   SourceLoc EndLoc;
   while (true) {
     DeclNameLoc Loc;
-    DeclNameRef Name = parseUnqualifiedDeclBaseName(
-        /*afterDot=*/false, Loc,
-        diag::expected_identifier_in_dotted_type);
+    DeclNameRef Name =
+        parseDeclNameRef(Loc, diag::expected_identifier_in_dotted_type, {});
     if (!Name)
       Status.setIsParseError();