Merge pull request swiftlang#189 from dan-zheng/transpose-attr

[AutoDiff upstream] Update gyb-generated files.

Author: akyrtzi

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -921,6 +921,12 @@ extension SyntaxNode {
     return DerivativeRegistrationAttributeArgumentsSyntax(asSyntaxData)
   }
 
+  public var isQualifiedDeclName: Bool { return raw.kind == .qualifiedDeclName }
+  public var asQualifiedDeclName: QualifiedDeclNameSyntax? {
+    guard isQualifiedDeclName else { return nil }
+    return QualifiedDeclNameSyntax(asSyntaxData)
+  }
+
   public var isFunctionDeclName: Bool { return raw.kind == .functionDeclName }
   public var asFunctionDeclName: FunctionDeclNameSyntax? {
     guard isFunctionDeclName else { return nil }
@@ -1729,6 +1735,8 @@ extension Syntax {
       return node
     case .derivativeRegistrationAttributeArguments(let node):
       return node
+    case .qualifiedDeclName(let node):
+      return node
     case .functionDeclName(let node):
       return node
     case .continueStmt(let node):
@@ -1896,6 +1904,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "3760114301864113995"
+      "-7765007021548643080"
   }
 }

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -1114,6 +1114,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: DerivativeRegistrationAttributeArgumentsSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: QualifiedDeclNameSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: QualifiedDeclNameSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: FunctionDeclNameSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -6548,8 +6548,8 @@ public struct DerivativeRegistrationAttributeArgumentsSyntaxBuilder {
     layout[idx] = node.raw
   }
 
-  public mutating func useOriginal(_ node: FunctionDeclNameSyntax) {
-    let idx = DerivativeRegistrationAttributeArgumentsSyntax.Cursor.original.rawValue
+  public mutating func useOriginalDeclName(_ node: QualifiedDeclNameSyntax) {
+    let idx = DerivativeRegistrationAttributeArgumentsSyntax.Cursor.originalDeclName.rawValue
     layout[idx] = node.raw
   }
 
@@ -6571,7 +6571,7 @@ public struct DerivativeRegistrationAttributeArgumentsSyntaxBuilder {
       layout[1] = RawSyntax.missingToken(TokenKind.colon)
     }
     if (layout[2] == nil) {
-      layout[2] = RawSyntax.missing(SyntaxKind.functionDeclName)
+      layout[2] = RawSyntax.missing(SyntaxKind.qualifiedDeclName)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .derivativeRegistrationAttributeArguments,
@@ -6596,6 +6596,59 @@ extension DerivativeRegistrationAttributeArgumentsSyntax {
   }
 }
 
+public struct QualifiedDeclNameSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 4)
+
+  internal init() {}
+
+  public mutating func useBaseType(_ node: TypeSyntax) {
+    let idx = QualifiedDeclNameSyntax.Cursor.baseType.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useDot(_ node: TokenSyntax) {
+    let idx = QualifiedDeclNameSyntax.Cursor.dot.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useName(_ node: TokenSyntax) {
+    let idx = QualifiedDeclNameSyntax.Cursor.name.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func useArguments(_ node: DeclNameArgumentsSyntax) {
+    let idx = QualifiedDeclNameSyntax.Cursor.arguments.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[2] == nil) {
+      layout[2] = RawSyntax.missingToken(TokenKind.identifier(""))
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .qualifiedDeclName,
+      layout: layout, presence: .present))
+  }
+}
+
+extension QualifiedDeclNameSyntax {
+  /// Creates a `QualifiedDeclNameSyntax` using the provided build function.
+  /// - Parameter:
+  ///   - build: A closure that wil be invoked in order to initialize
+  ///            the fields of the syntax node.
+  ///            This closure is passed a `QualifiedDeclNameSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `QualifiedDeclNameSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout QualifiedDeclNameSyntaxBuilder) -> Void) {
+    var builder = QualifiedDeclNameSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct FunctionDeclNameSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 2)

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -171,6 +171,7 @@ public enum SyntaxEnum {
   case differentiationParam(DifferentiationParamSyntax)
   case differentiableAttributeFuncSpecifier(DifferentiableAttributeFuncSpecifierSyntax)
   case derivativeRegistrationAttributeArguments(DerivativeRegistrationAttributeArgumentsSyntax)
+  case qualifiedDeclName(QualifiedDeclNameSyntax)
   case functionDeclName(FunctionDeclNameSyntax)
   case continueStmt(ContinueStmtSyntax)
   case whileStmt(WhileStmtSyntax)
@@ -571,6 +572,8 @@ public extension Syntax {
       return .differentiableAttributeFuncSpecifier(DifferentiableAttributeFuncSpecifierSyntax(self)!)
     case .derivativeRegistrationAttributeArguments:
       return .derivativeRegistrationAttributeArguments(DerivativeRegistrationAttributeArgumentsSyntax(self)!)
+    case .qualifiedDeclName:
+      return .qualifiedDeclName(QualifiedDeclNameSyntax(self)!)
     case .functionDeclName:
       return .functionDeclName(FunctionDeclNameSyntax(self)!)
     case .continueStmt:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -2993,11 +2993,11 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return DifferentiableAttributeFuncSpecifierSyntax(data)
   }
-  public static func makeDerivativeRegistrationAttributeArguments(ofLabel: TokenSyntax, colon: TokenSyntax, original: FunctionDeclNameSyntax, comma: TokenSyntax?, diffParams: DifferentiationParamsClauseSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax {
+  public static func makeDerivativeRegistrationAttributeArguments(ofLabel: TokenSyntax, colon: TokenSyntax, originalDeclName: QualifiedDeclNameSyntax, comma: TokenSyntax?, diffParams: DifferentiationParamsClauseSyntax?) -> DerivativeRegistrationAttributeArgumentsSyntax {
     let layout: [RawSyntax?] = [
       ofLabel.raw,
       colon.raw,
-      original.raw,
+      originalDeclName.raw,
       comma?.raw,
       diffParams?.raw,
     ]
@@ -3012,12 +3012,35 @@ public enum SyntaxFactory {
       layout: [
       RawSyntax.missingToken(TokenKind.identifier("")),
       RawSyntax.missingToken(TokenKind.colon),
-      RawSyntax.missing(SyntaxKind.functionDeclName),
+      RawSyntax.missing(SyntaxKind.qualifiedDeclName),
       nil,
       nil,
     ], length: .zero, presence: .present))
     return DerivativeRegistrationAttributeArgumentsSyntax(data)
   }
+  public static func makeQualifiedDeclName(baseType: TypeSyntax?, dot: TokenSyntax?, name: TokenSyntax, arguments: DeclNameArgumentsSyntax?) -> QualifiedDeclNameSyntax {
+    let layout: [RawSyntax?] = [
+      baseType?.raw,
+      dot?.raw,
+      name.raw,
+      arguments?.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.qualifiedDeclName,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return QualifiedDeclNameSyntax(data)
+  }
+
+  public static func makeBlankQualifiedDeclName() -> QualifiedDeclNameSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .qualifiedDeclName,
+      layout: [
+      nil,
+      nil,
+      RawSyntax.missingToken(TokenKind.identifier("")),
+      nil,
+    ], length: .zero, presence: .present))
+    return QualifiedDeclNameSyntax(data)
+  }
   public static func makeFunctionDeclName(name: Syntax, arguments: DeclNameArgumentsSyntax?) -> FunctionDeclNameSyntax {
     let layout: [RawSyntax?] = [
       name.raw,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -171,6 +171,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case differentiationParam = 237
   case differentiableAttributeFuncSpecifier = 238
   case derivativeRegistrationAttributeArguments = 241
+  case qualifiedDeclName = 242
   case functionDeclName = 239
   case continueStmt = 72
   case whileStmt = 73

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -1073,6 +1073,13 @@ open class SyntaxRewriter {
     return Syntax(visitChildren(node))
   }
 
+  /// Visit a `QualifiedDeclNameSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: QualifiedDeclNameSyntax) -> Syntax {
+    return Syntax(visitChildren(node))
+  }
+
   /// Visit a `FunctionDeclNameSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3224,6 +3231,16 @@ open class SyntaxRewriter {
       return visit(node)
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplQualifiedDeclNameSyntax(_ data: SyntaxData) -> Syntax {
+      let node = QualifiedDeclNameSyntax(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 visitImplFunctionDeclNameSyntax(_ data: SyntaxData) -> Syntax {
       let node = FunctionDeclNameSyntax(data)
@@ -4355,6 +4372,8 @@ open class SyntaxRewriter {
       return visitImplDifferentiableAttributeFuncSpecifierSyntax(data)
     case .derivativeRegistrationAttributeArguments:
       return visitImplDerivativeRegistrationAttributeArgumentsSyntax(data)
+    case .qualifiedDeclName:
+      return visitImplQualifiedDeclNameSyntax(data)
     case .functionDeclName:
       return visitImplFunctionDeclNameSyntax(data)
     case .continueStmt:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -1532,6 +1532,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `DerivativeRegistrationAttributeArgumentsSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: DerivativeRegistrationAttributeArgumentsSyntax) {}
+  /// Visiting `QualifiedDeclNameSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: QualifiedDeclNameSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `QualifiedDeclNameSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: QualifiedDeclNameSyntax) {}
   /// Visiting `FunctionDeclNameSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4060,6 +4070,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplQualifiedDeclNameSyntax(_ data: SyntaxData) {
+      let node = QualifiedDeclNameSyntax(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 visitImplFunctionDeclNameSyntax(_ data: SyntaxData) {
       let node = FunctionDeclNameSyntax(data)
@@ -5270,6 +5291,8 @@ open class SyntaxVisitor {
       visitImplDifferentiableAttributeFuncSpecifierSyntax(data)
     case .derivativeRegistrationAttributeArguments:
       visitImplDerivativeRegistrationAttributeArgumentsSyntax(data)
+    case .qualifiedDeclName:
+      visitImplQualifiedDeclNameSyntax(data)
     case .functionDeclName:
       visitImplFunctionDeclNameSyntax(data)
     case .continueStmt: