Change how OperatorDecl is presented and parsed & Update test cases

Author: StevenWong12

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -1283,24 +1283,14 @@ public let DECL_NODES: [Node] = [
     description: "A Swift `operator` declaration.",
     kind: "Decl",
     traits: [
-      "IdentifiedDecl",
-      "Attributed",
+      "IdentifiedDecl"
     ],
     children: [
       Child(
-        name: "Attributes",
-        kind: .collection(kind: "AttributeList", collectionElementName: "Attribute"),
-        nameForDiagnostics: "attributes",
-        description: "The attributes applied to the 'operator' declaration.",
-        isOptional: true
-      ),
-      Child(
-        name: "Modifiers",
-        kind: .collection(kind: "ModifierList", collectionElementName: "Modifier"),
-        nameForDiagnostics: "modifiers",
-        description: "The declaration modifiers applied to the 'operator' declaration.",
-        isOptional: true,
-        classification: "Attribute"
+        name: "OperatorModifier",
+        kind: .token(choices: [.keyword(text: "prefix"), .keyword(text: "postfix"), .keyword(text: "infix")]),
+        nameForDiagnostics: "modifier",
+        description: "The declaration modifier applied to the 'operator' declaration."
       ),
       Child(
         name: "OperatorKeyword",

Sources/IDEUtils/generated/SyntaxClassification.swift

@@ -87,7 +87,7 @@ extension SyntaxClassification {
         return (.buildConfigId, false)
       case (.memberTypeIdentifier, 5):
         return (.typeIdentifier, false)
-      case (.operatorDecl, 7):
+      case (.operatorDecl, 5):
         return (.operatorIdentifier, false)
       case (.precedenceGroupAssociativity, 1):
         return (.keyword, false)
@@ -106,8 +106,6 @@ extension SyntaxClassification {
         return (.keyword, false)
       case (.ifConfigClause, 3):
         return (.buildConfigId, false)
-      case (.operatorDecl, 3):
-        return (.attribute, false)
       default: 
         return nil
       }

Sources/SwiftOperators/OperatorTable+Semantics.swift

@@ -68,11 +68,7 @@ extension Operator {
   /// TODO: This ignores all semantic errors.
   init(from syntax: OperatorDeclSyntax) {
     self.syntax = syntax
-
-    kind =
-      syntax.modifiers?.compactMap {
-        OperatorKind(rawValue: $0.name.text)
-      }.first ?? .infix
+    kind = OperatorKind(rawValue: syntax.operatorModifier.text) ?? .infix
 
     name = syntax.identifier.text
 

Sources/SwiftOperators/SyntaxSynthesis.swift

@@ -26,9 +26,7 @@ extension Operator {
   /// Synthesize a syntactic representation of this operator based on its
   /// semantic definition.
   public func synthesizedSyntax() -> OperatorDeclSyntax {
-    let modifiers = ModifierListSyntax(
-      [DeclModifierSyntax(name: .keyword(kind.keyword))]
-    )
+    let modifier = TokenSyntax.keyword(kind.keyword)
     let operatorKeyword = TokenSyntax.keyword(.operator, leadingTrivia: .space)
     let identifierSyntax =
       TokenSyntax.binaryOperator(name, leadingTrivia: .space)
@@ -41,7 +39,7 @@ extension Operator {
     }
 
     return OperatorDeclSyntax(
-      modifiers: modifiers,
+      operatorModifier: modifier,
       operatorKeyword: operatorKeyword,
       identifier: identifierSyntax,
       operatorPrecedenceAndTypes: precedenceGroupSyntax

Sources/SwiftParser/Declarations.swift

@@ -211,15 +211,22 @@ extension Parser {
       break
     }
 
+    // If we are inside a memberDecl list, we don't want to eat closing braces (which most likely close the outer context)
+    // while recoverying to the declaration start.
+    let recoveryPrecedence = inMemberDeclList ? TokenPrecedence.closingBrace : nil
+
+    switch self.canRecoverTo(anyIn: DeclarationStart.self, overrideRecoveryPrecedence: recoveryPrecedence) {
+    case (.operatorKeyword, _)?:
+      return RawDeclSyntax(parseOperatorDeclaration())
+    default:
+      break
+    }
+
     let attrs = DeclAttributes(
       attributes: self.parseAttributeList(),
       modifiers: self.parseModifierList()
     )
 
-    // If we are inside a memberDecl list, we don't want to eat closing braces (which most likely close the outer context)
-    // while recoverying to the declaration start.
-    let recoveryPrecedence = inMemberDeclList ? TokenPrecedence.closingBrace : nil
-
     switch self.canRecoverTo(anyIn: DeclarationStart.self, overrideRecoveryPrecedence: recoveryPrecedence) {
     case (.importKeyword, let handle)?:
       return RawDeclSyntax(self.parseImportDeclaration(attrs, handle))
@@ -250,8 +257,8 @@ extension Parser {
       return RawDeclSyntax(self.parseInitializerDeclaration(attrs, handle))
     case (.deinitKeyword, let handle)?:
       return RawDeclSyntax(self.parseDeinitializerDeclaration(attrs, handle))
-    case (.operatorKeyword, let handle)?:
-      return RawDeclSyntax(self.parseOperatorDeclaration(attrs, handle))
+    case (.operatorKeyword, _)?:
+      return RawDeclSyntax(self.parseOperatorDeclaration())
     case (.precedencegroupKeyword, let handle)?:
       return RawDeclSyntax(self.parsePrecedenceGroupDeclaration(attrs, handle))
     case (.actorKeyword, let handle)?:
@@ -1686,11 +1693,12 @@ extension Parser {
   ///     infix-operator-declaration → 'infix' 'operator' operator infix-operator-group?
   ///     infix-operator-group → ':' precedence-group-name
   @_spi(RawSyntax)
-  public mutating func parseOperatorDeclaration(
-    _ attrs: DeclAttributes,
-    _ handle: RecoveryConsumptionHandle
-  ) -> RawOperatorDeclSyntax {
-    let (unexpectedBeforeOperatorKeyword, operatorKeyword) = self.eat(handle)
+  public mutating func parseOperatorDeclaration() -> RawOperatorDeclSyntax {
+
+    let (unexpectedBeforeModifier, modifier) = self.expect(.keyword(.infix), .keyword(.postfix), .keyword(.prefix), default: .keyword(.prefix))
+
+    let (unexpectedBeforeOperator, operatorKeyword) = self.expect(.keyword(.operator))
+
     let unexpectedBeforeName: RawUnexpectedNodesSyntax?
     let name: RawTokenSyntax
     switch self.canRecoverTo(anyIn: OperatorLike.self) {
@@ -1767,9 +1775,9 @@ extension Parser {
       unexpectedAtEnd = nil
     }
     return RawOperatorDeclSyntax(
-      attributes: attrs.attributes,
-      modifiers: attrs.modifiers,
-      unexpectedBeforeOperatorKeyword,
+      unexpectedBeforeModifier,
+      operatorModifier: modifier,
+      unexpectedBeforeOperator,
       operatorKeyword: operatorKeyword,
       unexpectedBeforeName,
       identifier: name,

Sources/SwiftParser/Lookahead.swift

@@ -179,6 +179,17 @@ extension Parser.Lookahead {
 }
 
 extension Parser.Lookahead {
+  mutating func consumeModifierList() -> Bool {
+    guard self.at(anyIn: DeclarationModifier.self) != nil else {
+      return false
+    }
+    while self.consume(ifAnyIn: DeclarationModifier.self) != nil {
+      self.skipSingle()
+    }
+
+    return true
+  }
+
   mutating func consumeAttributeList() -> Bool {
     guard self.at(.atSign) else {
       return false

Sources/SwiftParser/SyntaxUtils.swift

@@ -41,6 +41,13 @@ extension RawUnexpectedNodesSyntax {
   init?<SyntaxType: RawSyntaxNodeProtocol>(_ nodes: [SyntaxType?], arena: __shared SyntaxArena) {
     self.init(nodes.compactMap({ $0 }), arena: arena)
   }
+
+  init?<SyntaxType: RawSyntaxNodeProtocol>(_ nodes: [SyntaxType]?, arena: __shared SyntaxArena) {
+    guard let nodes = nodes else {
+      return nil
+    }
+    self.init(nodes, arena: arena)
+  }
 }
 
 // MARK: Combining unexpected nodes

Sources/SwiftParser/TokenPrecedence.swift

@@ -220,7 +220,7 @@ public enum TokenPrecedence: Comparable {
       // Variables
       .let, .var,
       // Operator stuff
-      .operator, .precedencegroup,
+      .operator, .precedencegroup, .infix, .prefix, .postfix,
       // Misc
       .import:
       self = .declKeyword

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -893,6 +893,15 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     if shouldSkip(node) {
       return .skipChildren
     }
+
+    if node.operatorModifier.presence == .missing {
+      addDiagnostic(
+        node.operatorModifier,
+        .missingModifierInOperatorDeclaration,
+        handledNodes: [node.operatorModifier.id]
+      )
+    }
+
     if let unexpected = node.unexpectedAfterOperatorPrecedenceAndTypes,
       unexpected.contains(where: { $0.is(PrecedenceGroupAttributeListSyntax.self) }) == true
     {

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -179,6 +179,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var misspelledThrows: Self {
     .init("expected throwing specifier; did you mean 'throws'?")
   }
+  public static var missingModifierInOperatorDeclaration: Self {
+    .init("operator must be declared as 'prefix', 'postfix', or 'infix'")
+  }
   public static var multiLineStringLiteralMustBeginOnNewLine: Self {
     .init("multi-line string literal content must begin on a new line")
   }