Rebase off changes to #643.

Author: zoecarver

Sources/ASTGen/ASTGen.swift

@@ -11,14 +11,6 @@ extension Array {
   }
 }
 
-extension Collection {
-  public var only: Element {
-    if isEmpty { fatalError("Empty Collection.") }
-    else if count > 1 { fatalError("More than one element") }
-    return first!
-  }
-}
-
 extension UnsafePointer {
   public var raw: UnsafeMutableRawPointer {
     UnsafeMutableRawPointer(mutating: self)
@@ -38,12 +30,17 @@ struct ASTGenVisitor: SyntaxTransformVisitor {
 //    return nil
 //  }
 
+  @_disfavoredOverload
+  public func visit(_ node: SourceFileSyntax) -> UnsafeMutableRawPointer {
+    fatalError("Use other overload.")
+  }
+  
   public func visit(_ node: SourceFileSyntax) -> [UnsafeMutableRawPointer] {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
     var out = [UnsafeMutableRawPointer]()
 
     for element in node.statements {
-      let swiftASTNodes = visit(element).only
+      let swiftASTNodes = visit(element)
       if element.item.is(StmtSyntax.self) || element.item.is(ExprSyntax.self) {
         out.append(SwiftTopLevelCodeDecl_create(ctx, declContext, loc, swiftASTNodes))
       } else {
@@ -55,103 +52,103 @@ struct ASTGenVisitor: SyntaxTransformVisitor {
     return out
   }
 
-  public func visit(_ node: FunctionCallExprSyntax) -> [UnsafeMutableRawPointer] {
-    let args = visit(node.argumentList).only
+  public func visit(_ node: FunctionCallExprSyntax) -> UnsafeMutableRawPointer {
+    let args = visit(node.argumentList)
     // TODO: hack
-    let callee = visit(node.calledExpression).only
-    let call = SwiftFunctionCallExpr_create(self.ctx, callee, args)
-    
-    return [call]
+    let callee = visit(node.calledExpression)
+    return SwiftFunctionCallExpr_create(self.ctx, callee, args)
   }
 
-  public func visit(_ node: IdentifierExprSyntax) -> [UnsafeMutableRawPointer] {
+  public func visit(_ node: IdentifierExprSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
 
     var text = node.identifier.text
     let id = text.withUTF8 { buf in
       return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
     }
 
-    return [SwiftIdentifierExpr_create(ctx, id, loc)]
+    return SwiftIdentifierExpr_create(ctx, id, loc)
   }
 
-  public func visit(_ node: SimpleTypeIdentifierSyntax) -> [UnsafeMutableRawPointer] {
+  public func visit(_ node: SimpleTypeIdentifierSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
 
     var text = node.name.text
     let id = text.withUTF8 { buf in
       return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
     }
 
-    return [SimpleIdentTypeRepr_create(ctx, loc, id)]
+    return SimpleIdentTypeRepr_create(ctx, loc, id)
   }
 
-  public func visit(_ node: IdentifierPatternSyntax) -> [UnsafeMutableRawPointer] {
+  public func visit(_ node: IdentifierPatternSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
 
     var text = node.identifier.text
     let id = text.withUTF8 { buf in
       return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
     }
 
-    return [SwiftIdentifierExpr_create(ctx, id, loc)]
+    return SwiftIdentifierExpr_create(ctx, id, loc)
   }
 
-  public func visit(_ node: MemberAccessExprSyntax) -> [UnsafeMutableRawPointer] {
+  public func visit(_ node: MemberAccessExprSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
-    let base = visit(node.base!).only
+    let base = visit(node.base!)
     var nameText = node.name.text
     let name = nameText.withUTF8 { buf in
       return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
     }
 
-    return [UnresolvedDotExpr_create(ctx, base, loc, name, loc)]
+    return UnresolvedDotExpr_create(ctx, base, loc, name, loc)
   }
 
+  public func visit(_ node: TupleExprElementSyntax) -> UnsafeMutableRawPointer {
+    visit(node.expression)
+  }
 
-  public func visit(_ node: TupleExprElementListSyntax) -> [UnsafeMutableRawPointer] {
-    let elements = node.map { visit($0).only }
+  public func visit(_ node: TupleExprElementListSyntax) -> UnsafeMutableRawPointer {
+    let elements = node.map(self.visit)
 
     // TODO: find correct paren locs.
     let lParenLoc = self.base.advanced(by: node.position.utf8Offset).raw
     let rParenLoc = self.base.advanced(by: node.position.utf8Offset).raw
 
-    return [elements.withBridgedArrayRef { elementsRef in
+    return elements.withBridgedArrayRef { elementsRef in
       SwiftTupleExpr_create(self.ctx, lParenLoc, elementsRef, rParenLoc)
-    }]
-  }
-
-  public func visit(_ node: PatternBindingSyntax) -> [UnsafeMutableRawPointer] {
-    let pattern = visit(node.pattern)
-    let initializer = visit(node.initializer!)
-
-    return [pattern.only, initializer.only]
+    }
   }
 
-  public func visit(_ node: VariableDeclSyntax) -> [UnsafeMutableRawPointer] {
-    let components = visit(node.bindings)
-    assert(components.count == 2)
-    let pattern = components.first!
-    let initializer = components.last!
+  public func visit(_ node: VariableDeclSyntax) -> UnsafeMutableRawPointer {
+    let pattern = visit(node.bindings.first!.pattern)
+    let initializer = visit(node.bindings.first!.initializer!)
 
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
     let isStateic = false // TODO: compute this
     let isLet = node.letOrVarKeyword.tokenKind == .letKeyword
 
     // TODO: don't drop "initializer" on the floor.
-    return [SwiftVarDecl_create(ctx, pattern, loc, isStateic, isLet, declContext)]
+    return SwiftVarDecl_create(ctx, pattern, loc, isStateic, isLet, declContext)
   }
 
-  public func visit(_ node: CodeBlockSyntax) -> [UnsafeMutableRawPointer] {
-    let statements = visit(node.statements)
+  public func visit(_ node: ConditionElementSyntax) -> UnsafeMutableRawPointer {
+    visit(node.condition)
+  }
+
+  public func visit(_ node: CodeBlockItemSyntax) -> UnsafeMutableRawPointer {
+    visit(node.item)
+  }
+
+  public func visit(_ node: CodeBlockSyntax) -> UnsafeMutableRawPointer {
+    let statements = node.statements.map(self.visit)
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
 
-    return [statements.withBridgedArrayRef { ref in
+    return statements.withBridgedArrayRef { ref in
       BraceStmt_create(ctx, loc, ref, loc)
-    }]
+    }
   }
 
-  public func visit(_ node: FunctionParameterSyntax) -> [UnsafeMutableRawPointer] {
+  public func visit(_ node: FunctionParameterSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
 
     let firstName: UnsafeMutableRawPointer?
@@ -175,10 +172,10 @@ struct ASTGenVisitor: SyntaxTransformVisitor {
       secondName = nil
     }
 
-    return [ParamDecl_create(ctx, loc, loc, firstName, loc, secondName, declContext)]
+    return ParamDecl_create(ctx, loc, loc, firstName, loc, secondName, declContext)
   }
 
-  public func visit(_ node: FunctionDeclSyntax) -> [UnsafeMutableRawPointer] {
+  public func visit(_ node: FunctionDeclSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
 
     var nameText = node.identifier.text
@@ -188,55 +185,53 @@ struct ASTGenVisitor: SyntaxTransformVisitor {
 
     let body: UnsafeMutableRawPointer?
     if let nodeBody = node.body {
-      body = visit(nodeBody).only
+      body = visit(nodeBody)
     } else {
       body = nil
     }
 
     let returnType: UnsafeMutableRawPointer?
     if let output = node.signature.output {
-      returnType = visit(output.returnType).only
+      returnType = visit(output.returnType)
     } else {
       returnType = nil
     }
 
-    let params = node.signature.input.parameterList.map { visit($0).only }
-    return [params.withBridgedArrayRef { ref in
+    let params = node.signature.input.parameterList.map { visit($0) }
+    return params.withBridgedArrayRef { ref in
       FuncDecl_create(ctx, loc, false, loc, name, loc, false, nil, false, nil, loc, ref, loc, body, returnType, declContext)
-    }]
+    }
   }
 
-  public func visit(_ node: IfStmtSyntax) -> [UnsafeMutableRawPointer] {
-    let conditions = node.conditions.map { self.visit($0).only }
+  public func visit(_ node: IfStmtSyntax) -> UnsafeMutableRawPointer {
+    let conditions = node.conditions.map(self.visit)
     assert(conditions.count == 1) // TODO: handle multiple conditions.
 
-    let body = visit(node.body).only
+    let body = visit(node.body)
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
 
     if let elseBody = node.elseBody, node.elseKeyword != nil {
-      let elseStmt = visit(elseBody.data).only // TODO: don't use SyntaxData
-      return [IfStmt_create(ctx, loc, conditions.only, body, loc,
-                            elseStmt)]
+      return IfStmt_create(ctx, loc, conditions.first!, body, loc, visit(elseBody))
     }
 
-    return [IfStmt_create(ctx, loc, conditions.only, body, nil, nil)]
+    return IfStmt_create(ctx, loc, conditions.first!, body, nil, nil)
   }
 
-  public func visit(_ node: StringLiteralExprSyntax) -> [UnsafeMutableRawPointer] {
+  public func visit(_ node: StringLiteralExprSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
-    var segment = node.segments.only.as(StringSegmentSyntax.self)!.content.text
+    var segment = node.segments.first!.as(StringSegmentSyntax.self)!.content.text
     return segment.withUTF8 { buf in
       let id = SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
-      return [SwiftStringLiteralExpr_create(ctx, id, buf.count, loc)]
+      return SwiftStringLiteralExpr_create(ctx, id, buf.count, loc)
     }
   }
 
-  public func visit(_ node: IntegerLiteralExprSyntax) -> [UnsafeMutableRawPointer] {
+  public func visit(_ node: IntegerLiteralExprSyntax) -> UnsafeMutableRawPointer {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
     var segment = node.digits.text
     return segment.withUTF8 { buf in
       let id = SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
-      return [SwiftIntegerLiteralExpr_create(ctx, id, buf.count, loc)]
+      return SwiftIntegerLiteralExpr_create(ctx, id, buf.count, loc)
     }
   }
 }
@@ -249,7 +244,7 @@ public func parseTopLevelSwift(
     callback: @convention(c) (UnsafeMutableRawPointer, UnsafeMutableRawPointer) -> Void
 ) {
   let syntax = try! Parser.parse(source: String(cString: buffer))
-//  dump(syntax)
+  dump(syntax)
   ASTGenVisitor(ctx: ctx, base: buffer, declContext: declContext)
     .visit(syntax)
     .forEach { callback($0, outputContext) }

Sources/SwiftSyntax/Syntax.swift

@@ -14,7 +14,7 @@
 /// Each node has accessors for its known children, and allows efficient
 /// iteration over the children through its `children` property.
 public struct Syntax: SyntaxProtocol, SyntaxHashable {
-  public let data: SyntaxData
+  let data: SyntaxData
 
   public var _syntaxNode: Syntax {
     return self