Merge pull request #537 from CodaFi/aligned-alloc

Add Layout Requirements To AST

Author: CodaFi

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -1285,6 +1285,12 @@ extension SyntaxNode {
     return SameTypeRequirementSyntax(asSyntaxData)
   }
 
+  public var isLayoutRequirement: Bool { return raw.kind == .layoutRequirement }
+  public var asLayoutRequirement: LayoutRequirementSyntax? {
+    guard isLayoutRequirement else { return nil }
+    return LayoutRequirementSyntax(asSyntaxData)
+  }
+
   public var isGenericParameterList: Bool { return raw.kind == .genericParameterList }
   public var asGenericParameterList: GenericParameterListSyntax? {
     guard isGenericParameterList else { return nil }
@@ -1989,6 +1995,8 @@ extension Syntax {
       return node
     case .sameTypeRequirement(let node):
       return node
+    case .layoutRequirement(let node):
+      return node
     case .genericParameterList(let node):
       return node
     case .genericParameter(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -1541,6 +1541,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: SameTypeRequirementSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: LayoutRequirementSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: LayoutRequirementSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: GenericParameterListSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -9227,6 +9227,85 @@ extension SameTypeRequirementSyntax {
   }
 }
 
+public struct LayoutRequirementSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 8)
+
+  internal init() {}
+
+  public mutating func useTypeIdentifier(_ node: TypeSyntax) {
+    let idx = LayoutRequirementSyntax.Cursor.typeIdentifier.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useColon(_ node: TokenSyntax) {
+    let idx = LayoutRequirementSyntax.Cursor.colon.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useLayoutConstraint(_ node: TokenSyntax) {
+    let idx = LayoutRequirementSyntax.Cursor.layoutConstraint.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useLeftParen(_ node: TokenSyntax) {
+    let idx = LayoutRequirementSyntax.Cursor.leftParen.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useSize(_ node: TokenSyntax) {
+    let idx = LayoutRequirementSyntax.Cursor.size.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useComma(_ node: TokenSyntax) {
+    let idx = LayoutRequirementSyntax.Cursor.comma.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useAlignment(_ node: TokenSyntax) {
+    let idx = LayoutRequirementSyntax.Cursor.alignment.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useRightParen(_ node: TokenSyntax) {
+    let idx = LayoutRequirementSyntax.Cursor.rightParen.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missing(SyntaxKind.missingType)
+    }
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missingToken(TokenKind.colon)
+    }
+    if (layout[2] == nil) {
+      layout[2] = RawSyntax.missingToken(TokenKind.identifier(""))
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .layoutRequirement,
+      layout: layout, presence: .present))
+  }
+}
+
+extension LayoutRequirementSyntax {
+  /// Creates a `LayoutRequirementSyntax` using the provided build function.
+  /// - Parameter:
+  ///   - build: A closure that will be invoked in order to initialize
+  ///            the fields of the syntax node.
+  ///            This closure is passed a `LayoutRequirementSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `LayoutRequirementSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout LayoutRequirementSyntaxBuilder) -> Void) {
+    var builder = LayoutRequirementSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct GenericParameterSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 5)

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -227,6 +227,7 @@ public enum SyntaxEnum {
   case genericRequirementList(GenericRequirementListSyntax)
   case genericRequirement(GenericRequirementSyntax)
   case sameTypeRequirement(SameTypeRequirementSyntax)
+  case layoutRequirement(LayoutRequirementSyntax)
   case genericParameterList(GenericParameterListSyntax)
   case genericParameter(GenericParameterSyntax)
   case primaryAssociatedTypeList(PrimaryAssociatedTypeListSyntax)
@@ -703,6 +704,8 @@ public extension Syntax {
       return .genericRequirement(GenericRequirementSyntax(self)!)
     case .sameTypeRequirement:
       return .sameTypeRequirement(SameTypeRequirementSyntax(self)!)
+    case .layoutRequirement:
+      return .layoutRequirement(LayoutRequirementSyntax(self)!)
     case .genericParameterList:
       return .genericParameterList(GenericParameterListSyntax(self)!)
     case .genericParameter:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -4195,6 +4195,37 @@ public enum SyntaxFactory {
     ], length: .zero, presence: presence))
     return SameTypeRequirementSyntax(data)
   }
+  public static func makeLayoutRequirement(typeIdentifier: TypeSyntax, colon: TokenSyntax, layoutConstraint: TokenSyntax, leftParen: TokenSyntax?, size: TokenSyntax?, comma: TokenSyntax?, alignment: TokenSyntax?, rightParen: TokenSyntax?) -> LayoutRequirementSyntax {
+    let layout: [RawSyntax?] = [
+      typeIdentifier.raw,
+      colon.raw,
+      layoutConstraint.raw,
+      leftParen?.raw,
+      size?.raw,
+      comma?.raw,
+      alignment?.raw,
+      rightParen?.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.layoutRequirement,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return LayoutRequirementSyntax(data)
+  }
+
+  public static func makeBlankLayoutRequirement(presence: SourcePresence = .present) -> LayoutRequirementSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .layoutRequirement,
+      layout: [
+      RawSyntax.missing(SyntaxKind.missingType),
+      RawSyntax.missingToken(TokenKind.colon),
+      RawSyntax.missingToken(TokenKind.identifier("")),
+      nil,
+      nil,
+      nil,
+      nil,
+      nil,
+    ], length: .zero, presence: presence))
+    return LayoutRequirementSyntax(data)
+  }
   public static func makeGenericParameterList(
     _ elements: [GenericParameterSyntax]) -> GenericParameterListSyntax {
     let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.genericParameterList,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -227,6 +227,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case genericRequirementList = 194
   case genericRequirement = 232
   case sameTypeRequirement = 149
+  case layoutRequirement = 164
   case genericParameterList = 195
   case genericParameter = 150
   case primaryAssociatedTypeList = 254

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -1500,6 +1500,13 @@ open class SyntaxRewriter {
     return Syntax(visitChildren(node))
   }
 
+  /// Visit a `LayoutRequirementSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: LayoutRequirementSyntax) -> Syntax {
+    return Syntax(visitChildren(node))
+  }
+
   /// Visit a `GenericParameterListSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -4009,6 +4016,16 @@ open class SyntaxRewriter {
       return visit(node)
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplLayoutRequirementSyntax(_ data: SyntaxData) -> Syntax {
+      let node = LayoutRequirementSyntax(data)
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
+      return visit(node)
+  }
+
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplGenericParameterListSyntax(_ data: SyntaxData) -> Syntax {
       let node = GenericParameterListSyntax(data)
@@ -4923,6 +4940,8 @@ open class SyntaxRewriter {
       return visitImplGenericRequirementSyntax
     case .sameTypeRequirement:
       return visitImplSameTypeRequirementSyntax
+    case .layoutRequirement:
+      return visitImplLayoutRequirementSyntax
     case .genericParameterList:
       return visitImplGenericParameterListSyntax
     case .genericParameter:
@@ -5448,6 +5467,8 @@ open class SyntaxRewriter {
       return visitImplGenericRequirementSyntax(data)
     case .sameTypeRequirement:
       return visitImplSameTypeRequirementSyntax(data)
+    case .layoutRequirement:
+      return visitImplLayoutRequirementSyntax(data)
     case .genericParameterList:
       return visitImplGenericParameterListSyntax(data)
     case .genericParameter:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -2151,6 +2151,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `SameTypeRequirementSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: SameTypeRequirementSyntax) {}
+  /// Visiting `LayoutRequirementSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: LayoutRequirementSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `LayoutRequirementSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: LayoutRequirementSyntax) {}
   /// Visiting `GenericParameterListSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4990,6 +5000,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplLayoutRequirementSyntax(_ data: SyntaxData) {
+      let node = LayoutRequirementSyntax(data)
+      let needsChildren = (visit(node) == .visitChildren)
+      // Avoid calling into visitChildren if possible.
+      if needsChildren && node.raw.numberOfChildren > 0 {
+        visitChildren(node)
+      }
+      visitPost(node)
+  }
+
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplGenericParameterListSyntax(_ data: SyntaxData) {
       let node = GenericParameterListSyntax(data)
@@ -5916,6 +5937,8 @@ open class SyntaxVisitor {
       visitImplGenericRequirementSyntax(data)
     case .sameTypeRequirement:
       visitImplSameTypeRequirementSyntax(data)
+    case .layoutRequirement:
+      visitImplLayoutRequirementSyntax(data)
     case .genericParameterList:
       visitImplGenericParameterListSyntax(data)
     case .genericParameter: