Push the options and extensions down into the JSONScanner, since they are immutable for the duration of the decode and are more heavily used in the scanner

Author: tbkka

Sources/SwiftProtobuf/AnyMessageStorage.swift

@@ -69,9 +69,7 @@ fileprivate func unpack(contentJSON: Data,
   var value = String()
   try contentJSON.withUnsafeBytes { (body: UnsafeRawBufferPointer) in
     if body.count > 0 {
-      var scanner = JSONScanner(source: body,
-                                messageDepthLimit: options.messageDepthLimit,
-                                ignoreUnknownFields: options.ignoreUnknownFields)
+      var scanner = JSONScanner(source: body, options: options, extensions: extensions)
       let key = try scanner.nextQuotedString()
       if key != "value" {
         // The only thing within a WKT should be "value".

Sources/SwiftProtobuf/JSONDecoder.swift

@@ -16,32 +16,27 @@ import Foundation
 
 internal struct JSONDecoder: Decoder {
   internal var scanner: JSONScanner
-  internal var options: JSONDecodingOptions
-  internal var extensions: ExtensionMap
   internal var messageType: Message.Type
   private var fieldCount = 0
   private var isMapKey = false
   private var fieldNameMap: _NameMap?
 
+  internal var options: JSONDecodingOptions { scanner.options }
+
   mutating func handleConflictingOneOf() throws {
     throw JSONDecodingError.conflictingOneOf
   }
 
   internal init(source: UnsafeRawBufferPointer, options: JSONDecodingOptions,
                 messageType: Message.Type, extensions: ExtensionMap) {
-    self.options = options
-    self.scanner = JSONScanner(source: source,
-                               messageDepthLimit: self.options.messageDepthLimit,
-                               ignoreUnknownFields: self.options.ignoreUnknownFields)
-    self.messageType = messageType
-    self.extensions = extensions
+    let scanner = JSONScanner(source: source,
+                               options: options,
+                               extensions: extensions)
+    self.init(scanner: scanner, messageType: messageType)
   }
 
-  private init(decoder: JSONDecoder, messageType: Message.Type) {
-    // The scanner is copied over along with the options.
-    self.scanner = decoder.scanner
-    self.options = decoder.options
-    self.extensions = decoder.extensions
+  private init(scanner: JSONScanner, messageType: Message.Type) {
+    self.scanner = scanner
     self.messageType = messageType
   }
 
@@ -53,8 +48,7 @@ internal struct JSONDecoder: Decoder {
       try scanner.skipRequiredComma()
     }
     let fieldNumber = try scanner.nextFieldNumber(names: fieldNameMap!,
-                                                  messageType: messageType,
-                                                  extensionMap: extensions)
+                                                  messageType: messageType)
     if let fieldNumber = fieldNumber {
       fieldCount += 1
       return fieldNumber
@@ -539,7 +533,7 @@ internal struct JSONDecoder: Decoder {
     if value == nil {
       value = M()
     }
-    var subDecoder = JSONDecoder(decoder: self, messageType: M.self)
+    var subDecoder = JSONDecoder(scanner: scanner, messageType: M.self)
     try subDecoder.decodeFullObject(message: &value!)
     assert(scanner.recursionBudget == subDecoder.scanner.recursionBudget)
     scanner = subDecoder.scanner
@@ -570,7 +564,7 @@ internal struct JSONDecoder: Decoder {
         }
       } else {
         var message = M()
-        var subDecoder = JSONDecoder(decoder: self, messageType: M.self)
+        var subDecoder = JSONDecoder(scanner: scanner, messageType: M.self)
         try subDecoder.decodeFullObject(message: &message)
         value.append(message)
         assert(scanner.recursionBudget == subDecoder.scanner.recursionBudget)
@@ -708,7 +702,7 @@ internal struct JSONDecoder: Decoder {
     fieldNumber: Int
   ) throws {
     // Force-unwrap: we can only get here if the extension exists.
-    let ext = extensions[messageType, fieldNumber]!
+    let ext = scanner.extensions[messageType, fieldNumber]!
 
     var fieldValue = values[fieldNumber]
     if fieldValue != nil {

Sources/SwiftProtobuf/JSONScanner.swift

@@ -374,9 +374,10 @@ internal struct JSONScanner {
   private let source: UnsafeRawBufferPointer
   private var index: UnsafeRawBufferPointer.Index
   private var numberParser = DoubleParser()
+  internal var options: JSONDecodingOptions
+  internal var extensions: ExtensionMap
   internal var recursionLimit: Int
   internal var recursionBudget: Int
-  private var ignoreUnknownFields: Bool
 
   /// True if the scanner has read all of the data from the source, with the
   /// exception of any trailing whitespace (which is consumed by reading this
@@ -400,14 +401,15 @@ internal struct JSONScanner {
 
   internal init(
     source: UnsafeRawBufferPointer,
-    messageDepthLimit: Int,
-    ignoreUnknownFields: Bool
+    options: JSONDecodingOptions,
+    extensions: ExtensionMap
   ) {
     self.source = source
     self.index = source.startIndex
-    self.recursionLimit = messageDepthLimit
-    self.recursionBudget = messageDepthLimit
-    self.ignoreUnknownFields = ignoreUnknownFields
+    self.recursionLimit = options.messageDepthLimit
+    self.recursionBudget = options.messageDepthLimit
+    self.options = options
+    self.extensions = extensions
   }
 
   private mutating func incrementRecursionDepth() throws {
@@ -1249,12 +1251,11 @@ internal struct JSONScanner {
   ///
   /// Throws if field name cannot be parsed.
   /// If it encounters an unknown field name, it throws
-  /// unless `ignoreUnknownFields` is set, in which case
+  /// unless `options.ignoreUnknownFields` is set, in which case
   /// it silently skips it.
   internal mutating func nextFieldNumber(
     names: _NameMap,
-    messageType: Message.Type,
-    extensionMap: ExtensionMap?
+    messageType: Message.Type
   ) throws -> Int? {
     while true {
       var fieldName: String
@@ -1273,8 +1274,7 @@ internal struct JSONScanner {
           return fieldNumber
         }
       }
-      if let extensions = extensionMap,
-         let first = fieldName.first, first == "[",
+      if let first = fieldName.first, first == "[",
          let last = fieldName.last, last == "]"
       {
         fieldName.removeFirst()
@@ -1283,7 +1283,7 @@ internal struct JSONScanner {
           return fieldNumber
         }
       }
-      if !ignoreUnknownFields {
+      if !options.ignoreUnknownFields {
         throw JSONDecodingError.unknownField(fieldName)
       }
       // Unknown field, skip it and try to parse the next field name