xxx

Author: hamishknight

include/swift/AST/CASTBridging.h

@@ -13,35 +13,47 @@ extension UnsafePointer {
 }
 
 enum ASTNode {
-  case decl(UnsafeMutableRawPointer)
-  case stmt(UnsafeMutableRawPointer)
-  case expr(UnsafeMutableRawPointer)
-  case type(UnsafeMutableRawPointer)
-  case misc(UnsafeMutableRawPointer)
+  case decl(BridgedDecl)
+  case stmt(BridgedStmt)
+  case expr(BridgedExpr)
+  case type(BridgedTypeRepr)
+
+  var castToExpr: BridgedExpr {
+    guard case .expr(let bridged) = self else {
+      fatalError("Expected an expr")
+    }
+    return bridged
+  }
 
-  var rawValue: UnsafeMutableRawPointer {
-    switch self {
-    case .decl(let ptr):
-      return ptr
-    case .stmt(let ptr):
-      return ptr
-    case .expr(let ptr):
-      return ptr
-    case .type(let ptr):
-      return ptr
-    case .misc(let ptr):
-      return ptr
+  var castToStmt: BridgedStmt {
+    guard case .stmt(let bridged) = self else {
+      fatalError("Expected a stmt")
+    }
+    return bridged
+  }
+
+  var castToDecl: BridgedDecl {
+    guard case .decl(let bridged) = self else {
+      fatalError("Expected a decl")
+    }
+    return bridged
+  }
+
+  var castToType: BridgedTypeRepr {
+    guard case .type(let bridged) = self else {
+      fatalError("Expected a type")
     }
+    return bridged
   }
 
   var bridged: BridgedASTNode {
     switch self {
     case .expr(let e):
-      return BridgedASTNode(ptr: e, kind: .expr)
+      return BridgedASTNode(ptr: e.ptr!, kind: .expr)
     case .stmt(let s):
-      return BridgedASTNode(ptr: s, kind: .stmt)
+      return BridgedASTNode(ptr: s.ptr!, kind: .stmt)
     case .decl(let d):
-      return BridgedASTNode(ptr: d, kind: .decl)
+      return BridgedASTNode(ptr: d.ptr!, kind: .decl)
     default:
       fatalError("Must be expr, stmt, or decl.")
     }
@@ -92,11 +104,11 @@ struct ASTGenVisitor {
       let swiftASTNodes = generate(element)
       switch swiftASTNodes {
       case .decl(let d):
-        out.append(d)
+        out.append(d.ptr!)
       case .stmt(let s):
-        out.append(TopLevelCodeDecl_createStmt(astContext: self.ctx, declContext: self.declContext, startLoc: loc, statement: s, endLoc: loc))
+        out.append(TopLevelCodeDecl_createStmt(astContext: self.ctx, declContext: self.declContext, startLoc: loc, statement: s, endLoc: loc).ptr!)
       case .expr(let e):
-        out.append(TopLevelCodeDecl_createExpr(astContext: self.ctx, declContext: self.declContext, startLoc: loc, expression: e, endLoc: loc))
+        out.append(TopLevelCodeDecl_createExpr(astContext: self.ctx, declContext: self.declContext, startLoc: loc, expression: e, endLoc: loc).ptr!)
       default:
         fatalError("Top level nodes must be decls, stmts, or exprs.")
       }
@@ -131,24 +143,24 @@ extension ASTGenVisitor {
 }
 
 extension ASTGenVisitor {
-  func generate(_ node: DeclSyntax) -> ASTNode {
-    return generate(Syntax(node))
+  func generate(_ node: DeclSyntax) -> BridgedDecl {
+    return generate(Syntax(node)).castToDecl
   }
 
-  func generate(_ node: ExprSyntax) -> ASTNode {
-    return generate(Syntax(node))
+  func generate(_ node: ExprSyntax) -> BridgedExpr {
+    return generate(Syntax(node)).castToExpr
   }
 
   func generate(_ node: PatternSyntax) -> ASTNode {
     return generate(Syntax(node))
   }
 
-  func generate(_ node: StmtSyntax) -> ASTNode {
-    return generate(Syntax(node))
+  func generate(_ node: StmtSyntax) -> BridgedStmt {
+    return generate(Syntax(node)).castToStmt
   }
 
-  func generate(_ node: TypeSyntax) -> ASTNode {
-    return generate(Syntax(node))
+  func generate(_ node: TypeSyntax) -> BridgedTypeRepr {
+    return generate(Syntax(node)).castToType
   }
 
   func generate(_ node: some SyntaxChildChoices) -> ASTNode {
@@ -160,23 +172,23 @@ extension ASTGenVisitor {
     case .actorDecl(let node):
       return generate(node)
     case .arrayElement(let node):
-      return generate(node)
+      return .expr(generate(node))
     case .arrayExpr(let node):
       return generate(node)
     case .arrayType(let node):
       return generate(node)
     case .associatedTypeDecl(let node):
       return generate(node)
     case .attributedType(let node):
-      return generate(node)
+      return .type(generate(node))
     case .booleanLiteralExpr(let node):
       return generate(node)
     case .classDecl(let node):
       return generate(node)
     case .closureExpr(let node):
       return generate(node)
     case .codeBlock(let node):
-      return generate(node)
+      return .stmt(generate(node))
     case .codeBlockItem(let node):
       return generate(node)
     case .compositionType(let node):
@@ -190,35 +202,19 @@ extension ASTGenVisitor {
     case .dictionaryType(let node):
       return generate(node)
     case .enumCaseDecl(let node):
-      return generate(node)
-    case .enumCaseElement(let node):
-      return generate(node)
-    case .enumCaseParameter(let node):
-      return generate(node)
-    case .enumCaseParameterClause(let node):
-      return generate(node)
+      return .decl(generate(node))
     case .enumDecl(let node):
       return generate(node)
     case .expressionStmt(let node):
-     return generate(node)
+      return .stmt(generate(node))
     case .extensionDecl(let node):
       return generate(node)
     case .functionCallExpr(let node):
       return generate(node)
     case .functionDecl(let node):
       return generate(node)
-    case .functionParameter(let node):
-      return generate(node)
-    case .functionParameterClause(let node):
-      return generate(node)
     case .functionType(let node):
       return generate(node)
-    case .genericParameter(let node):
-      return generate(node)
-    case .genericParameterClause(let node):
-      return generate(node)
-    case .genericWhereClause(let node):
-      return generate(node)
     case .identifierPattern(let node):
       return generate(node)
     case .identifierType(let node):
@@ -230,7 +226,7 @@ extension ASTGenVisitor {
     case .importDecl(let node):
       return generate(node)
     case .initializerClause(let node):
-      return generate(node)
+      return .expr(generate(node))
     case .initializerDecl(let node):
       return generate(node)
     case .integerLiteralExpr(let node):
@@ -240,7 +236,7 @@ extension ASTGenVisitor {
     case .memberAccessExpr(let node):
       return generate(node)
     case .memberBlockItem(let node):
-      return generate(node)
+      return .decl(generate(node))
     case .memberType(let node):
       return generate(node)
     case .metatypeType(let node):
@@ -260,15 +256,15 @@ extension ASTGenVisitor {
     case .protocolDecl(let node):
       return generate(node)
     case .returnStmt(let node):
-      return generate(node)
+      return .stmt(generate(node))
     case .someOrAnyType(let node):
       return generate(node)
     case .stringLiteralExpr(let node):
       return generate(node)
     case .structDecl(let node):
       return generate(node)
     case .tupleExpr(let node):
-      return generate(node)
+      return .expr(generate(node))
     case .tupleType(let node):
       return generate(node)
     case .typeAliasDecl(let node):
@@ -284,11 +280,11 @@ extension ASTGenVisitor {
 // Misc visits.
 // TODO: Some of these are called within a single file/method; we may want to move them to the respective files.
 extension ASTGenVisitor {
-  public func generate(_ node: MemberBlockItemSyntax) -> ASTNode {
+  public func generate(_ node: MemberBlockItemSyntax) -> BridgedDecl {
     generate(node.decl)
   }
 
-  public func generate(_ node: InitializerClauseSyntax) -> ASTNode {
+  public func generate(_ node: InitializerClauseSyntax) -> BridgedExpr {
     generate(node.value)
   }
 
@@ -300,7 +296,7 @@ extension ASTGenVisitor {
     generate(node.item)
   }
 
-  public func generate(_ node: ArrayElementSyntax) -> ASTNode {
+  public func generate(_ node: ArrayElementSyntax) -> BridgedExpr {
     generate(node.expression)
   }
 
@@ -314,18 +310,18 @@ extension ASTGenVisitor {
 // 'self.visit(<expr>)' recursion pattern between optional and non-optional inputs.
 extension ASTGenVisitor {
   @inline(__always)
-  func generate(_ node: TypeSyntax?) -> ASTNode? {
+  func generate(_ node: TypeSyntax?) -> BridgedTypeRepr {
     guard let node else {
-      return nil
+      return .init(ptr: nil)
     }
 
     return self.generate(node)
   }
 
   @inline(__always)
-  func generate(_ node: ExprSyntax?) -> ASTNode? {
+  func generate(_ node: ExprSyntax?) -> BridgedExpr {
     guard let node else {
-      return nil
+      return .init(ptr: nil)
     }
 
     return self.generate(node)
@@ -342,27 +338,27 @@ extension ASTGenVisitor {
   }
 
   @inline(__always)
-  func generate(_ node: GenericParameterClauseSyntax?) -> ASTNode? {
+  func generate(_ node: GenericParameterClauseSyntax?) -> BridgedGenericParamList {
     guard let node else {
-      return nil
+      return .init(ptr: nil)
     }
 
     return self.generate(node)
   }
 
   @inline(__always)
-  func generate(_ node: GenericWhereClauseSyntax?) -> ASTNode? {
+  func generate(_ node: GenericWhereClauseSyntax?) -> BridgedTrailingWhereClause {
     guard let node else {
-      return nil
+      return .init(ptr: nil)
     }
 
     return self.generate(node)
   }
 
   @inline(__always)
-  func generate(_ node: EnumCaseParameterClauseSyntax?) -> ASTNode? {
+  func generate(_ node: EnumCaseParameterClauseSyntax?) -> BridgedParameterList {
     guard let node else {
-      return nil
+      return .init(ptr: nil)
     }
 
     return self.generate(node)