Add Double and Int Convenience Properties (#239)

* Implements SR-11580

Author: vermont42

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/SyntaxBuilders.swift

@@ -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()

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -619,7 +619,7 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return ArrowExprSyntax(data)
   }
-  public static func makeFloatLiteralExpr(floatingDigits: TokenSyntax) -> FloatLiteralExprSyntax {
+  public static func makeFloatLiteralExpr(floatingDigits: TokenSyntax) -> FloatLiteralExprSyntax? {
     let layout: [RawSyntax?] = [
       floatingDigits.raw,
     ]
@@ -629,13 +629,6 @@ public enum SyntaxFactory {
     return FloatLiteralExprSyntax(data)
   }
 
-  public static func makeBlankFloatLiteralExpr() -> FloatLiteralExprSyntax {
-    let data = SyntaxData.forRoot(RawSyntax.create(kind: .floatLiteralExpr,
-      layout: [
-      RawSyntax.missingToken(TokenKind.floatingLiteral("")),
-    ], length: .zero, presence: .present))
-    return FloatLiteralExprSyntax(data)
-  }
   public static func makeTupleExpr(leftParen: TokenSyntax, elementList: TupleExprElementListSyntax, rightParen: TokenSyntax) -> TupleExprSyntax {
     let layout: [RawSyntax?] = [
       leftParen.raw,
@@ -764,7 +757,7 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return DictionaryElementSyntax(data)
   }
-  public static func makeIntegerLiteralExpr(digits: TokenSyntax) -> IntegerLiteralExprSyntax {
+  public static func makeIntegerLiteralExpr(digits: TokenSyntax) -> IntegerLiteralExprSyntax? {
     let layout: [RawSyntax?] = [
       digits.raw,
     ]
@@ -774,13 +767,6 @@ public enum SyntaxFactory {
     return IntegerLiteralExprSyntax(data)
   }
 
-  public static func makeBlankIntegerLiteralExpr() -> IntegerLiteralExprSyntax {
-    let data = SyntaxData.forRoot(RawSyntax.create(kind: .integerLiteralExpr,
-      layout: [
-      RawSyntax.missingToken(TokenKind.integerLiteral("")),
-    ], length: .zero, presence: .present))
-    return IntegerLiteralExprSyntax(data)
-  }
   public static func makeBooleanLiteralExpr(booleanLiteral: TokenSyntax) -> BooleanLiteralExprSyntax {
     let layout: [RawSyntax?] = [
       booleanLiteral.raw,

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -2128,7 +2128,8 @@ open class SyntaxRewriter {
 
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplFloatLiteralExprSyntax(_ data: SyntaxData) -> Syntax {
-      let node = FloatLiteralExprSyntax(data)
+      // 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 = FloatLiteralExprSyntax(data)!
       // Accessing _syntaxNode directly is faster than calling Syntax(node)
       visitPre(node._syntaxNode)
       defer { visitPost(node._syntaxNode) }
@@ -2198,7 +2199,8 @@ open class SyntaxRewriter {
 
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplIntegerLiteralExprSyntax(_ data: SyntaxData) -> Syntax {
-      let node = IntegerLiteralExprSyntax(data)
+      // 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 = IntegerLiteralExprSyntax(data)!
       // Accessing _syntaxNode directly is faster than calling Syntax(node)
       visitPre(node._syntaxNode)
       defer { visitPost(node._syntaxNode) }

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -2868,7 +2868,8 @@ open class SyntaxVisitor {
 
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplFloatLiteralExprSyntax(_ data: SyntaxData) {
-      let node = FloatLiteralExprSyntax(data)
+      // 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 = FloatLiteralExprSyntax(data)!
       let needsChildren = (visit(node) == .visitChildren)
       // Avoid calling into visitChildren if possible.
       if needsChildren && node.raw.numberOfChildren > 0 {
@@ -2945,7 +2946,8 @@ open class SyntaxVisitor {
 
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplIntegerLiteralExprSyntax(_ data: SyntaxData) {
-      let node = IntegerLiteralExprSyntax(data)
+      // 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 = IntegerLiteralExprSyntax(data)!
       let needsChildren = (visit(node) == .visitChildren)
       // Avoid calling into visitChildren if possible.
       if needsChildren && node.raw.numberOfChildren > 0 {