Made sure that LongBits ctor is always called with unsigned 32 bits +…

… static codegen compat., fixes #690

index.d.ts

@@ -2033,8 +2033,8 @@ export namespace util {
      * @classdesc Helper class for working with the low and high bits of a 64 bit value.
      * @memberof util
      * @constructor
-     * @param {number} lo Low bits
-     * @param {number} hi High bits
+     * @param {number} lo Low bits, unsigned
+     * @param {number} hi High bits, unsigned
      */
     class LongBits {
 
@@ -2043,8 +2043,8 @@ export namespace util {
          * @classdesc Helper class for working with the low and high bits of a 64 bit value.
          * @memberof util
          * @constructor
-         * @param {number} lo Low bits
-         * @param {number} hi High bits
+         * @param {number} lo Low bits, unsigned
+         * @param {number} hi High bits, unsigned
          */
         constructor(lo: number, hi: number);
 

src/converter.js

@@ -66,7 +66,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
                 ("else if(typeof d%s===\"number\")", prop)
                     ("m%s=d%s", prop, prop)
                 ("else if(typeof d%s===\"object\")", prop)
-                    ("m%s=new util.LongBits(d%s.low,d%s.high).toNumber(%s)", prop, prop, prop, isUnsigned ? "true" : "");
+                    ("m%s=new util.LongBits(d%s.low>>>0,d%s.high>>>0).toNumber(%s)", prop, prop, prop, isUnsigned ? "true" : "");
                 break;
             case "bytes": gen
                 ("if(typeof d%s===\"string\")", prop)
@@ -172,7 +172,7 @@ function genValuePartial_toObject(gen, field, fieldIndex, prop) {
             ("if(typeof m%s===\"number\")", prop)
                 ("d%s=o.longs===String?String(m%s):m%s", prop, prop, prop)
             ("else") // Long-like
-                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low,m%s.high).toNumber(%s):m%s", prop, prop, prop, prop, isUnsigned ? "true": "", prop);
+                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", prop, prop, prop, prop, isUnsigned ? "true": "", prop);
                 break;
             case "bytes": gen
             ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", prop, prop, prop, prop, prop);

src/reader.js

@@ -105,7 +105,7 @@ Reader.prototype.sint32 = function read_sint32() {
 
 function readLongVarint() {
     // tends to deopt with local vars for octet etc.
-    var bits = new LongBits(0 >>> 0, 0 >>> 0);
+    var bits = new LongBits(0, 0);
     var i = 0;
     if (this.len - this.pos > 4) { // fast route (lo)
         for (; i < 4; ++i) {

src/util/longbits.js

@@ -19,22 +19,25 @@ var util = require("../util/minimal");
  * @classdesc Helper class for working with the low and high bits of a 64 bit value.
  * @memberof util
  * @constructor
- * @param {number} lo Low bits
- * @param {number} hi High bits
+ * @param {number} lo Low bits, unsigned
+ * @param {number} hi High bits, unsigned
  */
-function LongBits(lo, hi) { // make sure to always call this with unsigned 32bits for proper optimization
+function LongBits(lo, hi) {
+
+    // note that the casts below are theoretically unnecessary as of today, but older statically
+    // generated converter code might still call the ctor with signed 32bits. kept for compat.
 
     /**
      * Low bits.
      * @type {number}
      */
-    this.lo = lo;
+    this.lo = lo >>> 0;
 
     /**
      * High bits.
      * @type {number}
      */
-    this.hi = hi;
+    this.hi = hi >>> 0;
 }
 
 /**