diff --git a/Changelog.md b/Changelog.md
index f62c1d6b6fd..4abf4117a8e 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -4,7 +4,7 @@ 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 `integerLiteralValue` and `floatLiteralValue` properties to `IntegerLiteralExprSyntax` and `FloatLiteralExprSyntax`, respectively.
 
 * 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).
 
diff --git a/Sources/SwiftSyntax/SyntaxBuilders.swift.gyb b/Sources/SwiftSyntax/SyntaxBuilders.swift.gyb
index 48889b61099..426f91977f3 100644
--- a/Sources/SwiftSyntax/SyntaxBuilders.swift.gyb
+++ b/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()
diff --git a/Sources/SwiftSyntax/SyntaxConvenienceMethods.swift b/Sources/SwiftSyntax/SyntaxConvenienceMethods.swift
index 0b52b1f6ff9..12a10f995f9 100644
--- a/Sources/SwiftSyntax/SyntaxConvenienceMethods.swift
+++ b/Sources/SwiftSyntax/SyntaxConvenienceMethods.swift
@@ -11,24 +11,20 @@
 //===----------------------------------------------------------------------===//
 
 public extension FloatLiteralExprSyntax {
-  var floatingValue: Double {
-    return potentialFloatingValue!
-  }
-
-  fileprivate var potentialFloatingValue: Double? {
+  var floatLiteralValue: Double? {
     let floatingDigitsWithoutUnderscores = floatingDigits.text.filter {
       $0 != "_"
     }
     return Double(floatingDigitsWithoutUnderscores)
   }
-}
 
-public extension IntegerLiteralExprSyntax {
-  var integerValue: Int {
-    return potentialIntegerValue!
+  var isValid: Bool {
+    floatLiteralValue != nil
   }
+}
 
-  fileprivate var potentialIntegerValue: Int? {
+public extension IntegerLiteralExprSyntax {
+  var integerLiteralValue: Int? {
     let text = digits.text
     let (prefixLength, radix) = IntegerLiteralExprSyntax.prefixLengthAndRadix(text: text)
     let digitsStartIndex = text.index(text.startIndex, offsetBy: prefixLength)
@@ -65,16 +61,8 @@ public extension IntegerLiteralExprSyntax {
       return (decimalPrefix.count, decimalRadix)
     }
   }
-}
 
-public extension IntegerLiteralExprSyntax {
-  var isValid: Bool {
-    potentialIntegerValue != nil
-  }
-}
-
-public extension FloatLiteralExprSyntax {
   var isValid: Bool {
-    potentialFloatingValue != nil
+    integerLiteralValue != nil
   }
 }
diff --git a/Sources/SwiftSyntax/SyntaxFactory.swift.gyb b/Sources/SwiftSyntax/SyntaxFactory.swift.gyb
index 35cd7ed9c3c..4a31c33a44e 100644
--- a/Sources/SwiftSyntax/SyntaxFactory.swift.gyb
+++ b/Sources/SwiftSyntax/SyntaxFactory.swift.gyb
@@ -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: [
diff --git a/Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template b/Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template
index 267065022e1..4766e761d3c 100644
--- a/Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template
+++ b/Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template
@@ -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:
diff --git a/Sources/SwiftSyntax/SyntaxRewriter.swift.gyb b/Sources/SwiftSyntax/SyntaxRewriter.swift.gyb
index 1e8275a009f..1aa326e8d6c 100644
--- a/Sources/SwiftSyntax/SyntaxRewriter.swift.gyb
+++ b/Sources/SwiftSyntax/SyntaxRewriter.swift.gyb
@@ -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) }
diff --git a/Sources/SwiftSyntax/SyntaxVisitor.swift.gyb b/Sources/SwiftSyntax/SyntaxVisitor.swift.gyb
index 781bf9ceb10..d962e90e427 100644
--- a/Sources/SwiftSyntax/SyntaxVisitor.swift.gyb
+++ b/Sources/SwiftSyntax/SyntaxVisitor.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 {
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift
index 84079e8af10..0fe467844fe 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift
+++ b/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()
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift
index dd410d280c2..d828aec3706 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift
+++ b/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,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,
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift
index 85d120e502f..8ac04abf2ec 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift
@@ -2128,8 +2128,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) }
@@ -2199,8 +2198,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) }
diff --git a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift
index def8457b19d..23e78d755ce 100644
--- a/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift
+++ b/Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift
@@ -2868,8 +2868,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 {
@@ -2946,8 +2945,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 {
diff --git a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift
index 6c040c30974..eb1de7a60a9 100644
--- a/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift
+++ b/Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxExprNodes.swift
@@ -1833,21 +1833,14 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public init?(_ syntax: Syntax) {
     guard syntax.raw.kind == .floatLiteralExpr else { return nil }
     self._syntaxNode = syntax
-    if !isValid {
-      fatalError("Instance of FloatLiteralExprSyntax is invalid.")
-    }
   }
 
   /// Creates a `FloatLiteralExprSyntax` node from the given `SyntaxData`. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
-  /// This initializer returns nil if the invariant is not satisfied.
-  internal init?(_ data: SyntaxData) {
+  internal init(_ data: SyntaxData) {
     assert(data.raw.kind == .floatLiteralExpr)
     self._syntaxNode = Syntax(data)
-    if !isValid {
-      return nil
-    }
   }
 
   public var syntaxNodeType: SyntaxProtocol.Type {
@@ -1860,24 +1853,8 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
                                  parent: Syntax(self))
       return TokenSyntax(childData!)
     }
-  }
-
-  public enum FloatingDigitsError: Error, CustomStringConvertible {
-    case invalid(floatingDigits: TokenSyntax)
-
-    public var description: String {
-      switch self {
-      case .invalid(let floatingDigits):
-        return "attempted to use setter with invalid FloatingDigits \"\(floatingDigits)\""
-      }
-    }
-  }
-
-  mutating public func setFloatingDigits(_ floatingDigits: TokenSyntax) throws {
-    if let childSyntax = withFloatingDigits(floatingDigits) {
-      self = childSyntax
-    } else {
-      throw FloatingDigitsError.invalid(floatingDigits: floatingDigits)
+    set(value) {
+      self = withFloatingDigits(value)
     }
   }
 
@@ -1885,7 +1862,7 @@ public struct FloatLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   /// - param newChild: The new `floatingDigits` to replace the node's
   ///                   current `floatingDigits`, if present.
   public func withFloatingDigits(
-    _ newChild: TokenSyntax?) -> FloatLiteralExprSyntax? {
+    _ newChild: TokenSyntax?) -> FloatLiteralExprSyntax {
     let raw = newChild?.raw ?? RawSyntax.missingToken(TokenKind.floatingLiteral(""))
     let newData = data.replacingChild(raw, at: Cursor.floatingDigits)
     return FloatLiteralExprSyntax(newData)
@@ -2378,21 +2355,14 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public init?(_ syntax: Syntax) {
     guard syntax.raw.kind == .integerLiteralExpr else { return nil }
     self._syntaxNode = syntax
-    if !isValid {
-      fatalError("Instance of IntegerLiteralExprSyntax is invalid.")
-    }
   }
 
   /// Creates a `IntegerLiteralExprSyntax` node from the given `SyntaxData`. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
-  /// This initializer returns nil if the invariant is not satisfied.
-  internal init?(_ data: SyntaxData) {
+  internal init(_ data: SyntaxData) {
     assert(data.raw.kind == .integerLiteralExpr)
     self._syntaxNode = Syntax(data)
-    if !isValid {
-      return nil
-    }
   }
 
   public var syntaxNodeType: SyntaxProtocol.Type {
@@ -2405,24 +2375,8 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
                                  parent: Syntax(self))
       return TokenSyntax(childData!)
     }
-  }
-
-  public enum DigitsError: Error, CustomStringConvertible {
-    case invalid(digits: TokenSyntax)
-
-    public var description: String {
-      switch self {
-      case .invalid(let digits):
-        return "attempted to use setter with invalid Digits \"\(digits)\""
-      }
-    }
-  }
-
-  mutating public func setDigits(_ digits: TokenSyntax) throws {
-    if let childSyntax = withDigits(digits) {
-      self = childSyntax
-    } else {
-      throw DigitsError.invalid(digits: digits)
+    set(value) {
+      self = withDigits(value)
     }
   }
 
@@ -2430,7 +2384,7 @@ public struct IntegerLiteralExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   /// - param newChild: The new `digits` to replace the node's
   ///                   current `digits`, if present.
   public func withDigits(
-    _ newChild: TokenSyntax?) -> IntegerLiteralExprSyntax? {
+    _ newChild: TokenSyntax?) -> IntegerLiteralExprSyntax {
     let raw = newChild?.raw ?? RawSyntax.missingToken(TokenKind.integerLiteral(""))
     let newData = data.replacingChild(raw, at: Cursor.digits)
     return IntegerLiteralExprSyntax(newData)
diff --git a/Sources/SwiftSyntaxBuilder/ExprBuildables.swift b/Sources/SwiftSyntaxBuilder/ExprBuildables.swift
index 7f5315b2ca7..26ae9c3ca53 100644
--- a/Sources/SwiftSyntaxBuilder/ExprBuildables.swift
+++ b/Sources/SwiftSyntaxBuilder/ExprBuildables.swift
@@ -46,7 +46,7 @@ public struct IntegerLiteral: ExprBuildable {
     public func buildExpr(format: Format, leadingTrivia: Trivia) -> ExprSyntax {
         let integerLiteral = SyntaxFactory.makeIntegerLiteralExpr(
             digits: SyntaxFactory.makeIntegerLiteral(String(value))
-        )!.withLeadingTrivia(leadingTrivia)
+        ).withLeadingTrivia(leadingTrivia)
         return ExprSyntax(integerLiteral)
     }
 }
diff --git a/Tests/SwiftSyntaxTest/CustomReflecatbleTests.swift b/Tests/SwiftSyntaxTest/CustomReflecatbleTests.swift
index 48ae3b89d73..190e49d7a4c 100644
--- a/Tests/SwiftSyntaxTest/CustomReflecatbleTests.swift
+++ b/Tests/SwiftSyntaxTest/CustomReflecatbleTests.swift
@@ -101,12 +101,12 @@ public class CustomReflectableTests: XCTestCase {
                                              presence: .present,
                                              leadingTrivia: [],
                                              trailingTrivia: [])
-        let expr1 = SyntaxFactory.makeIntegerLiteralExpr(digits: token1)!
+        let expr1 = SyntaxFactory.makeIntegerLiteralExpr(digits: token1)
         let token2 = SyntaxFactory.makeToken(.integerLiteral("2"),
                                              presence: .present,
                                              leadingTrivia: [],
                                              trailingTrivia: [])
-        let expr2 = SyntaxFactory.makeIntegerLiteralExpr(digits: token2)!
+        let expr2 = SyntaxFactory.makeIntegerLiteralExpr(digits: token2)
         let elements = [SyntaxFactory.makeTupleExprElement(label: nil,
                                                        colon: nil,
                                                        expression: ExprSyntax(expr1),
@@ -153,12 +153,12 @@ public class CustomReflectableTests: XCTestCase {
                                              presence: .present,
                                              leadingTrivia: [],
                                              trailingTrivia: [])
-        let expr1 = SyntaxFactory.makeIntegerLiteralExpr(digits: token1)!
+        let expr1 = SyntaxFactory.makeIntegerLiteralExpr(digits: token1)
         let token2 = SyntaxFactory.makeToken(.integerLiteral("2"),
                                              presence: .present,
                                              leadingTrivia: [],
                                              trailingTrivia: [])
-        let expr2 = SyntaxFactory.makeIntegerLiteralExpr(digits: token2)!
+        let expr2 = SyntaxFactory.makeIntegerLiteralExpr(digits: token2)
         let elements = [SyntaxFactory.makeTupleExprElement(label: nil,
                                                        colon: nil,
                                                        expression: ExprSyntax(expr1),
diff --git a/Tests/SwiftSyntaxTest/SyntaxCollectionsTests.swift b/Tests/SwiftSyntaxTest/SyntaxCollectionsTests.swift
index f471ebc97b2..b78d405c242 100644
--- a/Tests/SwiftSyntaxTest/SyntaxCollectionsTests.swift
+++ b/Tests/SwiftSyntaxTest/SyntaxCollectionsTests.swift
@@ -4,7 +4,7 @@ import SwiftSyntax
 fileprivate func integerLiteralElement(_ int: Int) -> ArrayElementSyntax {
     let literal = SyntaxFactory.makeIntegerLiteral("\(int)")
     return SyntaxFactory.makeArrayElement(
-        expression: ExprSyntax(SyntaxFactory.makeIntegerLiteralExpr(digits: literal)!),
+        expression: ExprSyntax(SyntaxFactory.makeIntegerLiteralExpr(digits: literal)),
         trailingComma: nil)
 }
 
diff --git a/Tests/SwiftSyntaxTest/SyntaxConvenienceMethodsTests.swift b/Tests/SwiftSyntaxTest/SyntaxConvenienceMethodsTests.swift
index 60821a20e88..9bb0ef1c087 100644
--- a/Tests/SwiftSyntaxTest/SyntaxConvenienceMethodsTests.swift
+++ b/Tests/SwiftSyntaxTest/SyntaxConvenienceMethodsTests.swift
@@ -2,14 +2,16 @@ import XCTest
 import SwiftSyntax
 
 public class SyntaxConvenienceMethodsTests: XCTestCase {
-
-  public func testFloatingValues() {
-    testFloatingValue(text: "5.3_8", expectedValue: 5.38)
-    testFloatingValue(text: "12e3", expectedValue: 12000.0)
-    testFloatingValue(text: "32E1", expectedValue: 320.0)
-    testFloatingValue(text: "0xdEFACE.C0FFEEp+1", expectedValue: 0xdEFACE.C0FFEEp+1)
-    testFloatingValue(text: "0xaffab1e.e1fP-2", expectedValue: 0xaffab1e.e1fP-2)
-    testFloatingValue(text: "🥥", expectedValue: nil)
+  public func testFloatValues() {
+    testFloatValue(text: "5.3_8", expectedValue: 5.38)
+    testFloatValue(text: "12e3", expectedValue: 12000.0)
+    testFloatValue(text: "32E1", expectedValue: 320.0)
+    testFloatValue(text: "0xdEFACE.C0FFEEp+1", expectedValue: 0xdEFACE.C0FFEEp+1)
+    testFloatValue(text: "0xaffab1e.e1fP-2", expectedValue: 0xaffab1e.e1fP-2)
+    testFloatValue(text: "🥥", expectedValue: nil)
+    // The following results in a valid FloatLiteralExprSyntax, but because Double.greatestFiniteMagnitude
+    // is 1.7976931348623157e+308, floatLiteralValue should be nil.
+    testFloatValue(text: "1.7976931348623157e+309", expectedValue: nil)
   }
 
   public func testIntegerValues() {
@@ -18,25 +20,30 @@ public class SyntaxConvenienceMethodsTests: XCTestCase {
     testIntegerValue(text: "0o3434", expectedValue: 0o3434)
     testIntegerValue(text: "0xba11aD", expectedValue: 0xba11aD)
     testIntegerValue(text: "🐋", expectedValue: nil)
+    // The following results in a valid IntegerLiteralExprSyntax, but because Int.max is
+    // 9223372036854775807, integerLiteralValue should be nil.
+    testIntegerValue(text: "9223372036854775808", expectedValue: nil)
   }
 }
 
-fileprivate func testFloatingValue(text: String, expectedValue: Double?) {
+fileprivate func testFloatValue(text: String, expectedValue: Double?) {
   let digits = SyntaxFactory.makeFloatingLiteral(text)
+
   let literalExpr = SyntaxFactory.makeFloatLiteralExpr(floatingDigits: digits)
   if let expectedValue = expectedValue {
-    XCTAssertEqual(literalExpr!.floatingValue, expectedValue)
+    XCTAssertEqual(literalExpr.floatLiteralValue!, expectedValue)
   } else {
-    XCTAssertNil(literalExpr)
+    XCTAssertNil(literalExpr.floatLiteralValue)
   }
 }
 
 fileprivate func testIntegerValue(text: String, expectedValue: Int?) {
   let digits = SyntaxFactory.makeIntegerLiteral(text)
+
   let literalExpr = SyntaxFactory.makeIntegerLiteralExpr(digits: digits)
   if let expectedValue = expectedValue {
-    XCTAssertEqual(literalExpr!.integerValue, expectedValue)
+    XCTAssertEqual(literalExpr.integerLiteralValue!, expectedValue)
   } else {
-    XCTAssertNil(literalExpr)
+    XCTAssertNil(literalExpr.integerLiteralValue)
   }
-}
\ No newline at end of file
+}
diff --git a/Tests/SwiftSyntaxTest/SyntaxFactoryTests.swift b/Tests/SwiftSyntaxTest/SyntaxFactoryTests.swift
index 8fc8630d0a3..202006b39df 100644
--- a/Tests/SwiftSyntaxTest/SyntaxFactoryTests.swift
+++ b/Tests/SwiftSyntaxTest/SyntaxFactoryTests.swift
@@ -168,10 +168,10 @@ public class SyntaxFactoryTests: XCTestCase {
   public func testMakeBinaryOperator() {
     let first = IntegerLiteralExprSyntax {
       $0.useDigits(SyntaxFactory.makeIntegerLiteral("1", trailingTrivia: .spaces(1)))
-    }!
+    }
     let second = IntegerLiteralExprSyntax {
       $0.useDigits(SyntaxFactory.makeIntegerLiteral("1"))
-    }!
+    }
     let operatorNames = ["==", "!=", "+", "-", "*", "/", "<", ">", "<=", ">="]
     operatorNames.forEach { operatorName in
       let operatorToken = SyntaxFactory.makeBinaryOperator(operatorName, trailingTrivia: .spaces(1))
diff --git a/Tests/SwiftSyntaxTest/SyntaxTests.swift b/Tests/SwiftSyntaxTest/SyntaxTests.swift
index dbe609251bd..3dc8bbb3085 100644
--- a/Tests/SwiftSyntaxTest/SyntaxTests.swift
+++ b/Tests/SwiftSyntaxTest/SyntaxTests.swift
@@ -87,9 +87,9 @@ public class SyntaxTests: XCTestCase {
   public func testCasting() {
     let integerExpr = IntegerLiteralExprSyntax {
       $0.useDigits(SyntaxFactory.makeIntegerLiteral("1", trailingTrivia: .spaces(1)))
-    }!
+    }
 
-    let expr = ExprSyntax(integerExpr)!
+    let expr = ExprSyntax(integerExpr)
     let node = Syntax(expr)
     XCTAssertTrue(expr.is(IntegerLiteralExprSyntax.self))
     XCTAssertTrue(node.is(IntegerLiteralExprSyntax.self))
@@ -127,7 +127,7 @@ public class SyntaxTests: XCTestCase {
   public func testNodeType() {
     let integerExpr = IntegerLiteralExprSyntax {
       $0.useDigits(SyntaxFactory.makeIntegerLiteral("1", trailingTrivia: .spaces(1)))
-    }!
+    }
     let expr = ExprSyntax(integerExpr)
     let node = Syntax(expr)
 
@@ -139,60 +139,9 @@ public class SyntaxTests: XCTestCase {
   public func testConstructFromSyntaxProtocol() {
     let integerExpr = IntegerLiteralExprSyntax {
       $0.useDigits(SyntaxFactory.makeIntegerLiteral("1", trailingTrivia: .spaces(1)))
-    }!
+    }
 
     XCTAssertEqual(Syntax(integerExpr), Syntax(fromProtocol: integerExpr as SyntaxProtocol))
     XCTAssertEqual(Syntax(integerExpr), Syntax(fromProtocol: integerExpr as ExprSyntaxProtocol))
   }
-
-  public func testNumericLiteralSetters() {
-    var integerExpr = IntegerLiteralExprSyntax {
-      $0.useDigits(SyntaxFactory.makeIntegerLiteral("1"))
-    }!
-    XCTAssert(integerExpr.isValid)
-
-    var token: TokenSyntax
-    var source = "2"
-    var tree = try! SyntaxParser.parse(source: source)
-    token = tree.firstToken!
-    try! integerExpr.setDigits(token)
-    XCTAssert(integerExpr.isValid)
-
-    let invalidNumericLiteral = "🥥"
-
-    source = invalidNumericLiteral
-    tree = try! SyntaxParser.parse(source: source)
-    token = tree.firstToken!
-
-    XCTAssertThrowsError(try integerExpr.setDigits(token)) { error in
-      if let error = error as? IntegerLiteralExprSyntax.DigitsError {
-        XCTAssertEqual("attempted to use setter with invalid Digits \"\(source)\"", error.description)
-      } else {
-        return XCTFail("unexpected error thrown")
-      }
-    }
-
-    var floatExpr = FloatLiteralExprSyntax {
-      $0.useFloatingDigits(SyntaxFactory.makeFloatingLiteral("4.2"))
-    }!
-    XCTAssert(floatExpr.isValid)
-
-    source = "2.4"
-    tree = try! SyntaxParser.parse(source: source)
-    token = tree.firstToken!
-    try! floatExpr.setFloatingDigits(token)
-    XCTAssert(floatExpr.isValid)
-
-    source = invalidNumericLiteral
-    tree = try! SyntaxParser.parse(source: source)
-    token = tree.firstToken!
-
-    XCTAssertThrowsError(try floatExpr.setFloatingDigits(token)) { error in
-      if let error = error as? FloatLiteralExprSyntax.FloatingDigitsError {
-        XCTAssertEqual("attempted to use setter with invalid FloatingDigits \"\(source)\"", error.description)
-      } else {
-        return XCTFail("unexpected error thrown")
-      }
-    }
-  }
 }