Rename library to nimpb

32 files changed, 330 insertions, 722 deletions

diff --git a/examples/addressbook/addressbook_pb.nim b/examples/addressbook/addressbook_pb.nim
index f145fa3..e495ada 100644
--- a/examples/addressbook/addressbook_pb.nim
+++ b/examples/addressbook/addressbook_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 import phonenumber_pb
 
diff --git a/examples/addressbook/phonenumber_pb.nim b/examples/addressbook/phonenumber_pb.nim
index 6d331d3..a77d985 100644
--- a/examples/addressbook/phonenumber_pb.nim
+++ b/examples/addressbook/phonenumber_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     PhoneType* {.pure.} = enum
diff --git a/examples/addressbook/reader.nim b/examples/addressbook/reader.nim
index aa0fd86..6aa7f27 100644
--- a/examples/addressbook/reader.nim
+++ b/examples/addressbook/reader.nim
@@ -1,7 +1,7 @@
 import streams
 import strformat
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 import addressbook_pb
 import phonenumber_pb
diff --git a/examples/addressbook/writer.nim b/examples/addressbook/writer.nim
index 44ff0a0..cd1e488 100644
--- a/examples/addressbook/writer.nim
+++ b/examples/addressbook/writer.nim
@@ -1,6 +1,6 @@
 import streams
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 import addressbook_pb
 import phonenumber_pb
diff --git a/examples/simple/simple_pb.nim b/examples/simple/simple_pb.nim
index 6f20088..a2b1db3 100644
--- a/examples/simple/simple_pb.nim
+++ b/examples/simple/simple_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     Test1_MyEnum* {.pure.} = enum
diff --git a/generator/descriptor_pb.nim b/generator/descriptor_pb.nim
index 8eeecb6..923885f 100644
--- a/generator/descriptor_pb.nim
+++ b/generator/descriptor_pb.nim
@@ -1,7 +1,7 @@
 import intsets
 
 import gen
-import protobuf/protobuf
+import nimpb/nimpb
 
 const
     FileDescriptorSetDesc = MessageDesc(
diff --git a/generator/gen.nim b/generator/gen.nim
index c51b746..c270918 100644
--- a/generator/gen.nim
+++ b/generator/gen.nim
@@ -1,7 +1,7 @@
 import macros
 import strutils
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     MessageDesc* = object
diff --git a/generator/plugin_pb.nim b/generator/plugin_pb.nim
index 7ddd381..fa9fc94 100644
--- a/generator/plugin_pb.nim
+++ b/generator/plugin_pb.nim
@@ -1,7 +1,7 @@
 import intsets
 
 import gen
-import protobuf/protobuf
+import nimpb/nimpb
 
 import descriptor_pb
 
diff --git a/generator/protoc_gen_nim.nim b/generator/protoc_gen_nim.nim
index 71b22f2..d2cb497 100644
--- a/generator/protoc_gen_nim.nim
+++ b/generator/protoc_gen_nim.nim
@@ -10,7 +10,7 @@ import tables
 import descriptor_pb
 import plugin_pb
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 import gen
 
@@ -866,14 +866,14 @@ proc processFile(filename: string, fdesc: FileDescriptorProto,
         addLine(result.data, "import tables")
         addLine(result.data, "export tables")
     addLine(result.data, "")
-    addLine(result.data, "import protobuf/protobuf")
+    addLine(result.data, "import nimpb/nimpb")
     addLine(result.data, "")
 
     for dep in fdesc.dependency:
         var (dir, depname, _) = splitFile(dep)
 
         if dir == "google/protobuf":
-            dir = "protobuf/wkt"
+            dir = "nimpb/wkt"
 
         var deppbname = (dir / depname) & "_pb"
         addLine(result.data, &"import {deppbname}")
diff --git a/protobuf.nimble b/nimpb.nimble
index 80c6acc..80c6acc 100644
--- a/protobuf.nimble
+++ b/nimpb.nimble
diff --git a/src/protobuf/protobuf.nim b/src/nimpb/nimpb.nim
index d15bfc7..d15bfc7 100644
--- a/src/protobuf/protobuf.nim
+++ b/src/nimpb/nimpb.nim
diff --git a/src/protobuf/wkt/any.proto b/src/nimpb/wkt/any.proto
index c748667..c748667 100644
--- a/src/protobuf/wkt/any.proto
+++ b/src/nimpb/wkt/any.proto
diff --git a/src/protobuf/wkt/any_pb.nim b/src/nimpb/wkt/any_pb.nim
index 9704ae9..21a9f49 100644
--- a/src/protobuf/wkt/any_pb.nim
+++ b/src/nimpb/wkt/any_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     google_protobuf_Any* = ref google_protobuf_AnyObj
@@ -24,7 +24,7 @@ proc newgoogle_protobuf_Any*(): google_protobuf_Any =
 
 proc cleartype_url*(message: google_protobuf_Any) =
     message.type_url = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hastype_url*(message: google_protobuf_Any): bool =
     result = contains(message.hasField, 1)
@@ -41,7 +41,7 @@ proc `type_url=`*(message: google_protobuf_Any, value: string) {.inline.} =
 
 proc clearvalue*(message: google_protobuf_Any) =
     message.value = bytes("")
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasvalue*(message: google_protobuf_Any): bool =
     result = contains(message.hasField, 2)
@@ -58,23 +58,17 @@ proc `value=`*(message: google_protobuf_Any, value: bytes) {.inline.} =
 
 proc sizeOfgoogle_protobuf_Any*(message: google_protobuf_Any): uint64 =
     if hastype_url(message):
-        let
-            sizeOfField = sizeOfString(message.type_url)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.type_url)
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfBytes(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(2, WireType.LengthDelimited)
+        result = result + sizeOfBytes(message.value)
 
 proc writegoogle_protobuf_Any*(stream: ProtobufStream, message: google_protobuf_Any) =
     if hastype_url(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.type_url)
+        writeString(stream, message.type_url, 1)
     if hasvalue(message):
-        writeTag(stream, 2, WireType.LengthDelimited)
-        writeBytes(stream, message.value)
+        writeBytes(stream, message.value, 2)
 
 proc readgoogle_protobuf_Any*(stream: ProtobufStream): google_protobuf_Any =
     result = newgoogle_protobuf_Any()
diff --git a/src/protobuf/wkt/api.proto b/src/nimpb/wkt/api.proto
index f37ee2f..f37ee2f 100644
--- a/src/protobuf/wkt/api.proto
+++ b/src/nimpb/wkt/api.proto
diff --git a/src/protobuf/wkt/api_pb.nim b/src/nimpb/wkt/api_pb.nim
index c6ca312..15fb7b7 100644
--- a/src/protobuf/wkt/api_pb.nim
+++ b/src/nimpb/wkt/api_pb.nim
@@ -2,10 +2,10 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
-import protobuf/wkt/source_context_pb
-import protobuf/wkt/type_pb
+import nimpb/wkt/source_context_pb
+import nimpb/wkt/type_pb
 
 type
     google_protobuf_Api* = ref google_protobuf_ApiObj
@@ -62,7 +62,7 @@ proc newgoogle_protobuf_Method*(): google_protobuf_Method =
 
 proc clearname*(message: google_protobuf_Method) =
     message.name = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasname*(message: google_protobuf_Method): bool =
     result = contains(message.hasField, 1)
@@ -79,7 +79,7 @@ proc `name=`*(message: google_protobuf_Method, value: string) {.inline.} =
 
 proc clearrequest_type_url*(message: google_protobuf_Method) =
     message.request_type_url = ""
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasrequest_type_url*(message: google_protobuf_Method): bool =
     result = contains(message.hasField, 2)
@@ -96,7 +96,7 @@ proc `request_type_url=`*(message: google_protobuf_Method, value: string) {.inli
 
 proc clearrequest_streaming*(message: google_protobuf_Method) =
     message.request_streaming = false
-    excl(message.hasField, 3)
+    excl(message.hasField, [3])
 
 proc hasrequest_streaming*(message: google_protobuf_Method): bool =
     result = contains(message.hasField, 3)
@@ -113,7 +113,7 @@ proc `request_streaming=`*(message: google_protobuf_Method, value: bool) {.inlin
 
 proc clearresponse_type_url*(message: google_protobuf_Method) =
     message.response_type_url = ""
-    excl(message.hasField, 4)
+    excl(message.hasField, [4])
 
 proc hasresponse_type_url*(message: google_protobuf_Method): bool =
     result = contains(message.hasField, 4)
@@ -130,7 +130,7 @@ proc `response_type_url=`*(message: google_protobuf_Method, value: string) {.inl
 
 proc clearresponse_streaming*(message: google_protobuf_Method) =
     message.response_streaming = false
-    excl(message.hasField, 5)
+    excl(message.hasField, [5])
 
 proc hasresponse_streaming*(message: google_protobuf_Method): bool =
     result = contains(message.hasField, 5)
@@ -147,10 +147,10 @@ proc `response_streaming=`*(message: google_protobuf_Method, value: bool) {.inli
 
 proc clearoptions*(message: google_protobuf_Method) =
     message.options = @[]
-    excl(message.hasField, 6)
+    excl(message.hasField, [6])
 
 proc hasoptions*(message: google_protobuf_Method): bool =
-    result = contains(message.hasField, 6)
+    result = contains(message.hasField, 6) or (len(message.options) > 0)
 
 proc setoptions*(message: google_protobuf_Method, value: seq[google_protobuf_Option]) =
     message.options = value
@@ -168,7 +168,7 @@ proc `options=`*(message: google_protobuf_Method, value: seq[google_protobuf_Opt
 
 proc clearsyntax*(message: google_protobuf_Method) =
     message.syntax = google_protobuf_Syntax(0)
-    excl(message.hasField, 7)
+    excl(message.hasField, [7])
 
 proc hassyntax*(message: google_protobuf_Method): bool =
     result = contains(message.hasField, 7)
@@ -185,66 +185,42 @@ proc `syntax=`*(message: google_protobuf_Method, value: google_protobuf_Syntax)
 
 proc sizeOfgoogle_protobuf_Method*(message: google_protobuf_Method): uint64 =
     if hasname(message):
-        let
-            sizeOfField = sizeOfString(message.name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.name)
     if hasrequest_type_url(message):
-        let
-            sizeOfField = sizeOfString(message.request_type_url)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(2, WireType.LengthDelimited)
+        result = result + sizeOfString(message.request_type_url)
     if hasrequest_streaming(message):
-        let
-            sizeOfField = sizeOfBool(message.request_streaming)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(3, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(3, WireType.Varint)
+        result = result + sizeOfBool(message.request_streaming)
     if hasresponse_type_url(message):
-        let
-            sizeOfField = sizeOfString(message.response_type_url)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(4, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(4, WireType.LengthDelimited)
+        result = result + sizeOfString(message.response_type_url)
     if hasresponse_streaming(message):
-        let
-            sizeOfField = sizeOfBool(message.response_streaming)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(5, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(5, WireType.Varint)
+        result = result + sizeOfBool(message.response_streaming)
     for value in message.options:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Option(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(6, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(6, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value))
     if hassyntax(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Syntax(message.syntax)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(7, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(7, WireType.Varint)
+        result = result + sizeOfgoogle_protobuf_Syntax(message.syntax)
 
 proc writegoogle_protobuf_Method*(stream: ProtobufStream, message: google_protobuf_Method) =
     if hasname(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.name)
+        writeString(stream, message.name, 1)
     if hasrequest_type_url(message):
-        writeTag(stream, 2, WireType.LengthDelimited)
-        writeString(stream, message.request_type_url)
+        writeString(stream, message.request_type_url, 2)
     if hasrequest_streaming(message):
-        writeTag(stream, 3, WireType.Varint)
-        writeBool(stream, message.request_streaming)
+        writeBool(stream, message.request_streaming, 3)
     if hasresponse_type_url(message):
-        writeTag(stream, 4, WireType.LengthDelimited)
-        writeString(stream, message.response_type_url)
+        writeString(stream, message.response_type_url, 4)
     if hasresponse_streaming(message):
-        writeTag(stream, 5, WireType.Varint)
-        writeBool(stream, message.response_streaming)
+        writeBool(stream, message.response_streaming, 5)
     for value in message.options:
-        writeTag(stream, 6, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Option(value))
-        writegoogle_protobuf_Option(stream, value)
+        writeMessage(stream, value, 6)
     if hassyntax(message):
-        writeTag(stream, 7, WireType.Varint)
-        writegoogle_protobuf_Syntax(stream, message.syntax)
+        writegoogle_protobuf_Syntax(stream, message.syntax, 7)
 
 proc readgoogle_protobuf_Method*(stream: ProtobufStream): google_protobuf_Method =
     result = newgoogle_protobuf_Method()
@@ -304,7 +280,7 @@ proc newgoogle_protobuf_Mixin*(): google_protobuf_Mixin =
 
 proc clearname*(message: google_protobuf_Mixin) =
     message.name = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasname*(message: google_protobuf_Mixin): bool =
     result = contains(message.hasField, 1)
@@ -321,7 +297,7 @@ proc `name=`*(message: google_protobuf_Mixin, value: string) {.inline.} =
 
 proc clearroot*(message: google_protobuf_Mixin) =
     message.root = ""
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasroot*(message: google_protobuf_Mixin): bool =
     result = contains(message.hasField, 2)
@@ -338,23 +314,17 @@ proc `root=`*(message: google_protobuf_Mixin, value: string) {.inline.} =
 
 proc sizeOfgoogle_protobuf_Mixin*(message: google_protobuf_Mixin): uint64 =
     if hasname(message):
-        let
-            sizeOfField = sizeOfString(message.name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.name)
     if hasroot(message):
-        let
-            sizeOfField = sizeOfString(message.root)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(2, WireType.LengthDelimited)
+        result = result + sizeOfString(message.root)
 
 proc writegoogle_protobuf_Mixin*(stream: ProtobufStream, message: google_protobuf_Mixin) =
     if hasname(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.name)
+        writeString(stream, message.name, 1)
     if hasroot(message):
-        writeTag(stream, 2, WireType.LengthDelimited)
-        writeString(stream, message.root)
+        writeString(stream, message.root, 2)
 
 proc readgoogle_protobuf_Mixin*(stream: ProtobufStream): google_protobuf_Mixin =
     result = newgoogle_protobuf_Mixin()
@@ -400,7 +370,7 @@ proc newgoogle_protobuf_Api*(): google_protobuf_Api =
 
 proc clearname*(message: google_protobuf_Api) =
     message.name = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasname*(message: google_protobuf_Api): bool =
     result = contains(message.hasField, 1)
@@ -417,10 +387,10 @@ proc `name=`*(message: google_protobuf_Api, value: string) {.inline.} =
 
 proc clearmethods*(message: google_protobuf_Api) =
     message.methods = @[]
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasmethods*(message: google_protobuf_Api): bool =
-    result = contains(message.hasField, 2)
+    result = contains(message.hasField, 2) or (len(message.methods) > 0)
 
 proc setmethods*(message: google_protobuf_Api, value: seq[google_protobuf_Method]) =
     message.methods = value
@@ -438,10 +408,10 @@ proc `methods=`*(message: google_protobuf_Api, value: seq[google_protobuf_Method
 
 proc clearoptions*(message: google_protobuf_Api) =
     message.options = @[]
-    excl(message.hasField, 3)
+    excl(message.hasField, [3])
 
 proc hasoptions*(message: google_protobuf_Api): bool =
-    result = contains(message.hasField, 3)
+    result = contains(message.hasField, 3) or (len(message.options) > 0)
 
 proc setoptions*(message: google_protobuf_Api, value: seq[google_protobuf_Option]) =
     message.options = value
@@ -459,7 +429,7 @@ proc `options=`*(message: google_protobuf_Api, value: seq[google_protobuf_Option
 
 proc clearversion*(message: google_protobuf_Api) =
     message.version = ""
-    excl(message.hasField, 4)
+    excl(message.hasField, [4])
 
 proc hasversion*(message: google_protobuf_Api): bool =
     result = contains(message.hasField, 4)
@@ -476,7 +446,7 @@ proc `version=`*(message: google_protobuf_Api, value: string) {.inline.} =
 
 proc clearsource_context*(message: google_protobuf_Api) =
     message.source_context = nil
-    excl(message.hasField, 5)
+    excl(message.hasField, [5])
 
 proc hassource_context*(message: google_protobuf_Api): bool =
     result = contains(message.hasField, 5)
@@ -493,10 +463,10 @@ proc `source_context=`*(message: google_protobuf_Api, value: google_protobuf_Sou
 
 proc clearmixins*(message: google_protobuf_Api) =
     message.mixins = @[]
-    excl(message.hasField, 6)
+    excl(message.hasField, [6])
 
 proc hasmixins*(message: google_protobuf_Api): bool =
-    result = contains(message.hasField, 6)
+    result = contains(message.hasField, 6) or (len(message.mixins) > 0)
 
 proc setmixins*(message: google_protobuf_Api, value: seq[google_protobuf_Mixin]) =
     message.mixins = value
@@ -514,7 +484,7 @@ proc `mixins=`*(message: google_protobuf_Api, value: seq[google_protobuf_Mixin])
 
 proc clearsyntax*(message: google_protobuf_Api) =
     message.syntax = google_protobuf_Syntax(0)
-    excl(message.hasField, 7)
+    excl(message.hasField, [7])
 
 proc hassyntax*(message: google_protobuf_Api): bool =
     result = contains(message.hasField, 7)
@@ -531,74 +501,42 @@ proc `syntax=`*(message: google_protobuf_Api, value: google_protobuf_Syntax) {.i
 
 proc sizeOfgoogle_protobuf_Api*(message: google_protobuf_Api): uint64 =
     if hasname(message):
-        let
-            sizeOfField = sizeOfString(message.name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.name)
     for value in message.methods:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Method(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(2, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Method(value))
     for value in message.options:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Option(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(3, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(3, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value))
     if hasversion(message):
-        let
-            sizeOfField = sizeOfString(message.version)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(4, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(4, WireType.LengthDelimited)
+        result = result + sizeOfString(message.version)
     if hassource_context(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_SourceContext(message.source_context)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(5, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
-        result = result + sizeOfUInt64(sizeOfField)
+        result = result + sizeOfTag(5, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context))
     for value in message.mixins:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Mixin(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(6, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(6, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Mixin(value))
     if hassyntax(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Syntax(message.syntax)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(7, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(7, WireType.Varint)
+        result = result + sizeOfgoogle_protobuf_Syntax(message.syntax)
 
 proc writegoogle_protobuf_Api*(stream: ProtobufStream, message: google_protobuf_Api) =
     if hasname(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.name)
+        writeString(stream, message.name, 1)
     for value in message.methods:
-        writeTag(stream, 2, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Method(value))
-        writegoogle_protobuf_Method(stream, value)
+        writeMessage(stream, value, 2)
     for value in message.options:
-        writeTag(stream, 3, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Option(value))
-        writegoogle_protobuf_Option(stream, value)
+        writeMessage(stream, value, 3)
     if hasversion(message):
-        writeTag(stream, 4, WireType.LengthDelimited)
-        writeString(stream, message.version)
+        writeString(stream, message.version, 4)
     if hassource_context(message):
-        writeTag(stream, 5, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_SourceContext(message.source_context))
-        writegoogle_protobuf_SourceContext(stream, message.source_context)
+        writeMessage(stream, message.source_context, 5)
     for value in message.mixins:
-        writeTag(stream, 6, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Mixin(value))
-        writegoogle_protobuf_Mixin(stream, value)
+        writeMessage(stream, value, 6)
     if hassyntax(message):
-        writeTag(stream, 7, WireType.Varint)
-        writegoogle_protobuf_Syntax(stream, message.syntax)
+        writegoogle_protobuf_Syntax(stream, message.syntax, 7)
 
 proc readgoogle_protobuf_Api*(stream: ProtobufStream): google_protobuf_Api =
     result = newgoogle_protobuf_Api()
diff --git a/src/protobuf/wkt/duration.proto b/src/nimpb/wkt/duration.proto
index 975fce4..975fce4 100644
--- a/src/protobuf/wkt/duration.proto
+++ b/src/nimpb/wkt/duration.proto
diff --git a/src/protobuf/wkt/duration_pb.nim b/src/nimpb/wkt/duration_pb.nim
index 1c72ec4..54b0d4c 100644
--- a/src/protobuf/wkt/duration_pb.nim
+++ b/src/nimpb/wkt/duration_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     google_protobuf_Duration* = ref google_protobuf_DurationObj
@@ -24,7 +24,7 @@ proc newgoogle_protobuf_Duration*(): google_protobuf_Duration =
 
 proc clearseconds*(message: google_protobuf_Duration) =
     message.seconds = 0
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasseconds*(message: google_protobuf_Duration): bool =
     result = contains(message.hasField, 1)
@@ -41,7 +41,7 @@ proc `seconds=`*(message: google_protobuf_Duration, value: int64) {.inline.} =
 
 proc clearnanos*(message: google_protobuf_Duration) =
     message.nanos = 0
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasnanos*(message: google_protobuf_Duration): bool =
     result = contains(message.hasField, 2)
@@ -58,23 +58,17 @@ proc `nanos=`*(message: google_protobuf_Duration, value: int32) {.inline.} =
 
 proc sizeOfgoogle_protobuf_Duration*(message: google_protobuf_Duration): uint64 =
     if hasseconds(message):
-        let
-            sizeOfField = sizeOfInt64(message.seconds)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfInt64(message.seconds)
     if hasnanos(message):
-        let
-            sizeOfField = sizeOfInt32(message.nanos)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(2, WireType.Varint)
+        result = result + sizeOfInt32(message.nanos)
 
 proc writegoogle_protobuf_Duration*(stream: ProtobufStream, message: google_protobuf_Duration) =
     if hasseconds(message):
-        writeTag(stream, 1, WireType.Varint)
-        writeInt64(stream, message.seconds)
+        writeInt64(stream, message.seconds, 1)
     if hasnanos(message):
-        writeTag(stream, 2, WireType.Varint)
-        writeInt32(stream, message.nanos)
+        writeInt32(stream, message.nanos, 2)
 
 proc readgoogle_protobuf_Duration*(stream: ProtobufStream): google_protobuf_Duration =
     result = newgoogle_protobuf_Duration()
diff --git a/src/protobuf/wkt/empty.proto b/src/nimpb/wkt/empty.proto
index 03cacd2..03cacd2 100644
--- a/src/protobuf/wkt/empty.proto
+++ b/src/nimpb/wkt/empty.proto
diff --git a/src/protobuf/wkt/empty_pb.nim b/src/nimpb/wkt/empty_pb.nim
index 83885f4..3e97d0c 100644
--- a/src/protobuf/wkt/empty_pb.nim
+++ b/src/nimpb/wkt/empty_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     google_protobuf_Empty* = ref google_protobuf_EmptyObj
diff --git a/src/protobuf/wkt/field_mask.proto b/src/nimpb/wkt/field_mask.proto
index c68d247..c68d247 100644
--- a/src/protobuf/wkt/field_mask.proto
+++ b/src/nimpb/wkt/field_mask.proto
diff --git a/src/protobuf/wkt/field_mask_pb.nim b/src/nimpb/wkt/field_mask_pb.nim
index cb38f30..5576d12 100644
--- a/src/protobuf/wkt/field_mask_pb.nim
+++ b/src/nimpb/wkt/field_mask_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     google_protobuf_FieldMask* = ref google_protobuf_FieldMaskObj
@@ -22,10 +22,10 @@ proc newgoogle_protobuf_FieldMask*(): google_protobuf_FieldMask =
 
 proc clearpaths*(message: google_protobuf_FieldMask) =
     message.paths = @[]
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc haspaths*(message: google_protobuf_FieldMask): bool =
-    result = contains(message.hasField, 1)
+    result = contains(message.hasField, 1) or (len(message.paths) > 0)
 
 proc setpaths*(message: google_protobuf_FieldMask, value: seq[string]) =
     message.paths = value
@@ -43,16 +43,12 @@ proc `paths=`*(message: google_protobuf_FieldMask, value: seq[string]) {.inline.
 
 proc sizeOfgoogle_protobuf_FieldMask*(message: google_protobuf_FieldMask): uint64 =
     for value in message.paths:
-        let
-            sizeOfValue = sizeOfString(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(value)
 
 proc writegoogle_protobuf_FieldMask*(stream: ProtobufStream, message: google_protobuf_FieldMask) =
     for value in message.paths:
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, value)
+        writeString(stream, value, 1)
 
 proc readgoogle_protobuf_FieldMask*(stream: ProtobufStream): google_protobuf_FieldMask =
     result = newgoogle_protobuf_FieldMask()
diff --git a/src/protobuf/wkt/source_context.proto b/src/nimpb/wkt/source_context.proto
index f3b2c96..f3b2c96 100644
--- a/src/protobuf/wkt/source_context.proto
+++ b/src/nimpb/wkt/source_context.proto
diff --git a/src/protobuf/wkt/source_context_pb.nim b/src/nimpb/wkt/source_context_pb.nim
index 1fa135b..8d58812 100644
--- a/src/protobuf/wkt/source_context_pb.nim
+++ b/src/nimpb/wkt/source_context_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     google_protobuf_SourceContext* = ref google_protobuf_SourceContextObj
@@ -22,7 +22,7 @@ proc newgoogle_protobuf_SourceContext*(): google_protobuf_SourceContext =
 
 proc clearfile_name*(message: google_protobuf_SourceContext) =
     message.file_name = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasfile_name*(message: google_protobuf_SourceContext): bool =
     result = contains(message.hasField, 1)
@@ -39,15 +39,12 @@ proc `file_name=`*(message: google_protobuf_SourceContext, value: string) {.inli
 
 proc sizeOfgoogle_protobuf_SourceContext*(message: google_protobuf_SourceContext): uint64 =
     if hasfile_name(message):
-        let
-            sizeOfField = sizeOfString(message.file_name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.file_name)
 
 proc writegoogle_protobuf_SourceContext*(stream: ProtobufStream, message: google_protobuf_SourceContext) =
     if hasfile_name(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.file_name)
+        writeString(stream, message.file_name, 1)
 
 proc readgoogle_protobuf_SourceContext*(stream: ProtobufStream): google_protobuf_SourceContext =
     result = newgoogle_protobuf_SourceContext()
diff --git a/src/protobuf/wkt/struct.proto b/src/nimpb/wkt/struct.proto
index 7d7808e..7d7808e 100644
--- a/src/protobuf/wkt/struct.proto
+++ b/src/nimpb/wkt/struct.proto
diff --git a/src/protobuf/wkt/struct_pb.nim b/src/nimpb/wkt/struct_pb.nim
index bf3f07d..0d378c4 100644
--- a/src/protobuf/wkt/struct_pb.nim
+++ b/src/nimpb/wkt/struct_pb.nim
@@ -4,7 +4,7 @@ import intsets
 import tables
 export tables
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     google_protobuf_NullValue* {.pure.} = enum
@@ -41,13 +41,12 @@ proc readgoogle_protobuf_NullValue*(stream: ProtobufStream): google_protobuf_Nul
 proc writegoogle_protobuf_NullValue*(stream: ProtobufStream, value: google_protobuf_NullValue) =
     writeUInt32(stream, uint32(value))
 
+proc writegoogle_protobuf_NullValue*(stream: ProtobufStream, value: google_protobuf_NullValue, fieldNumber: int) =
+    writeUInt32(stream, uint32(value), fieldNumber)
+
 proc sizeOfgoogle_protobuf_NullValue*(value: google_protobuf_NullValue): uint64 =
     sizeOfUInt32(uint32(value))
 
-proc newgoogle_protobuf_Struct_FieldsEntry*(): google_protobuf_Struct_FieldsEntry
-proc writegoogle_protobuf_Struct_FieldsEntry*(stream: ProtobufStream, message: google_protobuf_Struct_FieldsEntry)
-proc readgoogle_protobuf_Struct_FieldsEntry*(stream: ProtobufStream): google_protobuf_Struct_FieldsEntry
-proc sizeOfgoogle_protobuf_Struct_FieldsEntry*(message: google_protobuf_Struct_FieldsEntry): uint64
 proc writegoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, key: string, value: google_protobuf_Value)
 proc readgoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, tbl: TableRef[string, google_protobuf_Value])
 proc sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key: string, value: google_protobuf_Value): uint64
@@ -67,60 +66,15 @@ proc writegoogle_protobuf_Value*(stream: ProtobufStream, message: google_protobu
 proc readgoogle_protobuf_Value*(stream: ProtobufStream): google_protobuf_Value
 proc sizeOfgoogle_protobuf_Value*(message: google_protobuf_Value): uint64
 
-proc newgoogle_protobuf_Struct_FieldsEntry*(): google_protobuf_Struct_FieldsEntry =
-    new(result)
-    result.hasField = initIntSet()
-    result.key = ""
-    result.value = nil
-
-proc clearkey*(message: google_protobuf_Struct_FieldsEntry) =
-    message.key = ""
-    excl(message.hasField, 1)
-
-proc haskey*(message: google_protobuf_Struct_FieldsEntry): bool =
-    result = contains(message.hasField, 1)
-
-proc setkey*(message: google_protobuf_Struct_FieldsEntry, value: string) =
-    message.key = value
-    incl(message.hasField, 1)
-
-proc key*(message: google_protobuf_Struct_FieldsEntry): string {.inline.} =
-    message.key
-
-proc `key=`*(message: google_protobuf_Struct_FieldsEntry, value: string) {.inline.} =
-    setkey(message, value)
-
-proc clearvalue*(message: google_protobuf_Struct_FieldsEntry) =
-    message.value = nil
-    excl(message.hasField, 2)
-
-proc hasvalue*(message: google_protobuf_Struct_FieldsEntry): bool =
-    result = contains(message.hasField, 2)
-
-proc setvalue*(message: google_protobuf_Struct_FieldsEntry, value: google_protobuf_Value) =
-    message.value = value
-    incl(message.hasField, 2)
-
-proc value*(message: google_protobuf_Struct_FieldsEntry): google_protobuf_Value {.inline.} =
-    message.value
-
-proc `value=`*(message: google_protobuf_Struct_FieldsEntry, value: google_protobuf_Value) {.inline.} =
-    setvalue(message, value)
-
 proc sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key: string, value: google_protobuf_Value): uint64 =
+    result = result + sizeOfTag(1, WireType.LengthDelimited)
     result = result + sizeOfString(key)
-    result = result + sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-    let valueSize = sizeOfgoogle_protobuf_Value(value)
-    result = result + valueSize
-    result = result + sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-    result = result + sizeOfUInt64(valueSize)
+    result = result + sizeOfTag(2, WireType.LengthDelimited)
+    result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Value(value))
 
 proc writegoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, key: string, value: google_protobuf_Value) =
-    writeTag(stream, 1, WireType.LengthDelimited)
-    writeString(stream, key)
-    writeTag(stream, 2, WireType.LengthDelimited)
-    writeVarint(stream, sizeOfgoogle_protobuf_Value(value))
-    writegoogle_protobuf_Value(stream, value)
+    writeString(stream, key, 1)
+    writeMessage(stream, value, 2)
 
 proc readgoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, tbl: TableRef[string, google_protobuf_Value]) =
     var
@@ -150,62 +104,6 @@ proc readgoogle_protobuf_Struct_FieldsEntryKV(stream: ProtobufStream, tbl: Table
         raise newException(Exception, "missing value (google_protobuf_Struct_FieldsEntry)")
     tbl[key] = value
 
-proc sizeOfgoogle_protobuf_Struct_FieldsEntry*(message: google_protobuf_Struct_FieldsEntry): uint64 =
-    if haskey(message):
-        let
-            sizeOfField = sizeOfString(message.key)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
-    if hasvalue(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Value(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
-        result = result + sizeOfUInt64(sizeOfField)
-
-proc writegoogle_protobuf_Struct_FieldsEntry*(stream: ProtobufStream, message: google_protobuf_Struct_FieldsEntry) =
-    if haskey(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.key)
-    if hasvalue(message):
-        writeTag(stream, 2, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Value(message.value))
-        writegoogle_protobuf_Value(stream, message.value)
-
-proc readgoogle_protobuf_Struct_FieldsEntry*(stream: ProtobufStream): google_protobuf_Struct_FieldsEntry =
-    result = newgoogle_protobuf_Struct_FieldsEntry()
-    while not atEnd(stream):
-        let
-            tag = readTag(stream)
-            wireType = getTagWireType(tag)
-        case getTagFieldNumber(tag)
-        of 0:
-            raise newException(InvalidFieldNumberError, "Invalid field number: 0")
-        of 1:
-            expectWireType(wireType, WireType.LengthDelimited)
-            setkey(result, readString(stream))
-        of 2:
-            expectWireType(wireType, WireType.LengthDelimited)
-            let
-                size = readVarint(stream)
-                data = safeReadStr(stream, int(size))
-                pbs = newProtobufStream(newStringStream(data))
-            setvalue(result, readgoogle_protobuf_Value(pbs))
-        else: skipField(stream, wireType)
-
-proc serialize*(message: google_protobuf_Struct_FieldsEntry): string =
-    let
-        ss = newStringStream()
-        pbs = newProtobufStream(ss)
-    writegoogle_protobuf_Struct_FieldsEntry(pbs, message)
-    result = ss.data
-
-proc newgoogle_protobuf_Struct_FieldsEntry*(data: string): google_protobuf_Struct_FieldsEntry =
-    let
-        ss = newStringStream(data)
-        pbs = newProtobufStream(ss)
-    result = readgoogle_protobuf_Struct_FieldsEntry(pbs)
-
 
 proc newgoogle_protobuf_Struct*(): google_protobuf_Struct =
     new(result)
@@ -214,10 +112,10 @@ proc newgoogle_protobuf_Struct*(): google_protobuf_Struct =
 
 proc clearfields*(message: google_protobuf_Struct) =
     message.fields = newTable[string, google_protobuf_Value]()
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasfields*(message: google_protobuf_Struct): bool =
-    result = contains(message.hasField, 1)
+    result = contains(message.hasField, 1) or (len(message.fields) > 0)
 
 proc setfields*(message: google_protobuf_Struct, value: TableRef[string, google_protobuf_Value]) =
     message.fields = value
@@ -234,8 +132,8 @@ proc sizeOfgoogle_protobuf_Struct*(message: google_protobuf_Struct): uint64 =
         var sizeOfKV = 0'u64
         for key, value in message.fields:
             sizeOfKV = sizeOfKV + sizeOfgoogle_protobuf_Struct_FieldsEntryKV(key, value)
-        let sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfKV + sizeOfTag + sizeOfUInt64(sizeOfKV)
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfKV)
 
 proc writegoogle_protobuf_Struct*(stream: ProtobufStream, message: google_protobuf_Struct) =
     for key, value in message.fields:
@@ -282,10 +180,10 @@ proc newgoogle_protobuf_ListValue*(): google_protobuf_ListValue =
 
 proc clearvalues*(message: google_protobuf_ListValue) =
     message.values = @[]
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalues*(message: google_protobuf_ListValue): bool =
-    result = contains(message.hasField, 1)
+    result = contains(message.hasField, 1) or (len(message.values) > 0)
 
 proc setvalues*(message: google_protobuf_ListValue, value: seq[google_protobuf_Value]) =
     message.values = value
@@ -303,18 +201,12 @@ proc `values=`*(message: google_protobuf_ListValue, value: seq[google_protobuf_V
 
 proc sizeOfgoogle_protobuf_ListValue*(message: google_protobuf_ListValue): uint64 =
     for value in message.values:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Value(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Value(value))
 
 proc writegoogle_protobuf_ListValue*(stream: ProtobufStream, message: google_protobuf_ListValue) =
     for value in message.values:
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Value(value))
-        writegoogle_protobuf_Value(stream, value)
+        writeMessage(stream, value, 1)
 
 proc readgoogle_protobuf_ListValue*(stream: ProtobufStream): google_protobuf_ListValue =
     result = newgoogle_protobuf_ListValue()
@@ -360,12 +252,7 @@ proc newgoogle_protobuf_Value*(): google_protobuf_Value =
 
 proc clearnull_value*(message: google_protobuf_Value) =
     message.kind.null_value = google_protobuf_NullValue(0)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 3)
-    excl(message.hasField, 4)
-    excl(message.hasField, 5)
-    excl(message.hasField, 6)
+    excl(message.hasField, [1, 2, 3, 4, 5, 6])
 
 proc hasnull_value*(message: google_protobuf_Value): bool =
     result = contains(message.hasField, 1)
@@ -373,11 +260,7 @@ proc hasnull_value*(message: google_protobuf_Value): bool =
 proc setnull_value*(message: google_protobuf_Value, value: google_protobuf_NullValue) =
     message.kind.null_value = value
     incl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 3)
-    excl(message.hasField, 4)
-    excl(message.hasField, 5)
-    excl(message.hasField, 6)
+    excl(message.hasField, [2, 3, 4, 5, 6])
 
 proc null_value*(message: google_protobuf_Value): google_protobuf_NullValue {.inline.} =
     message.kind.null_value
@@ -387,12 +270,7 @@ proc `null_value=`*(message: google_protobuf_Value, value: google_protobuf_NullV
 
 proc clearnumber_value*(message: google_protobuf_Value) =
     message.kind.number_value = 0
-    excl(message.hasField, 2)
-    excl(message.hasField, 1)
-    excl(message.hasField, 3)
-    excl(message.hasField, 4)
-    excl(message.hasField, 5)
-    excl(message.hasField, 6)
+    excl(message.hasField, [2, 1, 3, 4, 5, 6])
 
 proc hasnumber_value*(message: google_protobuf_Value): bool =
     result = contains(message.hasField, 2)
@@ -400,11 +278,7 @@ proc hasnumber_value*(message: google_protobuf_Value): bool =
 proc setnumber_value*(message: google_protobuf_Value, value: float64) =
     message.kind.number_value = value
     incl(message.hasField, 2)
-    excl(message.hasField, 1)
-    excl(message.hasField, 3)
-    excl(message.hasField, 4)
-    excl(message.hasField, 5)
-    excl(message.hasField, 6)
+    excl(message.hasField, [1, 3, 4, 5, 6])
 
 proc number_value*(message: google_protobuf_Value): float64 {.inline.} =
     message.kind.number_value
@@ -414,12 +288,7 @@ proc `number_value=`*(message: google_protobuf_Value, value: float64) {.inline.}
 
 proc clearstring_value*(message: google_protobuf_Value) =
     message.kind.string_value = ""
-    excl(message.hasField, 3)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 4)
-    excl(message.hasField, 5)
-    excl(message.hasField, 6)
+    excl(message.hasField, [3, 1, 2, 4, 5, 6])
 
 proc hasstring_value*(message: google_protobuf_Value): bool =
     result = contains(message.hasField, 3)
@@ -427,11 +296,7 @@ proc hasstring_value*(message: google_protobuf_Value): bool =
 proc setstring_value*(message: google_protobuf_Value, value: string) =
     message.kind.string_value = value
     incl(message.hasField, 3)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 4)
-    excl(message.hasField, 5)
-    excl(message.hasField, 6)
+    excl(message.hasField, [1, 2, 4, 5, 6])
 
 proc string_value*(message: google_protobuf_Value): string {.inline.} =
     message.kind.string_value
@@ -441,12 +306,7 @@ proc `string_value=`*(message: google_protobuf_Value, value: string) {.inline.}
 
 proc clearbool_value*(message: google_protobuf_Value) =
     message.kind.bool_value = false
-    excl(message.hasField, 4)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 3)
-    excl(message.hasField, 5)
-    excl(message.hasField, 6)
+    excl(message.hasField, [4, 1, 2, 3, 5, 6])
 
 proc hasbool_value*(message: google_protobuf_Value): bool =
     result = contains(message.hasField, 4)
@@ -454,11 +314,7 @@ proc hasbool_value*(message: google_protobuf_Value): bool =
 proc setbool_value*(message: google_protobuf_Value, value: bool) =
     message.kind.bool_value = value
     incl(message.hasField, 4)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 3)
-    excl(message.hasField, 5)
-    excl(message.hasField, 6)
+    excl(message.hasField, [1, 2, 3, 5, 6])
 
 proc bool_value*(message: google_protobuf_Value): bool {.inline.} =
     message.kind.bool_value
@@ -468,12 +324,7 @@ proc `bool_value=`*(message: google_protobuf_Value, value: bool) {.inline.} =
 
 proc clearstruct_value*(message: google_protobuf_Value) =
     message.kind.struct_value = nil
-    excl(message.hasField, 5)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 3)
-    excl(message.hasField, 4)
-    excl(message.hasField, 6)
+    excl(message.hasField, [5, 1, 2, 3, 4, 6])
 
 proc hasstruct_value*(message: google_protobuf_Value): bool =
     result = contains(message.hasField, 5)
@@ -481,11 +332,7 @@ proc hasstruct_value*(message: google_protobuf_Value): bool =
 proc setstruct_value*(message: google_protobuf_Value, value: google_protobuf_Struct) =
     message.kind.struct_value = value
     incl(message.hasField, 5)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 3)
-    excl(message.hasField, 4)
-    excl(message.hasField, 6)
+    excl(message.hasField, [1, 2, 3, 4, 6])
 
 proc struct_value*(message: google_protobuf_Value): google_protobuf_Struct {.inline.} =
     message.kind.struct_value
@@ -495,12 +342,7 @@ proc `struct_value=`*(message: google_protobuf_Value, value: google_protobuf_Str
 
 proc clearlist_value*(message: google_protobuf_Value) =
     message.kind.list_value = nil
-    excl(message.hasField, 6)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 3)
-    excl(message.hasField, 4)
-    excl(message.hasField, 5)
+    excl(message.hasField, [6, 1, 2, 3, 4, 5])
 
 proc haslist_value*(message: google_protobuf_Value): bool =
     result = contains(message.hasField, 6)
@@ -508,11 +350,7 @@ proc haslist_value*(message: google_protobuf_Value): bool =
 proc setlist_value*(message: google_protobuf_Value, value: google_protobuf_ListValue) =
     message.kind.list_value = value
     incl(message.hasField, 6)
-    excl(message.hasField, 1)
-    excl(message.hasField, 2)
-    excl(message.hasField, 3)
-    excl(message.hasField, 4)
-    excl(message.hasField, 5)
+    excl(message.hasField, [1, 2, 3, 4, 5])
 
 proc list_value*(message: google_protobuf_Value): google_protobuf_ListValue {.inline.} =
     message.kind.list_value
@@ -522,59 +360,37 @@ proc `list_value=`*(message: google_protobuf_Value, value: google_protobuf_ListV
 
 proc sizeOfgoogle_protobuf_Value*(message: google_protobuf_Value): uint64 =
     if hasnull_value(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_NullValue(message.kind.null_value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfgoogle_protobuf_NullValue(message.kind.null_value)
     if hasnumber_value(message):
-        let
-            sizeOfField = sizeOfDouble(message.kind.number_value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.Fixed64)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(2, WireType.Fixed64)
+        result = result + sizeOfDouble(message.kind.number_value)
     if hasstring_value(message):
-        let
-            sizeOfField = sizeOfString(message.kind.string_value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(3, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(3, WireType.LengthDelimited)
+        result = result + sizeOfString(message.kind.string_value)
     if hasbool_value(message):
-        let
-            sizeOfField = sizeOfBool(message.kind.bool_value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(4, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(4, WireType.Varint)
+        result = result + sizeOfBool(message.kind.bool_value)
     if hasstruct_value(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Struct(message.kind.struct_value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(5, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
-        result = result + sizeOfUInt64(sizeOfField)
+        result = result + sizeOfTag(5, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Struct(message.kind.struct_value))
     if haslist_value(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_ListValue(message.kind.list_value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(6, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
-        result = result + sizeOfUInt64(sizeOfField)
+        result = result + sizeOfTag(6, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_ListValue(message.kind.list_value))
 
 proc writegoogle_protobuf_Value*(stream: ProtobufStream, message: google_protobuf_Value) =
     if hasnull_value(message):
-        writeTag(stream, 1, WireType.Varint)
-        writegoogle_protobuf_NullValue(stream, message.kind.null_value)
+        writegoogle_protobuf_NullValue(stream, message.kind.null_value, 1)
     if hasnumber_value(message):
-        writeTag(stream, 2, WireType.Fixed64)
-        writeDouble(stream, message.kind.number_value)
+        writeDouble(stream, message.kind.number_value, 2)
     if hasstring_value(message):
-        writeTag(stream, 3, WireType.LengthDelimited)
-        writeString(stream, message.kind.string_value)
+        writeString(stream, message.kind.string_value, 3)
     if hasbool_value(message):
-        writeTag(stream, 4, WireType.Varint)
-        writeBool(stream, message.kind.bool_value)
+        writeBool(stream, message.kind.bool_value, 4)
     if hasstruct_value(message):
-        writeTag(stream, 5, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Struct(message.kind.struct_value))
-        writegoogle_protobuf_Struct(stream, message.kind.struct_value)
+        writeMessage(stream, message.kind.struct_value, 5)
     if haslist_value(message):
-        writeTag(stream, 6, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_ListValue(message.kind.list_value))
-        writegoogle_protobuf_ListValue(stream, message.kind.list_value)
+        writeMessage(stream, message.kind.list_value, 6)
 
 proc readgoogle_protobuf_Value*(stream: ProtobufStream): google_protobuf_Value =
     result = newgoogle_protobuf_Value()
diff --git a/src/protobuf/wkt/timestamp.proto b/src/nimpb/wkt/timestamp.proto
index b7cbd17..b7cbd17 100644
--- a/src/protobuf/wkt/timestamp.proto
+++ b/src/nimpb/wkt/timestamp.proto
diff --git a/src/protobuf/wkt/timestamp_pb.nim b/src/nimpb/wkt/timestamp_pb.nim
index 958a894..d3af2b0 100644
--- a/src/protobuf/wkt/timestamp_pb.nim
+++ b/src/nimpb/wkt/timestamp_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     google_protobuf_Timestamp* = ref google_protobuf_TimestampObj
@@ -24,7 +24,7 @@ proc newgoogle_protobuf_Timestamp*(): google_protobuf_Timestamp =
 
 proc clearseconds*(message: google_protobuf_Timestamp) =
     message.seconds = 0
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasseconds*(message: google_protobuf_Timestamp): bool =
     result = contains(message.hasField, 1)
@@ -41,7 +41,7 @@ proc `seconds=`*(message: google_protobuf_Timestamp, value: int64) {.inline.} =
 
 proc clearnanos*(message: google_protobuf_Timestamp) =
     message.nanos = 0
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasnanos*(message: google_protobuf_Timestamp): bool =
     result = contains(message.hasField, 2)
@@ -58,23 +58,17 @@ proc `nanos=`*(message: google_protobuf_Timestamp, value: int32) {.inline.} =
 
 proc sizeOfgoogle_protobuf_Timestamp*(message: google_protobuf_Timestamp): uint64 =
     if hasseconds(message):
-        let
-            sizeOfField = sizeOfInt64(message.seconds)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfInt64(message.seconds)
     if hasnanos(message):
-        let
-            sizeOfField = sizeOfInt32(message.nanos)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(2, WireType.Varint)
+        result = result + sizeOfInt32(message.nanos)
 
 proc writegoogle_protobuf_Timestamp*(stream: ProtobufStream, message: google_protobuf_Timestamp) =
     if hasseconds(message):
-        writeTag(stream, 1, WireType.Varint)
-        writeInt64(stream, message.seconds)
+        writeInt64(stream, message.seconds, 1)
     if hasnanos(message):
-        writeTag(stream, 2, WireType.Varint)
-        writeInt32(stream, message.nanos)
+        writeInt32(stream, message.nanos, 2)
 
 proc readgoogle_protobuf_Timestamp*(stream: ProtobufStream): google_protobuf_Timestamp =
     result = newgoogle_protobuf_Timestamp()
diff --git a/src/protobuf/wkt/type.proto b/src/nimpb/wkt/type.proto
index 624c15e..624c15e 100644
--- a/src/protobuf/wkt/type.proto
+++ b/src/nimpb/wkt/type.proto
diff --git a/src/protobuf/wkt/type_pb.nim b/src/nimpb/wkt/type_pb.nim
index ca25cd0..90ea596 100644
--- a/src/protobuf/wkt/type_pb.nim
+++ b/src/nimpb/wkt/type_pb.nim
@@ -2,10 +2,10 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
-import protobuf/wkt/any_pb
-import protobuf/wkt/source_context_pb
+import nimpb/wkt/any_pb
+import nimpb/wkt/source_context_pb
 
 type
     google_protobuf_Syntax* {.pure.} = enum
@@ -84,6 +84,9 @@ proc readgoogle_protobuf_Syntax*(stream: ProtobufStream): google_protobuf_Syntax
 proc writegoogle_protobuf_Syntax*(stream: ProtobufStream, value: google_protobuf_Syntax) =
     writeUInt32(stream, uint32(value))
 
+proc writegoogle_protobuf_Syntax*(stream: ProtobufStream, value: google_protobuf_Syntax, fieldNumber: int) =
+    writeUInt32(stream, uint32(value), fieldNumber)
+
 proc sizeOfgoogle_protobuf_Syntax*(value: google_protobuf_Syntax): uint64 =
     sizeOfUInt32(uint32(value))
 
@@ -93,6 +96,9 @@ proc readgoogle_protobuf_Field_Kind*(stream: ProtobufStream): google_protobuf_Fi
 proc writegoogle_protobuf_Field_Kind*(stream: ProtobufStream, value: google_protobuf_Field_Kind) =
     writeUInt32(stream, uint32(value))
 
+proc writegoogle_protobuf_Field_Kind*(stream: ProtobufStream, value: google_protobuf_Field_Kind, fieldNumber: int) =
+    writeUInt32(stream, uint32(value), fieldNumber)
+
 proc sizeOfgoogle_protobuf_Field_Kind*(value: google_protobuf_Field_Kind): uint64 =
     sizeOfUInt32(uint32(value))
 
@@ -102,6 +108,9 @@ proc readgoogle_protobuf_Field_Cardinality*(stream: ProtobufStream): google_prot
 proc writegoogle_protobuf_Field_Cardinality*(stream: ProtobufStream, value: google_protobuf_Field_Cardinality) =
     writeUInt32(stream, uint32(value))
 
+proc writegoogle_protobuf_Field_Cardinality*(stream: ProtobufStream, value: google_protobuf_Field_Cardinality, fieldNumber: int) =
+    writeUInt32(stream, uint32(value), fieldNumber)
+
 proc sizeOfgoogle_protobuf_Field_Cardinality*(value: google_protobuf_Field_Cardinality): uint64 =
     sizeOfUInt32(uint32(value))
 
@@ -138,7 +147,7 @@ proc newgoogle_protobuf_Option*(): google_protobuf_Option =
 
 proc clearname*(message: google_protobuf_Option) =
     message.name = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasname*(message: google_protobuf_Option): bool =
     result = contains(message.hasField, 1)
@@ -155,7 +164,7 @@ proc `name=`*(message: google_protobuf_Option, value: string) {.inline.} =
 
 proc clearvalue*(message: google_protobuf_Option) =
     message.value = nil
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasvalue*(message: google_protobuf_Option): bool =
     result = contains(message.hasField, 2)
@@ -172,25 +181,17 @@ proc `value=`*(message: google_protobuf_Option, value: google_protobuf_Any) {.in
 
 proc sizeOfgoogle_protobuf_Option*(message: google_protobuf_Option): uint64 =
     if hasname(message):
-        let
-            sizeOfField = sizeOfString(message.name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.name)
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Any(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
-        result = result + sizeOfUInt64(sizeOfField)
+        result = result + sizeOfTag(2, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Any(message.value))
 
 proc writegoogle_protobuf_Option*(stream: ProtobufStream, message: google_protobuf_Option) =
     if hasname(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.name)
+        writeString(stream, message.name, 1)
     if hasvalue(message):
-        writeTag(stream, 2, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Any(message.value))
-        writegoogle_protobuf_Any(stream, message.value)
+        writeMessage(stream, message.value, 2)
 
 proc readgoogle_protobuf_Option*(stream: ProtobufStream): google_protobuf_Option =
     result = newgoogle_protobuf_Option()
@@ -243,7 +244,7 @@ proc newgoogle_protobuf_Field*(): google_protobuf_Field =
 
 proc clearkind*(message: google_protobuf_Field) =
     message.kind = google_protobuf_Field_Kind(0)
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc haskind*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 1)
@@ -260,7 +261,7 @@ proc `kind=`*(message: google_protobuf_Field, value: google_protobuf_Field_Kind)
 
 proc clearcardinality*(message: google_protobuf_Field) =
     message.cardinality = google_protobuf_Field_Cardinality(0)
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hascardinality*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 2)
@@ -277,7 +278,7 @@ proc `cardinality=`*(message: google_protobuf_Field, value: google_protobuf_Fiel
 
 proc clearnumber*(message: google_protobuf_Field) =
     message.number = 0
-    excl(message.hasField, 3)
+    excl(message.hasField, [3])
 
 proc hasnumber*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 3)
@@ -294,7 +295,7 @@ proc `number=`*(message: google_protobuf_Field, value: int32) {.inline.} =
 
 proc clearname*(message: google_protobuf_Field) =
     message.name = ""
-    excl(message.hasField, 4)
+    excl(message.hasField, [4])
 
 proc hasname*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 4)
@@ -311,7 +312,7 @@ proc `name=`*(message: google_protobuf_Field, value: string) {.inline.} =
 
 proc cleartype_url*(message: google_protobuf_Field) =
     message.type_url = ""
-    excl(message.hasField, 6)
+    excl(message.hasField, [6])
 
 proc hastype_url*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 6)
@@ -328,7 +329,7 @@ proc `type_url=`*(message: google_protobuf_Field, value: string) {.inline.} =
 
 proc clearoneof_index*(message: google_protobuf_Field) =
     message.oneof_index = 0
-    excl(message.hasField, 7)
+    excl(message.hasField, [7])
 
 proc hasoneof_index*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 7)
@@ -345,7 +346,7 @@ proc `oneof_index=`*(message: google_protobuf_Field, value: int32) {.inline.} =
 
 proc clearpacked*(message: google_protobuf_Field) =
     message.packed = false
-    excl(message.hasField, 8)
+    excl(message.hasField, [8])
 
 proc haspacked*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 8)
@@ -362,10 +363,10 @@ proc `packed=`*(message: google_protobuf_Field, value: bool) {.inline.} =
 
 proc clearoptions*(message: google_protobuf_Field) =
     message.options = @[]
-    excl(message.hasField, 9)
+    excl(message.hasField, [9])
 
 proc hasoptions*(message: google_protobuf_Field): bool =
-    result = contains(message.hasField, 9)
+    result = contains(message.hasField, 9) or (len(message.options) > 0)
 
 proc setoptions*(message: google_protobuf_Field, value: seq[google_protobuf_Option]) =
     message.options = value
@@ -383,7 +384,7 @@ proc `options=`*(message: google_protobuf_Field, value: seq[google_protobuf_Opti
 
 proc clearjson_name*(message: google_protobuf_Field) =
     message.json_name = ""
-    excl(message.hasField, 10)
+    excl(message.hasField, [10])
 
 proc hasjson_name*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 10)
@@ -400,7 +401,7 @@ proc `json_name=`*(message: google_protobuf_Field, value: string) {.inline.} =
 
 proc cleardefault_value*(message: google_protobuf_Field) =
     message.default_value = ""
-    excl(message.hasField, 11)
+    excl(message.hasField, [11])
 
 proc hasdefault_value*(message: google_protobuf_Field): bool =
     result = contains(message.hasField, 11)
@@ -417,90 +418,57 @@ proc `default_value=`*(message: google_protobuf_Field, value: string) {.inline.}
 
 proc sizeOfgoogle_protobuf_Field*(message: google_protobuf_Field): uint64 =
     if haskind(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Field_Kind(message.kind)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfgoogle_protobuf_Field_Kind(message.kind)
     if hascardinality(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Field_Cardinality(message.cardinality)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(2, WireType.Varint)
+        result = result + sizeOfgoogle_protobuf_Field_Cardinality(message.cardinality)
     if hasnumber(message):
-        let
-            sizeOfField = sizeOfInt32(message.number)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(3, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(3, WireType.Varint)
+        result = result + sizeOfInt32(message.number)
     if hasname(message):
-        let
-            sizeOfField = sizeOfString(message.name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(4, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(4, WireType.LengthDelimited)
+        result = result + sizeOfString(message.name)
     if hastype_url(message):
-        let
-            sizeOfField = sizeOfString(message.type_url)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(6, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(6, WireType.LengthDelimited)
+        result = result + sizeOfString(message.type_url)
     if hasoneof_index(message):
-        let
-            sizeOfField = sizeOfInt32(message.oneof_index)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(7, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(7, WireType.Varint)
+        result = result + sizeOfInt32(message.oneof_index)
     if haspacked(message):
-        let
-            sizeOfField = sizeOfBool(message.packed)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(8, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(8, WireType.Varint)
+        result = result + sizeOfBool(message.packed)
     for value in message.options:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Option(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(9, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(9, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value))
     if hasjson_name(message):
-        let
-            sizeOfField = sizeOfString(message.json_name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(10, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(10, WireType.LengthDelimited)
+        result = result + sizeOfString(message.json_name)
     if hasdefault_value(message):
-        let
-            sizeOfField = sizeOfString(message.default_value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(11, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(11, WireType.LengthDelimited)
+        result = result + sizeOfString(message.default_value)
 
 proc writegoogle_protobuf_Field*(stream: ProtobufStream, message: google_protobuf_Field) =
     if haskind(message):
-        writeTag(stream, 1, WireType.Varint)
-        writegoogle_protobuf_Field_Kind(stream, message.kind)
+        writegoogle_protobuf_Field_Kind(stream, message.kind, 1)
     if hascardinality(message):
-        writeTag(stream, 2, WireType.Varint)
-        writegoogle_protobuf_Field_Cardinality(stream, message.cardinality)
+        writegoogle_protobuf_Field_Cardinality(stream, message.cardinality, 2)
     if hasnumber(message):
-        writeTag(stream, 3, WireType.Varint)
-        writeInt32(stream, message.number)
+        writeInt32(stream, message.number, 3)
     if hasname(message):
-        writeTag(stream, 4, WireType.LengthDelimited)
-        writeString(stream, message.name)
+        writeString(stream, message.name, 4)
     if hastype_url(message):
-        writeTag(stream, 6, WireType.LengthDelimited)
-        writeString(stream, message.type_url)
+        writeString(stream, message.type_url, 6)
     if hasoneof_index(message):
-        writeTag(stream, 7, WireType.Varint)
-        writeInt32(stream, message.oneof_index)
+        writeInt32(stream, message.oneof_index, 7)
     if haspacked(message):
-        writeTag(stream, 8, WireType.Varint)
-        writeBool(stream, message.packed)
+        writeBool(stream, message.packed, 8)
     for value in message.options:
-        writeTag(stream, 9, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Option(value))
-        writegoogle_protobuf_Option(stream, value)
+        writeMessage(stream, value, 9)
     if hasjson_name(message):
-        writeTag(stream, 10, WireType.LengthDelimited)
-        writeString(stream, message.json_name)
+        writeString(stream, message.json_name, 10)
     if hasdefault_value(message):
-        writeTag(stream, 11, WireType.LengthDelimited)
-        writeString(stream, message.default_value)
+        writeString(stream, message.default_value, 11)
 
 proc readgoogle_protobuf_Field*(stream: ProtobufStream): google_protobuf_Field =
     result = newgoogle_protobuf_Field()
@@ -573,7 +541,7 @@ proc newgoogle_protobuf_Type*(): google_protobuf_Type =
 
 proc clearname*(message: google_protobuf_Type) =
     message.name = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasname*(message: google_protobuf_Type): bool =
     result = contains(message.hasField, 1)
@@ -590,10 +558,10 @@ proc `name=`*(message: google_protobuf_Type, value: string) {.inline.} =
 
 proc clearfields*(message: google_protobuf_Type) =
     message.fields = @[]
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasfields*(message: google_protobuf_Type): bool =
-    result = contains(message.hasField, 2)
+    result = contains(message.hasField, 2) or (len(message.fields) > 0)
 
 proc setfields*(message: google_protobuf_Type, value: seq[google_protobuf_Field]) =
     message.fields = value
@@ -611,10 +579,10 @@ proc `fields=`*(message: google_protobuf_Type, value: seq[google_protobuf_Field]
 
 proc clearoneofs*(message: google_protobuf_Type) =
     message.oneofs = @[]
-    excl(message.hasField, 3)
+    excl(message.hasField, [3])
 
 proc hasoneofs*(message: google_protobuf_Type): bool =
-    result = contains(message.hasField, 3)
+    result = contains(message.hasField, 3) or (len(message.oneofs) > 0)
 
 proc setoneofs*(message: google_protobuf_Type, value: seq[string]) =
     message.oneofs = value
@@ -632,10 +600,10 @@ proc `oneofs=`*(message: google_protobuf_Type, value: seq[string]) {.inline.} =
 
 proc clearoptions*(message: google_protobuf_Type) =
     message.options = @[]
-    excl(message.hasField, 4)
+    excl(message.hasField, [4])
 
 proc hasoptions*(message: google_protobuf_Type): bool =
-    result = contains(message.hasField, 4)
+    result = contains(message.hasField, 4) or (len(message.options) > 0)
 
 proc setoptions*(message: google_protobuf_Type, value: seq[google_protobuf_Option]) =
     message.options = value
@@ -653,7 +621,7 @@ proc `options=`*(message: google_protobuf_Type, value: seq[google_protobuf_Optio
 
 proc clearsource_context*(message: google_protobuf_Type) =
     message.source_context = nil
-    excl(message.hasField, 5)
+    excl(message.hasField, [5])
 
 proc hassource_context*(message: google_protobuf_Type): bool =
     result = contains(message.hasField, 5)
@@ -670,7 +638,7 @@ proc `source_context=`*(message: google_protobuf_Type, value: google_protobuf_So
 
 proc clearsyntax*(message: google_protobuf_Type) =
     message.syntax = google_protobuf_Syntax(0)
-    excl(message.hasField, 6)
+    excl(message.hasField, [6])
 
 proc hassyntax*(message: google_protobuf_Type): bool =
     result = contains(message.hasField, 6)
@@ -687,64 +655,37 @@ proc `syntax=`*(message: google_protobuf_Type, value: google_protobuf_Syntax) {.
 
 proc sizeOfgoogle_protobuf_Type*(message: google_protobuf_Type): uint64 =
     if hasname(message):
-        let
-            sizeOfField = sizeOfString(message.name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.name)
     for value in message.fields:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Field(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(2, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Field(value))
     for value in message.oneofs:
-        let
-            sizeOfValue = sizeOfString(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(3, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
+        result = result + sizeOfTag(3, WireType.LengthDelimited)
+        result = result + sizeOfString(value)
     for value in message.options:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Option(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(4, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(4, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value))
     if hassource_context(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_SourceContext(message.source_context)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(5, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
-        result = result + sizeOfUInt64(sizeOfField)
+        result = result + sizeOfTag(5, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context))
     if hassyntax(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Syntax(message.syntax)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(6, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(6, WireType.Varint)
+        result = result + sizeOfgoogle_protobuf_Syntax(message.syntax)
 
 proc writegoogle_protobuf_Type*(stream: ProtobufStream, message: google_protobuf_Type) =
     if hasname(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.name)
+        writeString(stream, message.name, 1)
     for value in message.fields:
-        writeTag(stream, 2, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Field(value))
-        writegoogle_protobuf_Field(stream, value)
+        writeMessage(stream, value, 2)
     for value in message.oneofs:
-        writeTag(stream, 3, WireType.LengthDelimited)
-        writeString(stream, value)
+        writeString(stream, value, 3)
     for value in message.options:
-        writeTag(stream, 4, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Option(value))
-        writegoogle_protobuf_Option(stream, value)
+        writeMessage(stream, value, 4)
     if hassource_context(message):
-        writeTag(stream, 5, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_SourceContext(message.source_context))
-        writegoogle_protobuf_SourceContext(stream, message.source_context)
+        writeMessage(stream, message.source_context, 5)
     if hassyntax(message):
-        writeTag(stream, 6, WireType.Varint)
-        writegoogle_protobuf_Syntax(stream, message.syntax)
+        writegoogle_protobuf_Syntax(stream, message.syntax, 6)
 
 proc readgoogle_protobuf_Type*(stream: ProtobufStream): google_protobuf_Type =
     result = newgoogle_protobuf_Type()
@@ -810,7 +751,7 @@ proc newgoogle_protobuf_EnumValue*(): google_protobuf_EnumValue =
 
 proc clearname*(message: google_protobuf_EnumValue) =
     message.name = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasname*(message: google_protobuf_EnumValue): bool =
     result = contains(message.hasField, 1)
@@ -827,7 +768,7 @@ proc `name=`*(message: google_protobuf_EnumValue, value: string) {.inline.} =
 
 proc clearnumber*(message: google_protobuf_EnumValue) =
     message.number = 0
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasnumber*(message: google_protobuf_EnumValue): bool =
     result = contains(message.hasField, 2)
@@ -844,10 +785,10 @@ proc `number=`*(message: google_protobuf_EnumValue, value: int32) {.inline.} =
 
 proc clearoptions*(message: google_protobuf_EnumValue) =
     message.options = @[]
-    excl(message.hasField, 3)
+    excl(message.hasField, [3])
 
 proc hasoptions*(message: google_protobuf_EnumValue): bool =
-    result = contains(message.hasField, 3)
+    result = contains(message.hasField, 3) or (len(message.options) > 0)
 
 proc setoptions*(message: google_protobuf_EnumValue, value: seq[google_protobuf_Option]) =
     message.options = value
@@ -865,34 +806,22 @@ proc `options=`*(message: google_protobuf_EnumValue, value: seq[google_protobuf_
 
 proc sizeOfgoogle_protobuf_EnumValue*(message: google_protobuf_EnumValue): uint64 =
     if hasname(message):
-        let
-            sizeOfField = sizeOfString(message.name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.name)
     if hasnumber(message):
-        let
-            sizeOfField = sizeOfInt32(message.number)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(2, WireType.Varint)
+        result = result + sizeOfInt32(message.number)
     for value in message.options:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Option(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(3, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(3, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value))
 
 proc writegoogle_protobuf_EnumValue*(stream: ProtobufStream, message: google_protobuf_EnumValue) =
     if hasname(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.name)
+        writeString(stream, message.name, 1)
     if hasnumber(message):
-        writeTag(stream, 2, WireType.Varint)
-        writeInt32(stream, message.number)
+        writeInt32(stream, message.number, 2)
     for value in message.options:
-        writeTag(stream, 3, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Option(value))
-        writegoogle_protobuf_Option(stream, value)
+        writeMessage(stream, value, 3)
 
 proc readgoogle_protobuf_EnumValue*(stream: ProtobufStream): google_protobuf_EnumValue =
     result = newgoogle_protobuf_EnumValue()
@@ -943,7 +872,7 @@ proc newgoogle_protobuf_Enum*(): google_protobuf_Enum =
 
 proc clearname*(message: google_protobuf_Enum) =
     message.name = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasname*(message: google_protobuf_Enum): bool =
     result = contains(message.hasField, 1)
@@ -960,10 +889,10 @@ proc `name=`*(message: google_protobuf_Enum, value: string) {.inline.} =
 
 proc clearenumvalue*(message: google_protobuf_Enum) =
     message.enumvalue = @[]
-    excl(message.hasField, 2)
+    excl(message.hasField, [2])
 
 proc hasenumvalue*(message: google_protobuf_Enum): bool =
-    result = contains(message.hasField, 2)
+    result = contains(message.hasField, 2) or (len(message.enumvalue) > 0)
 
 proc setenumvalue*(message: google_protobuf_Enum, value: seq[google_protobuf_EnumValue]) =
     message.enumvalue = value
@@ -981,10 +910,10 @@ proc `enumvalue=`*(message: google_protobuf_Enum, value: seq[google_protobuf_Enu
 
 proc clearoptions*(message: google_protobuf_Enum) =
     message.options = @[]
-    excl(message.hasField, 3)
+    excl(message.hasField, [3])
 
 proc hasoptions*(message: google_protobuf_Enum): bool =
-    result = contains(message.hasField, 3)
+    result = contains(message.hasField, 3) or (len(message.options) > 0)
 
 proc setoptions*(message: google_protobuf_Enum, value: seq[google_protobuf_Option]) =
     message.options = value
@@ -1002,7 +931,7 @@ proc `options=`*(message: google_protobuf_Enum, value: seq[google_protobuf_Optio
 
 proc clearsource_context*(message: google_protobuf_Enum) =
     message.source_context = nil
-    excl(message.hasField, 4)
+    excl(message.hasField, [4])
 
 proc hassource_context*(message: google_protobuf_Enum): bool =
     result = contains(message.hasField, 4)
@@ -1019,7 +948,7 @@ proc `source_context=`*(message: google_protobuf_Enum, value: google_protobuf_So
 
 proc clearsyntax*(message: google_protobuf_Enum) =
     message.syntax = google_protobuf_Syntax(0)
-    excl(message.hasField, 5)
+    excl(message.hasField, [5])
 
 proc hassyntax*(message: google_protobuf_Enum): bool =
     result = contains(message.hasField, 5)
@@ -1036,55 +965,32 @@ proc `syntax=`*(message: google_protobuf_Enum, value: google_protobuf_Syntax) {.
 
 proc sizeOfgoogle_protobuf_Enum*(message: google_protobuf_Enum): uint64 =
     if hasname(message):
-        let
-            sizeOfField = sizeOfString(message.name)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.name)
     for value in message.enumvalue:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_EnumValue(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(2, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(2, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_EnumValue(value))
     for value in message.options:
-        let
-            sizeOfValue = sizeOfgoogle_protobuf_Option(value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(3, WireType.LengthDelimited)))
-        result = result + sizeOfValue + sizeOfTag
-    
-        result = result + sizeOfUInt64(sizeOfValue)
+        result = result + sizeOfTag(3, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_Option(value))
     if hassource_context(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_SourceContext(message.source_context)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(4, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
-        result = result + sizeOfUInt64(sizeOfField)
+        result = result + sizeOfTag(4, WireType.LengthDelimited)
+        result = result + sizeOfLengthDelimited(sizeOfgoogle_protobuf_SourceContext(message.source_context))
     if hassyntax(message):
-        let
-            sizeOfField = sizeOfgoogle_protobuf_Syntax(message.syntax)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(5, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(5, WireType.Varint)
+        result = result + sizeOfgoogle_protobuf_Syntax(message.syntax)
 
 proc writegoogle_protobuf_Enum*(stream: ProtobufStream, message: google_protobuf_Enum) =
     if hasname(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.name)
+        writeString(stream, message.name, 1)
     for value in message.enumvalue:
-        writeTag(stream, 2, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_EnumValue(value))
-        writegoogle_protobuf_EnumValue(stream, value)
+        writeMessage(stream, value, 2)
     for value in message.options:
-        writeTag(stream, 3, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_Option(value))
-        writegoogle_protobuf_Option(stream, value)
+        writeMessage(stream, value, 3)
     if hassource_context(message):
-        writeTag(stream, 4, WireType.LengthDelimited)
-        writeVarint(stream, sizeOfgoogle_protobuf_SourceContext(message.source_context))
-        writegoogle_protobuf_SourceContext(stream, message.source_context)
+        writeMessage(stream, message.source_context, 4)
     if hassyntax(message):
-        writeTag(stream, 5, WireType.Varint)
-        writegoogle_protobuf_Syntax(stream, message.syntax)
+        writegoogle_protobuf_Syntax(stream, message.syntax, 5)
 
 proc readgoogle_protobuf_Enum*(stream: ProtobufStream): google_protobuf_Enum =
     result = newgoogle_protobuf_Enum()
diff --git a/src/protobuf/wkt/wrappers.proto b/src/nimpb/wkt/wrappers.proto
index 0194763..0194763 100644
--- a/src/protobuf/wkt/wrappers.proto
+++ b/src/nimpb/wkt/wrappers.proto
diff --git a/src/protobuf/wkt/wrappers_pb.nim b/src/nimpb/wkt/wrappers_pb.nim
index 873fcb7..18c9731 100644
--- a/src/protobuf/wkt/wrappers_pb.nim
+++ b/src/nimpb/wkt/wrappers_pb.nim
@@ -2,7 +2,7 @@
 
 import intsets
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 type
     google_protobuf_DoubleValue* = ref google_protobuf_DoubleValueObj
@@ -94,7 +94,7 @@ proc newgoogle_protobuf_Int32Value*(): google_protobuf_Int32Value =
 
 proc clearvalue*(message: google_protobuf_Int32Value) =
     message.value = 0
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_Int32Value): bool =
     result = contains(message.hasField, 1)
@@ -111,15 +111,12 @@ proc `value=`*(message: google_protobuf_Int32Value, value: int32) {.inline.} =
 
 proc sizeOfgoogle_protobuf_Int32Value*(message: google_protobuf_Int32Value): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfInt32(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfInt32(message.value)
 
 proc writegoogle_protobuf_Int32Value*(stream: ProtobufStream, message: google_protobuf_Int32Value) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.Varint)
-        writeInt32(stream, message.value)
+        writeInt32(stream, message.value, 1)
 
 proc readgoogle_protobuf_Int32Value*(stream: ProtobufStream): google_protobuf_Int32Value =
     result = newgoogle_protobuf_Int32Value()
@@ -156,7 +153,7 @@ proc newgoogle_protobuf_Int64Value*(): google_protobuf_Int64Value =
 
 proc clearvalue*(message: google_protobuf_Int64Value) =
     message.value = 0
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_Int64Value): bool =
     result = contains(message.hasField, 1)
@@ -173,15 +170,12 @@ proc `value=`*(message: google_protobuf_Int64Value, value: int64) {.inline.} =
 
 proc sizeOfgoogle_protobuf_Int64Value*(message: google_protobuf_Int64Value): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfInt64(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfInt64(message.value)
 
 proc writegoogle_protobuf_Int64Value*(stream: ProtobufStream, message: google_protobuf_Int64Value) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.Varint)
-        writeInt64(stream, message.value)
+        writeInt64(stream, message.value, 1)
 
 proc readgoogle_protobuf_Int64Value*(stream: ProtobufStream): google_protobuf_Int64Value =
     result = newgoogle_protobuf_Int64Value()
@@ -218,7 +212,7 @@ proc newgoogle_protobuf_DoubleValue*(): google_protobuf_DoubleValue =
 
 proc clearvalue*(message: google_protobuf_DoubleValue) =
     message.value = 0
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_DoubleValue): bool =
     result = contains(message.hasField, 1)
@@ -235,15 +229,12 @@ proc `value=`*(message: google_protobuf_DoubleValue, value: float64) {.inline.}
 
 proc sizeOfgoogle_protobuf_DoubleValue*(message: google_protobuf_DoubleValue): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfDouble(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Fixed64)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Fixed64)
+        result = result + sizeOfDouble(message.value)
 
 proc writegoogle_protobuf_DoubleValue*(stream: ProtobufStream, message: google_protobuf_DoubleValue) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.Fixed64)
-        writeDouble(stream, message.value)
+        writeDouble(stream, message.value, 1)
 
 proc readgoogle_protobuf_DoubleValue*(stream: ProtobufStream): google_protobuf_DoubleValue =
     result = newgoogle_protobuf_DoubleValue()
@@ -280,7 +271,7 @@ proc newgoogle_protobuf_StringValue*(): google_protobuf_StringValue =
 
 proc clearvalue*(message: google_protobuf_StringValue) =
     message.value = ""
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_StringValue): bool =
     result = contains(message.hasField, 1)
@@ -297,15 +288,12 @@ proc `value=`*(message: google_protobuf_StringValue, value: string) {.inline.} =
 
 proc sizeOfgoogle_protobuf_StringValue*(message: google_protobuf_StringValue): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfString(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfString(message.value)
 
 proc writegoogle_protobuf_StringValue*(stream: ProtobufStream, message: google_protobuf_StringValue) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeString(stream, message.value)
+        writeString(stream, message.value, 1)
 
 proc readgoogle_protobuf_StringValue*(stream: ProtobufStream): google_protobuf_StringValue =
     result = newgoogle_protobuf_StringValue()
@@ -342,7 +330,7 @@ proc newgoogle_protobuf_BoolValue*(): google_protobuf_BoolValue =
 
 proc clearvalue*(message: google_protobuf_BoolValue) =
     message.value = false
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_BoolValue): bool =
     result = contains(message.hasField, 1)
@@ -359,15 +347,12 @@ proc `value=`*(message: google_protobuf_BoolValue, value: bool) {.inline.} =
 
 proc sizeOfgoogle_protobuf_BoolValue*(message: google_protobuf_BoolValue): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfBool(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfBool(message.value)
 
 proc writegoogle_protobuf_BoolValue*(stream: ProtobufStream, message: google_protobuf_BoolValue) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.Varint)
-        writeBool(stream, message.value)
+        writeBool(stream, message.value, 1)
 
 proc readgoogle_protobuf_BoolValue*(stream: ProtobufStream): google_protobuf_BoolValue =
     result = newgoogle_protobuf_BoolValue()
@@ -404,7 +389,7 @@ proc newgoogle_protobuf_BytesValue*(): google_protobuf_BytesValue =
 
 proc clearvalue*(message: google_protobuf_BytesValue) =
     message.value = bytes("")
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_BytesValue): bool =
     result = contains(message.hasField, 1)
@@ -421,15 +406,12 @@ proc `value=`*(message: google_protobuf_BytesValue, value: bytes) {.inline.} =
 
 proc sizeOfgoogle_protobuf_BytesValue*(message: google_protobuf_BytesValue): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfBytes(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.LengthDelimited)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.LengthDelimited)
+        result = result + sizeOfBytes(message.value)
 
 proc writegoogle_protobuf_BytesValue*(stream: ProtobufStream, message: google_protobuf_BytesValue) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.LengthDelimited)
-        writeBytes(stream, message.value)
+        writeBytes(stream, message.value, 1)
 
 proc readgoogle_protobuf_BytesValue*(stream: ProtobufStream): google_protobuf_BytesValue =
     result = newgoogle_protobuf_BytesValue()
@@ -466,7 +448,7 @@ proc newgoogle_protobuf_FloatValue*(): google_protobuf_FloatValue =
 
 proc clearvalue*(message: google_protobuf_FloatValue) =
     message.value = 0
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_FloatValue): bool =
     result = contains(message.hasField, 1)
@@ -483,15 +465,12 @@ proc `value=`*(message: google_protobuf_FloatValue, value: float32) {.inline.} =
 
 proc sizeOfgoogle_protobuf_FloatValue*(message: google_protobuf_FloatValue): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfFloat(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Fixed32)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Fixed32)
+        result = result + sizeOfFloat(message.value)
 
 proc writegoogle_protobuf_FloatValue*(stream: ProtobufStream, message: google_protobuf_FloatValue) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.Fixed32)
-        writeFloat(stream, message.value)
+        writeFloat(stream, message.value, 1)
 
 proc readgoogle_protobuf_FloatValue*(stream: ProtobufStream): google_protobuf_FloatValue =
     result = newgoogle_protobuf_FloatValue()
@@ -528,7 +507,7 @@ proc newgoogle_protobuf_UInt64Value*(): google_protobuf_UInt64Value =
 
 proc clearvalue*(message: google_protobuf_UInt64Value) =
     message.value = 0
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_UInt64Value): bool =
     result = contains(message.hasField, 1)
@@ -545,15 +524,12 @@ proc `value=`*(message: google_protobuf_UInt64Value, value: uint64) {.inline.} =
 
 proc sizeOfgoogle_protobuf_UInt64Value*(message: google_protobuf_UInt64Value): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfUInt64(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfUInt64(message.value)
 
 proc writegoogle_protobuf_UInt64Value*(stream: ProtobufStream, message: google_protobuf_UInt64Value) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.Varint)
-        writeUInt64(stream, message.value)
+        writeUInt64(stream, message.value, 1)
 
 proc readgoogle_protobuf_UInt64Value*(stream: ProtobufStream): google_protobuf_UInt64Value =
     result = newgoogle_protobuf_UInt64Value()
@@ -590,7 +566,7 @@ proc newgoogle_protobuf_UInt32Value*(): google_protobuf_UInt32Value =
 
 proc clearvalue*(message: google_protobuf_UInt32Value) =
     message.value = 0
-    excl(message.hasField, 1)
+    excl(message.hasField, [1])
 
 proc hasvalue*(message: google_protobuf_UInt32Value): bool =
     result = contains(message.hasField, 1)
@@ -607,15 +583,12 @@ proc `value=`*(message: google_protobuf_UInt32Value, value: uint32) {.inline.} =
 
 proc sizeOfgoogle_protobuf_UInt32Value*(message: google_protobuf_UInt32Value): uint64 =
     if hasvalue(message):
-        let
-            sizeOfField = sizeOfUInt32(message.value)
-            sizeOfTag = sizeOfUInt32(uint32(makeTag(1, WireType.Varint)))
-        result = result + sizeOfField + sizeOfTag
+        result = result + sizeOfTag(1, WireType.Varint)
+        result = result + sizeOfUInt32(message.value)
 
 proc writegoogle_protobuf_UInt32Value*(stream: ProtobufStream, message: google_protobuf_UInt32Value) =
     if hasvalue(message):
-        writeTag(stream, 1, WireType.Varint)
-        writeUInt32(stream, message.value)
+        writeUInt32(stream, message.value, 1)
 
 proc readgoogle_protobuf_UInt32Value*(stream: ProtobufStream): google_protobuf_UInt32Value =
     result = newgoogle_protobuf_UInt32Value()
diff --git a/tests/conformance/conformance_nim.nim b/tests/conformance/conformance_nim.nim
index 9b0c736..9b30d26 100644
--- a/tests/conformance/conformance_nim.nim
+++ b/tests/conformance/conformance_nim.nim
@@ -2,7 +2,7 @@ import endians
 import streams
 import strformat
 
-import protobuf/protobuf
+import nimpb/nimpb
 
 import conformance_pb
 import test_messages_proto3_pb