disallow variable shadowing

24 files changed, 120 insertions, 133 deletions

diff --git a/.eslintrc b/.eslintrc
index db0ec78..86a6961 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -24,6 +24,7 @@
     "no-caller": 2,
     "no-undef": 2,
     "no-unused-vars": 2,
+    "no-shadow": 2,
     "no-eval": 2,
     "comma-style": [
       2,
diff --git a/lib/concatLimit.js b/lib/concatLimit.js
index e5c179a..39d0dd7 100644
--- a/lib/concatLimit.js
+++ b/lib/concatLimit.js
@@ -23,10 +23,10 @@ import mapLimit from './mapLimit';
 export default function(coll, limit, iteratee, callback) {
     callback = callback || noop;
     var _iteratee = wrapAsync(iteratee);
-    mapLimit(coll, limit, (val, callback) => {
+    mapLimit(coll, limit, (val, iterCb) => {
         _iteratee(val, (err, ...args) => {
-            if (err) return callback(err);
-            return callback(null, args);
+            if (err) return iterCb(err);
+            return iterCb(null, args);
         });
     }, (err, mapResults) => {
         var result = [];
diff --git a/lib/groupByLimit.js b/lib/groupByLimit.js
index fe484ec..aebe088 100644
--- a/lib/groupByLimit.js
+++ b/lib/groupByLimit.js
@@ -23,10 +23,10 @@ import wrapAsync from './internal/wrapAsync';
 export default function(coll, limit, iteratee, callback) {
     callback = callback || noop;
     var _iteratee = wrapAsync(iteratee);
-    mapLimit(coll, limit, (val, callback) => {
+    mapLimit(coll, limit, (val, iterCb) => {
         _iteratee(val, (err, key) => {
-            if (err) return callback(err);
-            return callback(null, {key, val});
+            if (err) return iterCb(err);
+            return iterCb(null, {key, val});
         });
     }, (err, mapResults) => {
         var result = {};
diff --git a/lib/internal/applyEach.js b/lib/internal/applyEach.js
index b029184..f95d8ac 100644
--- a/lib/internal/applyEach.js
+++ b/lib/internal/applyEach.js
@@ -2,18 +2,16 @@ import initialParams from './initialParams';
 import wrapAsync from './wrapAsync';
 
 export default function applyEach(eachfn) {
-    return function(fns, ...args) {
+    return function(fns, ...callArgs) {
         var go = initialParams(function(args, callback) {
             var that = this;
             return eachfn(fns, (fn, cb) => {
                 wrapAsync(fn).apply(that, args.concat(cb));
             }, callback);
         });
-        if (args.length) {
-            return go.apply(this, args);
-        }
-        else {
-            return go;
+        if (callArgs.length) {
+            return go.apply(this, callArgs);
         }
+        return go;
     };
 }
diff --git a/lib/internal/filter.js b/lib/internal/filter.js
index 4c9422b..ab37390 100644
--- a/lib/internal/filter.js
+++ b/lib/internal/filter.js
@@ -5,10 +5,10 @@ import wrapAsync from './wrapAsync';
 
 function filterArray(eachfn, arr, iteratee, callback) {
     var truthValues = new Array(arr.length);
-    eachfn(arr, (x, index, callback) => {
+    eachfn(arr, (x, index, iterCb) => {
         iteratee(x, (err, v) => {
             truthValues[index] = !!v;
-            callback(err);
+            iterCb(err);
         });
     }, err => {
         if (err) return callback(err);
@@ -22,16 +22,13 @@ function filterArray(eachfn, arr, iteratee, callback) {
 
 function filterGeneric(eachfn, coll, iteratee, callback) {
     var results = [];
-    eachfn(coll, (x, index, callback) => {
+    eachfn(coll, (x, index, iterCb) => {
         iteratee(x, (err, v) => {
-            if (err) {
-                callback(err);
-            } else {
-                if (v) {
-                    results.push({index, value: x});
-                }
-                callback();
+            if (err) return iterCb(err);
+            if (v) {
+                results.push({index, value: x});
             }
+            iterCb();
         });
     }, err => {
         if (err) return callback(err);
diff --git a/lib/internal/iterator.js b/lib/internal/iterator.js
index b0c4644..d167ff9 100644
--- a/lib/internal/iterator.js
+++ b/lib/internal/iterator.js
@@ -30,7 +30,7 @@ function createObjectIterator(obj) {
     };
 }
 
-export default function iterator(coll) {
+export default function createIterator(coll) {
     if (isArrayLike(coll)) {
         return createArrayIterator(coll);
     }
diff --git a/lib/internal/map.js b/lib/internal/map.js
index b99d8ee..3da8d9c 100644
--- a/lib/internal/map.js
+++ b/lib/internal/map.js
@@ -8,11 +8,11 @@ export default function _asyncMap(eachfn, arr, iteratee, callback) {
     var counter = 0;
     var _iteratee = wrapAsync(iteratee);
 
-    return eachfn(arr, (value, _, callback) => {
+    return eachfn(arr, (value, _, iterCb) => {
         var index = counter++;
         _iteratee(value, (err, v) => {
             results[index] = v;
-            callback(err);
+            iterCb(err);
         });
     }, err => {
         callback(err, results);
diff --git a/lib/internal/parallel.js b/lib/internal/parallel.js
index 89e181e..703947c 100644
--- a/lib/internal/parallel.js
+++ b/lib/internal/parallel.js
@@ -6,13 +6,13 @@ export default function _parallel(eachfn, tasks, callback) {
     callback = callback || noop;
     var results = isArrayLike(tasks) ? [] : {};
 
-    eachfn(tasks, (task, key, callback) => {
+    eachfn(tasks, (task, key, taskCb) => {
         wrapAsync(task)((err, ...result) => {
             if (result.length < 2) {
                 result = result[0];
             }
             results[key] = result;
-            callback(err);
+            taskCb(err);
         });
     }, err => callback(err, results));
 }
diff --git a/lib/reduce.js b/lib/reduce.js
index 963d619..7966e49 100644
--- a/lib/reduce.js
+++ b/lib/reduce.js
@@ -46,10 +46,10 @@ import wrapAsync from './internal/wrapAsync';
 export default function reduce(coll, memo, iteratee, callback) {
     callback = once(callback || noop);
     var _iteratee = wrapAsync(iteratee);
-    eachOfSeries(coll, (x, i, callback) => {
+    eachOfSeries(coll, (x, i, iterCb) => {
         _iteratee(memo, x, (err, v) => {
             memo = v;
-            callback(err);
+            iterCb(err);
         });
     }, err => callback(err, memo));
 }
diff --git a/lib/seq.js b/lib/seq.js
index 6dc28d8..1363cbd 100644
--- a/lib/seq.js
+++ b/lib/seq.js
@@ -52,9 +52,9 @@ export default function seq(...functions) {
             cb = noop;
         }
 
-        reduce(_functions, args, (newargs, fn, cb) => {
+        reduce(_functions, args, (newargs, fn, iterCb) => {
             fn.apply(that, newargs.concat((err, ...nextargs) => {
-                cb(err, nextargs);
+                iterCb(err, nextargs);
             }));
         },
         (err, results) => cb(err, ...results));
diff --git a/lib/sortBy.js b/lib/sortBy.js
index 3b9ce61..4316665 100644
--- a/lib/sortBy.js
+++ b/lib/sortBy.js
@@ -50,10 +50,10 @@ import wrapAsync from './internal/wrapAsync';
  */
 export default function sortBy (coll, iteratee, callback) {
     var _iteratee = wrapAsync(iteratee);
-    map(coll, (x, callback) => {
+    map(coll, (x, iterCb) => {
         _iteratee(x, (err, criteria) => {
-            if (err) return callback(err);
-            callback(null, {value: x, criteria});
+            if (err) return iterCb(err);
+            iterCb(null, {value: x, criteria});
         });
     }, (err, results) => {
         if (err) return callback(err);
diff --git a/lib/timeout.js b/lib/timeout.js
index 39fd335..920a1d7 100644
--- a/lib/timeout.js
+++ b/lib/timeout.js
@@ -60,9 +60,9 @@ export default function timeout(asyncFn, milliseconds, info) {
             callback(error);
         }
 
-        args.push((...args) => {
+        args.push((...cbArgs) => {
             if (!timedOut) {
-                callback(...args);
+                callback(...cbArgs);
                 clearTimeout(timer);
             }
         });
diff --git a/lib/tryEach.js b/lib/tryEach.js
index c987d24..e4a5f03 100644
--- a/lib/tryEach.js
+++ b/lib/tryEach.js
@@ -43,7 +43,7 @@ export default function tryEach(tasks, callback) {
     var error = null;
     var result;
     callback = callback || noop;
-    eachSeries(tasks, (task, callback) => {
+    eachSeries(tasks, (task, taskCb) => {
         wrapAsync(task)((err, ...args) => {
             if (args.length < 2) {
                 result = args[0];
@@ -51,9 +51,7 @@ export default function tryEach(tasks, callback) {
                 result = args;
             }
             error = err;
-            callback(err ? null : {});
+            taskCb(err ? null : {});
         });
-    }, () => {
-        callback(error, result);
-    });
+    }, () => callback(error, result));
 }
diff --git a/perf/benchmark.js b/perf/benchmark.js
index ba3c8e3..7f5736c 100755
--- a/perf/benchmark.js
+++ b/perf/benchmark.js
@@ -117,8 +117,8 @@ function setDefaultOptions(suiteConfig) {
 }
 
 function handleMultipleArgs(list, suiteConfig) {
-    return list.concat(suiteConfig.args.map((args) => {
-        return _.defaults({args}, suiteConfig);
+    return list.concat(suiteConfig.args.map((suiteArgs) => {
+        return _.defaults({args: suiteArgs}, suiteConfig);
     }));
 }
 
@@ -137,7 +137,6 @@ function doesNotMatch(suiteConfig) {
 
 function createSuite(suiteConfig) {
     var suite = new Benchmark.Suite();
-    var args = suiteConfig.args;
     var errored = false;
 
     function addBench(version, versionName) {
@@ -155,7 +154,7 @@ function createSuite(suiteConfig) {
         var options = _.extend({
             versionName,
             setup() {
-                suiteConfig.setup.apply(null, args);
+                suiteConfig.setup(...suiteConfig.args);
             },
             onError (err) {
                 console.log(err.stack);
@@ -220,12 +219,7 @@ function cloneVersion(tag, callback) {
 
         var cmd = "git clone --branch " + tag + " " + repoPath + " " + versionDir;
 
-        exec(cmd, (err) => {
-            if (err) {
-                throw err;
-            }
-            callback();
-        });
+        exec(cmd, callback);
 
     });
 }
diff --git a/perf/memory.js b/perf/memory.js
index d4a71e9..aee9006 100644
--- a/perf/memory.js
+++ b/perf/memory.js
@@ -7,7 +7,7 @@ var async = require("../");
 global.gc();
 var startMem = process.memoryUsage().heapUsed;
 
-function waterfallTest(cb) {
+function waterfallTest(done) {
     var functions = [];
 
     for(var i = 0; i < 10000; i++) {
@@ -29,7 +29,7 @@ function waterfallTest(cb) {
         });
     }
 
-    async.parallel(functions, cb);
+    async.parallel(functions, done);
 }
 
 function reportMemory() {
diff --git a/perf/suites.js b/perf/suites.js
index e3b0c6f..d3cb4e9 100644
--- a/perf/suites.js
+++ b/perf/suites.js
@@ -10,8 +10,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.each(tasks, (num, cb) => {
@@ -25,8 +25,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.eachSeries(tasks, (num, cb) => {
@@ -40,8 +40,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.eachLimit(tasks, 4, (num, cb) => {
@@ -56,8 +56,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.map(tasks, (num, cb) => {
@@ -71,8 +71,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.mapSeries(tasks, (num, cb) => {
@@ -86,8 +86,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.mapLimit(tasks, 4, (num, cb) => {
@@ -138,8 +138,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.concat(tasks, (num, cb) => {
@@ -156,8 +156,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.eachOf(tasks, (num, i, cb) => {
@@ -171,8 +171,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.eachOfSeries(tasks, (num, i, cb) => {
@@ -186,8 +186,8 @@ module.exports = [{
         [300],
         [10000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.eachOfLimit(tasks, 4, (num, i, cb) => {
@@ -201,8 +201,8 @@ module.exports = [{
         [100],
         [1000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count).map(() => {
+    setup: function setup(num) {
+        tasks = _.range(num).map(() => {
             return function(cb) {
                 setImmediate(cb);
             };
@@ -218,8 +218,8 @@ module.exports = [{
         [100],
         [1000]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count).map(() => {
+    setup: function setup(num) {
+        tasks = _.range(num).map(() => {
             return function(cb) {
                 setImmediate(cb);
             };
@@ -235,12 +235,12 @@ module.exports = [{
         [100],
         [1000]
     ],
-    setup: function setup(count) {
+    setup: function setup(num) {
         tasks = [
             function(cb) {
                 return cb(null, 1);
             }
-        ].concat(_.range(count).map((i) => {
+        ].concat(_.range(num).map((i) => {
             return function(arg, cb) {
                 setImmediate(() => {
                     cb(null, i);
@@ -258,11 +258,11 @@ module.exports = [{
         [10],
         [100]
     ],
-    setup: function setup(count) {
+    setup: function setup(num) {
         tasks = {
             dep1 (cb) { cb(null, 1); }
         };
-        _.times(count, (n) => {
+        _.times(num, (n) => {
             var task = ['dep' + (n+1), function(results, cb) {
                 setImmediate(cb, null, n);
             }];
@@ -283,8 +283,8 @@ module.exports = [{
         [100000],
         [200000]
     ],
-    setup: function setup(count) {
-        tasks = count;
+    setup: function setup(num) {
+        tasks = num;
     },
     fn(async, done) {
         var numEntries = tasks;
@@ -308,8 +308,8 @@ module.exports = [{
     args: [
         [500]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.some(tasks, (i, cb) => {
@@ -324,8 +324,8 @@ module.exports = [{
     args: [
         [500]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.some(tasks, (i, cb) => {
@@ -340,8 +340,8 @@ module.exports = [{
     args: [
         [500]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.every(tasks, (i, cb) => {
@@ -356,8 +356,8 @@ module.exports = [{
     args: [
         [500]
     ],
-    setup: function setup(count) {
-        tasks = _.range(count);
+    setup: function setup(num) {
+        tasks = _.range(num);
     },
     fn(async, done) {
         async.every(tasks, (i, cb) => {
diff --git a/support/es.test.js b/support/es.test.js
index 45552be..9a307cd 100644
--- a/support/es.test.js
+++ b/support/es.test.js
@@ -1,12 +1,10 @@
 // simple async example to test ES module build output
 
-import {waterfall as waterfall} from  "../build-es/index";
-import {wrapSync} from  "../build-es/index";
-import async from "../build-es/index";
+import {default as async, waterfall as wf, wrapSync} from  "../build-es/index";
 import constant from "../build-es/constant";
 import forEachOf from "../build-es/forEachOf";
 
-waterfall([
+wf([
     constant(42),
     function (val, next) {
         async.setImmediate(() => {
@@ -15,8 +13,8 @@ waterfall([
     },
     wrapSync((a) => { return a; }),
     function (val, next) {
-        async.forEachOf({a: 1}, (val, key, cb) => {
-            if (val !== 1 && key !== 'a') return cb(new Error('fail!'));
+        async.forEachOf({a: 1}, (v, key, cb) => {
+            if (v !== 1 && key !== 'a') return cb(new Error('fail!'));
             cb();
         }, (err) => { next (err, val)});
     },
diff --git a/support/generate-index.js b/support/generate-index.js
index ee760d2..0606551 100644
--- a/support/generate-index.js
+++ b/support/generate-index.js
@@ -10,7 +10,7 @@ generateIndex(err => {
     if (err) throw err
 })
 
-function generateIndex(cb) {
+function generateIndex(done) {
     autoInject({
         entries: cb => readEntries(cb),
         aliases: cb => loadAliases(cb),
@@ -19,8 +19,9 @@ function generateIndex(cb) {
             cb(null, renderTemplate(entries, aliases, template))
         }
     }, (err, results) => {
-        if (err) return cb(err)
+        if (err) return done(err)
         console.log(results.generated)
+        done()
     })
 }
 
diff --git a/support/jsdoc/jsdoc-fix-html.js b/support/jsdoc/jsdoc-fix-html.js
index 3741a18..2cc8991 100644
--- a/support/jsdoc/jsdoc-fix-html.js
+++ b/support/jsdoc/jsdoc-fix-html.js
@@ -45,8 +45,8 @@ function extractModuleFiles(files) {
 function combineFakeModules(files, callback) {
     var moduleFiles = extractModuleFiles(files);
 
-    fs.readFile(path.join(docsDir, mainModuleFile), 'utf8', (err, mainModuleData) => {
-        if (err) return callback(err);
+    fs.readFile(path.join(docsDir, mainModuleFile), 'utf8', (fileErr, mainModuleData) => {
+        if (fileErr) return callback(fileErr);
 
         var $mainPage = $(mainModuleData);
         // each 'module' (category) has a separate page, with all of the
@@ -179,10 +179,8 @@ fs.copySync(path.join(__dirname, './jsdoc-custom.js'), path.join(docsDir, 'scrip
 fs.copySync(path.join(__dirname, '..', '..', 'logo', 'favicon.ico'), path.join(docsDir, 'favicon.ico'), { clobber: true });
 fs.copySync(path.join(__dirname, '..', '..', 'logo', 'async-logo.svg'), path.join(docsDir, 'img', 'async-logo.svg'), { clobber: true });
 
-fs.readdir(docsDir, (err, files) => {
-    if (err) {
-        throw err;
-    }
+fs.readdir(docsDir, (readErr, files) => {
+    if (readErr) { throw readErr; }
 
     var HTMLFiles = _.filter(files, (file) => {
         return path.extname(file) === '.html';
@@ -196,6 +194,9 @@ fs.readdir(docsDir, (err, files) => {
                 return callback(null);
             });
         },
+        async.asyncify(() => {
+            HTMLFiles.push(docFilename)
+        }),
         function(callback) {
             fixModuleLinks(HTMLFiles, callback);
         }
diff --git a/test/applyEach.js b/test/applyEach.js
index e164dda..96c7a77 100644
--- a/test/applyEach.js
+++ b/test/applyEach.js
@@ -37,27 +37,27 @@ describe('applyEach', () => {
 
     it('applyEachSeries', (done) => {
         var call_order = [];
-        var one = function (val, cb) {
+        function one(val, cb) {
             expect(val).to.equal(5);
             setTimeout(() => {
                 call_order.push('one');
                 cb(null, 1);
             }, 10);
-        };
-        var two = function (val, cb) {
+        }
+        function two(val, cb) {
             expect(val).to.equal(5);
             setTimeout(() => {
                 call_order.push('two');
                 cb(null, 2);
             }, 5);
-        };
-        var three = function (val, cb) {
+        }
+        function three(val, cb) {
             expect(val).to.equal(5);
             setTimeout(() => {
                 call_order.push('three');
                 cb(null, 3);
             }, 15);
-        };
+        }
         async.applyEachSeries([one, two, three], 5, (err, results) => {
             assert(err === null, err + " passed instead of 'null'");
             expect(call_order).to.eql(['one', 'two', 'three']);
diff --git a/test/concat.js b/test/concat.js
index 229a9da..b1384fc 100644
--- a/test/concat.js
+++ b/test/concat.js
@@ -209,11 +209,10 @@ describe('concat', function() {
     });
 
     context('concatLimit', () => {
-        var arr = ['foo', 'bar', 'baz'];
         it('basics', (done) => {
             var running = 0;
             var concurrency = {'foo': 2, 'bar': 2, 'baz': 1};
-            async.concatLimit(arr, 2, (val, next) => {
+            async.concatLimit(['foo', 'bar', 'baz'], 2, (val, next) => {
                 running++;
                 async.setImmediate(() => {
                     expect(running).to.equal(concurrency[val]);
@@ -229,7 +228,7 @@ describe('concat', function() {
         });
 
         it('error', (done) => {
-            async.concatLimit(arr, 1, (val, next) => {
+            async.concatLimit(['foo', 'bar', 'baz'], 1, (val, next) => {
                 if (val === 'bar') {
                     return next(new Error('fail'));
                 }
diff --git a/test/consoleFunctions.js b/test/consoleFunctions.js
index 6d13151..7beeb26 100644
--- a/test/consoleFunctions.js
+++ b/test/consoleFunctions.js
@@ -28,8 +28,8 @@ describe('console functions', () => {
                 console[name] = function(val, ...extra){
                     expect(val).to.equal('test');
                     expect(extra.length).to.equal(0);
-                    console.error = function(val){
-                        expect(val).to.equal('error');
+                    console.error = function(errVal){
+                        expect(errVal).to.equal('error');
                         console[name] = _console_fn;
                         console.error = _error;
                         done();
diff --git a/test/memoize.js b/test/memoize.js
index b2c11b3..7db26d3 100644
--- a/test/memoize.js
+++ b/test/memoize.js
@@ -18,10 +18,10 @@ describe("memoize", () => {
         fn2(1, 2, (err, result) => {
             assert(err === null, err + " passed instead of 'null'");
             expect(result).to.equal(3);
-            fn2(1, 2, (err, result) => {
-                expect(result).to.equal(3);
-                fn2(2, 2, (err, result) => {
-                    expect(result).to.equal(4);
+            fn2(1, 2, (err2, result2) => {
+                expect(result2).to.equal(3);
+                fn2(2, 2, (err3, result3) => {
+                    expect(result3).to.equal(4);
                     expect(call_order).to.eql([['fn',1,2], ['fn',2,2]]);
                     done();
                 });
@@ -43,8 +43,8 @@ describe("memoize", () => {
         var fn2 = async.memoize(fn);
         fn2(1, 2, (err, result) => {
             expect(result).to.equal(3);
-            fn2(1, 2, (err, result) => {
-                expect(result).to.equal(3);
+            fn2(1, 2, (err2, result2) => {
+                expect(result2).to.equal(3);
                 async.nextTick(memoize_done);
                 call_order.push('tick3');
             });
@@ -81,10 +81,10 @@ describe("memoize", () => {
         var fn3 = async.unmemoize(fn2);
         fn3(1, 2, (err, result) => {
             expect(result).to.equal(3);
-            fn3(1, 2, (err, result) => {
-                expect(result).to.equal(3);
-                fn3(2, 2, (err, result) => {
-                    expect(result).to.equal(4);
+            fn3(1, 2, (err2, result2) => {
+                expect(result2).to.equal(3);
+                fn3(2, 2, (err3, result3) => {
+                    expect(result3).to.equal(4);
                     expect(call_order).to.eql([['fn',1,2], ['fn',1,2], ['fn',2,2]]);
                     done();
                 });
@@ -125,8 +125,8 @@ describe("memoize", () => {
             expect(err).to.equal(testerr);
             testerr = null;
 
-            memoized(1, 3, (err, result) => {
-                expect(err).to.equal(null);
+            memoized(1, 3, (err2, result) => {
+                expect(err2).to.equal(null);
                 expect(result).to.equal(4);
                 done();
             });
@@ -159,8 +159,8 @@ describe("memoize", () => {
         });
         fn2(1, 2, (err, result) => {
             expect(result).to.equal(3);
-            fn2(2, 2, (err, result) => {
-                expect(result).to.equal(3);
+            fn2(2, 2, (err2, result2) => {
+                expect(result2).to.equal(3);
                 done();
             });
         });
diff --git a/test/reduce.js b/test/reduce.js
index b3c58fc..2e0f06c 100644
--- a/test/reduce.js
+++ b/test/reduce.js
@@ -47,14 +47,14 @@ describe('reduce', () => {
 
     it('reduceRight', (done) => {
         var call_order = [];
-        var a = [1,2,3];
-        async.reduceRight(a, 0, (a, x, callback) => {
+        var arr = [1,2,3];
+        async.reduceRight(arr, 0, (a, x, callback) => {
             call_order.push(x);
             callback(null, a + x);
         }, (err, result) => {
             expect(result).to.equal(6);
             expect(call_order).to.eql([3,2,1]);
-            expect(a).to.eql([1,2,3]);
+            expect(arr).to.eql([1,2,3]);
             done();
         });
     });