stash

Author: zoecarver

Sources/ASTGen/ASTGen.swift

@@ -11,6 +11,14 @@ 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)
@@ -20,16 +28,42 @@ extension UnsafePointer {
 struct ASTGenVisitor: SyntaxTransformVisitor {
   let ctx: UnsafeMutableRawPointer
   let base: UnsafePointer<CChar>
+
+  // TOOD: we need to be up updating this.
+  var declContext: UnsafeMutableRawPointer
+  
+  // TODO: this some how messes up the witness table when I uncomment it locally :/
+//  public func visit<T>(_ node: T?) -> [UnsafeMutableRawPointer]? {
+//    if let node = node { return visit(node) }
+//    return nil
+//  }
 
+  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
+      if element.item.is(StmtSyntax.self) || element.item.is(ExprSyntax.self) {
+        out.append(SwiftTopLevelCodeDecl_create(ctx, declContext, loc, swiftASTNodes))
+      } else {
+        assert(element.item.is(DeclSyntax.self))
+        out.append(swiftASTNodes)
+      }
+    }
+    
+    return out
+  }
+
   public func visit(_ node: FunctionCallExprSyntax) -> [UnsafeMutableRawPointer] {
-    let args = visit(node.argumentList).first!
+    let args = visit(node.argumentList).only
     // TODO: hack
-    let callee = visit(node.calledExpression.as(IdentifierExprSyntax.self)!).first!
+    let callee = visit(node.calledExpression).only
     let call = SwiftFunctionCallExpr_create(self.ctx, callee, args)
 
     return [call]
   }
-  
+
   public func visit(_ node: IdentifierExprSyntax) -> [UnsafeMutableRawPointer] {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
 
@@ -40,9 +74,43 @@ struct ASTGenVisitor: SyntaxTransformVisitor {
 
     return [SwiftIdentifierExpr_create(ctx, id, loc)]
   }
+
+  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)]
+  }
+
+  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)]
+  }
 
+  public func visit(_ node: MemberAccessExprSyntax) -> [UnsafeMutableRawPointer] {
+    let loc = self.base.advanced(by: node.position.utf8Offset).raw
+    let base = visit(node.base!).only
+    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)]
+  }
+  
+
   public func visit(_ node: TupleExprElementListSyntax) -> [UnsafeMutableRawPointer] {
-    let elements = node.map { visit($0).first! }
+    let elements = node.map { visit($0).only }
 
     // TODO: find correct paren locs.
     let lParenLoc = self.base.advanced(by: node.position.utf8Offset).raw
@@ -52,22 +120,137 @@ struct ASTGenVisitor: SyntaxTransformVisitor {
       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!
 
+    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)]
+  }
+  
+  public func visit(_ node: CodeBlockSyntax) -> [UnsafeMutableRawPointer] {
+    let statements = visit(node.statements)
+    let loc = self.base.advanced(by: node.position.utf8Offset).raw
+
+    return [statements.withBridgedArrayRef { ref in
+      BraceStmt_create(ctx, loc, ref, loc)
+    }]
+  }
+
+  public func visit(_ node: FunctionParameterSyntax) -> [UnsafeMutableRawPointer] {
+    let loc = self.base.advanced(by: node.position.utf8Offset).raw
+    
+    let firstName: UnsafeMutableRawPointer?
+    let secondName: UnsafeMutableRawPointer?
+    
+    if let nodeFirstName = node.firstName {
+      var text = nodeFirstName.text
+      firstName = text.withUTF8 { buf in
+        SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count).raw
+      }
+    } else {
+      firstName = nil
+    }
+    
+    if let nodeSecondName = node.secondName {
+      var text = nodeSecondName.text
+      secondName = text.withUTF8 { buf in
+        SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count).raw
+      }
+    } else {
+      secondName = nil
+    }
+    
+    return [ParamDecl_create(ctx, loc, loc, firstName, loc, secondName, declContext)]
+  }
+
+  public func visit(_ node: FunctionDeclSyntax) -> [UnsafeMutableRawPointer] {
+    let loc = self.base.advanced(by: node.position.utf8Offset).raw
+    
+    var nameText = node.identifier.text
+    let name = nameText.withUTF8 { buf in
+      return SwiftASTContext_getIdentifier(ctx, buf.baseAddress, buf.count)
+    }
+    
+    let body: UnsafeMutableRawPointer?
+    if let nodeBody = node.body {
+      body = visit(nodeBody).only
+    } else {
+      body = nil
+    }
+
+    let returnType: UnsafeMutableRawPointer?
+    if let output = node.signature.output {
+      returnType = visit(output.returnType).only
+    } else {
+      returnType = nil
+    }
+    
+    let params = node.signature.input.parameterList.map { visit($0).only }
+    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 }
+    assert(conditions.count == 1) // TODO: handle multiple conditions.
+    
+    let body = visit(node.body).only
+    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.only, body, nil, nil)]
+  }
+
   public func visit(_ node: StringLiteralExprSyntax) -> [UnsafeMutableRawPointer] {
     let loc = self.base.advanced(by: node.position.utf8Offset).raw
-    var segment = node.segments.first!.as(StringSegmentSyntax.self)!.content.text
+    var segment = node.segments.only.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)]
     }
   }
+
+  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)]
+    }
+  }
 }
 
 @_cdecl("parseTopLevelSwift")
 public func parseTopLevelSwift(
-    buffer: UnsafePointer<CChar>, ctx: UnsafeMutableRawPointer
-) -> UnsafeMutableRawPointer {
-    let syntax = try! Parser.parse(source: String(cString: buffer))
-    let count = ASTGenVisitor(ctx: ctx, base: buffer).visit(syntax)
-    return count.first!
+    buffer: UnsafePointer<CChar>, declContext: UnsafeMutableRawPointer,
+    ctx: UnsafeMutableRawPointer,
+    outputContext: UnsafeMutableRawPointer,
+    callback: @convention(c) (UnsafeMutableRawPointer, UnsafeMutableRawPointer) -> Void
+) {
+  let syntax = try! Parser.parse(source: String(cString: buffer))
+//  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 {
-  let data: SyntaxData
+  public let data: SyntaxData
 
   public var _syntaxNode: Syntax {
     return self