         }
     }
 
-    // Jump to end of current field.
-    //
-    // This uses the bookmarked position saved by the last call to getTagType().
-    // On exit, fieldStartP points to the first byte of the tag, fieldEndP points
-    // to the first byte after the field contents.
-    //
+    /// Private: Skip to the end of the current field.
+    ///
+    /// Assumes that fieldStartP was bookmarked by a previous
+    /// call to getTagType().
+    ///
+    /// On exit, fieldStartP points to the first byte of the tag, fieldEndP points
+    /// to the first byte after the field contents, and p == fieldEndP.
     private mutating func skip() throws {
         if let end = fieldEndP {
             p = end
         } else {
+            // Rewind to start of current field.
             available += p - fieldStartP
             p = fieldStartP
             guard let tag = try getTagWithoutUpdatingFieldStart() else {

        self.extensions = extensions
    }

    // Since this is called for every field, I've taken some
    // pains to optimize it, including unrolling a tweaked version
    // of the varint parser.
    public mutating func nextFieldNumber() throws -> Int? {
        if fieldNumber > 0 {
            if let override = unknownOverride {
                if unknownData == nil {

        }
    }

    //
    // Private building blocks for the parsing above.
    //
    // Having these be private gives the compiler maximum latitude for
    // inlining.
    //

    /// Private:  Advance the current position.
    private mutating func consume(length: Int) {
        available -= length
        p += length
    }

    /// Private: Skip the body for the given tag.  If the given tag is
    /// a group, it parses up through the corresponding group end.
    private mutating func skipOver(tag: FieldTag) throws {
        switch tag.wireFormat {
        case .varint:
