Make all Syntax non-optional in OperatorError cases.

Always provide syntax nodes, even if they are synthesized, when forming
an OperatorError. This eliminates the need for clients to do this
synthesis.

Author: DougGregor

Sources/SwiftOperators/OperatorError+Diagnostics.swift

@@ -48,33 +48,23 @@ extension OperatorError : DiagnosticMessage {
 }
 
 extension OperatorError {
-  private func fixupDiagnosticDisplayNode<Node: SyntaxProtocol>(
-    _ node: Node?
-  ) -> Syntax {
-    if let node = node {
-      return Syntax(node)
-    }
-
-    return Syntax(MissingDeclSyntax(attributes: nil, modifiers: nil))
-  }
-
   /// Produce the syntax node at which a diagnostic should be displayed.
   var diagnosticDisplayNode: Syntax {
     switch self {
     case .incomparableOperators(let leftOperator, _, _, _):
       return Syntax(leftOperator)
 
     case .missingOperator(_, let node):
-      return fixupDiagnosticDisplayNode(node)
+      return node
 
     case .operatorAlreadyExists(_, let newOperator):
-      return fixupDiagnosticDisplayNode(newOperator.syntax)
+      return Syntax(newOperator.syntax ?? newOperator.synthesizedSyntax())
 
     case .missingGroup(_, let node):
-      return fixupDiagnosticDisplayNode(node)
+      return node
 
     case .groupAlreadyExists(_, let newGroup):
-      return fixupDiagnosticDisplayNode(newGroup.syntax)
+      return Syntax(newGroup.syntax ?? newGroup.synthesizedSyntax())
     }
   }
 

Sources/SwiftOperators/OperatorError.swift

@@ -18,13 +18,13 @@ public enum OperatorError: Error {
   case groupAlreadyExists(existing: PrecedenceGroup, new: PrecedenceGroup)
 
   /// The named precedence group is missing from the precedence graph.
-  case missingGroup(PrecedenceGroupName, referencedFrom: Syntax?)
+  case missingGroup(PrecedenceGroupName, referencedFrom: Syntax)
 
   /// Error produced when a given operator already exists.
   case operatorAlreadyExists(existing: Operator, new: Operator)
 
   /// The named operator is missing from the precedence graph.
-  case missingOperator(OperatorName, referencedFrom: Syntax?)
+  case missingOperator(OperatorName, referencedFrom: Syntax)
 
   /// No associativity relationship between operators.
   case incomparableOperators(

Sources/SwiftOperators/OperatorTable+Folding.swift

@@ -47,7 +47,7 @@ extension OperatorTable {
 
     return try precedenceGraph.precedence(
       relating: groupName, to: boundGroupName,
-      startSyntax: operatorSyntax, endSyntax: bound.syntax,
+      startSyntax: operatorSyntax, endSyntax: bound.syntax!,
       errorHandler: errorHandler
     ) != .lowerThan
   }
@@ -177,9 +177,9 @@ extension OperatorTable {
   /// Determine the associativity between two precedence groups.
   private func associativity(
     firstGroup: PrecedenceGroupName?,
-    firstOperatorSyntax: Syntax?,
+    firstOperatorSyntax: Syntax,
     secondGroup: PrecedenceGroupName?,
-    secondOperatorSyntax: Syntax?,
+    secondOperatorSyntax: Syntax,
     errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> Associativity {
     guard let firstGroup = firstGroup, let secondGroup = secondGroup else {

Sources/SwiftOperators/OperatorTable.swift

@@ -85,7 +85,7 @@ extension OperatorTable {
   /// Look for the precedence group corresponding to the given operator.
   func lookupOperatorPrecedenceGroupName(
     _ operatorName: OperatorName,
-    referencedFrom syntax: Syntax?,
+    referencedFrom syntax: Syntax,
     errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> PrecedenceGroupName? {
     guard let op = infixOperators[operatorName] else {

Sources/SwiftOperators/PrecedenceGraph.swift

@@ -61,7 +61,7 @@ struct PrecedenceGraph {
   /// (fromGroup, fromSyntax) and following precedence groups in the
   /// specified direction.
   private func searchRelationships(
-    initialGroupName: PrecedenceGroupName, initialSyntax: Syntax?,
+    initialGroupName: PrecedenceGroupName, initialSyntax: Syntax,
     targetGroupName: PrecedenceGroupName,
     direction: PrecedenceRelation.Kind,
     errorHandler: OperatorErrorHandler
@@ -70,7 +70,7 @@ struct PrecedenceGraph {
     // the graph. This detects cycles and prevents extraneous work.
     var groupsSeen: Set<PrecedenceGroupName> = []
 
-    var stack: [(PrecedenceGroupName, Syntax?)] =
+    var stack: [(PrecedenceGroupName, Syntax)] =
       [(initialGroupName, initialSyntax)]
     while let (currentGroupName, currentOperatorSyntax) = stack.popLast() {
       guard let currentGroup = lookupGroup(currentGroupName) else {
@@ -94,7 +94,14 @@ struct PrecedenceGraph {
           }
 
           if groupsSeen.insert(otherGroupName).inserted {
-            stack.append((otherGroupName, relation.syntax.map { Syntax($0) }))
+            let relationSyntax: Syntax
+            if let knownSyntax = relation.syntax {
+              relationSyntax = Syntax(knownSyntax)
+            } else {
+              relationSyntax =
+                Syntax(relation.synthesizedSyntax().otherNames.first!.name)
+            }
+            stack.append((otherGroupName, relationSyntax))
           }
         }
       }
@@ -114,8 +121,8 @@ struct PrecedenceGraph {
   func precedence(
     relating startGroupName: PrecedenceGroupName,
     to endGroupName: PrecedenceGroupName,
-    startSyntax: Syntax?,
-    endSyntax: Syntax?,
+    startSyntax: Syntax,
+    endSyntax: Syntax,
     errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> Precedence {
     if startGroupName == endGroupName {

Sources/SwiftOperators/SyntaxSynthesis.swift

@@ -39,6 +39,31 @@ extension Operator {
   }
 }
 
+extension PrecedenceRelation {
+  /// Synthesize a syntactic representation of this precedence relation based on
+  /// its semantic definition.
+  ///
+  /// We only use this internally to synthesize syntactic locations.
+  func synthesizedSyntax(
+    indentation: Int = 4
+  ) -> PrecedenceGroupRelationSyntax {
+    PrecedenceGroupRelationSyntax(
+      higherThanOrLowerThan: .contextualKeyword(
+        "\(kind)",
+        leadingTrivia: [ .newlines(1), .spaces(indentation) ]
+      ),
+      colon: .colonToken(),
+      otherNames: PrecedenceGroupNameListSyntax(
+        [
+          PrecedenceGroupNameElementSyntax(
+            name: .identifier(groupName, leadingTrivia:  .space),
+            trailingComma: nil)
+        ]
+      )
+    )
+  }
+}
+
 extension PrecedenceGroup {
   /// Synthesize a syntactic representation of this precedence group based on
   /// its semantic definition.
@@ -92,20 +117,7 @@ extension PrecedenceGroup {
     for relation in relations {
       groupAttributes.append(
         Syntax(
-          PrecedenceGroupRelationSyntax(
-            higherThanOrLowerThan: .contextualKeyword(
-              "\(relation.kind)",
-              leadingTrivia: [ .newlines(1), .spaces(indentation) ]
-            ),
-            colon: .colonToken(),
-            otherNames: PrecedenceGroupNameListSyntax(
-              [
-                PrecedenceGroupNameElementSyntax(
-                  name: .identifier(relation.groupName, leadingTrivia:  .space),
-                  trailingComma: nil)
-              ]
-            )
-          )
+          relation.synthesizedSyntax()
         )
       )
     }