protobufjs 8.6.4 → 8.6.6

package/ext/descriptor.js

@@ -251,7 +251,7 @@ function Type_fromDescriptor(descriptor, ctx, nested, depth) {
 
     var type = new Type(descriptor.name.length ? descriptor.name : "Type" + unnamedMessageIndex++, fromDescriptorOptions(descriptor.options, exports.MessageOptions)),
         i,
-        mapEntries = {};
+        mapEntries = Object.create(null);
 
     if (!nested) {
         type._edition = ctx.edition;
@@ -704,6 +704,8 @@ function Enum_fromDescriptor(descriptor, ctx, nested) {
                 valueName = name && name.length ? name : "NAME" + (descriptor.value[i].number || 0),
                 value = descriptor.value[i].number || 0,
                 options = fromDescriptorOptions(descriptor.value[i].options, exports.EnumValueOptions);
+            if (valueName === "__proto__")
+                continue;
             values[valueName] = value;
             if (options)
                 (valuesOptions || (valuesOptions = {}))[valueName] = options;
@@ -1006,7 +1008,7 @@ function fromDescriptorType(type) {
 }
 
 function groupTypeNames() {
-    var names = {};
+    var names = Object.create(null);
     for (var a = 0; a < arguments.length; ++a) {
         var fields = arguments[a];
         if (!fields)

package/ext/protojson.js

@@ -241,8 +241,10 @@ function readEnum(enm, value, name, options) {
         throw invalid(name, value, "unknown enum value");
     }
     if (typeof value === "number") {
-        if (!isFinite(value) || Math.floor(value) !== value)
+        if ((value | 0) !== value)
             throw invalid(name, value, "invalid enum number");
+        if (enm._features.enum_type === "CLOSED" && enm.valuesById[value] === undefined)
+            throw invalid(name, value, "unknown enum value");
         return value;
     }
     if (value === null && enm.fullName === ".google.protobuf.NullValue")

package/ext/textformat.js

@@ -464,17 +464,16 @@ Parser.prototype.parseAny = function parseAny(type, typeUrl, object, seen, depth
 };
 
 Parser.prototype.parseMapField = function parseMapField(field, object, depth) {
-    if (!object[field.name])
-        object[field.name] = {};
+    var map = getField(object, field, {});
     if (this.tn.skip("[")) {
         if (!this.tn.skip("]")) {
             do {
-                addMapEntry(field, object[field.name], this.parseMapEntry(field, depth + 1));
+                addMapEntry(field, map, this.parseMapEntry(field, depth + 1));
             } while (this.tn.skip(","));
             this.tn.expect("]");
         }
     } else
-        addMapEntry(field, object[field.name], this.parseMapEntry(field, depth + 1));
+        addMapEntry(field, map, this.parseMapEntry(field, depth + 1));
 };
 
 Parser.prototype.parseMessageFieldDelimiter = function parseMessageFieldDelimiter() {
@@ -637,7 +636,7 @@ Parser.prototype.skipBalanced = function skipBalanced(open, close, depth) {
 
 function addField(object, seen, field, value) {
     if (field.repeated) {
-        (object[field.name] || (object[field.name] = [])).push(value);
+        getField(object, field, []).push(value);
         return;
     }
     if (Object.prototype.hasOwnProperty.call(seen, field.name))
@@ -649,6 +648,18 @@ function addField(object, seen, field, value) {
         seen[oneofName] = true;
     }
     seen[field.name] = true;
+    setField(object, field, value);
+}
+
+function getField(object, field, value) {
+    if (!Object.prototype.hasOwnProperty.call(object, field.name))
+        setField(object, field, value);
+    return object[field.name];
+}
+
+function setField(object, field, value) {
+    if (field.name === "__proto__")
+        util.makeProp(object, field.name);
     object[field.name] = value;
 }
 
@@ -661,7 +672,10 @@ function addMapEntry(field, map, entry) {
         value = Object.prototype.hasOwnProperty.call(entry, "value")
             ? entry.value
             : defaultMapValue(valueField);
-    map[mapKey(keyField, key)] = value;
+    var outKey = mapKey(keyField, key);
+    if (outKey === "__proto__")
+        util.makeProp(map, outKey);
+    map[outKey] = value;
 }
 
 function defaultMapValue(field) {
@@ -832,6 +846,12 @@ function parseInteger(token, sign, unsigned, bits) {
         return parseIntegerBigInt(digits, radix, sign, unsigned, bits);
 
     var value = parseInt(digits, radix) * sign;
+    if (bits === 32) {
+        var min = unsigned ? 0 : -2147483648,
+            max = unsigned ? 4294967295 : 2147483647;
+        if (value < min || value > max)
+            throw Error((unsigned ? "unsigned " : "") + "integer value out of range");
+    }
     if (bits === 64 && util.Long)
         return util.Long.fromString(String(value), unsigned);
     return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobufjs",
-  "version": "8.6.4",
+  "version": "8.6.6",
   "description": "Protocol Buffers for JavaScript & TypeScript.",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
   "license": "BSD-3-Clause",
@@ -55,7 +55,7 @@
     "bundle-collapser": "^1.3.0",
     "escodegen": "^1.13.0",
     "eslint": "^10.0.0",
-    "eslint-plugin-jsdoc": "^62.9.0",
+    "eslint-plugin-jsdoc": "^63.0.0",
     "espree": "^9.0.0",
     "estraverse": "^5.1.0",
     "gh-pages": "^6.0.0",

package/src/converter.js

@@ -15,31 +15,33 @@ var Enum  = require("./enum"),
  * @param {Field} field Reflected field
  * @param {number} fieldIndex Field index
  * @param {string} prop Property reference
+ * @param {string} [dstProp] Repeated destination property reference
  * @returns {Codegen} Codegen instance
  * @ignore
  */
-function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
-    var defaultAlreadyEmitted = false;
+function genValuePartial_fromObject(gen, field, fieldIndex, prop, dstProp) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
     if (field.resolvedType) {
-        if (field.resolvedType instanceof Enum) { gen
+        if (field.resolvedType instanceof Enum) {
+            var dst = dstProp
+                ? "m" + dstProp + "[m" + dstProp + ".length]"
+                : "m" + prop;
+            gen
             ("switch(d%s){", prop);
-            for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) {
-                // enum unknown values passthrough
-                if (values[keys[i]] === field.typeDefault && !defaultAlreadyEmitted) { gen
-                    ("default:")
-                        ("if(typeof d%s===\"number\"){m%s=d%s;break}", prop, prop, prop);
-                    if (!field.repeated) gen // fallback to default value only for
-                                             // arrays, to avoid leaving holes.
-                        ("break");           // for non-repeated fields, just ignore
-                    defaultAlreadyEmitted = true;
-                }
-                gen
+            for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) { gen
                 ("case%j:", keys[i])
                 ("case %i:", values[keys[i]])
-                    ("m%s=%j", prop, values[keys[i]])
+                    ("%s=%j", dst, values[keys[i]])
                     ("break");
-            } gen
+            }
+            gen
+                ("default:");
+            if (field.resolvedType._features.enum_type !== "CLOSED") {
+                gen
+                    ("if(typeof d%s===\"number\"&&(d%s|0)===d%s)", prop, prop, prop)
+                        ("%s=d%s", dst, prop);
+            }
+            gen
             ("}");
         } else gen
             ("if(!util.isObject(d%s))", prop)
@@ -142,10 +144,14 @@ converter.fromObject = function fromObject(mtype) {
         } else if (field.repeated) { gen
     ("if(d%s){", prop)
         ("if(!Array.isArray(d%s))", prop)
-            ("throw TypeError(%j)", field.fullName + ": array expected")
-        ("m%s=Array(d%s.length)", prop, prop)
+            ("throw TypeError(%j)", field.fullName + ": array expected");
+            if (field.resolvedType instanceof Enum) gen
+        ("m%s=[]", prop);
+            else gen
+        ("m%s=Array(d%s.length)", prop, prop);
+            gen
         ("for(var i=0;i<d%s.length;++i){", prop);
-            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]")
+            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]", field.resolvedType instanceof Enum ? prop : undefined)
         ("}")
     ("}");
 
@@ -162,6 +168,8 @@ converter.fromObject = function fromObject(mtype) {
     ("if(d%s.length){", prop);
                 else if (field.type === "bool") gen
     ("if(d%s){", prop);
+                else if (field.type === "double" || field.type === "float") gen
+    ("if(!Object.is(Number(d%s),0)){", prop);
                 else if (types.long[field.type] !== undefined) gen
     ("if(typeof d%s===\"object\"?d%s.low||d%s.high:Number(d%s)!==0){", prop, prop, prop, prop);
                 else gen

package/src/decoder.js

@@ -13,6 +13,16 @@ function stringMethod(field) {
     return field._features.utf8_validation === "VERIFY" ? "stringVerify" : "string";
 }
 
+function genPreserveUnknown(gen, ref) {
+    /* eslint-disable no-unexpected-multiline */
+    return gen
+        ("if(!r.discardUnknown){")
+            ("util.makeProp(m,\"$unknowns\",false);")
+            ("(m.$unknowns||(m.$unknowns=[])).push(%s)", ref)
+        ("}");
+    /* eslint-enable no-unexpected-multiline */
+}
+
 /**
  * Generates a decoder specific to the specified message type.
  * @param {Type} mtype Message type
@@ -21,14 +31,14 @@ function stringMethod(field) {
 function decoder(mtype) {
     /* eslint-disable no-unexpected-multiline */
     var hasMapField = false,
-        hasImplicitPresenceField = false,
+        needsValueVar = false,
         i = 0;
     for (; i < mtype.fieldsArray.length; ++i) {
         var pfield = mtype._fieldsArray[i];
         if (pfield.map)
             hasMapField = true;
-        if (!pfield.repeated && !pfield.map && !pfield.hasPresence)
-            hasImplicitPresenceField = true;
+        if (pfield.resolvedType instanceof Enum || !pfield.repeated && !pfield.map && !pfield.hasPresence)
+            needsValueVar = true;
     }
     var gen = util.codegen(["r", "l", "z", "q", "g"])
     ("if(!(r instanceof Reader))")
@@ -36,7 +46,7 @@ function decoder(mtype) {
     ("if(q===undefined)q=0")
     ("if(q>Reader.recursionLimit)")
         ("throw Error(\"max depth exceeded\")")
-    ("var c=l===undefined?r.len:r.pos+l,m=g||new C" + (hasMapField ? ",k,v" : hasImplicitPresenceField ? ",v" : ""))
+    ("var c=l===undefined?r.len:r.pos+l,m=g||new C" + (hasMapField ? ",k,v" : needsValueVar ? ",v" : ""))
     ("while(r.pos<c){")
         ("var s=r.pos")
         ("var t=r.tag()")
@@ -48,18 +58,21 @@ function decoder(mtype) {
         ("var u=t&7")
         ("switch(t>>>=3){");
     for (i = 0; i < /* initializes */ mtype.fieldsArray.length; ++i) {
-        var field = mtype._fieldsArray[i].resolve(),
-            type  = field.resolvedType instanceof Enum ? "int32" : field.type,
-            ref   = "m" + util.safeProp(field.name);
+        var field  = mtype._fieldsArray[i].resolve(),
+            type   = field.resolvedType instanceof Enum ? "int32" : field.type,
+            ref    = "m" + util.safeProp(field.name),
+            closed = field.resolvedType instanceof Enum && field.resolvedType._features.enum_type === "CLOSED";
 
         // Map fields
         if (field.map) {
             gen
             ("case %i:{", field.id)
                 ("if(u!==2)")
-                    ("break")
+                    ("break");
+            if (!closed) gen
                 ("if(%s===util.emptyObject)", ref)
-                    ("%s={}", ref)
+                    ("%s={}", ref);
+            gen
                 ("var c2=r.uint32()+r.pos");
 
             if (types.defaults[field.keyType] !== undefined) gen
@@ -99,6 +112,15 @@ function decoder(mtype) {
                     ("r.skipType(u,q,t2)")
                 ("}");
 
+            if (closed) { gen
+                ("if(types[%i].valuesById[v]===undefined){", i);
+                    genPreserveUnknown(gen, "r.raw(s,r.pos)")
+                    ("continue")
+                ("}")
+                ("if(%s===util.emptyObject)", ref)
+                    ("%s={}", ref);
+            }
+
             var val = types.basic[type] === undefined ? "v||new types[" + i + "].ctor" : "v";
             if (types.long[field.keyType] !== undefined) gen
                 ("%s[typeof k===\"object\"?util.longToHash(k):k]=%s", ref, val);
@@ -116,20 +138,39 @@ function decoder(mtype) {
             ("{");
 
             // Packable (always check for forward and backward compatiblity)
-            if (types.packed[type] !== undefined) gen
-                ("if(u===2){")
+            if (types.packed[type] !== undefined) {
+                gen
+                ("if(u===2){");
+                if (!closed) gen
                     ("if(!(%s&&%s.length))", ref, ref)
-                        ("%s=[]", ref)
-                    ("var c2=r.uint32()+r.pos")
+                        ("%s=[]", ref);
+                gen
+                    ("var c2=r.uint32()+r.pos");
+                if (closed) {
+                    gen
+                    ("while(r.pos<c2){")
+                        ("s=r.pos")
+                        ("v=r.%s()", type)
+                        ("if(types[%i].valuesById[v]!==undefined){", i)
+                            ("if(!(%s&&%s.length))", ref, ref)
+                                ("%s=[]", ref)
+                            ("%s.push(v)", ref)
+                        ("}else");
+                            genPreserveUnknown(gen, "util.rawField(" + field.id + ",0,r.raw(s,r.pos))")
+                    ("}");
+                } else gen
                     ("while(r.pos<c2)")
-                        ("%s.push(r.%s())", ref, type)
+                        ("%s.push(r.%s())", ref, type);
+                gen
                     ("continue")
                 ("}");
+            }
 
             // Non-packed
             gen
                 ("if(u!==%i)", types.basic[type] === undefined ? field.delimited ? 3 : 2 : types.basic[type])
-                    ("break")
+                    ("break");
+            if (!closed) gen
                 ("if(!(%s&&%s.length))", ref, ref)
                     ("%s=[]", ref);
             if (types.basic[type] === undefined) {
@@ -137,6 +178,14 @@ function decoder(mtype) {
                     ("%s.push(types[%i].decode(r,undefined,%i,q+1))", ref, i, field.id * 8 + 4);
                 else gen
                     ("%s.push(types[%i].decode(r,r.uint32(),undefined,q+1))", ref, i);
+            } else if (closed) { gen
+                    ("v=r.%s()", type)
+                    ("if(types[%i].valuesById[v]!==undefined){", i)
+                        ("if(!(%s&&%s.length))", ref, ref)
+                            ("%s=[]", ref)
+                        ("%s.push(v)", ref)
+                    ("}else");
+                        genPreserveUnknown(gen, "r.raw(s,r.pos)");
             } else gen
                     ("%s.push(r.%s())", ref, type === "string" ? stringMethod(field) : type);
 
@@ -155,33 +204,55 @@ function decoder(mtype) {
             gen
             ("case %i:{", field.id)
                 ("if(u!==%i)", types.basic[type])
-                    ("break")
+                    ("break");
+            if (closed) { gen
+                ("v=r.%s()", type)
+                ("if(types[%i].valuesById[v]!==undefined){", i)
+                    ("%s=v", ref);
+                if (field.partOf) gen
+                    ("m%s=%j", util.safeProp(field.partOf.name), field.name);
+                gen
+                ("}else");
+                    genPreserveUnknown(gen, "r.raw(s,r.pos)");
+            } else gen
                 ("%s=r.%s()", ref, type === "string" ? stringMethod(field) : type);
         } else {
             gen
             ("case %i:{", field.id)
                 ("if(u!==%i)", types.basic[type])
                     ("break");
-            if (field.resolvedType instanceof Enum && field.typeDefault !== 0) gen
-                // TODO: Protoc rejects open enums whose first value is not zero.
-                // We should do the same, but for v8 this would be a regression.
-                ("if((v=r.%s())!==%j)", type, field.typeDefault);
-            else if (type === "string") gen
-                ("if((v=r.%s()).length)", stringMethod(field));
-            else if (type === "bytes") gen
-                ("if((v=r.%s()).length)", type);
-            else if (types.long[type] !== undefined) gen
-                ("if(typeof(v=r.%s())===\"object\"?v.low||v.high:v!==0)", type);
-            else if (type === "double" || type === "float") gen
-                ("if((v=r.%s())!==0)", type);
-            else gen
-                ("if(v=r.%s())", type);
-            gen
-                    ("%s=v", ref)
-                ("else")
-                    ("delete %s", ref); // rare/odd case: later default clears earlier non-default
+            if (closed) { gen
+                ("v=r.%s()", type)
+                ("if(types[%i].valuesById[v]!==undefined){", i)
+                    ("if(v!==%j)", field.typeDefault)
+                        ("%s=v", ref)
+                    ("else")
+                        ("delete %s", ref)
+                ("}else{");
+                    genPreserveUnknown(gen, "r.raw(s,r.pos)")
+                ("}");
+            } else {
+                if (field.resolvedType instanceof Enum && field.typeDefault !== 0) gen
+                    // TODO: Protoc rejects open enums whose first value is not zero.
+                    // We should do the same, but for v8 this would be a regression.
+                    ("if((v=r.%s())!==%j)", type, field.typeDefault);
+                else if (type === "string") gen
+                    ("if((v=r.%s()).length)", stringMethod(field));
+                else if (type === "bytes") gen
+                    ("if((v=r.%s()).length)", type);
+                else if (types.long[type] !== undefined) gen
+                    ("if(typeof(v=r.%s())===\"object\"?v.low||v.high:v!==0)", type);
+                else if (type === "double" || type === "float") gen
+                    ("if(!Object.is(v=r.%s(),0))", type);
+                else gen
+                    ("if(v=r.%s())", type);
+                gen
+                        ("%s=v", ref)
+                    ("else")
+                        ("delete %s", ref); // rare/odd case: later default clears earlier non-default
+            }
         }
-        if (field.partOf) gen
+        if (field.partOf && !closed) gen
                 ("m%s=%j", util.safeProp(field.partOf.name), field.name);
         gen
                 ("continue")
@@ -191,11 +262,8 @@ function decoder(mtype) {
         ("}");
     // Unknown fields
     gen
-        ("r.skipType(%s,q,t)", i ? "u" : "t&7")
-        ("if(!r.discardUnknown){")
-            ("util.makeProp(m,\"$unknowns\",false);")
-            ("(m.$unknowns||(m.$unknowns=[])).push(r.raw(s,r.pos))")
-        ("}")
+        ("r.skipType(%s,q,t)", i ? "u" : "t&7");
+    genPreserveUnknown(gen, "r.raw(s,r.pos)")
     ("}")
     ("if(z!==undefined)")
         ("throw Error(\"missing end group\")");

package/src/encoder.js

@@ -91,8 +91,23 @@ function encoder(mtype) {
 
         // Non-repeated
         } else {
-            if (!field.required) gen
+            if (!field.required)
+                if (field.hasPresence || !(field.resolvedType instanceof Enum || types.basic[type] !== undefined)) gen
     ("if(%s!=null&&Object.hasOwnProperty.call(m,%j))", ref, field.name); // !== undefined && !== null
+                else if (field.resolvedType instanceof Enum) gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==%j)", ref, field.name, ref, field.typeDefault);
+                else if (type === "bool") gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==false)", ref, field.name, ref);
+                else if (type === "string") gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==\"\")", ref, field.name, ref);
+                else if (type === "bytes") gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s.length)", ref, field.name, ref);
+                else if (type === "double" || type === "float") gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&!Object.is(%s,0))", ref, field.name, ref);
+                else if (types.long[type] !== undefined) gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&(typeof %s===\"object\"?%s.low||%s.high:%s!==0))", ref, field.name, ref, ref, ref, ref);
+                else gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==0)", ref, field.name, ref);
 
             if (wireType === undefined)
         genTypePartial(gen, field, index, ref);

package/src/enum.js

@@ -3,7 +3,15 @@ module.exports = Enum;
 
 // extends ReflectionObject
 var ReflectionObject = require("./object");
-((Enum.prototype = Object.create(ReflectionObject.prototype)).constructor = Enum).className = "Enum";
+Enum.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: Enum,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Enum.className = "Enum";
 
 var Namespace = require("./namespace"),
     util = require("./util");
@@ -30,7 +38,7 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
      * Enum values by id.
      * @type {Object.<number,string>}
      */
-    this.valuesById = {};
+    this.valuesById = Object.create(null);
 
     /**
      * Enum values by name.

package/src/field.js

@@ -3,7 +3,15 @@ module.exports = Field;
 
 // extends ReflectionObject
 var ReflectionObject = require("./object");
-((Field.prototype = Object.create(ReflectionObject.prototype)).constructor = Field).className = "Field";
+Field.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: Field,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Field.className = "Field";
 
 var Enum  = require("./enum"),
     types = require("./types"),

package/src/mapfield.js

@@ -3,7 +3,15 @@ module.exports = MapField;
 
 // extends Field
 var Field = require("./field");
-((MapField.prototype = Object.create(Field.prototype)).constructor = MapField).className = "MapField";
+MapField.prototype = Object.create(Field.prototype, {
+    constructor: {
+        value: MapField,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+MapField.className = "MapField";
 
 var types   = require("./types"),
     util    = require("./util");

package/src/method.js

@@ -3,7 +3,15 @@ module.exports = Method;
 
 // extends ReflectionObject
 var ReflectionObject = require("./object");
-((Method.prototype = Object.create(ReflectionObject.prototype)).constructor = Method).className = "Method";
+Method.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: Method,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Method.className = "Method";
 
 var util = require("./util");
 

package/src/namespace.js

@@ -3,7 +3,15 @@ module.exports = Namespace;
 
 // extends ReflectionObject
 var ReflectionObject = require("./object");
-((Namespace.prototype = Object.create(ReflectionObject.prototype)).constructor = Namespace).className = "Namespace";
+Namespace.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: Namespace,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Namespace.className = "Namespace";
 
 var Field    = require("./field"),
     util     = require("./util"),

package/src/object.js

@@ -270,7 +270,7 @@ ReflectionObject.prototype._inferLegacyProtoFeatures = function _inferLegacyProt
  * @returns {*} Option value or `undefined` if not set
  */
 ReflectionObject.prototype.getOption = function getOption(name) {
-    if (this.options)
+    if (this.options && Object.prototype.hasOwnProperty.call(this.options, name))
         return this.options[name];
     return undefined;
 };
@@ -289,9 +289,12 @@ ReflectionObject.prototype.setOption = function setOption(name, value, ifNotSet)
         this.options = {};
     if (/^features\./.test(name)) {
         util.setProperty(this.options, name, value, ifNotSet);
-    } else if (!ifNotSet || this.options[name] === undefined) {
-        if (this.getOption(name) !== value) this.resolved = false;
-        this.options[name] = value;
+    } else {
+        var prev = this.getOption(name);
+        if (!ifNotSet || prev === undefined) {
+            if (prev !== value) this.resolved = false;
+            this.options[name] = value;
+        }
     }
 
     return this;
@@ -353,15 +356,22 @@ ReflectionObject.prototype.setOptions = function setOptions(options, ifNotSet) {
 
 /**
  * Converts this instance to its string representation.
+ * @name ReflectionObject#toString
+ * @function
  * @returns {string} Class name[, space, full name]
  */
-ReflectionObject.prototype.toString = function toString() {
-    var className = this.constructor.className,
-        fullName  = this.fullName;
-    if (fullName.length)
-        return className + " " + fullName;
-    return className;
-};
+Object.defineProperty(ReflectionObject.prototype, "toString", {
+    value: function toString() {
+        var className = this.constructor.className,
+            fullName  = this.fullName;
+        if (fullName.length)
+            return className + " " + fullName;
+        return className;
+    },
+    writable: true,
+    enumerable: false,
+    configurable: true
+});
 
 /**
  * Converts the edition this object is pinned to for JSON format.

package/src/oneof.js

@@ -3,7 +3,15 @@ module.exports = OneOf;
 
 // extends ReflectionObject
 var ReflectionObject = require("./object");
-((OneOf.prototype = Object.create(ReflectionObject.prototype)).constructor = OneOf).className = "OneOf";
+OneOf.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: OneOf,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+OneOf.className = "OneOf";
 
 var Field = require("./field"),
     util  = require("./util");