Merge pull request swiftlang#242 from rintaro/revert-pr238

Revert "Add Double and Int Convenience Properties (swiftlang#239)"

Author: rintaro

Changelog.md

@@ -4,8 +4,6 @@ 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 build SwiftSyntax while building the Swift compiler using Xcode.
+Note that it is not currently supported to SwiftSyntax while building the Swift compiler using Xcode.
 
 ### CI Testing
 

Sources/SwiftSyntax/SyntaxBuilders.swift.gyb

@@ -85,11 +85,7 @@ 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

@@ -57,11 +57,7 @@ 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:
@@ -86,7 +82,7 @@ public enum SyntaxFactory {
   }
 %   end
 
-%   if not node.is_base() and not node.must_uphold_invariant:
+%   if not node.is_base():
   public static func makeBlank${node.syntax_kind}() -> ${node.name} {
     let data = SyntaxData.forRoot(RawSyntax.create(kind: .${node.swift_syntax_kind},
       layout: [

Sources/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -70,29 +70,14 @@ 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 {
@@ -122,33 +107,10 @@ 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
@@ -187,11 +149,7 @@ 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/SyntaxNodes.swift.gyb.template

@@ -91,12 +91,7 @@ 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/SyntaxRewriter.swift.gyb

@@ -86,12 +86,7 @@ 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/SyntaxVisitor.swift.gyb

@@ -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/SyntaxBuilders.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,6 +629,13 @@ 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,
@@ -757,7 +764,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,
     ]
@@ -767,6 +774,13 @@ 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/SyntaxFactory.swift

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

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

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