Add Double and Int Convenience Properties

Changelog.md

@@ -4,6 +4,8 @@ Note: This is in reverse chronological order, so newer entries are added to the
 
 ## Swift 5.3
 
+* Introduced `integerValue` and `floatingValue` properties to `IntegerLiteralExprSyntax` and `FloatLiteralExprSyntax`, respectively. Converted their `digits` and `floatingDigits` setters, respectively, into throwing functions.
+
 * Introduced `FunctionCallExprSyntax.additionalTrailingClosures` property with type `MultipleTrailingClosureElementListSyntax?` for supporting [SE-0279 Multiple Trailing Closures](https://github.com/apple/swift-evolution/blob/master/proposals/0279-multiple-trailing-closures.md).
 
 * Introduced `syntaxNodeType` property for all types conforming to `SyntaxProtocol`, which returns the underlying syntax node type. It is primarily intended as a debugging aid during development.

README.md

@@ -181,7 +181,7 @@ swift/utils/build-script --swiftsyntax --swiftpm --llbuild -t --skip-test-cmark
 ```
 This command will build SwiftSyntax and all its dependencies, tell the build script to run tests, but skip all tests but the SwiftSyntax tests.
 
-Note that it is not currently supported to SwiftSyntax while building the Swift compiler using Xcode.
+Note that it is not currently supported to build SwiftSyntax while building the Swift compiler using Xcode.
 
 ### CI Testing
 

Sources/SwiftSyntax/SyntaxBuilders.swift.gyb

@@ -85,7 +85,11 @@ extension ${node.name} {
   ///            incrementally build the structure of the node.
   /// - Returns: A `${node.name}` with all the fields populated in the builder
   ///            closure.
+%     if node.must_uphold_invariant:
+  public init?(_ build: (inout ${Builder}) -> Void) {
+%     else:
   public init(_ build: (inout ${Builder}) -> Void) {
+%     end
     var builder = ${Builder}()
     build(&builder)
     let data = builder.buildData()

Sources/SwiftSyntax/SyntaxConvenienceMethods.swift

@@ -0,0 +1,80 @@
+//===- SyntaxConvenienceMethods.swift - Convenience funcs for syntax nodes ===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+public extension FloatLiteralExprSyntax {
+  var floatingValue: Double {
+    return potentialFloatingValue!
+  }
+
+  fileprivate var potentialFloatingValue: Double? {
+    let floatingDigitsWithoutUnderscores = floatingDigits.text.filter {
+      $0 != "_"
+    }
+    return Double(floatingDigitsWithoutUnderscores)
+  }
+}
+
+public extension IntegerLiteralExprSyntax {
+  var integerValue: Int {
+    return potentialIntegerValue!
+  }
+
+  fileprivate var potentialIntegerValue: Int? {
+    let text = digits.text
+    let (prefixLength, radix) = IntegerLiteralExprSyntax.prefixLengthAndRadix(text: text)
+    let digitsStartIndex = text.index(text.startIndex, offsetBy: prefixLength)
+    let textWithoutPrefix = text.suffix(from: digitsStartIndex)
+
+    let textWithoutPrefixOrUnderscores = textWithoutPrefix.filter {
+      $0 != "_"
+    }
+
+    return Int(textWithoutPrefixOrUnderscores, radix: radix)
+  }
+
+  private static func prefixLengthAndRadix(text: String) -> (Int, Int) {
+    let nonDecimalPrefixLength = 2
+
+    let binaryPrefix = "0b"
+    let octalPrefix = "0o"
+    let decimalPrefix = ""
+    let hexadecimalPrefix = "0x"
+
+    let binaryRadix = 2
+    let octalRadix = 8
+    let decimalRadix = 10
+    let hexadecimalRadix = 16
+
+    switch String(text.prefix(nonDecimalPrefixLength)) {
+    case binaryPrefix:
+      return (binaryPrefix.count, binaryRadix)
+    case octalPrefix:
+      return (octalPrefix.count, octalRadix)
+    case hexadecimalPrefix:
+      return (hexadecimalPrefix.count, hexadecimalRadix)
+    default:
+      return (decimalPrefix.count, decimalRadix)
+    }
+  }
+}
+
+public extension IntegerLiteralExprSyntax {
+  var isValid: Bool {
+    potentialIntegerValue != nil
+  }
+}
+
+public extension FloatLiteralExprSyntax {
+  var isValid: Bool {
+    potentialFloatingValue != nil
+  }
+}

Sources/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -57,7 +57,11 @@ public enum SyntaxFactory {
 %            param_type = param_type + "?"
 %         child_params.append("%s: %s" % (child.swift_name, param_type))
 %     child_params = ', '.join(child_params)
+%     if node.must_uphold_invariant:
+  public static func make${node.syntax_kind}(${child_params}) -> ${node.name}? {
+%     else:
   public static func make${node.syntax_kind}(${child_params}) -> ${node.name} {
+%     end
     let layout: [RawSyntax?] = [
 %     for child in node.children:
 %       if child.is_optional:
@@ -82,7 +86,7 @@ public enum SyntaxFactory {
   }
 %   end
 
-%   if not node.is_base():
+%   if not node.is_base() and not node.must_uphold_invariant:
   public static func makeBlank${node.syntax_kind}() -> ${node.name} {
     let data = SyntaxData.forRoot(RawSyntax.create(kind: .${node.swift_syntax_kind},
       layout: [

Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template

@@ -70,14 +70,29 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
   public init?(_ syntax: Syntax) {
     guard syntax.raw.kind == .${node.swift_syntax_kind} else { return nil }
     self._syntaxNode = syntax
+%   if node.must_uphold_invariant:
+    if !isValid {
+      fatalError("Instance of ${node.name} is invalid.")
+    }
+%   end
   }
 
   /// Creates a `${node.name}` node from the given `SyntaxData`. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
+%   if node.must_uphold_invariant:
+  /// This initializer returns nil if the invariant is not satisfied.
+  internal init?(_ data: SyntaxData) {
+%   else:
   internal init(_ data: SyntaxData) {
+%   end
     assert(data.raw.kind == .${node.swift_syntax_kind})
     self._syntaxNode = Syntax(data)
+%   if node.must_uphold_invariant:
+    if !isValid {
+      return nil
+    }
+%   end
   }
 
   public var syntaxNodeType: SyntaxProtocol.Type {
@@ -107,10 +122,33 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
 %       end
       return ${child.type_name}(childData!)
     }
+%       if not node.must_uphold_invariant:
     set(value) {
       self = with${child.name}(value)
     }
+%       end
+  }
+%       if node.must_uphold_invariant:
+
+  public enum ${child.name}Error: Error, CustomStringConvertible {
+    case invalid(${child.swift_name}: ${ret_type})
+
+    public var description: String {
+      switch self {
+      case .invalid(let ${child.swift_name}):
+        return "attempted to use setter with invalid ${child.name} \"\(${child.swift_name})\""
+      }
+    }
   }
+
+  mutating public func set${child.name}(_ ${child.swift_name}: ${ret_type}) throws {
+    if let childSyntax = with${child.name}(${child.swift_name}) {
+      self = childSyntax
+    } else {
+      throw ${child.name}Error.invalid(${child.swift_name}: ${child.swift_name})
+    }
+  }
+%       end
 %
 %       # ===============
 %       # Adding children
@@ -149,7 +187,11 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
   /// - param newChild: The new `${child.swift_name}` to replace the node's
   ///                   current `${child.swift_name}`, if present.
   public func with${child.name}(
+%       if node.must_uphold_invariant:
+    _ newChild: ${child.type_name}?) -> ${node.name}? {
+%       else:
     _ newChild: ${child.type_name}?) -> ${node.name} {
+%       end
 %       if child.is_optional:
     let raw = newChild?.raw
 %       else:

Sources/SwiftSyntax/SyntaxRewriter.swift.gyb

@@ -91,7 +91,12 @@ open class SyntaxRewriter {
       if let newNode = visitAny(node._syntaxNode) { return newNode }
       return Syntax(visit(node))
 %   else:
+%     if node.must_uphold_invariant:
+      // We know that the SyntaxData is valid since we are walking a valid syntax tree and haven't modified the syntax data. Thus the initializer below will never return nil.
+      let node = ${node.name}(data)!
+%     else:
       let node = ${node.name}(data)
+%     end
       // Accessing _syntaxNode directly is faster than calling Syntax(node)
       visitPre(node._syntaxNode)
       defer { visitPost(node._syntaxNode) }

Sources/SwiftSyntax/SyntaxVisitor.swift.gyb

@@ -86,7 +86,12 @@ open class SyntaxVisitor {
       }
       visitPost(node)
 %   else:
+%     if node.must_uphold_invariant:
+      // We know that the SyntaxData is valid since we are walking a valid syntax tree and haven't modified the syntax data. Thus the initializer below will never return nil.
+      let node = ${node.name}(data)!
+%     else:
       let node = ${node.name}(data)
+%     end
       let needsChildren = (visit(node) == .visitChildren)
       // Avoid calling into visitChildren if possible.
       if needsChildren && node.raw.numberOfChildren > 0 {

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -1944,6 +1944,6 @@ extension Syntax {
 extension SyntaxParser {
   static func verifyNodeDeclarationHash() -> Bool {
     return String(cString: swiftparse_syntax_structure_versioning_identifier()!) ==
-      "26709743ccc5ea2001419f44996c8fa671901c03"
+      "fd719aaf2e0dab2620af2d4d123d123b3d0de28d"
   }
 }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -274,7 +274,7 @@ public struct AwaitExprSyntaxBuilder {
 
   internal mutating func buildData() -> SyntaxData {
     if (layout[0] == nil) {
-      layout[0] = RawSyntax.missingToken(TokenKind.identifier(""))
+      layout[0] = RawSyntax.missingToken(TokenKind.awaitKeyword)
     }
     if (layout[1] == nil) {
       layout[1] = RawSyntax.missing(SyntaxKind.expr)
@@ -1077,7 +1077,7 @@ extension FloatLiteralExprSyntax {
   ///            incrementally build the structure of the node.
   /// - Returns: A `FloatLiteralExprSyntax` with all the fields populated in the builder
   ///            closure.
-  public init(_ build: (inout FloatLiteralExprSyntaxBuilder) -> Void) {
+  public init?(_ build: (inout FloatLiteralExprSyntaxBuilder) -> Void) {
     var builder = FloatLiteralExprSyntaxBuilder()
     build(&builder)
     let data = builder.buildData()
@@ -1444,7 +1444,7 @@ extension IntegerLiteralExprSyntax {
   ///            incrementally build the structure of the node.
   /// - Returns: A `IntegerLiteralExprSyntax` with all the fields populated in the builder
   ///            closure.
-  public init(_ build: (inout IntegerLiteralExprSyntaxBuilder) -> Void) {
+  public init?(_ build: (inout IntegerLiteralExprSyntaxBuilder) -> Void) {
     var builder = IntegerLiteralExprSyntaxBuilder()
     build(&builder)
     let data = builder.buildData()
@@ -1917,7 +1917,7 @@ extension ClosureParamSyntax {
 
 public struct ClosureSignatureSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 6)
+    Array<RawSyntax?>(repeating: nil, count: 5)
 
   internal init() {}
 
@@ -1931,11 +1931,6 @@ public struct ClosureSignatureSyntaxBuilder {
     layout[idx] = node.raw
   }
 
-  public mutating func useAsyncKeyword(_ node: TokenSyntax) {
-    let idx = ClosureSignatureSyntax.Cursor.asyncKeyword.rawValue
-    layout[idx] = node.raw
-  }
-
   public mutating func useThrowsTok(_ node: TokenSyntax) {
     let idx = ClosureSignatureSyntax.Cursor.throwsTok.rawValue
     layout[idx] = node.raw
@@ -1952,8 +1947,8 @@ public struct ClosureSignatureSyntaxBuilder {
   }
 
   internal mutating func buildData() -> SyntaxData {
-    if (layout[5] == nil) {
-      layout[5] = RawSyntax.missingToken(TokenKind.inKeyword)
+    if (layout[4] == nil) {
+      layout[4] = RawSyntax.missingToken(TokenKind.inKeyword)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .closureSignature,

Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift

@@ -65,16 +65,8 @@ extension SyntaxClassification {
     // Separate checks for token nodes (most common checks) versus checks for layout nodes.
     if childKind == .token {
       switch (parentKind, indexInParent) {
-      case (.awaitExpr, 0):
-        return (.keyword, false)
-      case (.arrowExpr, 0):
-        return (.keyword, false)
-      case (.closureSignature, 2):
-        return (.keyword, false)
       case (.expressionSegment, 2):
         return (.stringInterpolationAnchor, true)
-      case (.functionSignature, 1):
-        return (.keyword, false)
       case (.ifConfigClause, 0):
         return (.buildConfigId, false)
       case (.ifConfigDecl, 1):
@@ -93,8 +85,6 @@ extension SyntaxClassification {
         return (.typeIdentifier, false)
       case (.someType, 0):
         return (.keyword, false)
-      case (.functionType, 3):
-        return (.keyword, false)
       case (.availabilityVersionRestriction, 0):
         return (.keyword, false)
       default: return nil
@@ -222,6 +212,8 @@ extension RawTokenKind {
       return .keyword
     case .throwsKeyword:
       return .keyword
+    case .awaitKeyword:
+      return .keyword
     case .__file__Keyword:
       return .keyword
     case .__line__Keyword: