Remove unused catch variables

calebsander · calebsander · commit 68aa8c4dbaf5 · 2018-10-02T22:25:22.000-07:00
diff --git a/dist/lib/growable-buffer.js b/dist/lib/growable-buffer.js
@@ -22,7 +22,7 @@ class GrowableBuffer extends appendable_1.default {
             assert_1.default.integer(initialLength);
             assert_1.default(initialLength >= 0);
         }
-        catch (e) {
+        catch (_a) {
             throw new RangeError(`${initialLength} is not a valid buffer length`);
         }
         this.buffer = new ArrayBuffer(initialLength);
diff --git a/dist/types/choice.js b/dist/types/choice.js
@@ -48,7 +48,7 @@ class ChoiceType extends absolute_1.default {
         try {
             assert_1.default.byteUnsignedInteger(types.length);
         }
-        catch (e) {
+        catch (_a) {
             assert_1.default.fail(`${types.length} types is too many`);
         }
         for (const type of types)
@@ -101,7 +101,7 @@ class ChoiceType extends absolute_1.default {
                 success = true;
                 break;
             }
-            catch (e) {
+            catch (_a) {
                 buffer.reset();
             }
         }
diff --git a/dist/types/enum.js b/dist/types/enum.js
@@ -41,7 +41,7 @@ class EnumType extends abstract_1.default {
         try {
             assert_1.default.byteUnsignedInteger(values.length);
         }
-        catch (e) {
+        catch (_a) {
             assert_1.default.fail(`${values.length} values is too many`);
         }
         this.type = type;
diff --git a/dist/types/named-choice.js b/dist/types/named-choice.js
@@ -69,7 +69,7 @@ class NamedChoiceType extends absolute_1.default {
         try {
             assert_1.default.byteUnsignedInteger(constructorTypes.size);
         }
-        catch (e) {
+        catch (_a) {
             assert_1.default.fail(`${constructorTypes.size} types is too many`);
         }
         this.indexConstructors = new Map;
@@ -86,7 +86,7 @@ class NamedChoiceType extends absolute_1.default {
             try {
                 assert_1.default.byteUnsignedInteger(typeNameBuffer.byteLength);
             }
-            catch (e) {
+            catch (_b) {
                 assert_1.default.fail(`Function name "${name}" is too long`);
             }
             assert_1.default.instanceOf(type, struct_1.default);
@@ -182,7 +182,7 @@ class NamedChoiceType extends absolute_1.default {
             try {
                 assert_1.default.equal(otherConstructor.nameBuffer, thisConstructor.nameBuffer);
             }
-            catch (e) {
+            catch (_a) {
                 return false;
             }
         }
diff --git a/dist/types/struct.js b/dist/types/struct.js
@@ -52,7 +52,7 @@ class StructType extends absolute_1.default {
         try {
             assert_1.default.byteUnsignedInteger(fieldCount);
         }
-        catch (e) {
+        catch (_a) {
             assert_1.default.fail(`${fieldCount} fields is too many`);
         }
         this.fields = new Array(fieldCount); //really a set, but we want ordering to be fixed so that type bytes are consistent
@@ -65,15 +65,15 @@ class StructType extends absolute_1.default {
             try {
                 assert_1.default.byteUnsignedInteger(fieldNameBuffer.byteLength);
             }
-            catch (e) {
+            catch (_b) {
                 assert_1.default.fail(`Field name ${fieldName} is too long`);
             }
             //Type must be a Type
             const fieldType = fields[fieldName];
             try {
                 assert_1.default.instanceOf(fieldType, abstract_1.default);
             }
-            catch (e) {
+            catch (_c) {
                 assert_1.default.fail(util_inspect_1.inspect(fieldType) + ' is not a valid field type');
             }
             this.fields[fieldIndex] = {
diff --git a/lib/growable-buffer.ts b/lib/growable-buffer.ts
@@ -27,7 +27,7 @@ export default class GrowableBuffer extends AppendableBuffer {
 			assert.integer(initialLength)
 			assert(initialLength >= 0)
 		}
-		catch (e) { throw new RangeError(`${initialLength} is not a valid buffer length`) }
+		catch { throw new RangeError(`${initialLength} is not a valid buffer length`) }
 		this.buffer = new ArrayBuffer(initialLength)
 		this.size = 0
 		this.pausePoints = []
diff --git a/types/choice.ts b/types/choice.ts
@@ -54,7 +54,7 @@ export default class ChoiceType<E, READ_E extends E = E> extends AbsoluteType<E,
 		super()
 		assert.instanceOf(types, Array)
 		try { assert.byteUnsignedInteger(types.length) }
-		catch (e) { assert.fail(`${types.length} types is too many`) }
+		catch { assert.fail(`${types.length} types is too many`) }
 		for (const type of types) assert.instanceOf(type, AbstractType)
 		this.types = types
 	}
@@ -100,7 +100,7 @@ export default class ChoiceType<E, READ_E extends E = E> extends AbsoluteType<E,
 				success = true
 				break
 			}
-			catch (e) { buffer.reset() }
+			catch { buffer.reset() }
 		}
 		buffer.resume()
 		if (!success) assert.fail('No types matched: ' + inspect(value))
diff --git a/types/enum.ts b/types/enum.ts
@@ -51,7 +51,7 @@ export default class EnumType<E> extends AbstractType<E> {
 		assert.instanceOf(values, Array)
 		//At most 255 values allowed
 		try { assert.byteUnsignedInteger(values.length) }
-		catch (e) { assert.fail(`${values.length} values is too many`) }
+		catch { assert.fail(`${values.length} values is too many`) }
 
 		this.type = type
 		this.values = values //used when reading to get constant-time lookup of value index into value
diff --git a/types/named-choice.ts b/types/named-choice.ts
@@ -83,7 +83,7 @@ export default class NamedChoiceType<E extends object, READ_E extends E = E> ext
 		super()
 		assert.instanceOf(constructorTypes, Map)
 		try { assert.byteUnsignedInteger(constructorTypes.size) }
-		catch (e) { assert.fail(`${constructorTypes.size} types is too many`) }
+		catch { assert.fail(`${constructorTypes.size} types is too many`) }
 		this.indexConstructors = new Map
 		this.constructorTypes = new Array(constructorTypes.size)
 		const usedNames = new Set<string>()
@@ -96,7 +96,7 @@ export default class NamedChoiceType<E extends object, READ_E extends E = E> ext
 			//Name must fit in 255 UTF-8 bytes
 			const typeNameBuffer = bufferString.fromString(name)
 			try { assert.byteUnsignedInteger(typeNameBuffer.byteLength) }
-			catch (e) { assert.fail(`Function name "${name}" is too long`) }
+			catch { assert.fail(`Function name "${name}" is too long`) }
 			assert.instanceOf(type, StructType)
 			const constructorIndex = this.indexConstructors.size
 			this.indexConstructors.set(constructorIndex, constructor)
@@ -184,7 +184,7 @@ export default class NamedChoiceType<E extends object, READ_E extends E = E> ext
 			const otherConstructor = otherChoiceType.constructorTypes[i]
 			if (!thisConstructor.type.equals(otherConstructor.type)) return false
 			try { assert.equal(otherConstructor.nameBuffer, thisConstructor.nameBuffer) }
-			catch (e) { return false }
+			catch { return false }
 		}
 		return true
 	}
diff --git a/types/struct.ts b/types/struct.ts
@@ -81,7 +81,7 @@ export default class StructType<E extends StringIndexable, READ_E extends E = E>
 		//Allow only 255 fields
 		const fieldCount = Object.keys(fields).length
 		try { assert.byteUnsignedInteger(fieldCount) }
-		catch (e) { assert.fail(`${fieldCount} fields is too many`) }
+		catch { assert.fail(`${fieldCount} fields is too many`) }
 
 		this.fields = new Array(fieldCount) //really a set, but we want ordering to be fixed so that type bytes are consistent
 		let fieldIndex = 0
@@ -90,11 +90,11 @@ export default class StructType<E extends StringIndexable, READ_E extends E = E>
 			//Name must fit in 255 UTF-8 bytes
 			const fieldNameBuffer = bufferString.fromString(fieldName)
 			try { assert.byteUnsignedInteger(fieldNameBuffer.byteLength) }
-			catch (e) { assert.fail(`Field name ${fieldName} is too long`) }
+			catch { assert.fail(`Field name ${fieldName} is too long`) }
 			//Type must be a Type
 			const fieldType = fields[fieldName]
 			try { assert.instanceOf(fieldType, AbstractType) }
-			catch (e) { assert.fail(inspect(fieldType) + ' is not a valid field type') }
+			catch { assert.fail(inspect(fieldType) + ' is not a valid field type') }
 			this.fields[fieldIndex] = {
 				name: fieldName,
 				type: fieldType,

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ class GrowableBuffer extends appendable_1.default {`
`22`	`22`	`assert_1.default.integer(initialLength);`
`23`	`23`	`assert_1.default(initialLength >= 0);`
`24`	`24`	`}`
`25`		`- catch (e) {`
	`25`	`+ catch (_a) {`
`26`	`26`	throw new RangeError(`${initialLength} is not a valid buffer length`);
`27`	`27`	`}`
`28`	`28`	`this.buffer = new ArrayBuffer(initialLength);`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ class ChoiceType extends absolute_1.default {`
`48`	`48`	`try {`
`49`	`49`	`assert_1.default.byteUnsignedInteger(types.length);`
`50`	`50`	`}`
`51`		`- catch (e) {`
	`51`	`+ catch (_a) {`
`52`	`52`	assert_1.default.fail(`${types.length} types is too many`);
`53`	`53`	`}`
`54`	`54`	`for (const type of types)`
`@@ -101,7 +101,7 @@ class ChoiceType extends absolute_1.default {`
`101`	`101`	`success = true;`
`102`	`102`	`break;`
`103`	`103`	`}`
`104`		`- catch (e) {`
	`104`	`+ catch (_a) {`
`105`	`105`	`buffer.reset();`
`106`	`106`	`}`
`107`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ class EnumType extends abstract_1.default {`
`41`	`41`	`try {`
`42`	`42`	`assert_1.default.byteUnsignedInteger(values.length);`
`43`	`43`	`}`
`44`		`- catch (e) {`
	`44`	`+ catch (_a) {`
`45`	`45`	assert_1.default.fail(`${values.length} values is too many`);
`46`	`46`	`}`
`47`	`47`	`this.type = type;`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ class NamedChoiceType extends absolute_1.default {`
`69`	`69`	`try {`
`70`	`70`	`assert_1.default.byteUnsignedInteger(constructorTypes.size);`
`71`	`71`	`}`
`72`		`- catch (e) {`
	`72`	`+ catch (_a) {`
`73`	`73`	assert_1.default.fail(`${constructorTypes.size} types is too many`);
`74`	`74`	`}`
`75`	`75`	`this.indexConstructors = new Map;`
`@@ -86,7 +86,7 @@ class NamedChoiceType extends absolute_1.default {`
`86`	`86`	`try {`
`87`	`87`	`assert_1.default.byteUnsignedInteger(typeNameBuffer.byteLength);`
`88`	`88`	`}`
`89`		`- catch (e) {`
	`89`	`+ catch (_b) {`
`90`	`90`	assert_1.default.fail(`Function name "${name}" is too long`);
`91`	`91`	`}`
`92`	`92`	`assert_1.default.instanceOf(type, struct_1.default);`
`@@ -182,7 +182,7 @@ class NamedChoiceType extends absolute_1.default {`
`182`	`182`	`try {`
`183`	`183`	`assert_1.default.equal(otherConstructor.nameBuffer, thisConstructor.nameBuffer);`
`184`	`184`	`}`
`185`		`- catch (e) {`
	`185`	`+ catch (_a) {`
`186`	`186`	`return false;`
`187`	`187`	`}`
`188`	`188`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ class StructType extends absolute_1.default {`
`52`	`52`	`try {`
`53`	`53`	`assert_1.default.byteUnsignedInteger(fieldCount);`
`54`	`54`	`}`
`55`		`- catch (e) {`
	`55`	`+ catch (_a) {`
`56`	`56`	assert_1.default.fail(`${fieldCount} fields is too many`);
`57`	`57`	`}`
`58`	`58`	`this.fields = new Array(fieldCount); //really a set, but we want ordering to be fixed so that type bytes are consistent`
`@@ -65,15 +65,15 @@ class StructType extends absolute_1.default {`
`65`	`65`	`try {`
`66`	`66`	`assert_1.default.byteUnsignedInteger(fieldNameBuffer.byteLength);`
`67`	`67`	`}`
`68`		`- catch (e) {`
	`68`	`+ catch (_b) {`
`69`	`69`	assert_1.default.fail(`Field name ${fieldName} is too long`);
`70`	`70`	`}`
`71`	`71`	`//Type must be a Type`
`72`	`72`	`const fieldType = fields[fieldName];`
`73`	`73`	`try {`
`74`	`74`	`assert_1.default.instanceOf(fieldType, abstract_1.default);`
`75`	`75`	`}`
`76`		`- catch (e) {`
	`76`	`+ catch (_c) {`
`77`	`77`	`assert_1.default.fail(util_inspect_1.inspect(fieldType) + ' is not a valid field type');`
`78`	`78`	`}`
`79`	`79`	`this.fields[fieldIndex] = {`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ export default class GrowableBuffer extends AppendableBuffer {`
`27`	`27`	`assert.integer(initialLength)`
`28`	`28`	`assert(initialLength >= 0)`
`29`	`29`	`}`
`30`		- catch (e) { throw new RangeError(`${initialLength} is not a valid buffer length`) }
	`30`	+ catch { throw new RangeError(`${initialLength} is not a valid buffer length`) }
`31`	`31`	`this.buffer = new ArrayBuffer(initialLength)`
`32`	`32`	`this.size = 0`
`33`	`33`	`this.pausePoints = []`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ export default class ChoiceType<E, READ_E extends E = E> extends AbsoluteType<E,`
`54`	`54`	`super()`
`55`	`55`	`assert.instanceOf(types, Array)`
`56`	`56`	`try { assert.byteUnsignedInteger(types.length) }`
`57`		- catch (e) { assert.fail(`${types.length} types is too many`) }
	`57`	+ catch { assert.fail(`${types.length} types is too many`) }
`58`	`58`	`for (const type of types) assert.instanceOf(type, AbstractType)`
`59`	`59`	`this.types = types`
`60`	`60`	`}`
`@@ -100,7 +100,7 @@ export default class ChoiceType<E, READ_E extends E = E> extends AbsoluteType<E,`
`100`	`100`	`success = true`
`101`	`101`	`break`
`102`	`102`	`}`
`103`		`- catch (e) { buffer.reset() }`
	`103`	`+ catch { buffer.reset() }`
`104`	`104`	`}`
`105`	`105`	`buffer.resume()`
`106`	`106`	`if (!success) assert.fail('No types matched: ' + inspect(value))`