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(open) {
+  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

@@ -826,6 +826,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

@@ -220,6 +220,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 SyntaxCollection {

lib/ASTGen/Sources/ASTGen/Decls.swift

@@ -351,6 +351,119 @@ 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
+    }
+
+    let body = node.groupAttributes.reduce(into: PrecedenceGroupBody()) { partialResult, element in
+      let duplicate: Syntax
+      let original: Syntax
+
+      switch element {
+      case .precedenceGroupRelation(let node):
+        let keyword = node.higherThanOrLowerThanLabel
+        switch keyword.tokenKind {
+        case .keyword(.higherThan):
+          guard let current = partialResult.higherThanRelation else {
+            partialResult.higherThanRelation = node
+            return
+          }
+          (duplicate, original) = (Syntax(node), Syntax(current))
+        case .keyword(.lowerThan):
+          guard let current = partialResult.lowerThanRelation else {
+            partialResult.lowerThanRelation = node
+            return
+          }
+          (duplicate, original) = (Syntax(node), Syntax(current))
+        default:
+          return self.diagnose(Diagnostic(node: keyword, message: UnexpectedTokenKindError(token: keyword)))
+        }
+      case .precedenceGroupAssignment(let node):
+        guard let current = partialResult.assignment else {
+          partialResult.assignment = node
+          return
+        }
+        (duplicate, original) = (Syntax(node), Syntax(current))
+      case .precedenceGroupAssociativity(let node):
+        guard let current = partialResult.associativity else {
+          partialResult.associativity = node
+          return
+        }
+        (duplicate, original) = (Syntax(node), Syntax(current))
+      }
+
+      self.diagnose(Diagnostic(node: duplicate, message: DuplicateSyntaxError(duplicate: duplicate, original: original)))
+    }
+
+    let associativityValue: BridgedAssociativity
+    switch body.associativity?.value {
+    case let token?:
+      guard let value = BridgedAssociativity(from: token.tokenKind) else {
+        self.diagnose(Diagnostic(node: token, message: UnexpectedTokenKindError(token: token)))
+        fallthrough
+      }
+
+      associativityValue = value
+    case nil:
+      associativityValue = .none
+    }
+
+    let assignmentValue: Bool
+    switch body.assignment?.value {
+    case let token?:
+      guard token.tokenKind == .keyword(.true) else {
+        self.diagnose(Diagnostic(node: token, message: UnexpectedTokenKindError(token: token)))
+        fallthrough
+      }
+
+      assignmentValue = true
+    case nil:
+      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 +519,10 @@ extension ASTGenVisitor {
   func visit(_ node: InheritedTypeListSyntax) -> BridgedArrayRef {
     node.map(in: self) { self.visit($0.type).rawValue }
   }
+
+  func visit(_ node: PrecedenceGroupNameListSyntax) -> BridgedArrayRef {
+    node.map(in: self) {
+      $0.name.bridgedIdentifierAndSourceLoc(in: self) as BridgedIdentifierAndSourceLoc
+    }
+  }
 }

lib/ASTGen/Sources/ASTGen/Diagnostics.swift

@@ -539,3 +539,28 @@ 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<S: SyntaxProtocol>(duplicate: S, original: S) {
+    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
+}