Add DeclNameRef to syntax tree

Author: beccadax

include/swift/AST/DiagnosticsParse.def

@@ -435,16 +435,19 @@ ERROR(deprecated_operator_body_use_group,PointsToFirstBadToken,
       "use a precedence group instead", ())
 ERROR(operator_decl_no_fixity,none,
       "operator must be declared as 'prefix', 'postfix', or 'infix'", ())
-ERROR(operator_decl_expected_precedencegroup, none,
-      "expected precedence group name after ':' in operator declaration", ())
 
 WARNING(operator_decl_remove_designated_types,none,
         "designated types are no longer used by the compiler; please remove "
         "the designated type list from this operator declaration", ())
 
-// PrecedenceGroup
 ERROR(precedencegroup_not_infix,none,
       "only infix operators may declare a precedence", ())
+ERROR(precedencegroup_too_many,none,
+      "infix operators may declare only one precedence", ())
+ERROR(expected_group_name_in_precedencegroup_list,none,
+      "expected name in precedence group list", ())
+
+// PrecedenceGroup
 ERROR(expected_precedencegroup_name,none,
       "expected identifier after 'precedencegroup'", ())
 ERROR(expected_precedencegroup_lbrace,none,
@@ -463,9 +466,6 @@ ERROR(expected_precedencegroup_associativity,none,
       "expected 'none', 'left', or 'right' after 'associativity'", ())
 ERROR(expected_precedencegroup_assignment,none,
       "expected 'true' or 'false' after 'assignment'", ())
-ERROR(expected_precedencegroup_relation,none,
-      "expected name of related precedence group after '%0'",
-      (StringRef))
 
 // SIL
 ERROR(expected_sil_keyword,none,
@@ -1856,5 +1856,9 @@ ERROR(expected_closure_literal,none,
 ERROR(expected_multiple_closures_block_rbrace,none,
       "expected '}' at the end of a trailing closures block", ())
 
+ERROR(impossible_parse,none,
+      "parser entered impossible state; please file a bug report with this "
+      "source file", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/Parse/Parser.h

@@ -1623,13 +1623,19 @@ class Parser {
 
     /// If passed, compound names with empty argument lists are allowed.
     AllowZeroArgCompoundNames = AllowCompoundNames | 1 << 5,
+
+    /// If passed, `$0` etc. are allowed.
+    AllowAnonymousParamNames = 1 << 6,
   };
   using DeclNameOptions = OptionSet<DeclNameFlag>;
 
   friend DeclNameOptions operator|(DeclNameFlag flag1, DeclNameFlag flag2) {
     return DeclNameOptions(flag1) | flag2;
   }
 
+  /// Parse a declaration name that results in a `DeclNameRef` in the syntax
+  /// tree.
+  /// 
   /// Without \c DeclNameFlag::AllowCompoundNames, parse an
   /// unqualified-decl-base-name.
   ///

include/swift/Syntax/SyntaxFactory.h.gyb

@@ -126,6 +126,14 @@ public:
       llvm::Optional<TokenSyntax> TrailingComma
   );
 
+  /// Creates a DeclNameRef with the indicated module selector (if any) and base
+  /// name.
+  DeclNameRefSyntax makeDeclNameRef(
+      llvm::Optional<StringRef> ModuleName,
+      StringRef BaseName,
+      StringRef LeadingTrivia,
+      StringRef TrailingTrivia);
+
   /// Creates a TypeIdentifierSyntax with the provided name and leading/trailing
   /// trivia.
   TypeSyntax makeTypeIdentifier(

lib/Parse/ParseDecl.cpp

@@ -665,8 +665,6 @@ bool Parser::parseSpecializeAttributeArguments(
       }
       if (ParamLabel == "target") {
         if (!parseSILTargetName(*this)) {
-          SyntaxParsingContext ContentContext(SyntaxContext,
-                                              SyntaxKind::DeclName);
           DeclNameLoc loc;
           targetFunction = parseDeclNameRef(
               loc, diag::attr_specialize_expected_function,
@@ -2482,17 +2480,13 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
         return false;
       }
       consumeToken(tok::colon);
-      {
-        SyntaxParsingContext ContentContext(SyntaxContext,
-                                            SyntaxKind::DeclName);
-
-        DeclNameLoc loc;
-        replacedFunction = parseDeclNameRef(loc,
-            diag::attr_dynamic_replacement_expected_function,
-            DeclNameFlag::AllowZeroArgCompoundNames |
-            DeclNameFlag::AllowKeywordsUsingSpecialNames |
-            DeclNameFlag::AllowOperators);
-      }
+
+      DeclNameLoc loc;
+      replacedFunction = parseDeclNameRef(loc,
+          diag::attr_dynamic_replacement_expected_function,
+          DeclNameFlag::AllowZeroArgCompoundNames |
+          DeclNameFlag::AllowKeywordsUsingSpecialNames |
+          DeclNameFlag::AllowOperators);
     }
 
     // Parse the matching ')'.
@@ -8104,6 +8098,42 @@ Parser::parseDeclOperator(ParseDeclOptions Flags, DeclAttributes &Attributes) {
   return DCC.fixupParserResult(Result);
 }
 
+template <typename Fn>
+static ParserStatus
+parsePrecedenceGroupNameList(Parser &P, Fn takeGroupName) {
+  SourceLoc prevCommaLoc;
+  do {
+    SyntaxParsingContext NameCtxt(P.SyntaxContext,
+                                  SyntaxKind::PrecedenceGroupNameElement);
+    if (P.Tok.is(tok::code_complete)) {
+      if (P.CodeCompletion)
+        // FIXME: weird that we use PrecedenceGroupRelation, not NameElement.
+        P.CodeCompletion->
+            completeInPrecedenceGroup(SyntaxKind::PrecedenceGroupRelation);
+      P.consumeToken();
+      return makeParserCodeCompletionStatus();
+    }
+
+    DeclNameLoc nameLoc;
+    auto name = P.parseDeclNameRef(nameLoc,
+        diag::expected_group_name_in_precedencegroup_list, {});
+    if (!name)
+      return makeParserError();
+
+    takeGroupName(prevCommaLoc, name, nameLoc);
+
+    if (P.Tok.is(tok::code_complete)
+        && P.getEndOfPreviousLoc() == P.Tok.getLoc()) {
+      P.consumeToken();
+      return makeParserCodeCompletionStatus();
+    }
+    if (!P.consumeIf(tok::comma, prevCommaLoc))
+      break;
+  } while (true);
+  P.SyntaxContext->collectNodesInPlace(SyntaxKind::PrecedenceGroupNameList);
+  return makeParserSuccess();
+}
+
 ParserResult<OperatorDecl>
 Parser::parseDeclOperatorImpl(SourceLoc OperatorLoc, Identifier Name,
                               SourceLoc NameLoc, DeclAttributes &Attributes) {
@@ -8131,56 +8161,58 @@ Parser::parseDeclOperatorImpl(SourceLoc OperatorLoc, Identifier Name,
       return makeParserCodeCompletionResult<OperatorDecl>();
     }
 
-    SyntaxParsingContext ListCtxt(SyntaxContext, SyntaxKind::IdentifierList);
-
-    (void)parseIdentifier(groupName, groupLoc,
-                          diag::operator_decl_expected_precedencegroup,
-                          /*diagnoseDollarPrefix=*/false);
+    // Although we parse this as a list, we actually only want there to be zero
+    // (prefix/postfix) or one (infix) elements. These SourceLocs point to the
+    // ends of the elements that should not be there (including the introducer
+    // token for the first one) so that we can diagnose them all at once. If
+    // `typesEndLoc` never becomes valid, we didn't find any excess elements.
+    SourceLoc excessStartLoc = isInfix ? SourceLoc() : colonLoc;
+    SourceLoc excessEndLoc;
+
+    ParserStatus listStatus = parsePrecedenceGroupNameList(*this,
+        [&](SourceLoc prevCommaLoc, DeclNameRef name, DeclNameLoc nameLoc) {
+      if (!isPrefix && !isPostfix && groupName.empty()) {
+        // For infix operator declarations, the first element is assumed to be
+        // a real precedence group.
+        groupName = name.getBaseIdentifier();
+        groupLoc = nameLoc.getBaseNameLoc();
+      } else {
+        // This is an excess element. Update excessStartLoc and excessEndLoc to
+        // include it in the range to diagnose.
+        if (excessStartLoc.isInvalid())
+          excessStartLoc = prevCommaLoc;
+        excessEndLoc = nameLoc.getEndLoc();
+      }
+    });
 
-    if (Context.TypeCheckerOpts.EnableOperatorDesignatedTypes) {
-      // Designated types have been removed; consume the list (mainly for source
-      // compatibility with old swiftinterfaces) and emit a warning.
+    if (listStatus.isErrorOrHasCompletion())
+      return makeParserResult<OperatorDecl>(listStatus, nullptr);
 
-      // These SourceLocs point to the ends of the designated type list. If
-      // `typesEndLoc` never becomes valid, we didn't find any designated types.
-      SourceLoc typesStartLoc = Tok.getLoc();
-      SourceLoc typesEndLoc;
+    // Nothing to complete here, simply consume the token.
+    if (Tok.is(tok::code_complete))
+      consumeToken();
 
-      if (isPrefix || isPostfix) {
-        // These have no precedence group, so we already parsed the first entry
-        // in the designated types list. Retroactively include it in the range.
-        typesStartLoc = colonLoc;
-        typesEndLoc = groupLoc;
-      }
+    if (excessEndLoc.isValid()) {
+      auto diagID = !isPrefix && !isPostfix ? diag::precedencegroup_too_many
+                                            : diag::precedencegroup_not_infix;
 
-      while (consumeIf(tok::comma, typesEndLoc)) {
-        if (Tok.isNot(tok::eof))
-          typesEndLoc = consumeToken();
-      }
+      if (Context.TypeCheckerOpts.EnableOperatorDesignatedTypes)
+        diagID = diag::operator_decl_remove_designated_types;
 
-      if (typesEndLoc.isValid())
-        diagnose(typesStartLoc, diag::operator_decl_remove_designated_types)
-            .fixItRemove({typesStartLoc, typesEndLoc});
-    } else {
-      if (isPrefix || isPostfix) {
-        diagnose(colonLoc, diag::precedencegroup_not_infix)
-            .fixItRemove({colonLoc, groupLoc});
-      }
-      // Nothing to complete here, simply consume the token.
-      if (Tok.is(tok::code_complete))
-        consumeToken();
+      diagnose(excessStartLoc, diagID)
+          .fixItRemove({excessStartLoc, excessEndLoc});
     }
   }
 
   // Diagnose deprecated operator body syntax `operator + { ... }`.
+  SourceLoc lastGoodLoc = PreviousLoc;
   SourceLoc lBraceLoc;
   if (consumeIf(tok::l_brace, lBraceLoc)) {
     if (isInfix && !Tok.is(tok::r_brace)) {
       diagnose(lBraceLoc, diag::deprecated_operator_body_use_group);
     } else {
       auto Diag = diagnose(lBraceLoc, diag::deprecated_operator_body);
       if (Tok.is(tok::r_brace)) {
-        SourceLoc lastGoodLoc = groupLoc.isValid() ? groupLoc : NameLoc;
         SourceLoc lastGoodLocEnd = Lexer::getLocForEndOfToken(SourceMgr,
                                                               lastGoodLoc);
         SourceLoc rBraceEnd = Lexer::getLocForEndOfToken(SourceMgr, Tok.getLoc());
@@ -8420,28 +8452,14 @@ Parser::parseDeclPrecedenceGroup(ParseDeclOptions flags,
                                        : higherThanKeywordLoc);
       auto &relations = (isLowerThan ? lowerThan : higherThan);
 
-      do {
-        SyntaxParsingContext NameCtxt(SyntaxContext,
-                                      SyntaxKind::PrecedenceGroupNameElement);
-        if (checkCodeCompletion(SyntaxKind::PrecedenceGroupRelation)) {
-          return abortBody(/*hasCodeCompletion*/true);
-        }
-
-        if (Tok.isNot(tok::identifier)) {
-          diagnose(Tok, diag::expected_precedencegroup_relation, attrName);
-          return abortBody();
-        }
-        Identifier name;
-        SourceLoc nameLoc = consumeIdentifier(name,
-                                              /*diagnoseDollarPrefix=*/false);
-        relations.push_back({nameLoc, name, nullptr});
-
-        if (skipUnspacedCodeCompleteToken())
-          return abortBody(/*hasCodeCompletion*/true);
-        if (!consumeIf(tok::comma))
-          break;
-      } while (true);
-      SyntaxContext->collectNodesInPlace(SyntaxKind::PrecedenceGroupNameList);
+      ParserStatus listStatus = parsePrecedenceGroupNameList(*this,
+          [&](SourceLoc prevCommaLoc, DeclNameRef name, DeclNameLoc nameLoc) {
+        relations.push_back({nameLoc.getBaseNameLoc(), name.getBaseIdentifier(),
+                             nullptr});
+      });
+      if (listStatus.isErrorOrHasCompletion()) {
+        return abortBody(listStatus.hasCodeCompletion());
+      }
       continue;
     }
 

lib/Parse/ParseExpr.cpp

@@ -1126,7 +1126,9 @@ Parser::parseExprPostfixSuffix(ParserResult<Expr> Result, bool isExprBasic,
       // Handle "x.42" - a tuple index.
       if (Tok.is(tok::integer_literal)) {
         DeclNameRef name(Context.getIdentifier(Tok.getText()));
-        SourceLoc nameLoc = consumeToken(tok::integer_literal);
+        SourceLoc nameLoc =
+            (SyntaxParsingContext(SyntaxContext, SyntaxKind::DeclNameRef),
+             consumeToken(tok::integer_literal));
         SyntaxContext->createNodeInPlace(SyntaxKind::MemberAccessExpr);
 
         // Don't allow '.<integer literal>' following a numeric literal
@@ -2250,13 +2252,19 @@ static bool tryParseArgLabelList(Parser &P, Parser::DeclNameOptions flags,
 DeclNameRef Parser::parseDeclNameRef(DeclNameLoc &loc,
                                      const Diagnostic &diag,
                                      DeclNameOptions flags) {
+  SyntaxParsingContext declNameRefCtxt(SyntaxContext, SyntaxKind::DeclNameRef);
+
   // Consume the base name.
   DeclBaseName baseName;
   SourceLoc baseNameLoc;
   if (Tok.isAny(tok::identifier, tok::kw_Self, tok::kw_self)) {
     Identifier baseNameId;
     baseNameLoc = consumeIdentifier(baseNameId, /*diagnoseDollarPrefix=*/false);
     baseName = baseNameId;
+  } else if (flags.contains(DeclNameFlag::AllowAnonymousParamNames)
+             && Tok.is(tok::dollarident)) {
+    baseName = Context.getIdentifier(Tok.getText());
+    baseNameLoc = consumeToken(tok::dollarident);
   } else if (flags.contains(DeclNameFlag::AllowOperators) &&
              Tok.isAnyOperator()) {
     baseName = Context.getIdentifier(Tok.getText());
@@ -3005,8 +3013,14 @@ ParserResult<Expr> Parser::parseExprClosure() {
 ///     dollarident
 Expr *Parser::parseExprAnonClosureArg() {
   SyntaxParsingContext ExprContext(SyntaxContext, SyntaxKind::IdentifierExpr);
-  StringRef Name = Tok.getText();
-  SourceLoc Loc = consumeToken(tok::dollarident);
+
+  DeclNameLoc nameLoc;
+  DeclNameRef nameRef =
+      parseDeclNameRef(nameLoc, diag::impossible_parse,
+                       DeclNameFlag::AllowAnonymousParamNames);
+
+  StringRef Name = nameRef.getBaseIdentifier().str();
+  SourceLoc Loc = nameLoc.getBaseNameLoc();
   assert(Name[0] == '$' && "Not a dollarident");
 
   // We know from the lexer that this is all-numeric.

lib/Parse/ParseType.cpp

@@ -889,6 +889,8 @@ Parser::parseTypeSimpleOrComposition(Diag<> MessageID, ParseTypeReason reason) {
 ParserResult<TypeRepr> Parser::parseAnyType() {
   SyntaxParsingContext IdentTypeCtxt(SyntaxContext,
                                      SyntaxKind::SimpleTypeIdentifier);
+  SyntaxParsingContext DeclNameRefCtxt(SyntaxContext, SyntaxKind::DeclNameRef);
+
   auto Loc = consumeToken(tok::kw_Any);
   auto TyR = CompositionTypeRepr::createEmptyComposition(Context, Loc);
   return makeParserResult(TyR);

lib/Syntax/SyntaxFactory.cpp.gyb

@@ -270,12 +270,19 @@ SyntaxFactory::makeGenericParameter(TokenSyntax Name,
   return makeGenericParameter(None, Name, None, None, TrailingComma);
 }
 
+DeclNameRefSyntax SyntaxFactory::makeDeclNameRef(Optional<StringRef> ModuleName,
+                                                 StringRef BaseName,
+                                                 StringRef LeadingTrivia,
+                                                 StringRef TrailingTrivia) {
+  auto baseNameIdent = makeIdentifier(BaseName, LeadingTrivia, TrailingTrivia);
+  return makeDeclNameRef(baseNameIdent, None);
+}
+
 TypeSyntax SyntaxFactory::makeTypeIdentifier(StringRef TypeName,
                                              StringRef LeadingTrivia,
                                              StringRef TrailingTrivia) {
-  auto identifier =
-      makeIdentifier(TypeName, LeadingTrivia, TrailingTrivia);
-  return makeSimpleTypeIdentifier(identifier, None);
+  auto nameRef = makeDeclNameRef(None, TypeName, LeadingTrivia, TrailingTrivia);
+  return makeSimpleTypeIdentifier(nameRef, None);
 }
 
 TypeSyntax SyntaxFactory::makeAnyTypeIdentifier(StringRef LeadingTrivia,