Remove "jspb" prefix from assert function names

The jspb.asserts namespace should be sufficient to prevent closure
from pruning the asserts, so remove the redundant prefix from the
function names.

Author: dibenede

asserts.js

@@ -11,50 +11,6 @@
 
 goog.provide('jspb.asserts');
 
-/**
- * Error object for failed assertions.
- *
- * @extends {Error}
- * @final
- */
-
-class JspbAssertionError extends Error {
-  /**
-   * @param {string} messagePattern The pattern that was used to form message.
-   * @param {!Array<*>} messageArgs The items to substitute into the pattern.
-   */
-  constructor(messagePattern, messageArgs) {
-    super(subs(messagePattern, messageArgs));
-
-    /**
-     * The message pattern used to format the error message. Error handlers can
-     * use this to uniquely identify the assertion.
-     * @type {string}
-     */
-    this.messagePattern = messagePattern;
-  }
-}
-
-jspb.asserts.JspbAssertionError = JspbAssertionError;
-
-/**
- * The default error handler.
- * @param {!JspbAssertionError} e The exception to be handled.
- * @return {void}
- */
-jspb.asserts.JSPB_DEFAULT_ERROR_HANDLER = function(e) {
-  throw e;
-}
-
-
-
-/**
- * The handler responsible for throwing or logging assertion errors.
- * @type {function(!JspbAssertionError)}
- */
-let errorHandler_ = jspb.asserts.JSPB_DEFAULT_ERROR_HANDLER;
-
-
 /**
  * Does simple python-style string substitution.
  * subs("foo%s hot%s", "bar", "dog") becomes "foobar hotdog".
@@ -85,7 +41,7 @@ function subs(pattern, subs) {
  * @param {?Array<*>} defaultArgs The substitution arguments for defaultMessage.
  * @param {string|undefined} givenMessage Message supplied by the caller.
  * @param {!Array<*>} givenArgs The substitution arguments for givenMessage.
- * @throws {JspbAssertionError} When the value is not a number.
+ * @throws {Error} When the value is not a number.
  */
 function doAssertFailure(defaultMessage, defaultArgs, givenMessage, givenArgs) {
   let message = 'Assertion failed';
@@ -101,36 +57,22 @@ function doAssertFailure(defaultMessage, defaultArgs, givenMessage, givenArgs) {
   // a stack trace is added to var message above. With this, a stack trace is
   // not added until this line (it causes the extra garbage to be added after
   // the assertion message instead of in the middle of it).
-  const e = new JspbAssertionError('' + message, args || []);
-  errorHandler_(e);
+  throw new Error('' + message, args || []);
 }
 
-/**
- * Sets a custom error handler that can be used to customize the behavior of
- * assertion failures, for example by turning all assertion failures into log
- * messages.
- * @param {function(!JspbAssertionError)} errorHandler
- * @return {void}
- */
-jspb.asserts.setJspbErrorHandler = function(errorHandler) {
-  errorHandler_ = errorHandler;
-};
-
-
 /**
  * Checks if the condition evaluates to true.
  * @template T
  * @param {T} condition The condition to check.
  * @param {string=} opt_message Error message in case of failure.
- * @param {...*} var_args The items to substitute into the failure message.
+ * @param {...*} args The items to substitute into the failure message.
  * @return {T} The value of the condition.
- * @throws {JspbAssertionError} When the condition evaluates to false.
+ * @throws {Error} When the condition evaluates to false.
  */
 
-jspb.asserts.jspbAssert = function(condition, opt_message, var_args) {
+jspb.asserts.assert = function(condition, opt_message, ...args) {
   if (!condition) {
-    doAssertFailure(
-        '', null, opt_message, Array.prototype.slice.call(arguments, 2));
+    doAssertFailure('', null, opt_message, args);
   }
   return condition;
 };
@@ -140,15 +82,15 @@ jspb.asserts.jspbAssert = function(condition, opt_message, var_args) {
  * Checks if the value is a string.
  * @param {*} value The value to check.
  * @param {string=} opt_message Error message in case of failure.
- * @param {...*} var_args The items to substitute into the failure message.
+ * @param {...*} args The items to substitute into the failure message.
  * @return {string} The value, guaranteed to be a string when asserts enabled.
- * @throws {JspbAssertionError} When the value is not a string.
+ * @throws {Error} When the value is not a string.
  */
-jspb.asserts.jspbAssertString = function(value, opt_message, var_args) {
+jspb.asserts.assertString = function(value, opt_message, ...args) {
   if (typeof value !== 'string') {
     doAssertFailure(
         'Expected string but got %s: %s.', [goog.typeOf(value), value],
-        opt_message, Array.prototype.slice.call(arguments, 2));
+        opt_message, args);
   }
   return /** @type {string} */ (value);
 };
@@ -158,15 +100,15 @@ jspb.asserts.jspbAssertString = function(value, opt_message, var_args) {
  * Checks if the value is an Array.
  * @param {*} value The value to check.
  * @param {string=} opt_message Error message in case of failure.
- * @param {...*} var_args The items to substitute into the failure message.
+ * @param {...*} args The items to substitute into the failure message.
  * @return {!Array<?>} The value, guaranteed to be a non-null array.
- * @throws {JspbAssertionError} When the value is not an array.
+ * @throws {Error} When the value is not an array.
  */
-jspb.asserts.jspbAssertArray = function(value, opt_message, var_args) {
+jspb.asserts.assertArray = function(value, opt_message, ...args) {
   if (!Array.isArray(value)) {
     doAssertFailure(
         'Expected array but got %s: %s.', [goog.typeOf(value), value],
-        opt_message, Array.prototype.slice.call(arguments, 2));
+        opt_message, args);
   }
   return /** @type {!Array<?>} */ (value);
 };
@@ -185,14 +127,14 @@ jspb.asserts.jspbAssertArray = function(value, opt_message, var_args) {
  * </pre>
  *
  * @param {string=} opt_message Error message in case of failure.
- * @param {...*} var_args The items to substitute into the failure message.
+ * @param {...*} args The items to substitute into the failure message.
  * @return {void}
- * @throws {JspbAssertionError} Failure.
+ * @throws {Error} Failure.
  */
-jspb.asserts.jspbFail = function(opt_message, var_args) {
-  errorHandler_(new JspbAssertionError(
+jspb.asserts.fail = function(opt_message, ...args) {
+  throw new Error(
       'Failure' + (opt_message ? ': ' + opt_message : ''),
-      Array.prototype.slice.call(arguments, 1)));
+      args);
 };
 
 /**
@@ -205,17 +147,17 @@ jspb.asserts.jspbFail = function(opt_message, var_args) {
  * @param {?} value The value to check.
  * @param {function(new: T, ...)} type A user-defined constructor.
  * @param {string=} opt_message Error message in case of failure.
- * @param {...*} var_args The items to substitute into the failure message.
- * @throws {JspbAssertionError} When the value is not an instance of
+ * @param {...*} args The items to substitute into the failure message.
+ * @throws {Error} When the value is not an instance of
  *     type.
  * @return {T}
  * @template T
  */
-jspb.asserts.jspbAssertInstanceof = function(value, type, opt_message, var_args) {
+jspb.asserts.assertInstanceof = function(value, type, opt_message, ...args) {
   if (!(value instanceof type)) {
     doAssertFailure(
         'Expected instanceof %s but got %s.', [getType(type), getType(value)],
-        opt_message, Array.prototype.slice.call(arguments, 3));
+        opt_message, args);
   }
   return value;
 };

binary/decoder.js

@@ -235,7 +235,7 @@ jspb.BinaryDecoder.prototype.setCursor = function(cursor) {
  */
 jspb.BinaryDecoder.prototype.advance = function(count) {
   this.cursor_ += count;
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
 };
 
 
@@ -316,7 +316,7 @@ jspb.BinaryDecoder.prototype.readSplitVarint64 = function(convert) {
   }
 
   // If we did not see the terminator, the encoding was invalid.
-  jspb.asserts.jspbFail('Failed to read varint, encoding is invalid.');
+  jspb.asserts.fail('Failed to read varint, encoding is invalid.');
   this.error_ = true;
 };
 
@@ -422,31 +422,31 @@ jspb.BinaryDecoder.prototype.readUnsignedVarint32 = function() {
   var x = (temp & 0x7F);
   if (temp < 128) {
     this.cursor_ += 1;
-    jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+    jspb.asserts.assert(this.cursor_ <= this.end_);
     return x;
   }
 
   temp = bytes[this.cursor_ + 1];
   x |= (temp & 0x7F) << 7;
   if (temp < 128) {
     this.cursor_ += 2;
-    jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+    jspb.asserts.assert(this.cursor_ <= this.end_);
     return x;
   }
 
   temp = bytes[this.cursor_ + 2];
   x |= (temp & 0x7F) << 14;
   if (temp < 128) {
     this.cursor_ += 3;
-    jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+    jspb.asserts.assert(this.cursor_ <= this.end_);
     return x;
   }
 
   temp = bytes[this.cursor_ + 3];
   x |= (temp & 0x7F) << 21;
   if (temp < 128) {
     this.cursor_ += 4;
-    jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+    jspb.asserts.assert(this.cursor_ <= this.end_);
     return x;
   }
 
@@ -456,7 +456,7 @@ jspb.BinaryDecoder.prototype.readUnsignedVarint32 = function() {
     // We're reading the high bits of an unsigned varint. The byte we just read
     // also contains bits 33 through 35, which we're going to discard.
     this.cursor_ += 5;
-    jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+    jspb.asserts.assert(this.cursor_ <= this.end_);
     return x >>> 0;
   }
 
@@ -467,10 +467,10 @@ jspb.BinaryDecoder.prototype.readUnsignedVarint32 = function() {
       bytes[this.cursor_++] >= 128 && bytes[this.cursor_++] >= 128 &&
       bytes[this.cursor_++] >= 128) {
     // If we get here, the varint is too long.
-    jspb.asserts.jspbAssert(false);
+    jspb.asserts.assert(false);
   }
 
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
   return x;
 };
 
@@ -638,7 +638,7 @@ jspb.BinaryDecoder.prototype.readZigzagVarint64String = function() {
 jspb.BinaryDecoder.prototype.readUint8 = function() {
   var a = this.bytes_[this.cursor_ + 0];
   this.cursor_ += 1;
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
   return a;
 };
 
@@ -652,7 +652,7 @@ jspb.BinaryDecoder.prototype.readUint16 = function() {
   var a = this.bytes_[this.cursor_ + 0];
   var b = this.bytes_[this.cursor_ + 1];
   this.cursor_ += 2;
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
   return (a << 0) | (b << 8);
 };
 
@@ -668,7 +668,7 @@ jspb.BinaryDecoder.prototype.readUint32 = function() {
   var c = this.bytes_[this.cursor_ + 2];
   var d = this.bytes_[this.cursor_ + 3];
   this.cursor_ += 4;
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
   return ((a << 0) | (b << 8) | (c << 16) | (d << 24)) >>> 0;
 };
 
@@ -710,7 +710,7 @@ jspb.BinaryDecoder.prototype.readUint64String = function() {
 jspb.BinaryDecoder.prototype.readInt8 = function() {
   var a = this.bytes_[this.cursor_ + 0];
   this.cursor_ += 1;
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
   return (a << 24) >> 24;
 };
 
@@ -724,7 +724,7 @@ jspb.BinaryDecoder.prototype.readInt16 = function() {
   var a = this.bytes_[this.cursor_ + 0];
   var b = this.bytes_[this.cursor_ + 1];
   this.cursor_ += 2;
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
   return (((a << 0) | (b << 8)) << 16) >> 16;
 };
 
@@ -740,7 +740,7 @@ jspb.BinaryDecoder.prototype.readInt32 = function() {
   var c = this.bytes_[this.cursor_ + 2];
   var d = this.bytes_[this.cursor_ + 3];
   this.cursor_ += 4;
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
   return (a << 0) | (b << 8) | (c << 16) | (d << 24);
 };
 
@@ -902,14 +902,14 @@ jspb.BinaryDecoder.prototype.readStringWithLength = function() {
 jspb.BinaryDecoder.prototype.readBytes = function(length) {
   if (length < 0 || this.cursor_ + length > this.bytes_.length) {
     this.error_ = true;
-    jspb.asserts.jspbFail('Invalid byte length!');
+    jspb.asserts.fail('Invalid byte length!');
     return new Uint8Array(0);
   }
 
   var result = this.bytes_.subarray(this.cursor_, this.cursor_ + length);
 
   this.cursor_ += length;
-  jspb.asserts.jspbAssert(this.cursor_ <= this.end_);
+  jspb.asserts.assert(this.cursor_ <= this.end_);
   return result;
 };