ASTGen: Translate precedence group declarations

Author: AnthonyLatsis

include/swift/AST/CASTBridging.h

@@ -434,6 +434,24 @@ void *OperatorDecl_create(BridgedASTContext cContext,
                           BridgedIdentifier cPrecedenceGroupName,
                           BridgedSourceLoc cPrecedenceGroupLoc);
 
+typedef enum ENUM_EXTENSIBILITY_ATTR(closed) {
+  BridgedAssociativityNone,
+  BridgedAssociativityLeft,
+  BridgedAssociativityRight,
+} BridgedAssociativity;
+
+void *PrecedenceGroupDecl_create(
+    BridgedDeclContext cDeclContext,
+    BridgedSourceLoc cPrecedencegroupKeywordLoc, BridgedIdentifier cName,
+    BridgedSourceLoc cNameLoc, BridgedSourceLoc cLeftBraceLoc,
+    BridgedSourceLoc cAssociativityKeywordLoc,
+    BridgedSourceLoc cAssociativityValueLoc,
+    BridgedAssociativity cAssociativity, BridgedSourceLoc cAssignmentKeywordLoc,
+    BridgedSourceLoc cAssignmentValueLoc, _Bool isAssignment,
+    BridgedSourceLoc cHigherThanKeywordLoc, BridgedArrayRef cHigherThanNames,
+    BridgedSourceLoc cLowerThanKeywordLoc, BridgedArrayRef cLowerThanNames,
+    BridgedSourceLoc cRightBraceLoc);
+
 typedef enum ENUM_EXTENSIBILITY_ATTR(open) {
   BridgedImportKindModule,
   BridgedImportKindType,

lib/AST/CASTBridging.cpp

@@ -807,6 +807,48 @@ void *OperatorDecl_create(BridgedASTContext cContext,
   return static_cast<Decl *>(decl);
 }
 
+void *PrecedenceGroupDecl_create(
+    BridgedDeclContext cDeclContext,
+    BridgedSourceLoc cPrecedencegroupKeywordLoc, BridgedIdentifier cName,
+    BridgedSourceLoc cNameLoc, BridgedSourceLoc cLeftBraceLoc,
+    BridgedSourceLoc cAssociativityKeywordLoc,
+    BridgedSourceLoc cAssociativityValueLoc,
+    BridgedAssociativity cAssociativity, BridgedSourceLoc cAssignmentKeywordLoc,
+    BridgedSourceLoc cAssignmentValueLoc, bool isAssignment,
+    BridgedSourceLoc cHigherThanKeywordLoc, BridgedArrayRef cHigherThanNames,
+    BridgedSourceLoc cLowerThanKeywordLoc, BridgedArrayRef cLowerThanNames,
+    BridgedSourceLoc cRightBraceLoc) {
+
+  SmallVector<PrecedenceGroupDecl::Relation, 2> higherThanNames;
+  for (auto &pair :
+       convertArrayRef<BridgedIdentifierAndSourceLoc>(cHigherThanNames)) {
+    higherThanNames.push_back({convertSourceLoc(pair.nameLoc),
+                               convertIdentifier(pair.name), nullptr});
+  }
+
+  SmallVector<PrecedenceGroupDecl::Relation, 2> lowerThanNames;
+  for (auto &pair :
+       convertArrayRef<BridgedIdentifierAndSourceLoc>(cLowerThanNames)) {
+    lowerThanNames.push_back({convertSourceLoc(pair.nameLoc),
+                              convertIdentifier(pair.name), nullptr});
+  }
+
+  auto *decl = PrecedenceGroupDecl::create(
+      convertDeclContext(cDeclContext),
+      convertSourceLoc(cPrecedencegroupKeywordLoc), convertSourceLoc(cNameLoc),
+      convertIdentifier(cName), convertSourceLoc(cLeftBraceLoc),
+      convertSourceLoc(cAssociativityKeywordLoc),
+      convertSourceLoc(cAssociativityValueLoc),
+      static_cast<Associativity>(cAssociativity),
+      convertSourceLoc(cAssignmentKeywordLoc),
+      convertSourceLoc(cAssignmentValueLoc), isAssignment,
+      convertSourceLoc(cHigherThanKeywordLoc), higherThanNames,
+      convertSourceLoc(cLowerThanKeywordLoc), lowerThanNames,
+      convertSourceLoc(cRightBraceLoc));
+
+  return static_cast<Decl *>(decl);
+}
+
 void *ImportDecl_create(BridgedASTContext cContext,
                         BridgedDeclContext cDeclContext,
                         BridgedSourceLoc cImportKeywordLoc,

lib/ASTGen/Sources/ASTGen/ASTGen.swift

@@ -242,6 +242,15 @@ extension ASTGenVisitor {
 
     return self.visit(node)
   }
+
+  @inline(__always)
+  func visit(_ node: PrecedenceGroupNameListSyntax?) -> BridgedArrayRef {
+    guard let node else {
+      return .init()
+    }
+
+    return self.visit(node)
+  }
 }
 
 extension Collection {

lib/ASTGen/Sources/ASTGen/Decls.swift

@@ -350,6 +350,116 @@ extension ASTGenVisitor {
   }
 }
 
+// MARK: - PrecedenceGroupDecl
+
+extension BridgedAssociativity {
+  fileprivate init?(from tokenKind: TokenKind) {
+    switch tokenKind {
+    case .keyword(.none): self = .none
+    case .keyword(.left): self = .left
+    case .keyword(.right): self = .right
+    default: return nil
+    }
+  }
+}
+
+extension ASTGenVisitor {
+  func visit(_ node: PrecedenceGroupDeclSyntax) -> ASTNode {
+    let (name, nameLoc) = node.name.bridgedIdentifierAndSourceLoc(in: self)
+
+    struct PrecedenceGroupBody {
+      var associativity: PrecedenceGroupAssociativitySyntax? = nil
+      var assignment: PrecedenceGroupAssignmentSyntax? = nil
+      var higherThanRelation: PrecedenceGroupRelationSyntax? = nil
+      var lowerThanRelation: PrecedenceGroupRelationSyntax? = nil
+    }
+
+    func diagnoseDuplicateSyntax(_ duplicate: some SyntaxProtocol, original: some SyntaxProtocol) {
+      self.diagnose(Diagnostic(node: duplicate, message: DuplicateSyntaxError(duplicate: duplicate, original: original)))
+    }
+
+    let body = node.groupAttributes.reduce(into: PrecedenceGroupBody()) { body, element in
+      switch element {
+      case .precedenceGroupRelation(let relation):
+        let keyword = relation.higherThanOrLowerThanLabel
+        switch keyword.tokenKind {
+        case .keyword(.higherThan):
+          if let current = body.higherThanRelation {
+            diagnoseDuplicateSyntax(relation, original: current)
+          } else {
+            body.higherThanRelation = relation
+          }
+        case .keyword(.lowerThan):
+          if let current = body.lowerThanRelation {
+            diagnoseDuplicateSyntax(relation, original: current)
+          } else {
+            body.lowerThanRelation = relation
+          }
+        default:
+          return self.diagnose(Diagnostic(node: keyword, message: UnexpectedTokenKindError(token: keyword)))
+        }
+      case .precedenceGroupAssignment(let assignment):
+        if let current = body.assignment {
+          diagnoseDuplicateSyntax(assignment, original: current)
+        } else {
+          body.assignment = assignment
+        }
+      case .precedenceGroupAssociativity(let associativity):
+        if let current = body.associativity {
+          diagnoseDuplicateSyntax(node, original: current)
+        } else {
+          body.associativity = associativity
+        }
+      }
+    }
+
+    let associativityValue: BridgedAssociativity
+    if let token = body.associativity?.value {
+      if let value = BridgedAssociativity(from: token.tokenKind) {
+        associativityValue = value
+      } else {
+        self.diagnose(Diagnostic(node: token, message: UnexpectedTokenKindError(token: token)))
+        associativityValue = .none
+      }
+    } else {
+      associativityValue = .none
+    }
+
+    let assignmentValue: Bool
+    if let token = body.assignment?.value {
+      if token.tokenKind == .keyword(.true) {
+        assignmentValue = true
+      } else {
+        self.diagnose(Diagnostic(node: token, message: UnexpectedTokenKindError(token: token)))
+        assignmentValue = false
+      }
+    } else {
+      assignmentValue = false
+    }
+
+    return .decl(
+      PrecedenceGroupDecl_create(
+        self.declContext,
+        self.bridgedSourceLoc(for: node.precedencegroupKeyword),
+        name,
+        nameLoc,
+        self.bridgedSourceLoc(for: node.leftBrace),
+        self.bridgedSourceLoc(for: body.associativity?.associativityLabel),
+        self.bridgedSourceLoc(for: body.associativity?.value),
+        associativityValue,
+        self.bridgedSourceLoc(for: body.assignment?.assignmentLabel),
+        self.bridgedSourceLoc(for: body.assignment?.value),
+        assignmentValue,
+        self.bridgedSourceLoc(for: body.higherThanRelation?.higherThanOrLowerThanLabel),
+        self.visit(body.higherThanRelation?.precedenceGroups),
+        self.bridgedSourceLoc(for: body.lowerThanRelation?.higherThanOrLowerThanLabel),
+        self.visit(body.lowerThanRelation?.precedenceGroups),
+        self.bridgedSourceLoc(for: node.rightBrace)
+      )
+    )
+  }
+}
+
 // MARK: - ImportDecl
 
 extension BridgedImportKind {
@@ -406,4 +516,11 @@ extension ASTGenVisitor {
   func visit(_ node: InheritedTypeListSyntax) -> BridgedArrayRef {
     node.lazy.map { self.visit($0.type).rawValue }.bridgedArray(in: self)
   }
+
+  @inline(__always)
+  func visit(_ node: PrecedenceGroupNameListSyntax) -> BridgedArrayRef {
+    node.lazy.map {
+      $0.name.bridgedIdentifierAndSourceLoc(in: self) as BridgedIdentifierAndSourceLoc
+    }.bridgedArray(in: self)
+  }
 }

lib/ASTGen/Sources/ASTGen/Diagnostics.swift

@@ -66,3 +66,30 @@ struct MissingChildTokenError: ASTGenError {
     """
   }
 }
+
+/// An error emitted when a syntax collection entry is encountered that is considered a duplicate of a previous entry
+/// per the language grammar.
+struct DuplicateSyntaxError: ASTGenError {
+  let duplicate: Syntax
+  let original: Syntax
+
+  init(duplicate: some SyntaxProtocol, original: some SyntaxProtocol) {
+    precondition(duplicate.kind == original.kind, "Expected duplicate and original to be of same kind")
+
+    guard let duplicateParent = duplicate.parent, let originalParent = original.parent, duplicateParent == originalParent, duplicateParent.kind.isSyntaxCollection else {
+      preconditionFailure("Expected a shared syntax collection parent")
+    }
+
+    self.duplicate = Syntax(duplicate)
+    self.original = Syntax(original)
+  }
+
+  var message: String {
+    """
+    unexpected duplicate syntax in list:
+      \(duplicate.debugDescription(indentString: "  "))
+    previous syntax:
+      \(original.debugDescription(indentString: "  "))
+    """
+  }
+}

test/ASTGen/verify-parse.swift

@@ -191,3 +191,14 @@ operator
 
 postfix
 operator ⎩^-^⎩
+
+
+precedencegroup Precedence1 {
+}
+
+precedencegroup Precedence2 {
+  lowerThan: BitwiseShiftPrecedence, MultiplicationPrecedence
+  higherThan: Precedence1, AdditionPrecedence
+  associativity: left
+  assignment: true
+}