protobufjs 3.6.0 → 3.8.2

package/src/ProtoBuf/DotProto/Tokenizer.js

@@ -1,11 +1,11 @@
 /*?
-    // --- Scope -----------------
-    // Lang : Language expressions
-    */
+// --- Scope -----------------
+// Lang : Language expressions
+*/
 /**
  * Constructs a new Tokenizer.
  * @exports ProtoBuf.DotProto.Tokenizer
- * @class proto tokenizer
+ * @class prototype tokenizer
  * @param {string} proto Proto to tokenize
  * @constructor
  */
@@ -54,22 +54,28 @@ var Tokenizer = function(proto) {
     this.stringEndsWith = Lang.STRINGCLOSE;
 };
 
+/**
+ * @alias ProtoBuf.DotProto.Tokenizer.prototype
+ * @inner
+ */
+var TokenizerPrototype = Tokenizer.prototype;
+
 /**
  * Reads a string beginning at the current index.
  * @return {string} The string
  * @throws {Error} If it's not a valid string
  * @private
  */
-Tokenizer.prototype._readString = function() {
+TokenizerPrototype._readString = function() {
     Lang.STRING.lastIndex = this.index-1; // Include the open quote
     var match;
     if ((match = Lang.STRING.exec(this.source)) !== null) {
-        var s = match[1];
+        var s = typeof match[1] !== 'undefined' ? match[1] : match[2];
         this.index = Lang.STRING.lastIndex;
         this.stack.push(this.stringEndsWith);
         return s;
     }
-    throw Error("Illegal string value at line "+this.line+", index "+this.index);
+    throw Error("Unterminated string at line "+this.line+", index "+this.index);
 };
 
 /**
@@ -78,7 +84,7 @@ Tokenizer.prototype._readString = function() {
  * @throws {Error} If it's not a valid proto file
  * @expose
  */
-Tokenizer.prototype.next = function() {
+TokenizerPrototype.next = function() {
     if (this.stack.length > 0)
         return this.stack.shift();
     if (this.index >= this.source.length)
@@ -121,7 +127,7 @@ Tokenizer.prototype.next = function() {
                 this.index++;
                 repeat = true;
             } else
-                throw Error("Invalid comment at line "+this.line+": /"+this.source.charAt(this.index)+" ('/' or '*' expected)");
+                throw Error("Unterminated comment at line "+this.line+": /"+this.source.charAt(this.index));
         }
     } while (repeat);
     if (this.index === this.source.length) return null;
@@ -152,7 +158,7 @@ Tokenizer.prototype.next = function() {
  * @throws {Error} If it's not a valid proto file
  * @expose
  */
-Tokenizer.prototype.peek = function() {
+TokenizerPrototype.peek = function() {
     if (this.stack.length === 0) {
         var token = this.next();
         if (token === null)
@@ -167,6 +173,6 @@ Tokenizer.prototype.peek = function() {
  * @return {string} String representation as of "Tokenizer(index/length)"
  * @expose
  */
-Tokenizer.prototype.toString = function() {
+TokenizerPrototype.toString = function() {
     return "Tokenizer("+this.index+"/"+this.source.length+" at line "+this.line+")";
 };

package/src/ProtoBuf/Lang.js

@@ -33,6 +33,6 @@ ProtoBuf.Lang = {
     ID: /^(?:[1-9][0-9]*|0|0x[0-9a-fA-F]+|0[0-7]+)$/,
     NEGID: /^\-?(?:[1-9][0-9]*|0|0x[0-9a-fA-F]+|0[0-7]+)$/,
     WHITESPACE: /\s/,
-    STRING: /['"]([^'"\\]*(\\.[^"\\]*)*)['"]/g,
+    STRING: /(?:"([^"\\]*(?:\\.[^"\\]*)*)")|(?:'([^'\\]*(?:\\.[^'\\]*)*)')/g,
     BOOL: /^(?:true|false)$/i
 };

package/src/ProtoBuf/Reflect/Enum/Value.js

@@ -1,14 +1,15 @@
 /**
  * Constructs a new Enum Value.
  * @exports ProtoBuf.Reflect.Enum.Value
+ * @param {!ProtoBuf.Builder} builder Builder reference
  * @param {!ProtoBuf.Reflect.Enum} enm Enum reference
  * @param {string} name Field name
  * @param {number} id Unique field id
  * @constructor
  * @extends ProtoBuf.Reflect.T
  */
-var Value = function(enm, name, id) {
-    T.call(this, enm, name);
+var Value = function(builder, enm, name, id) {
+    T.call(this, builder, enm, name);
 
     /**
      * @override

package/src/ProtoBuf/Reflect/Enum.js

@@ -1,14 +1,15 @@
 /**
  * Constructs a new Enum.
  * @exports ProtoBuf.Reflect.Enum
+ * @param {!ProtoBuf.Builder} builder Builder reference
  * @param {!ProtoBuf.Reflect.T} parent Parent Reflect object
  * @param {string} name Enum name
  * @param {Object.<string,*>=} options Enum options
  * @constructor
  * @extends ProtoBuf.Reflect.Namespace
  */
-var Enum = function(parent, name, options) {
-    Namespace.call(this, parent, name, options);
+var Enum = function(builder, parent, name, options) {
+    Namespace.call(this, builder, parent, name, options);
 
     /**
      * @override
@@ -23,15 +24,18 @@ var Enum = function(parent, name, options) {
     this.object = null;
 };
 
-// Extends Namespace
-Enum.prototype = Object.create(Namespace.prototype);
+/**
+ * @alias ProtoBuf.Reflect.Enum.prototype
+ * @inner
+ */
+var EnumPrototype = Enum.prototype = Object.create(Namespace.prototype);
 
 /**
  * Builds this enum and returns the runtime counterpart.
  * @return {Object<string,*>}
  * @expose
  */
-Enum.prototype.build = function() {
+EnumPrototype.build = function() {
     var enm = {},
         values = this.getChildren(Enum.Value);
     for (var i=0, k=values.length; i<k; ++i)

package/src/ProtoBuf/Reflect/Extension.js

@@ -2,12 +2,13 @@
  * An extension (field).
  * @exports ProtoBuf.Reflect.Extension
  * @constructor
- * @param {ProtoBuf.Reflect.T} parent Parent object
+ * @param {!ProtoBuf.Builder} builder Builder reference
+ * @param {!ProtoBuf.Reflect.T} parent Parent object
  * @param {string} name Object name
  * @param {!ProtoBuf.Reflect.Message.Field} field Extension field
  */
-var Extension = function(parent, name, field) {
-    T.call(this, parent, name);
+var Extension = function(builder, parent, name, field) {
+    T.call(this, builder, parent, name);
 
     /**
      * Extended message field.

package/src/ProtoBuf/Reflect/Message/ExtensionField.js

@@ -1,7 +1,8 @@
 /**
  * Constructs a new Message ExtensionField.
  * @exports ProtoBuf.Reflect.Message.ExtensionField
- * @param {ProtoBuf.Reflect.Message} message Message reference
+ * @param {!ProtoBuf.Builder} builder Builder reference
+ * @param {!ProtoBuf.Reflect.Message} message Message reference
  * @param {string} rule Rule, one of requried, optional, repeated
  * @param {string} type Data type, e.g. int32
  * @param {string} name Field name
@@ -10,8 +11,8 @@
  * @constructor
  * @extends ProtoBuf.Reflect.Message.Field
  */
-var ExtensionField = function(message, rule, type, name, id, options) {
-    Field.call(this, message, rule, type, name, id, options);
+var ExtensionField = function(builder, message, rule, type, name, id, options) {
+    Field.call(this, builder, message, rule, type, name, id, options);
 
     /**
      * Extension reference.

package/src/ProtoBuf/Reflect/Message/Field.js

@@ -1,17 +1,19 @@
 /**
  * Constructs a new Message Field.
  * @exports ProtoBuf.Reflect.Message.Field
- * @param {ProtoBuf.Reflect.Message} message Message reference
+ * @param {!ProtoBuf.Builder} builder Builder reference
+ * @param {!ProtoBuf.Reflect.Message} message Message reference
  * @param {string} rule Rule, one of requried, optional, repeated
  * @param {string} type Data type, e.g. int32
  * @param {string} name Field name
  * @param {number} id Unique field id
  * @param {Object.<string,*>=} options Options
+ * @param {!ProtoBuf.Reflect.Message.OneOf=} oneof Enclosing OneOf
  * @constructor
  * @extends ProtoBuf.Reflect.T
  */
-var Field = function(message, rule, type, name, id, options) {
-    T.call(this, message, name);
+var Field = function(builder, message, rule, type, name, id, options, oneof) {
+    T.call(this, builder, message, name);
 
     /**
      * @override
@@ -68,6 +70,13 @@ var Field = function(message, rule, type, name, id, options) {
      */
     this.defaultValue = null;
 
+    /**
+     * Enclosing OneOf.
+     * @type {?ProtoBuf.Reflect.Message.OneOf}
+     * @expose
+     */
+    this.oneof = oneof || null;
+
     /**
      * Original field name.
      * @type {string}
@@ -76,22 +85,34 @@ var Field = function(message, rule, type, name, id, options) {
     this.originalName = this.name; // Used to revert camelcase transformation on naming collisions
 
     // Convert field names to camel case notation if the override is set
-    if (ProtoBuf.convertFieldsToCamelCase && !(this instanceof Message.ExtensionField)) {
-        this.name = this.name.replace(/_([a-zA-Z])/g, function($0, $1) {
-            return $1.toUpperCase();
-        });
-    }
+    if (this.builder.options['convertFieldsToCamelCase'] && !(this instanceof Message.ExtensionField))
+        this.name = Field._toCamelCase(this.name);
 };
 
-// Extends T
-Field.prototype = Object.create(T.prototype);
+/**
+ * Converts a field name to camel case.
+ * @param {string} name Likely underscore notated name
+ * @returns {string} Camel case notated name
+ * @private
+ */
+Field._toCamelCase = function(name) {
+    return name.replace(/_([a-zA-Z])/g, function($0, $1) {
+        return $1.toUpperCase();
+    });
+};
+
+/**
+ * @alias ProtoBuf.Reflect.Message.Field.prototype
+ * @inner
+ */
+var FieldPrototype = Field.prototype = Object.create(T.prototype);
 
 /**
  * Builds the field.
  * @override
  * @expose
  */
-Field.prototype.build = function() {
+FieldPrototype.build = function() {
     this.defaultValue = typeof this.options['default'] !== 'undefined'
         ? this.verifyValue(this.options['default']) : null;
 };
@@ -124,7 +145,7 @@ function mkLong(value, unsigned) {
  * @throws {Error} If the value cannot be set for this field
  * @expose
  */
-Field.prototype.verifyValue = function(value, skipRepeated) {
+FieldPrototype.verifyValue = function(value, skipRepeated) {
     skipRepeated = skipRepeated || false;
     var fail = function(val, msg) {
         throw Error("Illegal value for "+this.toString(true)+" of type "+this.type.name+": "+val+" ("+msg+")");
@@ -212,20 +233,18 @@ Field.prototype.verifyValue = function(value, skipRepeated) {
 
         // Length-delimited bytes
         case ProtoBuf.TYPES["bytes"]:
-            return value && value instanceof ByteBuffer
-                ? value
-                : ByteBuffer.wrap(value);
+            if (ByteBuffer.isByteBuffer(value))
+                return value;
+            return ByteBuffer.wrap(value, "base64");
 
         // Constant enum value
         case ProtoBuf.TYPES["enum"]: {
             var values = this.resolvedType.getChildren(Enum.Value);
-            for (i=0; i<values.length; i++) {
-                if (values[i].name == value) {
+            for (i=0; i<values.length; i++)
+                if (values[i].name == value)
                     return values[i].id;
-                } else if (values[i].id == value) {
+                else if (values[i].id == value)
                     return values[i].id;
-                }
-            }
             fail(value, "not a valid enum value");
         }
         // Embedded message
@@ -260,7 +279,7 @@ Field.prototype.verifyValue = function(value, skipRepeated) {
  * @throws {Error} If the field cannot be encoded
  * @expose
  */
-Field.prototype.encode = function(value, buffer) {
+FieldPrototype.encode = function(value, buffer) {
     if (this.type === null || typeof this.type !== 'object')
         throw Error("[INTERNAL] Unresolved type in "+this.toString(true)+": "+this.type);
     if (value === null || (this.repeated && value.length == 0))
@@ -312,7 +331,7 @@ Field.prototype.encode = function(value, buffer) {
  * @throws {Error} If the value cannot be encoded
  * @expose
  */
-Field.prototype.encodeValue = function(value, buffer) {
+FieldPrototype.encodeValue = function(value, buffer) {
     if (value === null) return buffer; // Nothing to encode
     // Tag has already been written
 
@@ -433,7 +452,7 @@ Field.prototype.encodeValue = function(value, buffer) {
  * @returns {number} Byte length
  * @expose
  */
-Field.prototype.calculate = function(value) {
+FieldPrototype.calculate = function(value) {
     value = this.verifyValue(value); // May throw
     if (this.type === null || typeof this.type !== 'object')
         throw Error("[INTERNAL] Unresolved type in "+this.toString(true)+": "+this.type);
@@ -472,7 +491,7 @@ Field.prototype.calculate = function(value) {
  * @throws {Error} If the value cannot be calculated
  * @expose
  */
-Field.prototype.calculateValue = function(value) {
+FieldPrototype.calculateValue = function(value) {
     if (value === null) return 0; // Nothing to encode
     // Tag has already been written
     var n;
@@ -528,7 +547,7 @@ Field.prototype.calculateValue = function(value) {
  * @throws {Error} If the field cannot be decoded
  * @expose
  */
-Field.prototype.decode = function(wireType, buffer, skipRepeated) {
+FieldPrototype.decode = function(wireType, buffer, skipRepeated) {
     var value, nBytes;
     if (wireType != this.type.wireType && (skipRepeated || (wireType != ProtoBuf.WIRE_TYPES.LDELIM || !this.repeated)))
         throw Error("Illegal wire type for field "+this.toString(true)+": "+wireType+" ("+this.type.wireType+" expected)");
@@ -628,4 +647,4 @@ Field.prototype.decode = function(wireType, buffer, skipRepeated) {
 
     // We should never end here
     throw Error("[INTERNAL] Illegal wire type for "+this.toString(true)+": "+wireType);
-}
+};

package/src/ProtoBuf/Reflect/Message/OneOf.js

@@ -0,0 +1,19 @@
+/**
+ * Constructs a new Message OneOf.
+ * @exports ProtoBuf.Reflect.Message.OneOf
+ * @param {!ProtoBuf.Builder} builder Builder reference
+ * @param {!ProtoBuf.Reflect.Message} message Message reference
+ * @param {string} name OneOf name
+ * @constructor
+ * @extends ProtoBuf.Reflect.T
+ */
+var OneOf = function(builder, message, name) {
+    T.call(this, builder, message, name);
+
+    /**
+     * Enclosed fields.
+     * @type {!Array.<!ProtoBuf.Reflect.Message.Field>}
+     * @expose
+     */
+    this.fields = [];
+};

package/src/ProtoBuf/Reflect/Message.js

@@ -1,15 +1,16 @@
 /**
  * Constructs a new Message.
  * @exports ProtoBuf.Reflect.Message
- * @param {ProtoBuf.Reflect.Namespace} parent Parent message or namespace
+ * @param {!ProtoBuf.Builder} builder Builder reference
+ * @param {!ProtoBuf.Reflect.Namespace} parent Parent message or namespace
  * @param {string} name Message name
- * @param {Object.<string,*>} options Message options
+ * @param {Object.<string,*>=} options Message options
  * @param {boolean=} isGroup `true` if this is a legacy group
  * @constructor
  * @extends ProtoBuf.Reflect.Namespace
  */
-var Message = function(parent, name, options, isGroup) {
-    Namespace.call(this, parent, name, options);
+var Message = function(builder, parent, name, options, isGroup) {
+    Namespace.call(this, builder, parent, name, options);
 
     /**
      * @override
@@ -52,10 +53,20 @@ var Message = function(parent, name, options, isGroup) {
      * @private
      */
     this._fieldsById = null;
+
+    /**
+     * Cached fields by name.
+     * @type {?Object.<string,!ProtoBuf.Reflect.Message.Field>}
+     * @private
+     */
+    this._fieldsByName = null;
 };
 
-// Extends Namespace
-Message.prototype = Object.create(Namespace.prototype);
+/**
+ * @alias ProtoBuf.Reflect.Message.prototype
+ * @inner
+ */
+var MessagePrototype = Message.prototype = Object.create(Namespace.prototype);
 
 /**
  * Builds the message and returns the runtime counterpart, which is a fully functional class.
@@ -65,7 +76,7 @@ Message.prototype = Object.create(Namespace.prototype);
  * @throws {Error} If the message cannot be built
  * @expose
  */
-Message.prototype.build = function(rebuild) {
+MessagePrototype.build = function(rebuild) {
     if (this.clazz && !rebuild)
         return this.clazz;
 
@@ -80,20 +91,20 @@ Message.prototype.build = function(rebuild) {
 
     // Static enums and prototyped sub-messages / cached collections
     this._fields = [];
-    this._fieldsById = [];
+    this._fieldsById = {};
+    this._fieldsByName = {};
     for (var i=0, k=this.children.length, child; i<k; i++) {
         child = this.children[i];
         if (child instanceof Enum)
-            clazz[child['name']] = child.build();
+            clazz[child.name] = child.build();
         else if (child instanceof Message)
-            clazz[child['name']] = child.build();
+            clazz[child.name] = child.build();
         else if (child instanceof Message.Field)
             child.build(),
             this._fields.push(child),
-            this._fieldsById[child.id] = child;
-        else if (child instanceof Extension) {
-            // Ignore
-        } else
+            this._fieldsById[child.id] = child,
+            this._fieldsByName[child.name] = child;
+        else if (!(child instanceof Message.OneOf) && !(child instanceof Extension)) // Not built
             throw Error("Illegal reflect child of "+this.toString(true)+": "+children[i].toString(true));
     }
 
@@ -109,11 +120,11 @@ Message.prototype.build = function(rebuild) {
  * @throws {Error} If required fields are missing or the message cannot be encoded for another reason
  * @expose
  */
-Message.prototype.encode = function(message, buffer, noVerify) {
+MessagePrototype.encode = function(message, buffer, noVerify) {
     var fieldMissing = null,
         field;
     for (var i=0, k=this._fields.length, val; i<k; ++i) {
-        field = this.children[i];
+        field = this._fields[i];
         val = message[field.name];
         if (field.required && val === null) {
             if (fieldMissing === null)
@@ -136,7 +147,7 @@ Message.prototype.encode = function(message, buffer, noVerify) {
  * @throws {Error} If required fields are missing or the message cannot be calculated for another reason
  * @expose
  */
-Message.prototype.calculate = function(message) {
+MessagePrototype.calculate = function(message) {
     for (var n=0, i=0, k=this._fields.length, field, val; i<k; ++i) {
         field = this._fields[i];
         val = message[field.name];
@@ -198,7 +209,7 @@ function skipTillGroupEnd(expectedId, buf) {
  * @throws {Error} If the message cannot be decoded
  * @expose
  */
-Message.prototype.decode = function(buffer, length, expectedGroupEndId) {
+MessagePrototype.decode = function(buffer, length, expectedGroupEndId) {
     length = typeof length === 'number' ? length : -1;
     var start = buffer.offset,
         msg = new (this.clazz)(),
@@ -238,8 +249,14 @@ Message.prototype.decode = function(buffer, length, expectedGroupEndId) {
         }
         if (field.repeated && !field.options["packed"])
             msg[field.name].push(field.decode(wireType, buffer));
-        else
+        else {
             msg[field.name] = field.decode(wireType, buffer);
+            if (field.oneof) {
+                if (this[field.oneof.name] !== null)
+                    this[this[field.oneof.name]] = null;
+                msg[field.oneof.name] = field.name;
+            }
+        }
     }
 
     // Check if all required fields are present and set default values for optional fields that are not

package/src/ProtoBuf/Reflect/Namespace.js

@@ -1,14 +1,15 @@
 /**
  * Constructs a new Namespace.
  * @exports ProtoBuf.Reflect.Namespace
- * @param {ProtoBuf.Reflect.Namespace|null} parent Namespace parent
+ * @param {!ProtoBuf.Builder} builder Builder reference
+ * @param {?ProtoBuf.Reflect.Namespace} parent Namespace parent
  * @param {string} name Namespace name
- * @param {Object.<string,*>} options Namespace options
+ * @param {Object.<string,*>=} options Namespace options
  * @constructor
  * @extends ProtoBuf.Reflect.T
  */
-var Namespace = function(parent, name, options) {
-    T.call(this, parent, name);
+var Namespace = function(builder, parent, name, options) {
+    T.call(this, builder, parent, name);
 
     /**
      * @override
@@ -17,19 +18,22 @@ var Namespace = function(parent, name, options) {
 
     /**
      * Children inside the namespace.
-     * @type {Array.<ProtoBuf.Reflect.T>}
+     * @type {!Array.<ProtoBuf.Reflect.T>}
      */
     this.children = [];
 
     /**
      * Options.
-     * @type {Object.<string, *>}
+     * @type {!Object.<string, *>}
      */
     this.options = options || {};
 };
 
-// Extends T
-Namespace.prototype = Object.create(T.prototype);
+/**
+ * @alias ProtoBuf.Reflect.Namespace.prototype
+ * @inner
+ */
+var NamespacePrototype = Namespace.prototype = Object.create(T.prototype);
 
 /**
  * Returns an array of the namespace's children.
@@ -37,7 +41,7 @@ Namespace.prototype = Object.create(T.prototype);
  * @return {Array.<ProtoBuf.Reflect.T>}
  * @expose
  */
-Namespace.prototype.getChildren = function(type) {
+NamespacePrototype.getChildren = function(type) {
     type = type || null;
     if (type == null)
         return this.children.slice();
@@ -54,7 +58,7 @@ Namespace.prototype.getChildren = function(type) {
  * @throws {Error} If the child cannot be added (duplicate)
  * @expose
  */
-Namespace.prototype.addChild = function(child) {
+NamespacePrototype.addChild = function(child) {
     var other;
     if (other = this.getChild(child.name)) {
         // Try to revert camelcase transformation on collision
@@ -74,7 +78,7 @@ Namespace.prototype.addChild = function(child) {
  * @return {?ProtoBuf.Reflect.T} The child or null if not found
  * @expose
  */
-Namespace.prototype.getChild = function(nameOrId) {
+NamespacePrototype.getChild = function(nameOrId) {
     var key = typeof nameOrId === 'number' ? 'id' : 'name';
     for (var i=0, k=this.children.length; i<k; ++i)
         if (this.children[i][key] === nameOrId)
@@ -89,7 +93,7 @@ Namespace.prototype.getChild = function(nameOrId) {
  * @return {?ProtoBuf.Reflect.Namespace} The resolved type or null if not found
  * @expose
  */
-Namespace.prototype.resolve = function(qn, excludeFields) {
+NamespacePrototype.resolve = function(qn, excludeFields) {
     var part = qn.split("."),
         ptr = this,
         i = 0;
@@ -123,7 +127,7 @@ Namespace.prototype.resolve = function(qn, excludeFields) {
  * @return {Object.<string,Function|Object>} Runtime namespace
  * @expose
  */
-Namespace.prototype.build = function() {
+NamespacePrototype.build = function() {
     /** @dict */
     var ns = {};
     var children = this.children;
@@ -141,7 +145,7 @@ Namespace.prototype.build = function() {
  * Builds the namespace's '$options' property.
  * @return {Object.<string,*>}
  */
-Namespace.prototype.buildOpt = function() {
+NamespacePrototype.buildOpt = function() {
     var opt = {},
         keys = Object.keys(this.options);
     for (var i=0, k=keys.length; i<k; ++i) {
@@ -162,7 +166,7 @@ Namespace.prototype.buildOpt = function() {
  * @param {string=} name Returns the option value if specified, otherwise all options are returned.
  * @return {*|Object.<string,*>}null} Option value or NULL if there is no such option
  */
-Namespace.prototype.getOption = function(name) {
+NamespacePrototype.getOption = function(name) {
     if (typeof name === 'undefined')
         return this.options;
     return typeof this.options[name] !== 'undefined' ? this.options[name] : null;

package/src/ProtoBuf/Reflect/Service/Method.js

@@ -1,14 +1,15 @@
 /**
  * Abstract service method.
  * @exports ProtoBuf.Reflect.Service.Method
+ * @param {!ProtoBuf.Builder} builder Builder reference
  * @param {!ProtoBuf.Reflect.Service} svc Service
  * @param {string} name Method name
  * @param {Object.<string,*>=} options Options
  * @constructor
  * @extends ProtoBuf.Reflect.T
  */
-var Method = function(svc, name, options) {
-    T.call(this, svc, name);
+var Method = function(builder, svc, name, options) {
+    T.call(this, builder, svc, name);
 
     /**
      * @override
@@ -23,8 +24,11 @@ var Method = function(svc, name, options) {
     this.options = options || {};
 };
 
-// Extends T
-Method.prototype = Object.create(T.prototype);
+/**
+ * @alias ProtoBuf.Reflect.Service.Method.prototype
+ * @inner
+ */
+var MethodPrototype = Method.prototype = Object.create(T.prototype);
 
 /**
  * Builds the method's '$options' property.
@@ -32,4 +36,4 @@ Method.prototype = Object.create(T.prototype);
  * @function
  * @return {Object.<string,*>}
  */
-Method.prototype.buildOpt = Namespace.prototype.buildOpt;
+MethodPrototype.buildOpt = NamespacePrototype.buildOpt;

package/src/ProtoBuf/Reflect/Service/RPCMethod.js

@@ -1,6 +1,7 @@
 /**
  * RPC service method.
  * @exports ProtoBuf.Reflect.Service.RPCMethod
+ * @param {!ProtoBuf.Builder} builder Builder reference
  * @param {!ProtoBuf.Reflect.Service} svc Service
  * @param {string} name Method name
  * @param {string} request Request message name
@@ -9,8 +10,8 @@
  * @constructor
  * @extends ProtoBuf.Reflect.Service.Method
  */
-var RPCMethod = function(svc, name, request, response, options) {
-    Method.call(this, svc, name, options);
+var RPCMethod = function(builder, svc, name, request, response, options) {
+    Method.call(this, builder, svc, name, options);
 
     /**
      * @override