diff --git a/.eslintrc b/.eslintrc
index 2392f2d362..74f17bbdee 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -88,7 +88,9 @@
         // Strict Mode
         "strict": [2, "global"],
         // Variables
+        "prefer-const": 2,
         "no-catch-shadow": 2,
+        "no-const-assign": 2,
         "no-delete-var": 2,
         "no-label-var": 2,
         "no-shadow": 2,
@@ -98,6 +100,7 @@
         "no-undefined": 2,
         "no-unused-vars": 2,
         "no-use-before-define": 2,
+        "no-var": 2,
         // Stylistic Issues
         "indent": [2, 2, {
           "SwitchCase": 1
diff --git a/index.js b/index.js
index d9c1df21d1..2cf0a5f224 100644
--- a/index.js
+++ b/index.js
@@ -1,8 +1,8 @@
 'use strict';
 
-var has = require('has');
+const has = require('has');
 
-var allRules = {
+const allRules = {
   'jsx-uses-react': require('./lib/rules/jsx-uses-react'),
   'no-multi-comp': require('./lib/rules/no-multi-comp'),
   'prop-types': require('./lib/rules/prop-types'),
@@ -68,8 +68,8 @@ var allRules = {
 };
 
 function filterRules(rules, predicate) {
-  var result = {};
-  for (var key in rules) {
+  const result = {};
+  for (const key in rules) {
     if (has(rules, key) && predicate(rules[key])) {
       result[key] = rules[key];
     }
@@ -78,8 +78,8 @@ function filterRules(rules, predicate) {
 }
 
 function configureAsError(rules) {
-  var result = {};
-  for (var key in rules) {
+  const result = {};
+  for (const key in rules) {
     if (!has(rules, key)) {
       continue;
     }
@@ -88,12 +88,12 @@ function configureAsError(rules) {
   return result;
 }
 
-var activeRules = filterRules(allRules, function(rule) {
+const activeRules = filterRules(allRules, function(rule) {
   return !rule.meta.deprecated;
 });
-var activeRulesConfig = configureAsError(activeRules);
+const activeRulesConfig = configureAsError(activeRules);
 
-var deprecatedRules = filterRules(allRules, function(rule) {
+const deprecatedRules = filterRules(allRules, function(rule) {
   return rule.meta.deprecated;
 });
 
diff --git a/lib/rules/default-props-match-prop-types.js b/lib/rules/default-props-match-prop-types.js
index 0ccdc8e080..0e6b29835b 100644
--- a/lib/rules/default-props-match-prop-types.js
+++ b/lib/rules/default-props-match-prop-types.js
@@ -36,7 +36,7 @@ module.exports = {
   create: Components.detect(function(context, components, utils) {
     const configuration = context.options[0] || {};
     const allowRequiredDefaults = configuration.allowRequiredDefaults || false;
-    var propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
+    const propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
 
     /**
      * Get properties name
@@ -603,7 +603,7 @@ module.exports = {
       'Program:exit': function() {
         const list = components.list();
 
-        for (let component in list) {
+        for (const component in list) {
           if (!has(list, component)) {
             continue;
           }
diff --git a/lib/rules/display-name.js b/lib/rules/display-name.js
index 5fdfaa760e..84070096e7 100644
--- a/lib/rules/display-name.js
+++ b/lib/rules/display-name.js
@@ -4,8 +4,8 @@
  */
 'use strict';
 
-var has = require('has');
-var Components = require('../util/Components');
+const has = require('has');
+const Components = require('../util/Components');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -31,11 +31,11 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components, utils) {
-    var sourceCode = context.getSourceCode();
-    var config = context.options[0] || {};
-    var ignoreTranspilerName = config.ignoreTranspilerName || false;
+    const sourceCode = context.getSourceCode();
+    const config = context.options[0] || {};
+    const ignoreTranspilerName = config.ignoreTranspilerName || false;
 
-    var MISSING_MESSAGE = 'Component definition is missing display name';
+    const MISSING_MESSAGE = 'Component definition is missing display name';
 
     /**
      * Checks if we are declaring a display name
@@ -47,7 +47,7 @@ module.exports = {
         // Special case for class properties
         // (babel-eslint does not expose property name so we have to rely on tokens)
         case 'ClassProperty':
-          var tokens = sourceCode.getFirstTokens(node, 2);
+          const tokens = sourceCode.getFirstTokens(node, 2);
           if (
             tokens[0].value === 'displayName' ||
             (tokens[1] && tokens[1].value === 'displayName')
@@ -94,7 +94,7 @@ module.exports = {
      * @returns {Boolean} True if component has a name, false if not.
      */
     function hasTranspilerName(node) {
-      var namedObjectAssignment = (
+      const namedObjectAssignment = (
         node.type === 'ObjectExpression' &&
         node.parent &&
         node.parent.parent &&
@@ -105,25 +105,25 @@ module.exports = {
           node.parent.parent.left.property.name !== 'exports'
         )
       );
-      var namedObjectDeclaration = (
+      const namedObjectDeclaration = (
         node.type === 'ObjectExpression' &&
         node.parent &&
         node.parent.parent &&
         node.parent.parent.type === 'VariableDeclarator'
       );
-      var namedClass = (
+      const namedClass = (
         (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') &&
         node.id &&
         node.id.name
       );
 
-      var namedFunctionDeclaration = (
+      const namedFunctionDeclaration = (
         (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression') &&
         node.id &&
         node.id.name
       );
 
-      var namedFunctionExpression = (
+      const namedFunctionExpression = (
         (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') &&
         node.parent &&
         (node.parent.type === 'VariableDeclarator' || node.parent.method === true) &&
@@ -157,7 +157,7 @@ module.exports = {
         if (!isDisplayNameDeclaration(node.property)) {
           return;
         }
-        var component = utils.getRelatedComponent(node);
+        const component = utils.getRelatedComponent(node);
         if (!component) {
           return;
         }
@@ -221,9 +221,9 @@ module.exports = {
       },
 
       'Program:exit': function() {
-        var list = components.list();
+        const list = components.list();
         // Report missing display name for all components
-        for (var component in list) {
+        for (const component in list) {
           if (!has(list, component) || list[component].hasDisplayName) {
             continue;
           }
diff --git a/lib/rules/forbid-component-props.js b/lib/rules/forbid-component-props.js
index 2c806a620e..a5951e551a 100644
--- a/lib/rules/forbid-component-props.js
+++ b/lib/rules/forbid-component-props.js
@@ -8,7 +8,7 @@
 // Constants
 // ------------------------------------------------------------------------------
 
-var DEFAULTS = ['className', 'style'];
+const DEFAULTS = ['className', 'style'];
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -38,21 +38,21 @@ module.exports = {
 
   create: function(context) {
     function isForbidden(prop) {
-      var configuration = context.options[0] || {};
+      const configuration = context.options[0] || {};
 
-      var forbid = configuration.forbid || DEFAULTS;
+      const forbid = configuration.forbid || DEFAULTS;
       return forbid.indexOf(prop) >= 0;
     }
 
     return {
       JSXAttribute: function(node) {
-        var tag = node.parent.name.name;
+        const tag = node.parent.name.name;
         if (tag && tag[0] !== tag[0].toUpperCase()) {
           // This is a DOM node, not a Component, so exit.
           return;
         }
 
-        var prop = node.name.name;
+        const prop = node.name.name;
 
         if (!isForbidden(prop)) {
           return;
diff --git a/lib/rules/forbid-elements.js b/lib/rules/forbid-elements.js
index e7d49be36f..962d7697a5 100644
--- a/lib/rules/forbid-elements.js
+++ b/lib/rules/forbid-elements.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var has = require('has');
+const has = require('has');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -44,11 +44,11 @@ module.exports = {
   },
 
   create: function(context) {
-    var sourceCode = context.getSourceCode();
-    var configuration = context.options[0] || {};
-    var forbidConfiguration = configuration.forbid || [];
+    const sourceCode = context.getSourceCode();
+    const configuration = context.options[0] || {};
+    const forbidConfiguration = configuration.forbid || [];
 
-    var indexedForbidConfigs = {};
+    const indexedForbidConfigs = {};
 
     forbidConfiguration.forEach(function(item) {
       if (typeof item === 'string') {
@@ -59,8 +59,8 @@ module.exports = {
     });
 
     function errorMessageForElement(name) {
-      var message = `<${name}> is forbidden`;
-      var additionalMessage = indexedForbidConfigs[name].message;
+      const message = `<${name}> is forbidden`;
+      const additionalMessage = indexedForbidConfigs[name].message;
 
       if (additionalMessage) {
         return `${message}, ${additionalMessage}`;
@@ -96,8 +96,8 @@ module.exports = {
           return;
         }
 
-        var argument = node.arguments[0];
-        var argType = argument.type;
+        const argument = node.arguments[0];
+        const argType = argument.type;
 
         if (argType === 'Identifier' && /^[A-Z_]/.test(argument.name)) {
           reportIfForbidden(argument.name, argument);
diff --git a/lib/rules/forbid-foreign-prop-types.js b/lib/rules/forbid-foreign-prop-types.js
index 02b0dfbc9a..dd95e35a6d 100644
--- a/lib/rules/forbid-foreign-prop-types.js
+++ b/lib/rules/forbid-foreign-prop-types.js
@@ -45,7 +45,7 @@ module.exports = {
       },
 
       ObjectPattern: function(node) {
-        var propTypesNode = node.properties.find(function(property) {
+        const propTypesNode = node.properties.find(function(property) {
           return property.type === 'Property' && property.key.name === 'propTypes';
         });
 
diff --git a/lib/rules/forbid-prop-types.js b/lib/rules/forbid-prop-types.js
index 20718fd652..03d89fd1c9 100644
--- a/lib/rules/forbid-prop-types.js
+++ b/lib/rules/forbid-prop-types.js
@@ -7,7 +7,7 @@
 // Constants
 // ------------------------------------------------------------------------------
 
-var DEFAULTS = ['any', 'array', 'object'];
+const DEFAULTS = ['any', 'array', 'object'];
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -36,12 +36,12 @@ module.exports = {
   },
 
   create: function(context) {
-    var propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
+    const propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
 
     function isForbidden(type) {
-      var configuration = context.options[0] || {};
+      const configuration = context.options[0] || {};
 
-      var forbid = configuration.forbid || DEFAULTS;
+      const forbid = configuration.forbid || DEFAULTS;
       return forbid.indexOf(type) >= 0;
     }
 
@@ -54,7 +54,7 @@ module.exports = {
       // Special case for class properties
       // (babel-eslint does not expose property name so we have to rely on tokens)
       if (node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         if (tokens[0].value === 'propTypes' || (tokens[1] && tokens[1].value === 'propTypes')) {
           return true;
         }
@@ -78,8 +78,8 @@ module.exports = {
         if (declaration.type !== 'Property') {
           return;
         }
-        var target;
-        var value = declaration.value;
+        let target;
+        let value = declaration.value;
         if (
           value.type === 'MemberExpression' &&
           value.property &&
@@ -135,7 +135,7 @@ module.exports = {
           return;
         }
 
-        var right = node.parent.right;
+        const right = node.parent.right;
         switch (right && right.type) {
           case 'ObjectExpression':
             checkForbidden(right.properties);
diff --git a/lib/rules/jsx-closing-bracket-location.js b/lib/rules/jsx-closing-bracket-location.js
index 43ee47abcd..e8cfedc6cd 100644
--- a/lib/rules/jsx-closing-bracket-location.js
+++ b/lib/rules/jsx-closing-bracket-location.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var has = require('has');
+const has = require('has');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -48,19 +48,19 @@ module.exports = {
   },
 
   create: function(context) {
-    var MESSAGE = 'The closing bracket must be {{location}}{{details}}';
-    var MESSAGE_LOCATION = {
+    const MESSAGE = 'The closing bracket must be {{location}}{{details}}';
+    const MESSAGE_LOCATION = {
       'after-props': 'placed after the last prop',
       'after-tag': 'placed after the opening tag',
       'props-aligned': 'aligned with the last prop',
       'tag-aligned': 'aligned with the opening tag',
       'line-aligned': 'aligned with the line containing the opening tag'
     };
-    var DEFAULT_LOCATION = 'tag-aligned';
+    const DEFAULT_LOCATION = 'tag-aligned';
 
-    var sourceCode = context.getSourceCode();
-    var config = context.options[0];
-    var options = {
+    const sourceCode = context.getSourceCode();
+    const config = context.options[0];
+    const options = {
       nonEmpty: DEFAULT_LOCATION,
       selfClosing: DEFAULT_LOCATION
     };
@@ -91,7 +91,7 @@ module.exports = {
      * @return {String} Expected location for the closing bracket
      */
     function getExpectedLocation(tokens) {
-      var location;
+      let location;
       // Is always after the opening tag if there is no props
       if (typeof tokens.lastProp === 'undefined') {
         location = 'after-tag';
@@ -140,7 +140,7 @@ module.exports = {
         case 'props-aligned':
         case 'tag-aligned':
         case 'line-aligned':
-          var correctColumn = getCorrectColumn(tokens, expectedLocation);
+          const correctColumn = getCorrectColumn(tokens, expectedLocation);
           return correctColumn === tokens.closing.column;
         default:
           return true;
@@ -155,7 +155,7 @@ module.exports = {
      * @return {String} The characters used for indentation
      */
     function getIndentation(tokens, expectedLocation, correctColumn) {
-      var indentation, spaces = [];
+      let indentation, spaces = [];
       switch (expectedLocation) {
         case 'props-aligned':
           indentation = /^\s*/.exec(sourceCode.lines[tokens.lastProp.firstLine - 1])[0];
@@ -182,10 +182,10 @@ module.exports = {
      * prop and start of opening line.
      */
     function getTokensLocations(node) {
-      var opening = sourceCode.getFirstToken(node).loc.start;
-      var closing = sourceCode.getLastTokens(node, node.selfClosing ? 2 : 1)[0].loc.start;
-      var tag = sourceCode.getFirstToken(node.name).loc.start;
-      var lastProp;
+      const opening = sourceCode.getFirstToken(node).loc.start;
+      const closing = sourceCode.getLastTokens(node, node.selfClosing ? 2 : 1)[0].loc.start;
+      const tag = sourceCode.getFirstToken(node.name).loc.start;
+      let lastProp;
       if (node.attributes.length) {
         lastProp = node.attributes[node.attributes.length - 1];
         lastProp = {
@@ -194,8 +194,8 @@ module.exports = {
           lastLine: sourceCode.getLastToken(lastProp).loc.end.line
         };
       }
-      var openingLine = sourceCode.lines[opening.line - 1];
-      var openingStartOfLine = {
+      const openingLine = sourceCode.lines[opening.line - 1];
+      const openingStartOfLine = {
         column: /^\s*/.exec(openingLine)[0].length,
         line: opening.line
       };
@@ -219,7 +219,7 @@ module.exports = {
       return node.range.join(':');
     }
 
-    var lastAttributeNode = {};
+    const lastAttributeNode = {};
 
     return {
       JSXAttribute: function(node) {
@@ -231,18 +231,18 @@ module.exports = {
       },
 
       'JSXOpeningElement:exit': function(node) {
-        var attributeNode = lastAttributeNode[getOpeningElementId(node)];
-        var cachedLastAttributeEndPos = attributeNode ? attributeNode.end : null;
-        var expectedNextLine;
-        var tokens = getTokensLocations(node);
-        var expectedLocation = getExpectedLocation(tokens);
+        const attributeNode = lastAttributeNode[getOpeningElementId(node)];
+        const cachedLastAttributeEndPos = attributeNode ? attributeNode.end : null;
+        let expectedNextLine;
+        const tokens = getTokensLocations(node);
+        const expectedLocation = getExpectedLocation(tokens);
 
         if (hasCorrectLocation(tokens, expectedLocation)) {
           return;
         }
 
-        var data = {location: MESSAGE_LOCATION[expectedLocation], details: ''};
-        var correctColumn = getCorrectColumn(tokens, expectedLocation);
+        const data = {location: MESSAGE_LOCATION[expectedLocation], details: ''};
+        const correctColumn = getCorrectColumn(tokens, expectedLocation);
 
         if (correctColumn !== null) {
           expectedNextLine = tokens.lastProp &&
@@ -256,7 +256,7 @@ module.exports = {
           message: MESSAGE,
           data: data,
           fix: function(fixer) {
-            var closingTag = tokens.selfClosing ? '/>' : '>';
+            const closingTag = tokens.selfClosing ? '/>' : '>';
             switch (expectedLocation) {
               case 'after-tag':
                 if (cachedLastAttributeEndPos) {
diff --git a/lib/rules/jsx-closing-tag-location.js b/lib/rules/jsx-closing-tag-location.js
index 9059d529d4..7cea4eb66d 100644
--- a/lib/rules/jsx-closing-tag-location.js
+++ b/lib/rules/jsx-closing-tag-location.js
@@ -18,7 +18,7 @@ module.exports = {
   },
 
   create: function(context) {
-    var sourceCode = context.getSourceCode();
+    const sourceCode = context.getSourceCode();
 
     /**
      * Checks if the node is the first in its line, excluding whitespace.
@@ -38,8 +38,8 @@ module.exports = {
         /^\s*$/.test(lines[lines.length - 1])
       );
 
-      var startLine = node.loc.start.line;
-      var endLine = token ? token.loc.end.line : -1;
+      const startLine = node.loc.start.line;
+      const endLine = token ? token.loc.end.line : -1;
       return startLine !== endLine;
     }
 
diff --git a/lib/rules/jsx-curly-spacing.js b/lib/rules/jsx-curly-spacing.js
index cb85c92e60..2889b85102 100644
--- a/lib/rules/jsx-curly-spacing.js
+++ b/lib/rules/jsx-curly-spacing.js
@@ -10,17 +10,17 @@
  */
 'use strict';
 
-var has = require('has');
+const has = require('has');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
-var SPACING = {
+const SPACING = {
   always: 'always',
   never: 'never'
 };
-var SPACING_VALUES = [SPACING.always, SPACING.never];
+const SPACING_VALUES = [SPACING.always, SPACING.never];
 
 module.exports = {
   meta: {
@@ -99,11 +99,11 @@ module.exports = {
 
   create: function(context) {
     function normalizeConfig(configOrTrue, defaults, lastPass) {
-      var config = configOrTrue === true ? {} : configOrTrue;
-      var when = config.when || defaults.when;
-      var allowMultiline = has(config, 'allowMultiline') ? config.allowMultiline : defaults.allowMultiline;
-      var spacing = config.spacing || {};
-      var objectLiteralSpaces = spacing.objectLiterals || defaults.objectLiteralSpaces;
+      const config = configOrTrue === true ? {} : configOrTrue;
+      const when = config.when || defaults.when;
+      const allowMultiline = has(config, 'allowMultiline') ? config.allowMultiline : defaults.allowMultiline;
+      const spacing = config.spacing || {};
+      let objectLiteralSpaces = spacing.objectLiterals || defaults.objectLiteralSpaces;
       if (lastPass) {
         // On the final pass assign the values that should be derived from others if they are still undefined
         objectLiteralSpaces = objectLiteralSpaces || when;
@@ -116,24 +116,24 @@ module.exports = {
       };
     }
 
-    var DEFAULT_WHEN = SPACING.never;
-    var DEFAULT_ALLOW_MULTILINE = true;
-    var DEFAULT_ATTRIBUTES = true;
-    var DEFAULT_CHILDREN = false;
+    const DEFAULT_WHEN = SPACING.never;
+    const DEFAULT_ALLOW_MULTILINE = true;
+    const DEFAULT_ATTRIBUTES = true;
+    const DEFAULT_CHILDREN = false;
 
-    var sourceCode = context.getSourceCode();
-    var originalConfig = context.options[0] || {};
+    const sourceCode = context.getSourceCode();
+    let originalConfig = context.options[0] || {};
     if (SPACING_VALUES.indexOf(originalConfig) !== -1) {
       originalConfig = Object.assign({when: context.options[0]}, context.options[1]);
     }
-    var defaultConfig = normalizeConfig(originalConfig, {
+    const defaultConfig = normalizeConfig(originalConfig, {
       when: DEFAULT_WHEN,
       allowMultiline: DEFAULT_ALLOW_MULTILINE
     });
-    var attributes = has(originalConfig, 'attributes') ? originalConfig.attributes : DEFAULT_ATTRIBUTES;
-    var attributesConfig = attributes ? normalizeConfig(attributes, defaultConfig, true) : null;
-    var children = has(originalConfig, 'children') ? originalConfig.children : DEFAULT_CHILDREN;
-    var childrenConfig = children ? normalizeConfig(children, defaultConfig, true) : null;
+    const attributes = has(originalConfig, 'attributes') ? originalConfig.attributes : DEFAULT_ATTRIBUTES;
+    const attributesConfig = attributes ? normalizeConfig(attributes, defaultConfig, true) : null;
+    const children = has(originalConfig, 'children') ? originalConfig.children : DEFAULT_CHILDREN;
+    const childrenConfig = children ? normalizeConfig(children, defaultConfig, true) : null;
 
     // --------------------------------------------------------------------------
     // Helpers
@@ -161,7 +161,7 @@ module.exports = {
         loc: token.loc.start,
         message: `There should be no newline after '${token.value}'`,
         fix: function(fixer) {
-          var nextToken = sourceCode.getTokenAfter(token);
+          const nextToken = sourceCode.getTokenAfter(token);
           return fixer.replaceTextRange([token.range[1], nextToken.range[0]], spacing === SPACING.always ? ' ' : '');
         }
       });
@@ -179,7 +179,7 @@ module.exports = {
         loc: token.loc.start,
         message: `There should be no newline before '${token.value}'`,
         fix: function(fixer) {
-          var previousToken = sourceCode.getTokenBefore(token);
+          const previousToken = sourceCode.getTokenBefore(token);
           return fixer.replaceTextRange([previousToken.range[1], token.range[0]], spacing === SPACING.always ? ' ' : '');
         }
       });
@@ -197,10 +197,10 @@ module.exports = {
         loc: token.loc.start,
         message: `There should be no space after '${token.value}'`,
         fix: function(fixer) {
-          var nextToken = sourceCode.getTokenAfter(token);
-          var nextNode = sourceCode.getNodeByRangeIndex(nextToken.range[0]);
-          var leadingComments = sourceCode.getComments(nextNode).leading;
-          var rangeEndRef = leadingComments.length ? leadingComments[0] : nextToken;
+          const nextToken = sourceCode.getTokenAfter(token);
+          const nextNode = sourceCode.getNodeByRangeIndex(nextToken.range[0]);
+          const leadingComments = sourceCode.getComments(nextNode).leading;
+          const rangeEndRef = leadingComments.length ? leadingComments[0] : nextToken;
           return fixer.removeRange([token.range[1], rangeEndRef.range[0]]);
         }
       });
@@ -218,10 +218,10 @@ module.exports = {
         loc: token.loc.start,
         message: `There should be no space before '${token.value}'`,
         fix: function(fixer) {
-          var previousToken = sourceCode.getTokenBefore(token);
-          var previousNode = sourceCode.getNodeByRangeIndex(previousToken.range[0]);
-          var trailingComments = sourceCode.getComments(previousNode).trailing;
-          var rangeStartRef = trailingComments.length ? trailingComments[trailingComments.length - 1] : previousToken;
+          const previousToken = sourceCode.getTokenBefore(token);
+          const previousNode = sourceCode.getNodeByRangeIndex(previousToken.range[0]);
+          const trailingComments = sourceCode.getComments(previousNode).trailing;
+          const rangeStartRef = trailingComments.length ? trailingComments[trailingComments.length - 1] : previousToken;
           return fixer.removeRange([rangeStartRef.range[1], token.range[0]]);
         }
       });
@@ -267,7 +267,7 @@ module.exports = {
      * @returns {void}
      */
     function validateBraceSpacing(node) {
-      var config;
+      let config;
       switch (node.parent.type) {
         case 'JSXAttribute':
         case 'JSXOpeningElement':
@@ -285,24 +285,24 @@ module.exports = {
         return;
       }
 
-      var first = context.getFirstToken(node);
-      var last = sourceCode.getLastToken(node);
-      var second = context.getTokenAfter(first, {includeComments: true});
-      var penultimate = sourceCode.getTokenBefore(last, {includeComments: true});
+      const first = context.getFirstToken(node);
+      const last = sourceCode.getLastToken(node);
+      let second = context.getTokenAfter(first, {includeComments: true});
+      let penultimate = sourceCode.getTokenBefore(last, {includeComments: true});
 
       if (!second) {
         second = context.getTokenAfter(first);
-        var leadingComments = sourceCode.getNodeByRangeIndex(second.range[0]).leadingComments;
+        const leadingComments = sourceCode.getNodeByRangeIndex(second.range[0]).leadingComments;
         second = leadingComments ? leadingComments[0] : second;
       }
       if (!penultimate) {
         penultimate = sourceCode.getTokenBefore(last);
-        var trailingComments = sourceCode.getNodeByRangeIndex(penultimate.range[0]).trailingComments;
+        const trailingComments = sourceCode.getNodeByRangeIndex(penultimate.range[0]).trailingComments;
         penultimate = trailingComments ? trailingComments[trailingComments.length - 1] : penultimate;
       }
 
-      var isObjectLiteral = first.value === second.value;
-      var spacing = isObjectLiteral ? config.objectLiteralSpaces : config.when;
+      const isObjectLiteral = first.value === second.value;
+      const spacing = isObjectLiteral ? config.objectLiteralSpaces : config.when;
       if (spacing === SPACING.always) {
         if (!sourceCode.isSpaceBetweenTokens(first, second)) {
           reportRequiredBeginningSpace(node, first);
diff --git a/lib/rules/jsx-equals-spacing.js b/lib/rules/jsx-equals-spacing.js
index 78219a763b..d9667b9672 100644
--- a/lib/rules/jsx-equals-spacing.js
+++ b/lib/rules/jsx-equals-spacing.js
@@ -23,8 +23,8 @@ module.exports = {
   },
 
   create: function(context) {
-    var config = context.options[0];
-    var sourceCode = context.getSourceCode();
+    const config = context.options[0];
+    const sourceCode = context.getSourceCode();
 
     /**
      * Determines a given attribute node has an equal sign.
@@ -46,9 +46,9 @@ module.exports = {
             return;
           }
 
-          var equalToken = sourceCode.getTokenAfter(attrNode.name);
-          var spacedBefore = sourceCode.isSpaceBetweenTokens(attrNode.name, equalToken);
-          var spacedAfter = sourceCode.isSpaceBetweenTokens(equalToken, attrNode.value);
+          const equalToken = sourceCode.getTokenAfter(attrNode.name);
+          const spacedBefore = sourceCode.isSpaceBetweenTokens(attrNode.name, equalToken);
+          const spacedAfter = sourceCode.isSpaceBetweenTokens(equalToken, attrNode.value);
 
           switch (config) {
             default:
diff --git a/lib/rules/jsx-filename-extension.js b/lib/rules/jsx-filename-extension.js
index 04692b3e74..3b97c4aa0b 100644
--- a/lib/rules/jsx-filename-extension.js
+++ b/lib/rules/jsx-filename-extension.js
@@ -4,13 +4,13 @@
  */
 'use strict';
 
-var path = require('path');
+const path = require('path');
 
 // ------------------------------------------------------------------------------
 // Constants
 // ------------------------------------------------------------------------------
 
-var DEFAULTS = {
+const DEFAULTS = {
   extensions: ['.jsx']
 };
 
@@ -45,8 +45,8 @@ module.exports = {
       return context.options[0] && context.options[0].extensions || DEFAULTS.extensions;
     }
 
-    var invalidExtension;
-    var invalidNode;
+    let invalidExtension;
+    let invalidNode;
 
     // --------------------------------------------------------------------------
     // Public
@@ -54,7 +54,7 @@ module.exports = {
 
     return {
       JSXElement: function(node) {
-        var filename = context.getFilename();
+        const filename = context.getFilename();
         if (filename === '<text>') {
           return;
         }
@@ -63,8 +63,8 @@ module.exports = {
           return;
         }
 
-        var allowedExtensions = getExtensionsConfig();
-        var isAllowedExtension = allowedExtensions.some(function (extension) {
+        const allowedExtensions = getExtensionsConfig();
+        const isAllowedExtension = allowedExtensions.some(function (extension) {
           return filename.slice(-extension.length) === extension;
         });
 
diff --git a/lib/rules/jsx-first-prop-new-line.js b/lib/rules/jsx-first-prop-new-line.js
index 2c6b7c8638..f30fe5f60d 100644
--- a/lib/rules/jsx-first-prop-new-line.js
+++ b/lib/rules/jsx-first-prop-new-line.js
@@ -23,7 +23,7 @@ module.exports = {
   },
 
   create: function (context) {
-    var configuration = context.options[0] || 'multiline-multiprop';
+    const configuration = context.options[0] || 'multiline-multiprop';
 
     function isMultilineJSX(jsxNode) {
       return jsxNode.loc.start.line < jsxNode.loc.end.line;
@@ -49,7 +49,7 @@ module.exports = {
             return true;
           });
         } else if (configuration === 'never' && node.attributes.length > 0) {
-          var firstNode = node.attributes[0];
+          const firstNode = node.attributes[0];
           if (node.loc.start.line < firstNode.loc.start.line) {
             context.report({
               node: firstNode,
diff --git a/lib/rules/jsx-handler-names.js b/lib/rules/jsx-handler-names.js
index f77a78126f..413949a5d9 100644
--- a/lib/rules/jsx-handler-names.js
+++ b/lib/rules/jsx-handler-names.js
@@ -31,13 +31,13 @@ module.exports = {
   },
 
   create: function(context) {
-    var sourceCode = context.getSourceCode();
-    var configuration = context.options[0] || {};
-    var eventHandlerPrefix = configuration.eventHandlerPrefix || 'handle';
-    var eventHandlerPropPrefix = configuration.eventHandlerPropPrefix || 'on';
+    const sourceCode = context.getSourceCode();
+    const configuration = context.options[0] || {};
+    const eventHandlerPrefix = configuration.eventHandlerPrefix || 'handle';
+    const eventHandlerPropPrefix = configuration.eventHandlerPropPrefix || 'on';
 
-    var EVENT_HANDLER_REGEX = new RegExp(`^((props\\.${eventHandlerPropPrefix})|((.*\\.)?${eventHandlerPrefix}))[A-Z].*$`);
-    var PROP_EVENT_HANDLER_REGEX = new RegExp(`^(${eventHandlerPropPrefix}[A-Z].*|ref)$`);
+    const EVENT_HANDLER_REGEX = new RegExp(`^((props\\.${eventHandlerPropPrefix})|((.*\\.)?${eventHandlerPrefix}))[A-Z].*$`);
+    const PROP_EVENT_HANDLER_REGEX = new RegExp(`^(${eventHandlerPropPrefix}[A-Z].*|ref)$`);
 
     return {
       JSXAttribute: function(node) {
@@ -45,15 +45,15 @@ module.exports = {
           return;
         }
 
-        var propKey = typeof node.name === 'object' ? node.name.name : node.name;
-        var propValue = sourceCode.getText(node.value.expression).replace(/^this\.|.*::/, '');
+        const propKey = typeof node.name === 'object' ? node.name.name : node.name;
+        const propValue = sourceCode.getText(node.value.expression).replace(/^this\.|.*::/, '');
 
         if (propKey === 'ref') {
           return;
         }
 
-        var propIsEventHandler = PROP_EVENT_HANDLER_REGEX.test(propKey);
-        var propFnIsNamedCorrectly = EVENT_HANDLER_REGEX.test(propValue);
+        const propIsEventHandler = PROP_EVENT_HANDLER_REGEX.test(propKey);
+        const propFnIsNamedCorrectly = EVENT_HANDLER_REGEX.test(propValue);
 
         if (propIsEventHandler && !propFnIsNamedCorrectly) {
           context.report({
diff --git a/lib/rules/jsx-indent-props.js b/lib/rules/jsx-indent-props.js
index 001c0520de..d0becee64f 100644
--- a/lib/rules/jsx-indent-props.js
+++ b/lib/rules/jsx-indent-props.js
@@ -51,13 +51,13 @@ module.exports = {
   },
 
   create: function(context) {
-    var MESSAGE = 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.';
+    const MESSAGE = 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.';
 
-    var extraColumnStart = 0;
-    var indentType = 'space';
-    var indentSize = 4;
+    const extraColumnStart = 0;
+    let indentType = 'space';
+    let indentSize = 4;
 
-    var sourceCode = context.getSourceCode();
+    const sourceCode = context.getSourceCode();
 
     if (context.options.length) {
       if (context.options[0] === 'tab') {
@@ -77,7 +77,7 @@ module.exports = {
      * @param {Object=} loc Error line and column location
      */
     function report(node, needed, gotten, loc) {
-      var msgContext = {
+      const msgContext = {
         needed: needed,
         type: indentType,
         characters: needed === 1 ? 'character' : 'characters',
@@ -115,24 +115,24 @@ module.exports = {
       byLastLine = byLastLine || false;
       excludeCommas = excludeCommas || false;
 
-      var src = sourceCode.getText(node, node.loc.start.column + extraColumnStart);
-      var lines = src.split('\n');
+      let src = sourceCode.getText(node, node.loc.start.column + extraColumnStart);
+      const lines = src.split('\n');
       if (byLastLine) {
         src = lines[lines.length - 1];
       } else {
         src = lines[0];
       }
 
-      var skip = excludeCommas ? ',' : '';
+      const skip = excludeCommas ? ',' : '';
 
-      var regExp;
+      let regExp;
       if (indentType === 'space') {
         regExp = new RegExp(`^[ ${skip}]+`);
       } else {
         regExp = new RegExp(`^[\t${skip}]+`);
       }
 
-      var indent = regExp.exec(src);
+      const indent = regExp.exec(src);
       return indent ? indent[0].length : 0;
     }
 
@@ -143,9 +143,9 @@ module.exports = {
      * @return {Boolean} true if its the first in the its start line
      */
     function isNodeFirstInLine(node, byEndLocation) {
-      var firstToken = byEndLocation === true ? sourceCode.getLastToken(node, 1) : sourceCode.getTokenBefore(node);
-      var startLine = byEndLocation === true ? node.loc.end.line : node.loc.start.line;
-      var endLine = firstToken ? firstToken.loc.end.line : -1;
+      const firstToken = byEndLocation === true ? sourceCode.getLastToken(node, 1) : sourceCode.getTokenBefore(node);
+      const startLine = byEndLocation === true ? node.loc.end.line : node.loc.start.line;
+      const endLine = firstToken ? firstToken.loc.end.line : -1;
 
       return startLine !== endLine;
     }
@@ -158,7 +158,7 @@ module.exports = {
      */
     function checkNodesIndent(nodes, indent, excludeCommas) {
       nodes.forEach(function(node) {
-        var nodeIndent = getNodeIndent(node, false, excludeCommas);
+        const nodeIndent = getNodeIndent(node, false, excludeCommas);
         if (
           node.type !== 'ArrayExpression' && node.type !== 'ObjectExpression' &&
           nodeIndent !== indent && isNodeFirstInLine(node)
@@ -170,7 +170,7 @@ module.exports = {
 
     return {
       JSXOpeningElement: function(node) {
-        var elementIndent = getNodeIndent(node);
+        const elementIndent = getNodeIndent(node);
         checkNodesIndent(node.attributes, elementIndent + indentSize);
       }
     };
diff --git a/lib/rules/jsx-indent.js b/lib/rules/jsx-indent.js
index 6d74294898..b5b62e577c 100644
--- a/lib/rules/jsx-indent.js
+++ b/lib/rules/jsx-indent.js
@@ -50,13 +50,13 @@ module.exports = {
   },
 
   create: function(context) {
-    var MESSAGE = 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.';
+    const MESSAGE = 'Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}.';
 
-    var extraColumnStart = 0;
-    var indentType = 'space';
-    var indentSize = 4;
+    const extraColumnStart = 0;
+    let indentType = 'space';
+    let indentSize = 4;
 
-    var sourceCode = context.getSourceCode();
+    const sourceCode = context.getSourceCode();
 
     if (context.options.length) {
       if (context.options[0] === 'tab') {
@@ -68,7 +68,7 @@ module.exports = {
       }
     }
 
-    var indentChar = indentType === 'space' ? ' ' : '\t';
+    const indentChar = indentType === 'space' ? ' ' : '\t';
 
     /**
      * Responsible for fixing the indentation issue fix
@@ -79,7 +79,7 @@ module.exports = {
      */
     function getFixerFunction(node, needed) {
       return function(fixer) {
-        var indent = Array(needed + 1).join(indentChar);
+        const indent = Array(needed + 1).join(indentChar);
         return fixer.replaceTextRange(
           [node.start - node.loc.start.column, node.start],
           indent
@@ -95,7 +95,7 @@ module.exports = {
      * @param {Object} loc Error line and column location
      */
     function report(node, needed, gotten, loc) {
-      var msgContext = {
+      const msgContext = {
         needed: needed,
         type: indentType,
         characters: needed === 1 ? 'character' : 'characters',
@@ -131,24 +131,24 @@ module.exports = {
       byLastLine = byLastLine || false;
       excludeCommas = excludeCommas || false;
 
-      var src = sourceCode.getText(node, node.loc.start.column + extraColumnStart);
-      var lines = src.split('\n');
+      let src = sourceCode.getText(node, node.loc.start.column + extraColumnStart);
+      const lines = src.split('\n');
       if (byLastLine) {
         src = lines[lines.length - 1];
       } else {
         src = lines[0];
       }
 
-      var skip = excludeCommas ? ',' : '';
+      const skip = excludeCommas ? ',' : '';
 
-      var regExp;
+      let regExp;
       if (indentType === 'space') {
         regExp = new RegExp(`^[ ${skip}]+`);
       } else {
         regExp = new RegExp(`^[\t${skip}]+`);
       }
 
-      var indent = regExp.exec(src);
+      const indent = regExp.exec(src);
       return indent ? indent[0].length : 0;
     }
 
@@ -158,12 +158,12 @@ module.exports = {
      * @return {Boolean} true if its the first in the its start line
      */
     function isNodeFirstInLine(node) {
-      var token = node;
+      let token = node;
       do {
         token = sourceCode.getTokenBefore(token);
       } while (token.type === 'JSXText' && /^\s*$/.test(token.value));
-      var startLine = node.loc.start.line;
-      var endLine = token ? token.loc.end.line : -1;
+      const startLine = node.loc.start.line;
+      const endLine = token ? token.loc.end.line : -1;
 
       return startLine !== endLine;
     }
@@ -204,9 +204,9 @@ module.exports = {
      * @param {Boolean} excludeCommas skip comma on start of line
      */
     function checkNodesIndent(node, indent, excludeCommas) {
-      var nodeIndent = getNodeIndent(node, false, excludeCommas);
-      var isCorrectRightInLogicalExp = isRightInLogicalExp(node) && (nodeIndent - indent) === indentSize;
-      var isCorrectAlternateInCondExp = isAlternateInConditionalExp(node) && (nodeIndent - indent) === 0;
+      const nodeIndent = getNodeIndent(node, false, excludeCommas);
+      const isCorrectRightInLogicalExp = isRightInLogicalExp(node) && (nodeIndent - indent) === indentSize;
+      const isCorrectAlternateInCondExp = isAlternateInConditionalExp(node) && (nodeIndent - indent) === 0;
       if (
         nodeIndent !== indent &&
         isNodeFirstInLine(node) &&
@@ -219,7 +219,7 @@ module.exports = {
 
     return {
       JSXOpeningElement: function(node) {
-        var prevToken = sourceCode.getTokenBefore(node);
+        let prevToken = sourceCode.getTokenBefore(node);
         if (!prevToken) {
           return;
         }
@@ -239,8 +239,8 @@ module.exports = {
         }
         prevToken = prevToken.type === 'JSXExpressionContainer' ? prevToken.expression : prevToken;
 
-        var parentElementIndent = getNodeIndent(prevToken);
-        var indent = (
+        const parentElementIndent = getNodeIndent(prevToken);
+        const indent = (
           prevToken.loc.start.line === node.loc.start.line ||
           isRightInLogicalExp(node) ||
           isAlternateInConditionalExp(node)
@@ -251,14 +251,14 @@ module.exports = {
         if (!node.parent) {
           return;
         }
-        var peerElementIndent = getNodeIndent(node.parent.openingElement);
+        const peerElementIndent = getNodeIndent(node.parent.openingElement);
         checkNodesIndent(node, peerElementIndent);
       },
       JSXExpressionContainer: function(node) {
         if (!node.parent) {
           return;
         }
-        var parentNodeIndent = getNodeIndent(node.parent);
+        const parentNodeIndent = getNodeIndent(node.parent);
         checkNodesIndent(node, parentNodeIndent + indentSize);
       }
     };
diff --git a/lib/rules/jsx-key.js b/lib/rules/jsx-key.js
index 8a4a486add..c12f2afc0f 100644
--- a/lib/rules/jsx-key.js
+++ b/lib/rules/jsx-key.js
@@ -5,7 +5,7 @@
 'use strict';
 
 // var Components = require('../util/Components');
-var hasProp = require('jsx-ast-utils/hasProp');
+const hasProp = require('jsx-ast-utils/hasProp');
 
 
 // ------------------------------------------------------------------------------
@@ -62,9 +62,9 @@ module.exports = {
           return;
         }
 
-        var fn = node.arguments[0];
-        var isFn = fn && fn.type === 'FunctionExpression';
-        var isArrFn = fn && fn.type === 'ArrowFunctionExpression';
+        const fn = node.arguments[0];
+        const isFn = fn && fn.type === 'FunctionExpression';
+        const isArrFn = fn && fn.type === 'ArrowFunctionExpression';
 
         if (isArrFn && fn.body.type === 'JSXElement') {
           checkIteratorElement(fn.body);
@@ -72,7 +72,7 @@ module.exports = {
 
         if (isFn || isArrFn) {
           if (fn.body.type === 'BlockStatement') {
-            var returnStatement = getReturnStatement(fn.body.body);
+            const returnStatement = getReturnStatement(fn.body.body);
             if (returnStatement && returnStatement.argument) {
               checkIteratorElement(returnStatement.argument);
             }
diff --git a/lib/rules/jsx-max-props-per-line.js b/lib/rules/jsx-max-props-per-line.js
index 3fd8305604..4ea38b24a0 100644
--- a/lib/rules/jsx-max-props-per-line.js
+++ b/lib/rules/jsx-max-props-per-line.js
@@ -33,10 +33,10 @@ module.exports = {
   },
 
   create: function (context) {
-    var sourceCode = context.getSourceCode();
-    var configuration = context.options[0] || {};
-    var maximum = configuration.maximum || 1;
-    var when = configuration.when || 'always';
+    const sourceCode = context.getSourceCode();
+    const configuration = context.options[0] || {};
+    const maximum = configuration.maximum || 1;
+    const when = configuration.when || 'always';
 
     function getPropName(propNode) {
       if (propNode.type === 'JSXSpreadAttribute') {
@@ -46,11 +46,11 @@ module.exports = {
     }
 
     function generateFixFunction(line, max) {
-      var output = [];
-      var front = line[0].start;
-      var back = line[line.length - 1].end;
-      for (var i = 0; i < line.length; i += max) {
-        var nodes = line.slice(i, i + max);
+      const output = [];
+      const front = line[0].start;
+      const back = line[line.length - 1].end;
+      for (let i = 0; i < line.length; i += max) {
+        const nodes = line.slice(i, i + max);
         output.push(nodes.reduce(function(prev, curr) {
           if (prev === '') {
             return sourceCode.getText(curr);
@@ -58,7 +58,7 @@ module.exports = {
           return `${prev} ${sourceCode.getText(curr)}`;
         }, ''));
       }
-      var code = output.join('\n');
+      const code = output.join('\n');
       return function(fixer) {
         return fixer.replaceTextRange([front, back], code);
       };
@@ -74,8 +74,8 @@ module.exports = {
           return;
         }
 
-        var firstProp = node.attributes[0];
-        var linePartitionedProps = [[firstProp]];
+        const firstProp = node.attributes[0];
+        const linePartitionedProps = [[firstProp]];
 
         node.attributes.reduce(function (last, decl) {
           if (last.loc.end.line === decl.loc.start.line) {
@@ -88,7 +88,7 @@ module.exports = {
 
         linePartitionedProps.forEach(function (propsInLine) {
           if (propsInLine.length > maximum) {
-            var name = getPropName(propsInLine[maximum]);
+            const name = getPropName(propsInLine[maximum]);
             context.report({
               node: propsInLine[maximum],
               message: `Prop \`${name}\` must be placed on a new line`,
diff --git a/lib/rules/jsx-no-bind.js b/lib/rules/jsx-no-bind.js
index 19fa6de6ed..4c0e671418 100644
--- a/lib/rules/jsx-no-bind.js
+++ b/lib/rules/jsx-no-bind.js
@@ -5,8 +5,8 @@
  */
 'use strict';
 
-var Components = require('../util/Components');
-var propName = require('jsx-ast-utils/propName');
+const Components = require('../util/Components');
+const propName = require('jsx-ast-utils/propName');
 
 // -----------------------------------------------------------------------------
 // Rule Definition
@@ -41,19 +41,19 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components, utils) {
-    var configuration = context.options[0] || {};
+    const configuration = context.options[0] || {};
 
     return {
       CallExpression: function(node) {
-        var callee = node.callee;
+        const callee = node.callee;
         if (
           !configuration.allowBind &&
           (callee.type !== 'MemberExpression' || callee.property.name !== 'bind')
         ) {
           return;
         }
-        var ancestors = context.getAncestors(callee).reverse();
-        for (var i = 0, j = ancestors.length; i < j; i++) {
+        const ancestors = context.getAncestors(callee).reverse();
+        for (let i = 0, j = ancestors.length; i < j; i++) {
           if (
             !configuration.allowBind &&
             (ancestors[i].type === 'MethodDefinition' && ancestors[i].key.name === 'render') ||
@@ -71,11 +71,11 @@ module.exports = {
       },
 
       JSXAttribute: function(node) {
-        var isRef = configuration.ignoreRefs && propName(node) === 'ref';
+        const isRef = configuration.ignoreRefs && propName(node) === 'ref';
         if (isRef || !node.value || !node.value.expression) {
           return;
         }
-        var valueNode = node.value.expression;
+        const valueNode = node.value.expression;
         if (
           !configuration.allowBind &&
           valueNode.type === 'CallExpression' &&
diff --git a/lib/rules/jsx-no-duplicate-props.js b/lib/rules/jsx-no-duplicate-props.js
index 7b7d658ed6..643f019ead 100644
--- a/lib/rules/jsx-no-duplicate-props.js
+++ b/lib/rules/jsx-no-duplicate-props.js
@@ -5,7 +5,7 @@
 
 'use strict';
 
-var has = require('has');
+const has = require('has');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -31,19 +31,19 @@ module.exports = {
   },
 
   create: function (context) {
-    var configuration = context.options[0] || {};
-    var ignoreCase = configuration.ignoreCase || false;
+    const configuration = context.options[0] || {};
+    const ignoreCase = configuration.ignoreCase || false;
 
     return {
       JSXOpeningElement: function (node) {
-        var props = {};
+        const props = {};
 
         node.attributes.forEach(function(decl) {
           if (decl.type === 'JSXSpreadAttribute') {
             return;
           }
 
-          var name = decl.name.name;
+          let name = decl.name.name;
 
           if (ignoreCase) {
             name = name.toLowerCase();
diff --git a/lib/rules/jsx-no-target-blank.js b/lib/rules/jsx-no-target-blank.js
index 1e3cf20f81..551d640c20 100644
--- a/lib/rules/jsx-no-target-blank.js
+++ b/lib/rules/jsx-no-target-blank.js
@@ -26,7 +26,7 @@ function hasExternalLink(element) {
 function hasSecureRel(element) {
   return element.attributes.find(function (attr) {
     if (attr.name.name === 'rel') {
-      var tags = attr.value && attr.value.type === 'Literal' && attr.value.value.toLowerCase().split(' ');
+      const tags = attr.value && attr.value.type === 'Literal' && attr.value.value.toLowerCase().split(' ');
       return tags && (tags.indexOf('noopener') >= 0 && tags.indexOf('noreferrer') >= 0);
     }
     return false;
diff --git a/lib/rules/jsx-no-undef.js b/lib/rules/jsx-no-undef.js
index 868eb8f1a1..5f84a9a137 100644
--- a/lib/rules/jsx-no-undef.js
+++ b/lib/rules/jsx-no-undef.js
@@ -10,7 +10,7 @@
  * @param {String} name - Name of the node to check.
  * @returns {boolean} Whether or not the node name match the JSX tag convention.
  */
-var tagConvention = /^[a-z]|\-/;
+const tagConvention = /^[a-z]|\-/;
 function isTagName(name) {
   return tagConvention.test(name);
 }
@@ -38,8 +38,8 @@ module.exports = {
   },
 
   create: function(context) {
-    var config = context.options[0] || {};
-    var allowGlobals = config.allowGlobals || false;
+    const config = context.options[0] || {};
+    const allowGlobals = config.allowGlobals || false;
 
     /**
      * Compare an identifier with the variables declared in the scope
@@ -47,13 +47,13 @@ module.exports = {
      * @returns {void}
      */
     function checkIdentifierInJSX(node) {
-      var scope = context.getScope();
-      var sourceCode = context.getSourceCode();
-      var sourceType = sourceCode.ast.sourceType;
-      var variables = scope.variables;
-      var scopeType = 'global';
-      var i;
-      var len;
+      let scope = context.getScope();
+      const sourceCode = context.getSourceCode();
+      const sourceType = sourceCode.ast.sourceType;
+      let variables = scope.variables;
+      let scopeType = 'global';
+      let i;
+      let len;
 
       // Ignore 'this' keyword (also maked as JSXIdentifier when used in JSX)
       if (node.name === 'this') {
diff --git a/lib/rules/jsx-pascal-case.js b/lib/rules/jsx-pascal-case.js
index b7ca0f0ad2..25589be96b 100644
--- a/lib/rules/jsx-pascal-case.js
+++ b/lib/rules/jsx-pascal-case.js
@@ -5,15 +5,15 @@
 
 'use strict';
 
-var elementType = require('jsx-ast-utils/elementType');
+const elementType = require('jsx-ast-utils/elementType');
 
 // ------------------------------------------------------------------------------
 // Constants
 // ------------------------------------------------------------------------------
 
-var PASCAL_CASE_REGEX = /^([A-Z0-9]|[A-Z0-9]+[a-z0-9]+(?:[A-Z0-9]+[a-z0-9]*)*)$/;
-var COMPAT_TAG_REGEX = /^[a-z]|\-/;
-var ALL_CAPS_TAG_REGEX = /^[A-Z0-9]+$/;
+const PASCAL_CASE_REGEX = /^([A-Z0-9]|[A-Z0-9]+[a-z0-9]+(?:[A-Z0-9]+[a-z0-9]*)*)$/;
+const COMPAT_TAG_REGEX = /^[a-z]|\-/;
+const ALL_CAPS_TAG_REGEX = /^[A-Z0-9]+$/;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -42,13 +42,13 @@ module.exports = {
   },
 
   create: function(context) {
-    var configuration = context.options[0] || {};
-    var allowAllCaps = configuration.allowAllCaps || false;
-    var ignore = configuration.ignore || [];
+    const configuration = context.options[0] || {};
+    const allowAllCaps = configuration.allowAllCaps || false;
+    const ignore = configuration.ignore || [];
 
     return {
       JSXOpeningElement: function(node) {
-        var name = elementType(node);
+        let name = elementType(node);
 
         // Get namespace if the type is JSXNamespacedName or JSXMemberExpression
         if (name.indexOf(':') > -1) {
@@ -57,10 +57,10 @@ module.exports = {
           name = name.substring(0, name.indexOf('.'));
         }
 
-        var isPascalCase = PASCAL_CASE_REGEX.test(name);
-        var isCompatTag = COMPAT_TAG_REGEX.test(name);
-        var isAllowedAllCaps = allowAllCaps && ALL_CAPS_TAG_REGEX.test(name);
-        var isIgnored = ignore.indexOf(name) !== -1;
+        const isPascalCase = PASCAL_CASE_REGEX.test(name);
+        const isCompatTag = COMPAT_TAG_REGEX.test(name);
+        const isAllowedAllCaps = allowAllCaps && ALL_CAPS_TAG_REGEX.test(name);
+        const isIgnored = ignore.indexOf(name) !== -1;
 
         if (!isPascalCase && !isCompatTag && !isAllowedAllCaps && !isIgnored) {
           context.report({
diff --git a/lib/rules/jsx-sort-props.js b/lib/rules/jsx-sort-props.js
index a525d06d3f..4f4f6769d9 100644
--- a/lib/rules/jsx-sort-props.js
+++ b/lib/rules/jsx-sort-props.js
@@ -4,8 +4,8 @@
  */
 'use strict';
 
-var elementType = require('jsx-ast-utils/elementType');
-var propName = require('jsx-ast-utils/propName');
+const elementType = require('jsx-ast-utils/elementType');
+const propName = require('jsx-ast-utils/propName');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -15,9 +15,9 @@ function isCallbackPropName(name) {
   return /^on[A-Z]/.test(name);
 }
 
-var COMPAT_TAG_REGEX = /^[a-z]|\-/;
+const COMPAT_TAG_REGEX = /^[a-z]|\-/;
 function isDOMComponent(node) {
-  var name = elementType(node);
+  let name = elementType(node);
 
   // Get namespace if the type is JSXNamespacedName or JSXMemberExpression
   if (name.indexOf(':') > -1) {
@@ -29,7 +29,7 @@ function isDOMComponent(node) {
   return COMPAT_TAG_REGEX.test(name);
 }
 
-var RESERVED_PROPS_LIST = [
+const RESERVED_PROPS_LIST = [
   'children',
   'dangerouslySetInnerHTML',
   'key',
@@ -52,7 +52,7 @@ function validateReservedFirstConfig(context, reservedFirst) {
     if (Array.isArray(reservedFirst)) {
       // Only allow a subset of reserved words in customized lists
       // eslint-disable-next-line consistent-return
-      var nonReservedWords = reservedFirst.filter(function(word) {
+      const nonReservedWords = reservedFirst.filter(function(word) {
         if (!isReservedPropName(word, RESERVED_PROPS_LIST)) {
           return true;
         }
@@ -121,15 +121,15 @@ module.exports = {
   },
 
   create: function(context) {
-    var configuration = context.options[0] || {};
-    var ignoreCase = configuration.ignoreCase || false;
-    var callbacksLast = configuration.callbacksLast || false;
-    var shorthandFirst = configuration.shorthandFirst || false;
-    var shorthandLast = configuration.shorthandLast || false;
-    var noSortAlphabetically = configuration.noSortAlphabetically || false;
-    var reservedFirst = configuration.reservedFirst || false;
-    var reservedFirstError = validateReservedFirstConfig(context, reservedFirst);
-    var reservedList = Array.isArray(reservedFirst) ? reservedFirst : RESERVED_PROPS_LIST;
+    const configuration = context.options[0] || {};
+    const ignoreCase = configuration.ignoreCase || false;
+    const callbacksLast = configuration.callbacksLast || false;
+    const shorthandFirst = configuration.shorthandFirst || false;
+    const shorthandLast = configuration.shorthandLast || false;
+    const noSortAlphabetically = configuration.noSortAlphabetically || false;
+    const reservedFirst = configuration.reservedFirst || false;
+    const reservedFirstError = validateReservedFirstConfig(context, reservedFirst);
+    let reservedList = Array.isArray(reservedFirst) ? reservedFirst : RESERVED_PROPS_LIST;
 
     return {
       JSXOpeningElement: function(node) {
@@ -145,12 +145,12 @@ module.exports = {
             return attrs[idx + 1];
           }
 
-          var previousPropName = propName(memo);
-          var currentPropName = propName(decl);
-          var previousValue = memo.value;
-          var currentValue = decl.value;
-          var previousIsCallback = isCallbackPropName(previousPropName);
-          var currentIsCallback = isCallbackPropName(currentPropName);
+          let previousPropName = propName(memo);
+          let currentPropName = propName(decl);
+          const previousValue = memo.value;
+          const currentValue = decl.value;
+          const previousIsCallback = isCallbackPropName(previousPropName);
+          const currentIsCallback = isCallbackPropName(currentPropName);
 
           if (ignoreCase) {
             previousPropName = previousPropName.toLowerCase();
@@ -163,8 +163,8 @@ module.exports = {
               return memo;
             }
 
-            var previousIsReserved = isReservedPropName(previousPropName, reservedList);
-            var currentIsReserved = isReservedPropName(currentPropName, reservedList);
+            const previousIsReserved = isReservedPropName(previousPropName, reservedList);
+            const currentIsReserved = isReservedPropName(currentPropName, reservedList);
 
             if (previousIsReserved && currentIsReserved) {
               if (!noSortAlphabetically && currentPropName < previousPropName) {
diff --git a/lib/rules/jsx-space-before-closing.js b/lib/rules/jsx-space-before-closing.js
index 4facdad813..299fbfc4c8 100644
--- a/lib/rules/jsx-space-before-closing.js
+++ b/lib/rules/jsx-space-before-closing.js
@@ -5,8 +5,8 @@
  */
 'use strict';
 
-var getTokenBeforeClosingBracket = require('../util/getTokenBeforeClosingBracket');
-var isWarnedForDeprecation = false;
+const getTokenBeforeClosingBracket = require('../util/getTokenBeforeClosingBracket');
+let isWarnedForDeprecation = false;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -28,11 +28,11 @@ module.exports = {
   },
 
   create: function(context) {
-    var configuration = context.options[0] || 'always';
-    var sourceCode = context.getSourceCode();
+    const configuration = context.options[0] || 'always';
+    const sourceCode = context.getSourceCode();
 
-    var NEVER_MESSAGE = 'A space is forbidden before closing bracket';
-    var ALWAYS_MESSAGE = 'A space is required before closing bracket';
+    const NEVER_MESSAGE = 'A space is forbidden before closing bracket';
+    const ALWAYS_MESSAGE = 'A space is required before closing bracket';
 
     // --------------------------------------------------------------------------
     // Public
@@ -44,8 +44,8 @@ module.exports = {
           return;
         }
 
-        var leftToken = getTokenBeforeClosingBracket(node);
-        var closingSlash = sourceCode.getTokenAfter(leftToken);
+        const leftToken = getTokenBeforeClosingBracket(node);
+        const closingSlash = sourceCode.getTokenAfter(leftToken);
 
         if (leftToken.loc.end.line !== closingSlash.loc.start.line) {
           return;
@@ -64,7 +64,7 @@ module.exports = {
             loc: closingSlash.loc.start,
             message: NEVER_MESSAGE,
             fix: function(fixer) {
-              var previousToken = sourceCode.getTokenBefore(closingSlash);
+              const previousToken = sourceCode.getTokenBefore(closingSlash);
               return fixer.removeRange([previousToken.range[1], closingSlash.range[0]]);
             }
           });
diff --git a/lib/rules/jsx-tag-spacing.js b/lib/rules/jsx-tag-spacing.js
index 9bb3b5fc65..f61533863d 100644
--- a/lib/rules/jsx-tag-spacing.js
+++ b/lib/rules/jsx-tag-spacing.js
@@ -4,25 +4,25 @@
  */
 'use strict';
 
-var has = require('has');
-var getTokenBeforeClosingBracket = require('../util/getTokenBeforeClosingBracket');
+const has = require('has');
+const getTokenBeforeClosingBracket = require('../util/getTokenBeforeClosingBracket');
 
 // ------------------------------------------------------------------------------
 // Validators
 // ------------------------------------------------------------------------------
 
 function validateClosingSlash(context, node, option) {
-  var sourceCode = context.getSourceCode();
+  const sourceCode = context.getSourceCode();
 
-  var SELF_CLOSING_NEVER_MESSAGE = 'Whitespace is forbidden between `/` and `>`; write `/>`';
-  var SELF_CLOSING_ALWAYS_MESSAGE = 'Whitespace is required between `/` and `>`; write `/ >`';
-  var NEVER_MESSAGE = 'Whitespace is forbidden between `<` and `/`; write `</`';
-  var ALWAYS_MESSAGE = 'Whitespace is required between `<` and `/`; write `< /`';
+  const SELF_CLOSING_NEVER_MESSAGE = 'Whitespace is forbidden between `/` and `>`; write `/>`';
+  const SELF_CLOSING_ALWAYS_MESSAGE = 'Whitespace is required between `/` and `>`; write `/ >`';
+  const NEVER_MESSAGE = 'Whitespace is forbidden between `<` and `/`; write `</`';
+  const ALWAYS_MESSAGE = 'Whitespace is required between `<` and `/`; write `< /`';
 
-  var adjacent;
+  let adjacent;
 
   if (node.selfClosing) {
-    var lastTokens = sourceCode.getLastTokens(node, 2);
+    const lastTokens = sourceCode.getLastTokens(node, 2);
 
     adjacent = !sourceCode.isSpaceBetweenTokens(lastTokens[0], lastTokens[1]);
 
@@ -54,7 +54,7 @@ function validateClosingSlash(context, node, option) {
       });
     }
   } else {
-    var firstTokens = sourceCode.getFirstTokens(node, 2);
+    const firstTokens = sourceCode.getFirstTokens(node, 2);
 
     adjacent = !sourceCode.isSpaceBetweenTokens(firstTokens[0], firstTokens[1]);
 
@@ -89,13 +89,13 @@ function validateClosingSlash(context, node, option) {
 }
 
 function validateBeforeSelfClosing(context, node, option) {
-  var sourceCode = context.getSourceCode();
+  const sourceCode = context.getSourceCode();
 
-  var NEVER_MESSAGE = 'A space is forbidden before closing bracket';
-  var ALWAYS_MESSAGE = 'A space is required before closing bracket';
+  const NEVER_MESSAGE = 'A space is forbidden before closing bracket';
+  const ALWAYS_MESSAGE = 'A space is required before closing bracket';
 
-  var leftToken = getTokenBeforeClosingBracket(node);
-  var closingSlash = sourceCode.getTokenAfter(leftToken);
+  const leftToken = getTokenBeforeClosingBracket(node);
+  const closingSlash = sourceCode.getTokenAfter(leftToken);
 
   if (leftToken.loc.end.line !== closingSlash.loc.start.line) {
     return;
@@ -116,7 +116,7 @@ function validateBeforeSelfClosing(context, node, option) {
       loc: closingSlash.loc.start,
       message: NEVER_MESSAGE,
       fix: function(fixer) {
-        var previousToken = sourceCode.getTokenBefore(closingSlash);
+        const previousToken = sourceCode.getTokenBefore(closingSlash);
         return fixer.removeRange([previousToken.range[1], closingSlash.range[0]]);
       }
     });
@@ -124,12 +124,12 @@ function validateBeforeSelfClosing(context, node, option) {
 }
 
 function validateAfterOpening(context, node, option) {
-  var sourceCode = context.getSourceCode();
+  const sourceCode = context.getSourceCode();
 
-  var NEVER_MESSAGE = 'A space is forbidden after opening bracket';
-  var ALWAYS_MESSAGE = 'A space is required after opening bracket';
+  const NEVER_MESSAGE = 'A space is forbidden after opening bracket';
+  const ALWAYS_MESSAGE = 'A space is required after opening bracket';
 
-  var openingToken = sourceCode.getTokenBefore(node.name);
+  const openingToken = sourceCode.getTokenBefore(node.name);
 
   if (option === 'allow-multiline') {
     if (openingToken.loc.start.line !== node.name.loc.start.line) {
@@ -137,7 +137,7 @@ function validateAfterOpening(context, node, option) {
     }
   }
 
-  var adjacent = !sourceCode.isSpaceBetweenTokens(openingToken, node.name);
+  const adjacent = !sourceCode.isSpaceBetweenTokens(openingToken, node.name);
 
   if (option === 'never' || option === 'allow-multiline') {
     if (!adjacent) {
@@ -200,12 +200,12 @@ module.exports = {
     ]
   },
   create: function (context) {
-    var options = {
+    const options = {
       closingSlash: 'never',
       beforeSelfClosing: 'always',
       afterOpening: 'never'
     };
-    for (var key in options) {
+    for (const key in options) {
       if (has(options, key) && has(context.options[0] || {}, key)) {
         options[key] = context.options[0][key];
       }
diff --git a/lib/rules/jsx-uses-react.js b/lib/rules/jsx-uses-react.js
index e2b34eec84..e6b9c6b527 100644
--- a/lib/rules/jsx-uses-react.js
+++ b/lib/rules/jsx-uses-react.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var pragmaUtil = require('../util/pragma');
+const pragmaUtil = require('../util/pragma');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -21,7 +21,7 @@ module.exports = {
   },
 
   create: function(context) {
-    var pragma = pragmaUtil.getFromContext(context);
+    const pragma = pragmaUtil.getFromContext(context);
 
     // --------------------------------------------------------------------------
     // Public
diff --git a/lib/rules/jsx-uses-vars.js b/lib/rules/jsx-uses-vars.js
index d688639c2c..8040eb455c 100644
--- a/lib/rules/jsx-uses-vars.js
+++ b/lib/rules/jsx-uses-vars.js
@@ -21,7 +21,7 @@ module.exports = {
   create: function(context) {
     return {
       JSXOpeningElement: function(node) {
-        var name;
+        let name;
         if (node.name.namespace && node.name.namespace.name) {
           // <Foo:Bar>
           name = node.name.namespace.name;
@@ -30,7 +30,7 @@ module.exports = {
           name = node.name.name;
         } else if (node.name.object) {
           // <Foo...Bar>
-          var parent = node.name.object;
+          let parent = node.name.object;
           while (parent.object) {
             parent = parent.object;
           }
diff --git a/lib/rules/jsx-wrap-multilines.js b/lib/rules/jsx-wrap-multilines.js
index e18bf1a081..ca12f033e6 100644
--- a/lib/rules/jsx-wrap-multilines.js
+++ b/lib/rules/jsx-wrap-multilines.js
@@ -4,13 +4,13 @@
  */
 'use strict';
 
-var has = require('has');
+const has = require('has');
 
 // ------------------------------------------------------------------------------
 // Constants
 // ------------------------------------------------------------------------------
 
-var DEFAULTS = {
+const DEFAULTS = {
   declaration: true,
   assignment: true,
   return: true,
@@ -51,11 +51,11 @@ module.exports = {
   },
 
   create: function(context) {
-    var sourceCode = context.getSourceCode();
+    const sourceCode = context.getSourceCode();
 
     function isParenthesised(node) {
-      var previousToken = sourceCode.getTokenBefore(node);
-      var nextToken = sourceCode.getTokenAfter(node);
+      const previousToken = sourceCode.getTokenBefore(node);
+      const nextToken = sourceCode.getTokenAfter(node);
 
       return previousToken && nextToken &&
         previousToken.value === '(' && previousToken.range[1] <= node.range[0] &&
@@ -83,7 +83,7 @@ module.exports = {
     }
 
     function isEnabled(type) {
-      var userOptions = context.options[0] || {};
+      const userOptions = context.options[0] || {};
       if (has(userOptions, type)) {
         return userOptions[type];
       }
@@ -127,7 +127,7 @@ module.exports = {
       },
 
       'ArrowFunctionExpression:exit': function (node) {
-        var arrowBody = node.body;
+        const arrowBody = node.body;
 
         if (isEnabled('arrow') && arrowBody.type !== 'BlockStatement') {
           check(arrowBody);
diff --git a/lib/rules/no-array-index-key.js b/lib/rules/no-array-index-key.js
index a3cbe8f5c4..556b3e3a6f 100644
--- a/lib/rules/no-array-index-key.js
+++ b/lib/rules/no-array-index-key.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var has = require('has');
+const has = require('has');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -25,8 +25,8 @@ module.exports = {
     // --------------------------------------------------------------------------
     // Public
     // --------------------------------------------------------------------------
-    var indexParamNames = [];
-    var iteratorFunctionsToIndexParamPosition = {
+    const indexParamNames = [];
+    const iteratorFunctionsToIndexParamPosition = {
       every: 1,
       filter: 1,
       find: 1,
@@ -37,7 +37,7 @@ module.exports = {
       reduceRight: 2,
       some: 1
     };
-    var ERROR_MESSAGE = 'Do not use Array index in keys';
+    const ERROR_MESSAGE = 'Do not use Array index in keys';
 
     function isArrayIndex(node) {
       return node.type === 'Identifier'
@@ -45,7 +45,7 @@ module.exports = {
     }
 
     function getMapIndexParamName(node) {
-      var callee = node.callee;
+      const callee = node.callee;
       if (callee.type !== 'MemberExpression') {
         return null;
       }
@@ -56,12 +56,12 @@ module.exports = {
         return null;
       }
 
-      var firstArg = node.arguments[0];
+      const firstArg = node.arguments[0];
       if (!firstArg) {
         return null;
       }
 
-      var isFunction = [
+      const isFunction = [
         'ArrowFunctionExpression',
         'FunctionExpression'
       ].indexOf(firstArg.type) !== -1;
@@ -69,9 +69,9 @@ module.exports = {
         return null;
       }
 
-      var params = firstArg.params;
+      const params = firstArg.params;
 
-      var indexParamPosition = iteratorFunctionsToIndexParamPosition[callee.property.name];
+      const indexParamPosition = iteratorFunctionsToIndexParamPosition[callee.property.name];
       if (params.length < indexParamPosition + 1) {
         return null;
       }
@@ -86,8 +86,8 @@ module.exports = {
 
       if (side.type === 'BinaryExpression') {
         // recurse
-        var left = getIdentifiersFromBinaryExpression(side.left);
-        var right = getIdentifiersFromBinaryExpression(side.right);
+        const left = getIdentifiersFromBinaryExpression(side.left);
+        const right = getIdentifiersFromBinaryExpression(side.right);
         return [].concat(left, right).filter(Boolean);
       }
 
@@ -115,7 +115,7 @@ module.exports = {
 
       if (node.type === 'BinaryExpression') {
         // key={'foo' + bar}
-        var identifiers = getIdentifiersFromBinaryExpression(node);
+        const identifiers = getIdentifiersFromBinaryExpression(node);
 
         identifiers.filter(isArrayIndex).forEach(function() {
           context.report({node: node, message: ERROR_MESSAGE});
@@ -138,7 +138,7 @@ module.exports = {
             return;
           }
 
-          var props = node.arguments[1];
+          const props = node.arguments[1];
 
           if (props.type !== 'ObjectExpression') {
             return;
@@ -157,7 +157,7 @@ module.exports = {
           return;
         }
 
-        var mapIndexParamName = getMapIndexParamName(node);
+        const mapIndexParamName = getMapIndexParamName(node);
         if (!mapIndexParamName) {
           return;
         }
@@ -176,7 +176,7 @@ module.exports = {
           return;
         }
 
-        var value = node.value;
+        const value = node.value;
         if (!value || value.type !== 'JSXExpressionContainer') {
           // key='foo' or just simply 'key'
           return;
@@ -186,7 +186,7 @@ module.exports = {
       },
 
       'CallExpression:exit': function(node) {
-        var mapIndexParamName = getMapIndexParamName(node);
+        const mapIndexParamName = getMapIndexParamName(node);
         if (!mapIndexParamName) {
           return;
         }
diff --git a/lib/rules/no-children-prop.js b/lib/rules/no-children-prop.js
index f4da63eccc..67d95009bb 100644
--- a/lib/rules/no-children-prop.js
+++ b/lib/rules/no-children-prop.js
@@ -52,8 +52,8 @@ module.exports = {
           return;
         }
 
-        var props = node.arguments[1].properties;
-        var childrenProp = props.find(function(prop) {
+        const props = node.arguments[1].properties;
+        const childrenProp = props.find(function(prop) {
           return prop.key && prop.key.name === 'children';
         });
 
diff --git a/lib/rules/no-danger-with-children.js b/lib/rules/no-danger-with-children.js
index 6e873d151d..d2ec2cb332 100644
--- a/lib/rules/no-danger-with-children.js
+++ b/lib/rules/no-danger-with-children.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var variableUtil = require('../util/variable');
+const variableUtil = require('../util/variable');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -37,7 +37,7 @@ module.exports = {
         if (prop.type === 'Property') {
           return prop.key.name === propName;
         } else if (prop.type === 'ExperimentalSpreadProperty') {
-          var variable = findSpreadVariable(prop.argument.name);
+          const variable = findSpreadVariable(prop.argument.name);
           if (variable && variable.defs[0].node.init) {
             return findObjectProp(variable.defs[0].node.init, propName);
           }
@@ -52,10 +52,10 @@ module.exports = {
      * @param {string} propName - name of the prop to look for
      */
     function findJsxProp(node, propName) {
-      var attributes = node.openingElement.attributes;
+      const attributes = node.openingElement.attributes;
       return attributes.find(function (attribute) {
         if (attribute.type === 'JSXSpreadAttribute') {
-          var variable = findSpreadVariable(attribute.argument.name);
+          const variable = findSpreadVariable(attribute.argument.name);
           if (variable && variable.defs.length && variable.defs[0].node.init) {
             return findObjectProp(variable.defs[0].node.init, propName);
           }
@@ -66,7 +66,7 @@ module.exports = {
 
     return {
       JSXElement: function (node) {
-        var hasChildren = false;
+        let hasChildren = false;
 
         if (node.children.length) {
           hasChildren = true;
@@ -89,12 +89,12 @@ module.exports = {
           && node.callee.property.name === 'createElement'
           && node.arguments.length > 1
         ) {
-          var hasChildren = false;
+          let hasChildren = false;
 
-          var props = node.arguments[1];
+          let props = node.arguments[1];
 
           if (props.type === 'Identifier') {
-            var variable = variableUtil.variablesInScope(context).find(function (item) {
+            const variable = variableUtil.variablesInScope(context).find(function (item) {
               return item.name === props.name;
             });
             if (variable && variable.defs[0].node.init) {
@@ -102,7 +102,7 @@ module.exports = {
             }
           }
 
-          var dangerously = findObjectProp(props, 'dangerouslySetInnerHTML');
+          const dangerously = findObjectProp(props, 'dangerouslySetInnerHTML');
 
           if (node.arguments.length === 2) {
             if (findObjectProp(props, 'children')) {
diff --git a/lib/rules/no-danger.js b/lib/rules/no-danger.js
index 74190a7fbc..37143fe722 100644
--- a/lib/rules/no-danger.js
+++ b/lib/rules/no-danger.js
@@ -8,13 +8,13 @@
 // Constants
 // ------------------------------------------------------------------------------
 
-var DANGEROUS_MESSAGE = 'Dangerous property \'{{name}}\' found';
+const DANGEROUS_MESSAGE = 'Dangerous property \'{{name}}\' found';
 
-var DANGEROUS_PROPERTY_NAMES = [
+const DANGEROUS_PROPERTY_NAMES = [
   'dangerouslySetInnerHTML'
 ];
 
-var DANGEROUS_PROPERTIES = DANGEROUS_PROPERTY_NAMES.reduce(function (props, prop) {
+const DANGEROUS_PROPERTIES = DANGEROUS_PROPERTY_NAMES.reduce(function (props, prop) {
   props[prop] = prop;
   return props;
 }, Object.create(null));
@@ -28,7 +28,7 @@ var DANGEROUS_PROPERTIES = DANGEROUS_PROPERTY_NAMES.reduce(function (props, prop
  * @param {String} name - Name of the node to check.
  * @returns {boolean} Whether or not the node name match the JSX tag convention.
  */
-var tagConvention = /^[a-z]|\-/;
+const tagConvention = /^[a-z]|\-/;
 function isTagName(name) {
   return tagConvention.test(name);
 }
diff --git a/lib/rules/no-deprecated.js b/lib/rules/no-deprecated.js
index 7cc4b8c35c..234060e1e5 100644
--- a/lib/rules/no-deprecated.js
+++ b/lib/rules/no-deprecated.js
@@ -5,21 +5,21 @@
  */
 'use strict';
 
-var has = require('has');
+const has = require('has');
 
-var pragmaUtil = require('../util/pragma');
-var versionUtil = require('../util/version');
+const pragmaUtil = require('../util/pragma');
+const versionUtil = require('../util/version');
 
 // ------------------------------------------------------------------------------
 // Constants
 // ------------------------------------------------------------------------------
 
-var MODULES = {
+const MODULES = {
   react: ['React'],
   'react-addons-perf': ['ReactPerf', 'Perf']
 };
 
-var DEPRECATED_MESSAGE = '{{oldMethod}} is deprecated since React {{version}}{{newMethod}}';
+const DEPRECATED_MESSAGE = '{{oldMethod}} is deprecated since React {{version}}{{newMethod}}';
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -36,11 +36,11 @@ module.exports = {
   },
 
   create: function(context) {
-    var sourceCode = context.getSourceCode();
-    var pragma = pragmaUtil.getFromContext(context);
+    const sourceCode = context.getSourceCode();
+    const pragma = pragmaUtil.getFromContext(context);
 
     function getDeprecated() {
-      var deprecated = {};
+      const deprecated = {};
       // 0.12.0
       deprecated[`${pragma}.renderComponent`] = ['0.12.0', `${pragma}.render`];
       deprecated[`${pragma}.renderComponentToString`] = ['0.12.0', `${pragma}.renderToString`];
@@ -73,7 +73,7 @@ module.exports = {
     }
 
     function isDeprecated(method) {
-      var deprecated = getDeprecated();
+      const deprecated = getDeprecated();
 
       return (
         deprecated &&
@@ -86,7 +86,7 @@ module.exports = {
       if (!isDeprecated(method)) {
         return;
       }
-      var deprecated = getDeprecated();
+      const deprecated = getDeprecated();
       context.report({
         node: node,
         message: DEPRECATED_MESSAGE,
@@ -99,11 +99,11 @@ module.exports = {
     }
 
     function getReactModuleName(node) {
-      var moduleName = false;
+      let moduleName = false;
       if (!node.init) {
         return moduleName;
       }
-      for (var module in MODULES) {
+      for (const module in MODULES) {
         if (!has(MODULES, module)) {
           continue;
         }
@@ -128,7 +128,7 @@ module.exports = {
       },
 
       ImportDeclaration: function(node) {
-        var isReactImport = typeof MODULES[node.source.value] !== 'undefined';
+        const isReactImport = typeof MODULES[node.source.value] !== 'undefined';
         if (!isReactImport) {
           return;
         }
@@ -141,13 +141,13 @@ module.exports = {
       },
 
       VariableDeclarator: function(node) {
-        var reactModuleName = getReactModuleName(node);
-        var isRequire = node.init && node.init.callee && node.init.callee.name === 'require';
-        var isReactRequire =
+        const reactModuleName = getReactModuleName(node);
+        const isRequire = node.init && node.init.callee && node.init.callee.name === 'require';
+        const isReactRequire =
           node.init && node.init.arguments &&
           node.init.arguments.length && typeof MODULES[node.init.arguments[0].value] !== 'undefined'
         ;
-        var isDestructuring = node.id && node.id.type === 'ObjectPattern';
+        const isDestructuring = node.id && node.id.type === 'ObjectPattern';
 
         if (
           !(isDestructuring && reactModuleName) &&
diff --git a/lib/rules/no-did-mount-set-state.js b/lib/rules/no-did-mount-set-state.js
index dd6422a602..a3d378b2f3 100644
--- a/lib/rules/no-did-mount-set-state.js
+++ b/lib/rules/no-did-mount-set-state.js
@@ -4,6 +4,6 @@
  */
 'use strict';
 
-var makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
+const makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
 
 module.exports = makeNoMethodSetStateRule('componentDidMount');
diff --git a/lib/rules/no-did-update-set-state.js b/lib/rules/no-did-update-set-state.js
index 75f42e5270..eb14688187 100644
--- a/lib/rules/no-did-update-set-state.js
+++ b/lib/rules/no-did-update-set-state.js
@@ -4,6 +4,6 @@
  */
 'use strict';
 
-var makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
+const makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
 
 module.exports = makeNoMethodSetStateRule('componentDidUpdate');
diff --git a/lib/rules/no-direct-mutation-state.js b/lib/rules/no-direct-mutation-state.js
index f843990480..6bf9012b3b 100644
--- a/lib/rules/no-direct-mutation-state.js
+++ b/lib/rules/no-direct-mutation-state.js
@@ -5,7 +5,7 @@
  */
 'use strict';
 
-var Components = require('../util/Components');
+const Components = require('../util/Components');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -35,8 +35,8 @@ module.exports = {
      * @param {Object} component The component to process
      */
     function reportMutations(component) {
-      var mutation;
-      for (var i = 0, j = component.mutations.length; i < j; i++) {
+      let mutation;
+      for (let i = 0, j = component.mutations.length; i < j; i++) {
         mutation = component.mutations[i];
         context.report({
           node: mutation,
diff --git a/lib/rules/no-find-dom-node.js b/lib/rules/no-find-dom-node.js
index bc08e2d061..10e1fbc21d 100644
--- a/lib/rules/no-find-dom-node.js
+++ b/lib/rules/no-find-dom-node.js
@@ -26,9 +26,9 @@ module.exports = {
     return {
 
       CallExpression: function(node) {
-        var callee = node.callee;
+        const callee = node.callee;
 
-        var isfindDOMNode =
+        const isfindDOMNode =
           (callee.name === 'findDOMNode') ||
           (callee.property && callee.property.name === 'findDOMNode')
         ;
diff --git a/lib/rules/no-is-mounted.js b/lib/rules/no-is-mounted.js
index 8fdc54e175..2c9fcfb27b 100644
--- a/lib/rules/no-is-mounted.js
+++ b/lib/rules/no-is-mounted.js
@@ -26,15 +26,15 @@ module.exports = {
     return {
 
       CallExpression: function(node) {
-        var callee = node.callee;
+        const callee = node.callee;
         if (callee.type !== 'MemberExpression') {
           return;
         }
         if (callee.object.type !== 'ThisExpression' || callee.property.name !== 'isMounted') {
           return;
         }
-        var ancestors = context.getAncestors(callee);
-        for (var i = 0, j = ancestors.length; i < j; i++) {
+        const ancestors = context.getAncestors(callee);
+        for (let i = 0, j = ancestors.length; i < j; i++) {
           if (ancestors[i].type === 'Property' || ancestors[i].type === 'MethodDefinition') {
             context.report({
               node: callee,
diff --git a/lib/rules/no-multi-comp.js b/lib/rules/no-multi-comp.js
index 4de5168fb4..af3c9a409b 100644
--- a/lib/rules/no-multi-comp.js
+++ b/lib/rules/no-multi-comp.js
@@ -4,8 +4,8 @@
  */
 'use strict';
 
-var has = require('has');
-var Components = require('../util/Components');
+const has = require('has');
+const Components = require('../util/Components');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -32,10 +32,10 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components) {
-    var configuration = context.options[0] || {};
-    var ignoreStateless = configuration.ignoreStateless || false;
+    const configuration = context.options[0] || {};
+    const ignoreStateless = configuration.ignoreStateless || false;
 
-    var MULTI_COMP_MESSAGE = 'Declare only one React component per file';
+    const MULTI_COMP_MESSAGE = 'Declare only one React component per file';
 
     /**
      * Checks if the component is ignored
@@ -56,10 +56,10 @@ module.exports = {
           return;
         }
 
-        var list = components.list();
-        var i = 0;
+        const list = components.list();
+        let i = 0;
 
-        for (var component in list) {
+        for (const component in list) {
           if (!has(list, component) || isIgnored(list[component]) || ++i === 1) {
             continue;
           }
diff --git a/lib/rules/no-redundant-should-component-update.js b/lib/rules/no-redundant-should-component-update.js
index c42d830812..b11225166a 100644
--- a/lib/rules/no-redundant-should-component-update.js
+++ b/lib/rules/no-redundant-should-component-update.js
@@ -3,7 +3,7 @@
  */
 'use strict';
 
-var Components = require('../util/Components');
+const Components = require('../util/Components');
 
 function errorMessage(node) {
   return `${node} does not need shouldComponentUpdate when extending React.PureComponent.`;
@@ -35,7 +35,7 @@ module.exports = {
       } else if (node.type === 'ClassProperty') {
         // Special case for class properties
         // (babel-eslint does not expose property name so we have to rely on tokens)
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         return tokens[1] && tokens[1].type === 'Identifier' ? tokens[1].value : tokens[0].value;
       }
       return '';
@@ -62,9 +62,9 @@ module.exports = {
      * @returns {Boolean} Whether or not the property exists.
      */
     function hasShouldComponentUpdate(node) {
-      var properties = getComponentProperties(node);
+      const properties = getComponentProperties(node);
       return properties.some(function(property) {
-        var name = getPropertyName(property);
+        const name = getPropertyName(property);
         return name === 'shouldComponentUpdate';
       });
     }
@@ -89,9 +89,9 @@ module.exports = {
      */
     function checkForViolation(node) {
       if (utils.isPureComponent(node)) {
-        var hasScu = hasShouldComponentUpdate(node);
+        const hasScu = hasShouldComponentUpdate(node);
         if (hasScu) {
-          var className = getNodeName(node);
+          const className = getNodeName(node);
           context.report({
             node: node,
             message: errorMessage(className)
diff --git a/lib/rules/no-render-return-value.js b/lib/rules/no-render-return-value.js
index 13a1d7b995..e854481392 100644
--- a/lib/rules/no-render-return-value.js
+++ b/lib/rules/no-render-return-value.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var versionUtil = require('../util/version');
+const versionUtil = require('../util/version');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -28,13 +28,13 @@ module.exports = {
     return {
 
       CallExpression: function(node) {
-        var callee = node.callee;
-        var parent = node.parent;
+        const callee = node.callee;
+        const parent = node.parent;
         if (callee.type !== 'MemberExpression') {
           return;
         }
 
-        var calleeObjectName = /^ReactDOM$/;
+        let calleeObjectName = /^ReactDOM$/;
         if (versionUtil.test(context, '15.0.0')) {
           calleeObjectName = /^ReactDOM$/;
         } else if (versionUtil.test(context, '0.14.0')) {
diff --git a/lib/rules/no-set-state.js b/lib/rules/no-set-state.js
index 2ec5271bce..ec97f2b3c9 100644
--- a/lib/rules/no-set-state.js
+++ b/lib/rules/no-set-state.js
@@ -4,8 +4,8 @@
  */
 'use strict';
 
-var has = require('has');
-var Components = require('../util/Components');
+const has = require('has');
+const Components = require('../util/Components');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -36,8 +36,8 @@ module.exports = {
      * @param {Object} component The component to process
      */
     function reportSetStateUsages(component) {
-      var setStateUsage;
-      for (var i = 0, j = component.setStateUsages.length; i < j; i++) {
+      let setStateUsage;
+      for (let i = 0, j = component.setStateUsages.length; i < j; i++) {
         setStateUsage = component.setStateUsages[i];
         context.report({
           node: setStateUsage,
@@ -53,7 +53,7 @@ module.exports = {
     return {
 
       CallExpression: function(node) {
-        var callee = node.callee;
+        const callee = node.callee;
         if (
           callee.type !== 'MemberExpression' ||
           callee.object.type !== 'ThisExpression' ||
@@ -61,8 +61,8 @@ module.exports = {
         ) {
           return;
         }
-        var component = components.get(utils.getParentComponent());
-        var setStateUsages = component && component.setStateUsages || [];
+        const component = components.get(utils.getParentComponent());
+        const setStateUsages = component && component.setStateUsages || [];
         setStateUsages.push(callee);
         components.set(node, {
           useSetState: true,
@@ -71,8 +71,8 @@ module.exports = {
       },
 
       'Program:exit': function() {
-        var list = components.list();
-        for (var component in list) {
+        const list = components.list();
+        for (const component in list) {
           if (!has(list, component) || isValid(list[component])) {
             continue;
           }
diff --git a/lib/rules/no-string-refs.js b/lib/rules/no-string-refs.js
index e156b9e303..2c7a3a3411 100644
--- a/lib/rules/no-string-refs.js
+++ b/lib/rules/no-string-refs.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var Components = require('../util/Components');
+const Components = require('../util/Components');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
diff --git a/lib/rules/no-unescaped-entities.js b/lib/rules/no-unescaped-entities.js
index 0497318ce7..2b04ffffc5 100644
--- a/lib/rules/no-unescaped-entities.js
+++ b/lib/rules/no-unescaped-entities.js
@@ -11,7 +11,7 @@
 // NOTE: '<' and '{' are also problematic characters, but they do not need
 // to be included here because it is a syntax error when these characters are
 // included accidentally.
-var DEFAULTS = ['>', '"', '\'', '}'];
+const DEFAULTS = ['>', '"', '\'', '}'];
 
 module.exports = {
   meta: {
@@ -36,15 +36,15 @@ module.exports = {
 
   create: function(context) {
     function reportInvalidEntity(node) {
-      var configuration = context.options[0] || {};
-      var entities = configuration.forbid || DEFAULTS;
+      const configuration = context.options[0] || {};
+      const entities = configuration.forbid || DEFAULTS;
 
       // HTML entites are already escaped in node.value (as well as node.raw),
       // so pull the raw text from context.getSourceCode()
-      for (var i = node.loc.start.line; i <= node.loc.end.line; i++) {
-        var rawLine = context.getSourceCode().lines[i - 1];
-        var start = 0;
-        var end = rawLine.length;
+      for (let i = node.loc.start.line; i <= node.loc.end.line; i++) {
+        let rawLine = context.getSourceCode().lines[i - 1];
+        let start = 0;
+        let end = rawLine.length;
         if (i === node.loc.start.line) {
           start = node.loc.start.column;
         }
@@ -52,9 +52,9 @@ module.exports = {
           end = node.loc.end.column;
         }
         rawLine = rawLine.substring(start, end);
-        for (var j = 0; j < entities.length; j++) {
-          for (var index = 0; index < rawLine.length; index++) {
-            var c = rawLine[index];
+        for (let j = 0; j < entities.length; j++) {
+          for (let index = 0; index < rawLine.length; index++) {
+            const c = rawLine[index];
             if (c === entities[j]) {
               context.report({
                 loc: {line: i, column: start + index},
diff --git a/lib/rules/no-unknown-property.js b/lib/rules/no-unknown-property.js
index d0babba1ea..660eea3c21 100644
--- a/lib/rules/no-unknown-property.js
+++ b/lib/rules/no-unknown-property.js
@@ -8,20 +8,20 @@
 // Constants
 // ------------------------------------------------------------------------------
 
-var DEFAULTS = {
+const DEFAULTS = {
   ignore: []
 };
 
-var UNKNOWN_MESSAGE = 'Unknown property \'{{name}}\' found, use \'{{standardName}}\' instead';
+const UNKNOWN_MESSAGE = 'Unknown property \'{{name}}\' found, use \'{{standardName}}\' instead';
 
-var DOM_ATTRIBUTE_NAMES = {
+const DOM_ATTRIBUTE_NAMES = {
   'accept-charset': 'acceptCharset',
   class: 'className',
   for: 'htmlFor',
   'http-equiv': 'httpEquiv'
 };
 
-var SVGDOM_ATTRIBUTE_NAMES = {
+const SVGDOM_ATTRIBUTE_NAMES = {
   'accent-height': 'accentHeight',
   'alignment-baseline': 'alignmentBaseline',
   'arabic-form': 'arabicForm',
@@ -106,7 +106,7 @@ var SVGDOM_ATTRIBUTE_NAMES = {
   'xml:space': 'xmlSpace'
 };
 
-var DOM_PROPERTY_NAMES = [
+const DOM_PROPERTY_NAMES = [
   // Standard
   'acceptCharset', 'accessKey', 'allowFullScreen', 'allowTransparency', 'autoComplete', 'autoFocus', 'autoPlay',
   'cellPadding', 'cellSpacing', 'charSet', 'classID', 'className', 'colSpan', 'contentEditable', 'contextMenu',
@@ -134,7 +134,7 @@ var DOM_PROPERTY_NAMES = [
  * @param {Object} node - JSX element being tested.
  * @returns {boolean} Whether or not the node name match the JSX tag convention.
  */
-var tagConvention = /^[a-z][^-]*$/;
+const tagConvention = /^[a-z][^-]*$/;
 function isTagName(node) {
   if (tagConvention.test(node.parent.name.name)) {
     // http://www.w3.org/TR/custom-elements/#type-extension-semantics
@@ -161,8 +161,8 @@ function getStandardName(name) {
   if (SVGDOM_ATTRIBUTE_NAMES[name]) {
     return SVGDOM_ATTRIBUTE_NAMES[name];
   }
-  var i;
-  var found = DOM_PROPERTY_NAMES.some(function(element, index) {
+  let i;
+  const found = DOM_PROPERTY_NAMES.some(function(element, index) {
     i = index;
     return element.toLowerCase() === name;
   });
@@ -201,14 +201,14 @@ module.exports = {
       return context.options[0] && context.options[0].ignore || DEFAULTS.ignore;
     }
 
-    var sourceCode = context.getSourceCode();
+    const sourceCode = context.getSourceCode();
 
     return {
 
       JSXAttribute: function(node) {
-        var ignoreNames = getIgnoreConfig();
-        var name = sourceCode.getText(node.name);
-        var standardName = getStandardName(name);
+        const ignoreNames = getIgnoreConfig();
+        const name = sourceCode.getText(node.name);
+        const standardName = getStandardName(name);
         if (!isTagName(node) || !standardName || ignoreNames.indexOf(name) >= 0) {
           return;
         }
diff --git a/lib/rules/no-unused-prop-types.js b/lib/rules/no-unused-prop-types.js
index e4a3931f74..252e349574 100644
--- a/lib/rules/no-unused-prop-types.js
+++ b/lib/rules/no-unused-prop-types.js
@@ -7,10 +7,10 @@
 // As for exceptions for props.children or props.className (and alike) look at
 // https://github.com/yannickcr/eslint-plugin-react/issues/7
 
-var has = require('has');
-var Components = require('../util/Components');
-var variable = require('../util/variable');
-var annotations = require('../util/annotations');
+const has = require('has');
+const Components = require('../util/Components');
+const variable = require('../util/variable');
+const annotations = require('../util/annotations');
 
 // ------------------------------------------------------------------------------
 // Constants
@@ -51,18 +51,18 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components, utils) {
-    var defaults = {skipShapeProps: true};
-    var sourceCode = context.getSourceCode();
-    var configuration = Object.assign({}, defaults, context.options[0] || {});
-    var skipShapeProps = configuration.skipShapeProps;
-    var customValidators = configuration.customValidators || [];
-    var propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
+    const defaults = {skipShapeProps: true};
+    const sourceCode = context.getSourceCode();
+    const configuration = Object.assign({}, defaults, context.options[0] || {});
+    const skipShapeProps = configuration.skipShapeProps;
+    const customValidators = configuration.customValidators || [];
+    const propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
 
     // Used to track the type annotations in scope.
     // Necessary because babel's scopes do not track type annotations.
-    var stack = null;
+    let stack = null;
 
-    var UNUSED_MESSAGE = '\'{{name}}\' PropType is defined but prop is never used';
+    const UNUSED_MESSAGE = '\'{{name}}\' PropType is defined but prop is never used';
 
     /**
      * Helper for accessing the current scope in the stack.
@@ -85,7 +85,7 @@ module.exports = {
      * @return {boolean} true if we are in a class constructor, false if not
      **/
     function inLifeCycleMethod() {
-      var scope = context.getScope();
+      let scope = context.getScope();
       while (scope) {
         if (
           scope.block && scope.block.parent &&
@@ -105,11 +105,11 @@ module.exports = {
      * @returns {Boolean} True if we are using a prop, false if not.
      */
     function isPropTypesUsage(node) {
-      var isClassUsage = (
+      const isClassUsage = (
         (utils.getParentES6Component() || utils.getParentES5Component()) &&
         node.object.type === 'ThisExpression' && node.property.name === 'props'
       );
-      var isStatelessFunctionUsage = node.object.name === 'props';
+      const isStatelessFunctionUsage = node.object.name === 'props';
       return isClassUsage || isStatelessFunctionUsage || inLifeCycleMethod();
     }
 
@@ -120,7 +120,7 @@ module.exports = {
      */
     function isAnnotatedClassPropsDeclaration(node) {
       if (node && node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         if (
           node.typeAnnotation && (
             tokens[0].value === 'props' ||
@@ -142,7 +142,7 @@ module.exports = {
       // Special case for class properties
       // (babel-eslint does not expose property name so we have to rely on tokens)
       if (node && node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         if (
           tokens[0].value === 'propTypes' ||
           (tokens[1] && tokens[1].value === 'propTypes')
@@ -186,7 +186,7 @@ module.exports = {
      * @return {Boolean} True if the node is a lifecycle method
      */
     function isNodeALifeCycleMethod(node) {
-      var nodeKeyName = (node.key || {}).name;
+      const nodeKeyName = (node.key || {}).name;
       return (
         node.kind === 'constructor' ||
         nodeKeyName === 'componentWillReceiveProps' ||
@@ -234,8 +234,8 @@ module.exports = {
      * @returns {Boolean} True if the prop is used, false if not.
      */
     function isPropUsed(node, prop) {
-      for (var i = 0, l = node.usedPropTypes.length; i < l; i++) {
-        var usedProp = node.usedPropTypes[i];
+      for (let i = 0, l = node.usedPropTypes.length; i < l; i++) {
+        const usedProp = node.usedPropTypes[i];
         if (
           prop.type === 'shape' ||
           prop.name === '__ANY_KEY__' ||
@@ -254,7 +254,7 @@ module.exports = {
      * @returns {Boolean} True if the prop has spread operator, false if not.
      */
     function hasSpreadOperator(node) {
-      var tokens = sourceCode.getTokens(node);
+      const tokens = sourceCode.getTokens(node);
       return tokens.length && tokens[0].value === '...';
     }
 
@@ -265,10 +265,10 @@ module.exports = {
      */
     function getKeyValue(node) {
       if (node.type === 'ObjectTypeProperty') {
-        var tokens = context.getFirstTokens(node, 1);
+        const tokens = context.getFirstTokens(node, 1);
         return tokens[0].value;
       }
-      var key = node.key || node.argument;
+      const key = node.key || node.argument;
       return key.type === 'Identifier' ? key.name : key.value;
     }
 
@@ -280,11 +280,11 @@ module.exports = {
      */
     function iterateProperties(properties, fn) {
       if (properties.length && typeof fn === 'function') {
-        for (var i = 0, j = properties.length; i < j; i++) {
-          var node = properties[i];
-          var key = getKeyValue(node);
+        for (let i = 0, j = properties.length; i < j; i++) {
+          const node = properties[i];
+          const key = getKeyValue(node);
 
-          var value = node.value;
+          const value = node.value;
           fn(key, value);
         }
       }
@@ -328,8 +328,8 @@ module.exports = {
         value.arguments &&
         value.arguments.length > 0
       ) {
-        var callName = value.callee.property.name;
-        var argument = value.arguments[0];
+        const callName = value.callee.property.name;
+        const argument = value.arguments[0];
         switch (callName) {
           case 'shape':
             if (skipShapeProps) {
@@ -340,13 +340,13 @@ module.exports = {
               // Invalid proptype or cannot analyse statically
               return true;
             }
-            var shapeTypeDefinition = {
+            const shapeTypeDefinition = {
               type: 'shape',
               children: []
             };
             iterateProperties(argument.properties, function(childKey, childValue) {
-              var fullName = [parentName, childKey].join('.');
-              var types = buildReactDeclarationTypes(childValue, fullName);
+              const fullName = [parentName, childKey].join('.');
+              let types = buildReactDeclarationTypes(childValue, fullName);
               if (types === true) {
                 types = {};
               }
@@ -358,8 +358,8 @@ module.exports = {
             return shapeTypeDefinition;
           case 'arrayOf':
           case 'objectOf':
-            var fullName = [parentName, '*'].join('.');
-            var child = buildReactDeclarationTypes(argument, fullName);
+            const fullName = [parentName, '*'].join('.');
+            let child = buildReactDeclarationTypes(argument, fullName);
             if (child === true) {
               child = {};
             }
@@ -378,12 +378,12 @@ module.exports = {
               // Invalid proptype or cannot analyse statically
               return true;
             }
-            var unionTypeDefinition = {
+            const unionTypeDefinition = {
               type: 'union',
               children: []
             };
-            for (var i = 0, j = argument.elements.length; i < j; i++) {
-              var type = buildReactDeclarationTypes(argument.elements[i], parentName);
+            for (let i = 0, j = argument.elements.length; i < j; i++) {
+              const type = buildReactDeclarationTypes(argument.elements[i], parentName);
               // keep only complex type
               if (type !== true) {
                 if (type.children === true) {
@@ -431,13 +431,13 @@ module.exports = {
           }
           return true;
         case 'ObjectTypeAnnotation':
-          var shapeTypeDefinition = {
+          const shapeTypeDefinition = {
             type: 'shape',
             children: []
           };
           iterateProperties(annotation.properties, function(childKey, childValue) {
-            var fullName = [parentName, childKey].join('.');
-            var types = buildTypeAnnotationDeclarationTypes(childValue, fullName);
+            const fullName = [parentName, childKey].join('.');
+            let types = buildTypeAnnotationDeclarationTypes(childValue, fullName);
             if (types === true) {
               types = {};
             }
@@ -448,12 +448,12 @@ module.exports = {
           });
           return shapeTypeDefinition;
         case 'UnionTypeAnnotation':
-          var unionTypeDefinition = {
+          const unionTypeDefinition = {
             type: 'union',
             children: []
           };
-          for (var i = 0, j = annotation.types.length; i < j; i++) {
-            var type = buildTypeAnnotationDeclarationTypes(annotation.types[i], parentName);
+          for (let i = 0, j = annotation.types.length; i < j; i++) {
+            const type = buildTypeAnnotationDeclarationTypes(annotation.types[i], parentName);
             // keep only complex type
             if (type !== true) {
               if (type.children === true) {
@@ -471,8 +471,8 @@ module.exports = {
           }
           return unionTypeDefinition;
         case 'ArrayTypeAnnotation':
-          var fullName = [parentName, '*'].join('.');
-          var child = buildTypeAnnotationDeclarationTypes(annotation.elementType, fullName);
+          const fullName = [parentName, '*'].join('.');
+          let child = buildTypeAnnotationDeclarationTypes(annotation.elementType, fullName);
           if (child === true) {
             child = {};
           }
@@ -494,7 +494,7 @@ module.exports = {
      * @return {boolean} true if we are in a class constructor, false if not
      */
     function inConstructor() {
-      var scope = context.getScope();
+      let scope = context.getScope();
       while (scope) {
         if (scope.block && scope.block.parent && scope.block.parent.kind === 'constructor') {
           return true;
@@ -510,12 +510,12 @@ module.exports = {
      * @return {string} the name of the property or undefined if not found
      */
     function getPropertyName(node) {
-      var isDirectProp = DIRECT_PROPS_REGEX.test(sourceCode.getText(node));
-      var isDirectNextProp = DIRECT_NEXT_PROPS_REGEX.test(sourceCode.getText(node));
-      var isDirectPrevProp = DIRECT_PREV_PROPS_REGEX.test(sourceCode.getText(node));
-      var isInClassComponent = utils.getParentES6Component() || utils.getParentES5Component();
-      var isNotInConstructor = !inConstructor(node);
-      var isNotInLifeCycleMethod = !inLifeCycleMethod();
+      const isDirectProp = DIRECT_PROPS_REGEX.test(sourceCode.getText(node));
+      const isDirectNextProp = DIRECT_NEXT_PROPS_REGEX.test(sourceCode.getText(node));
+      const isDirectPrevProp = DIRECT_PREV_PROPS_REGEX.test(sourceCode.getText(node));
+      const isInClassComponent = utils.getParentES6Component() || utils.getParentES5Component();
+      const isNotInConstructor = !inConstructor(node);
+      const isNotInLifeCycleMethod = !inLifeCycleMethod();
       if ((isDirectProp || isDirectNextProp || isDirectPrevProp)
         && isInClassComponent
         && isNotInConstructor
@@ -525,7 +525,7 @@ module.exports = {
       if (!isDirectProp && !isDirectNextProp && !isDirectPrevProp) {
         node = node.parent;
       }
-      var property = node.property;
+      const property = node.property;
       if (property) {
         switch (property.type) {
           case 'Identifier':
@@ -557,10 +557,10 @@ module.exports = {
      */
     function markPropTypesAsUsed(node, parentNames) {
       parentNames = parentNames || [];
-      var type;
-      var name;
-      var allNames;
-      var properties;
+      let type;
+      let name;
+      let allNames;
+      let properties;
       switch (node.type) {
         case 'MemberExpression':
           name = getPropertyName(node);
@@ -588,16 +588,16 @@ module.exports = {
           properties = node.params[0].properties;
           break;
         case 'VariableDeclarator':
-          for (var i = 0, j = node.id.properties.length; i < j; i++) {
+          for (let i = 0, j = node.id.properties.length; i < j; i++) {
             // let {props: {firstname}} = this
-            var thisDestructuring = (
+            const thisDestructuring = (
               node.id.properties[i].key && (
                 (node.id.properties[i].key.name === 'props' || node.id.properties[i].key.value === 'props') &&
                 node.id.properties[i].value.type === 'ObjectPattern'
               )
             );
             // let {firstname} = props
-            var genericDestructuring = isPropAttributeName(node) && (
+            const genericDestructuring = isPropAttributeName(node) && (
               utils.getParentStatelessComponent() ||
               isInLifeCycleMethod(node)
             );
@@ -617,9 +617,9 @@ module.exports = {
           throw new Error(`${node.type} ASTNodes are not handled by markPropTypesAsUsed`);
       }
 
-      var component = components.get(utils.getParentComponent());
-      var usedPropTypes = component && component.usedPropTypes || [];
-      var ignorePropsValidation = component && component.ignorePropsValidation || false;
+      const component = components.get(utils.getParentComponent());
+      const usedPropTypes = component && component.usedPropTypes || [];
+      let ignorePropsValidation = component && component.ignorePropsValidation || false;
 
       switch (type) {
         case 'direct':
@@ -634,14 +634,14 @@ module.exports = {
           });
           break;
         case 'destructuring':
-          for (var k = 0, l = (properties || []).length; k < l; k++) {
+          for (let k = 0, l = (properties || []).length; k < l; k++) {
             if (hasSpreadOperator(properties[k]) || properties[k].computed) {
               ignorePropsValidation = true;
               break;
             }
-            var propName = getKeyValue(properties[k]);
+            const propName = getKeyValue(properties[k]);
 
-            var currentNode = node;
+            let currentNode = node;
             allNames = [];
             while (currentNode.property && currentNode.property.name !== 'props') {
               allNames.unshift(currentNode.property.name);
@@ -673,9 +673,9 @@ module.exports = {
      * @param {propTypes} node The AST node containing the proptypes
      */
     function markPropTypesAsDeclared(node, propTypes) {
-      var component = components.get(node);
-      var declaredPropTypes = component && component.declaredPropTypes || [];
-      var ignorePropsValidation = component && component.ignorePropsValidation || false;
+      const component = components.get(node);
+      const declaredPropTypes = component && component.declaredPropTypes || [];
+      let ignorePropsValidation = component && component.ignorePropsValidation || false;
 
       switch (propTypes && propTypes.type) {
         case 'ObjectTypeAnnotation':
@@ -684,7 +684,7 @@ module.exports = {
               ignorePropsValidation = true;
               return;
             }
-            var types = buildTypeAnnotationDeclarationTypes(value, key);
+            let types = buildTypeAnnotationDeclarationTypes(value, key);
             if (types === true) {
               types = {};
             }
@@ -700,7 +700,7 @@ module.exports = {
               ignorePropsValidation = true;
               return;
             }
-            var types = buildReactDeclarationTypes(value, key);
+            let types = buildReactDeclarationTypes(value, key);
             if (types === true) {
               types = {};
             }
@@ -713,12 +713,12 @@ module.exports = {
         case 'MemberExpression':
           break;
         case 'Identifier':
-          var variablesInScope = variable.variablesInScope(context);
-          for (var i = 0, j = variablesInScope.length; i < j; i++) {
+          const variablesInScope = variable.variablesInScope(context);
+          for (let i = 0, j = variablesInScope.length; i < j; i++) {
             if (variablesInScope[i].name !== propTypes.name) {
               continue;
             }
-            var defInScope = variablesInScope[i].defs[variablesInScope[i].defs.length - 1];
+            const defInScope = variablesInScope[i].defs[variablesInScope[i].defs.length - 1];
             markPropTypesAsDeclared(node, defInScope.node && defInScope.node.init);
             return;
           }
@@ -797,7 +797,7 @@ module.exports = {
      * @returns {ASTNode} The resolved type annotation for the node.
      */
     function resolveTypeAnnotation(node) {
-      var annotation = node.typeAnnotation || node;
+      let annotation = node.typeAnnotation || node;
       while (annotation && (annotation.type === 'TypeAnnotation' || annotation.type === 'NullableTypeAnnotation')) {
         annotation = annotation.typeAnnotation;
       }
@@ -812,7 +812,7 @@ module.exports = {
      *   FunctionDeclaration, or FunctionExpression
      */
     function markDestructuredFunctionArgumentsAsUsed(node) {
-      var destructuring = node.params && node.params[0] && node.params[0].type === 'ObjectPattern';
+      const destructuring = node.params && node.params[0] && node.params[0].type === 'ObjectPattern';
       if (destructuring && components.get(node)) {
         markPropTypesAsUsed(node);
       }
@@ -852,11 +852,11 @@ module.exports = {
       },
 
       VariableDeclarator: function(node) {
-        var destructuring = node.init && node.id && node.id.type === 'ObjectPattern';
+        const destructuring = node.init && node.id && node.id.type === 'ObjectPattern';
         // let {props: {firstname}} = this
-        var thisDestructuring = destructuring && node.init.type === 'ThisExpression';
+        const thisDestructuring = destructuring && node.init.type === 'ThisExpression';
         // let {firstname} = props
-        var statelessDestructuring = destructuring && isPropAttributeName(node) && (
+        const statelessDestructuring = destructuring && isPropAttributeName(node) && (
           utils.getParentStatelessComponent() ||
           isInLifeCycleMethod(node)
         );
@@ -874,7 +874,7 @@ module.exports = {
       FunctionExpression: handleStatelessComponent,
 
       MemberExpression: function(node) {
-        var type;
+        let type;
         if (isPropTypesUsage(node)) {
           type = 'usage';
         } else if (isPropTypesDeclaration(node.property)) {
@@ -886,7 +886,7 @@ module.exports = {
             markPropTypesAsUsed(node);
             break;
           case 'declaration':
-            var component = utils.getRelatedComponent(node);
+            const component = utils.getRelatedComponent(node);
             if (!component) {
               return;
             }
@@ -902,7 +902,7 @@ module.exports = {
           return;
         }
 
-        var i = node.value.body.body.length - 1;
+        let i = node.value.body.body.length - 1;
         for (; i >= 0; i--) {
           if (node.value.body.body[i].type === 'ReturnStatement') {
             break;
@@ -954,9 +954,9 @@ module.exports = {
 
       'Program:exit': function() {
         stack = null;
-        var list = components.list();
+        const list = components.list();
         // Report undeclared proptypes for all classes
-        for (var component in list) {
+        for (const component in list) {
           if (!has(list, component) || !mustBeValidated(list[component])) {
             continue;
           }
diff --git a/lib/rules/no-will-update-set-state.js b/lib/rules/no-will-update-set-state.js
index 8f73df7525..51f44ebe59 100644
--- a/lib/rules/no-will-update-set-state.js
+++ b/lib/rules/no-will-update-set-state.js
@@ -4,6 +4,6 @@
  */
 'use strict';
 
-var makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
+const makeNoMethodSetStateRule = require('../util/makeNoMethodSetStateRule');
 
 module.exports = makeNoMethodSetStateRule('componentWillUpdate');
diff --git a/lib/rules/prefer-es6-class.js b/lib/rules/prefer-es6-class.js
index 8b6562e050..ec3325a6ee 100644
--- a/lib/rules/prefer-es6-class.js
+++ b/lib/rules/prefer-es6-class.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var Components = require('../util/Components');
+const Components = require('../util/Components');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -24,7 +24,7 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components, utils) {
-    var configuration = context.options[0] || 'always';
+    const configuration = context.options[0] || 'always';
 
     return {
       ObjectExpression: function(node) {
diff --git a/lib/rules/prefer-stateless-function.js b/lib/rules/prefer-stateless-function.js
index 30ee9ba472..6fe946d767 100644
--- a/lib/rules/prefer-stateless-function.js
+++ b/lib/rules/prefer-stateless-function.js
@@ -6,9 +6,9 @@
  */
 'use strict';
 
-var has = require('has');
-var Components = require('../util/Components');
-var versionUtil = require('../util/version');
+const has = require('has');
+const Components = require('../util/Components');
+const versionUtil = require('../util/version');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -34,10 +34,10 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components, utils) {
-    var configuration = context.options[0] || {};
-    var ignorePureComponents = configuration.ignorePureComponents || false;
+    const configuration = context.options[0] || {};
+    const ignorePureComponents = configuration.ignorePureComponents || false;
 
-    var sourceCode = context.getSourceCode();
+    const sourceCode = context.getSourceCode();
 
     // --------------------------------------------------------------------------
     // Public
@@ -52,7 +52,7 @@ module.exports = {
       // Special case for class properties
       // (babel-eslint does not expose property name so we have to rely on tokens)
       if (node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         return tokens[1] && tokens[1].type === 'Identifier' ? tokens[1].value : tokens[0].value;
       }
 
@@ -177,7 +177,7 @@ module.exports = {
         return false;
       }
 
-      for (var i = 0; i < ctorParams.length; ++i) {
+      for (let i = 0; i < ctorParams.length; ++i) {
         if (!isValidPair(ctorParams[i], superArgs[i])) {
           return false;
         }
@@ -210,17 +210,17 @@ module.exports = {
      * @returns {Boolean} True if the node has at least one other property, false if not.
      */
     function hasOtherProperties(node) {
-      var properties = getComponentProperties(node);
+      const properties = getComponentProperties(node);
       return properties.some(function(property) {
-        var name = getPropertyName(property);
-        var isDisplayName = name === 'displayName';
-        var isPropTypes = name === 'propTypes' || name === 'props' && property.typeAnnotation;
-        var contextTypes = name === 'contextTypes';
-        var isUselessConstructor =
+        const name = getPropertyName(property);
+        const isDisplayName = name === 'displayName';
+        const isPropTypes = name === 'propTypes' || name === 'props' && property.typeAnnotation;
+        const contextTypes = name === 'contextTypes';
+        const isUselessConstructor =
           property.kind === 'constructor' &&
           isRedundantSuperCall(property.value.body.body, property.value.params)
         ;
-        var isRender = name === 'render';
+        const isRender = name === 'render';
         return !isDisplayName && !isPropTypes && !contextTypes && !isUselessConstructor && !isRender;
       });
     }
@@ -229,7 +229,7 @@ module.exports = {
      * Mark component as pure as declared
      * @param {ASTNode} node The AST node being checked.
      */
-    var markSCUAsDeclared = function (node) {
+    const markSCUAsDeclared = function (node) {
       components.set(node, {
         hasSCU: true
       });
@@ -239,7 +239,7 @@ module.exports = {
      * Mark childContextTypes as declared
      * @param {ASTNode} node The AST node being checked.
      */
-    var markChildContextTypesAsDeclared = function (node) {
+    const markChildContextTypesAsDeclared = function (node) {
       components.set(node, {
         hasChildContextTypes: true
       });
@@ -316,8 +316,8 @@ module.exports = {
           return;
         }
         // Ignore `props` and `context`
-        var useThis = node.id.properties.some(function(property) {
-          var name = getPropertyName(property);
+        const useThis = node.id.properties.some(function(property) {
+          const name = getPropertyName(property);
           return name !== 'props' && name !== 'context';
         });
         if (!useThis) {
@@ -331,7 +331,7 @@ module.exports = {
       MemberExpression: function(node) {
         if (node.object.type !== 'ThisExpression') {
           if (node.property && node.property.name === 'childContextTypes') {
-            var component = utils.getRelatedComponent(node);
+            const component = utils.getRelatedComponent(node);
             if (!component) {
               return;
             }
@@ -352,7 +352,7 @@ module.exports = {
 
       // Mark `ref` usage
       JSXAttribute: function(node) {
-        var name = sourceCode.getText(node.name);
+        const name = sourceCode.getText(node.name);
         if (name !== 'ref') {
           return;
         }
@@ -361,8 +361,8 @@ module.exports = {
 
       // Mark `render` that do not return some JSX
       ReturnStatement: function(node) {
-        var blockNode;
-        var scope = context.getScope();
+        let blockNode;
+        let scope = context.getScope();
         while (scope) {
           blockNode = scope.block && scope.block.parent;
           if (blockNode && (blockNode.type === 'MethodDefinition' || blockNode.type === 'Property')) {
@@ -370,10 +370,10 @@ module.exports = {
           }
           scope = scope.upper;
         }
-        var isRender = blockNode && blockNode.key && blockNode.key.name === 'render';
-        var allowNull = versionUtil.test(context, '15.0.0'); // Stateless components can return null since React 15
-        var isReturningJSX = utils.isReturningJSX(node, !allowNull);
-        var isReturningNull = node.argument && (node.argument.value === null || node.argument.value === false);
+        const isRender = blockNode && blockNode.key && blockNode.key.name === 'render';
+        const allowNull = versionUtil.test(context, '15.0.0'); // Stateless components can return null since React 15
+        const isReturningJSX = utils.isReturningJSX(node, !allowNull);
+        const isReturningNull = node.argument && (node.argument.value === null || node.argument.value === false);
         if (
           !isRender ||
           (allowNull && (isReturningJSX || isReturningNull)) ||
@@ -385,8 +385,8 @@ module.exports = {
       },
 
       'Program:exit': function() {
-        var list = components.list();
-        for (var component in list) {
+        const list = components.list();
+        for (const component in list) {
           if (
             !has(list, component) ||
             hasOtherProperties(list[component].node) ||
diff --git a/lib/rules/prop-types.js b/lib/rules/prop-types.js
index 07daffe1f9..7aebc09c93 100644
--- a/lib/rules/prop-types.js
+++ b/lib/rules/prop-types.js
@@ -7,17 +7,17 @@
 // As for exceptions for props.children or props.className (and alike) look at
 // https://github.com/yannickcr/eslint-plugin-react/issues/7
 
-var has = require('has');
-var Components = require('../util/Components');
-var variable = require('../util/variable');
-var annotations = require('../util/annotations');
+const has = require('has');
+const Components = require('../util/Components');
+const variable = require('../util/variable');
+const annotations = require('../util/annotations');
 
 // ------------------------------------------------------------------------------
 // Constants
 // ------------------------------------------------------------------------------
 
-var PROPS_REGEX = /^(props|nextProps)$/;
-var DIRECT_PROPS_REGEX = /^(props|nextProps)\s*(\.|\[)/;
+const PROPS_REGEX = /^(props|nextProps)$/;
+const DIRECT_PROPS_REGEX = /^(props|nextProps)\s*(\.|\[)/;
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -55,17 +55,17 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components, utils) {
-    var sourceCode = context.getSourceCode();
-    var configuration = context.options[0] || {};
-    var propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
-    var ignored = configuration.ignore || [];
-    var customValidators = configuration.customValidators || [];
-    var skipUndeclared = configuration.skipUndeclared || false;
+    const sourceCode = context.getSourceCode();
+    const configuration = context.options[0] || {};
+    const propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
+    const ignored = configuration.ignore || [];
+    const customValidators = configuration.customValidators || [];
+    const skipUndeclared = configuration.skipUndeclared || false;
     // Used to track the type annotations in scope.
     // Necessary because babel's scopes do not track type annotations.
-    var stack = null;
+    let stack = null;
 
-    var MISSING_MESSAGE = '\'{{name}}\' is missing in props validation';
+    const MISSING_MESSAGE = '\'{{name}}\' is missing in props validation';
 
     /**
      * Helper for accessing the current scope in the stack.
@@ -88,7 +88,7 @@ module.exports = {
      * @return {boolean} true if we are in a class constructor, false if not
      */
     function inConstructor() {
-      var scope = context.getScope();
+      let scope = context.getScope();
       while (scope) {
         if (scope.block && scope.block.parent && scope.block.parent.kind === 'constructor') {
           return true;
@@ -103,7 +103,7 @@ module.exports = {
      * @return {boolean} true if we are in a class constructor, false if not
      */
     function inComponentWillReceiveProps() {
-      var scope = context.getScope();
+      let scope = context.getScope();
       while (scope) {
         if (
           scope.block && scope.block.parent &&
@@ -122,12 +122,12 @@ module.exports = {
      * @returns {Boolean} True if we are using a prop, false if not.
      */
     function isPropTypesUsage(node) {
-      var isClassUsage = (
+      const isClassUsage = (
         (utils.getParentES6Component() || utils.getParentES5Component()) &&
         node.object.type === 'ThisExpression' && node.property.name === 'props'
       );
-      var isStatelessFunctionUsage = node.object.name === 'props';
-      var isNextPropsUsage = node.object.name === 'nextProps' && inComponentWillReceiveProps();
+      const isStatelessFunctionUsage = node.object.name === 'props';
+      const isNextPropsUsage = node.object.name === 'nextProps' && inComponentWillReceiveProps();
       return isClassUsage || isStatelessFunctionUsage || isNextPropsUsage;
     }
 
@@ -138,7 +138,7 @@ module.exports = {
      */
     function isAnnotatedClassPropsDeclaration(node) {
       if (node && node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         if (
           node.typeAnnotation && (
             tokens[0].value === 'props' ||
@@ -175,7 +175,7 @@ module.exports = {
       // Special case for class properties
       // (babel-eslint does not expose property name so we have to rely on tokens)
       if (node && node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         if (
           tokens[0].value === 'propTypes' ||
           (tokens[1] && tokens[1].value === 'propTypes')
@@ -215,7 +215,7 @@ module.exports = {
      * @returns {Boolean} True if the component must be validated, false if not.
      */
     function mustBeValidated(component) {
-      var isSkippedByConfig = skipUndeclared && typeof component.declaredPropTypes === 'undefined';
+      const isSkippedByConfig = skipUndeclared && typeof component.declaredPropTypes === 'undefined';
       return Boolean(
         component &&
         component.usedPropTypes &&
@@ -231,9 +231,9 @@ module.exports = {
      * @returns {Boolean} True if the prop is declared, false if not.
      */
     function _isDeclaredInComponent(declaredPropTypes, keyList) {
-      for (var i = 0, j = keyList.length; i < j; i++) {
-        var key = keyList[i];
-        var propType = (
+      for (let i = 0, j = keyList.length; i < j; i++) {
+        const key = keyList[i];
+        const propType = (
           declaredPropTypes && (
             // Check if this key is declared
             (declaredPropTypes[key] || // If not, check if this type accepts any key
@@ -262,11 +262,11 @@ module.exports = {
             return true;
           }
           // non trivial, check all of them
-          var unionTypes = propType.children;
-          var unionPropType = {};
-          for (var k = 0, z = unionTypes.length; k < z; k++) {
+          const unionTypes = propType.children;
+          const unionPropType = {};
+          for (let k = 0, z = unionTypes.length; k < z; k++) {
             unionPropType[key] = unionTypes[k];
-            var isValid = _isDeclaredInComponent(
+            const isValid = _isDeclaredInComponent(
               unionPropType,
               keyList.slice(i)
             );
@@ -291,8 +291,8 @@ module.exports = {
      */
     function isDeclaredInComponent(node, names) {
       while (node) {
-        var component = components.get(node);
-        var isDeclared =
+        const component = components.get(node);
+        const isDeclared =
           component && component.confidence === 2 &&
           _isDeclaredInComponent(component.declaredPropTypes || {}, names)
         ;
@@ -310,7 +310,7 @@ module.exports = {
      * @returns {Boolean} True if the prop has spread operator, false if not.
      */
     function hasSpreadOperator(node) {
-      var tokens = sourceCode.getTokens(node);
+      const tokens = sourceCode.getTokens(node);
       return tokens.length && tokens[0].value === '...';
     }
 
@@ -332,13 +332,13 @@ module.exports = {
      */
     function getKeyValue(node) {
       if (node.type === 'ObjectTypeProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         return (tokens[0].value === '+' || tokens[0].value === '-'
           ? tokens[1].value
           : stripQuotes(tokens[0].value)
         );
       }
-      var key = node.key || node.argument;
+      const key = node.key || node.argument;
       return key.type === 'Identifier' ? key.name : key.value;
     }
 
@@ -350,11 +350,11 @@ module.exports = {
      */
     function iterateProperties(properties, fn) {
       if (properties.length && typeof fn === 'function') {
-        for (var i = 0, j = properties.length; i < j; i++) {
-          var node = properties[i];
-          var key = getKeyValue(node);
+        for (let i = 0, j = properties.length; i < j; i++) {
+          const node = properties[i];
+          const key = getKeyValue(node);
 
-          var value = node.value;
+          const value = node.value;
           fn(key, value);
         }
       }
@@ -397,15 +397,15 @@ module.exports = {
         value.arguments &&
         value.arguments.length > 0
       ) {
-        var callName = value.callee.property.name;
-        var argument = value.arguments[0];
+        const callName = value.callee.property.name;
+        const argument = value.arguments[0];
         switch (callName) {
           case 'shape':
             if (argument.type !== 'ObjectExpression') {
               // Invalid proptype or cannot analyse statically
               return true;
             }
-            var shapeTypeDefinition = {
+            const shapeTypeDefinition = {
               type: 'shape',
               children: {}
             };
@@ -429,12 +429,12 @@ module.exports = {
               // Invalid proptype or cannot analyse statically
               return true;
             }
-            var unionTypeDefinition = {
+            const unionTypeDefinition = {
               type: 'union',
               children: []
             };
-            for (var i = 0, j = argument.elements.length; i < j; i++) {
-              var type = buildReactDeclarationTypes(argument.elements[i]);
+            for (let i = 0, j = argument.elements.length; i < j; i++) {
+              const type = buildReactDeclarationTypes(argument.elements[i]);
               // keep only complex type
               if (type !== true) {
                 if (type.children === true) {
@@ -482,7 +482,7 @@ module.exports = {
           return true;
         case 'ObjectTypeAnnotation':
           let containsObjectTypeSpread = false;
-          var shapeTypeDefinition = {
+          const shapeTypeDefinition = {
             type: 'shape',
             children: {}
           };
@@ -500,12 +500,12 @@ module.exports = {
           }
           return shapeTypeDefinition;
         case 'UnionTypeAnnotation':
-          var unionTypeDefinition = {
+          const unionTypeDefinition = {
             type: 'union',
             children: []
           };
-          for (var i = 0, j = annotation.types.length; i < j; i++) {
-            var type = buildTypeAnnotationDeclarationTypes(annotation.types[i]);
+          for (let i = 0, j = annotation.types.length; i < j; i++) {
+            const type = buildTypeAnnotationDeclarationTypes(annotation.types[i]);
             // keep only complex type
             if (type !== true) {
               if (type.children === true) {
@@ -541,17 +541,17 @@ module.exports = {
      * @return {string} the name of the property or undefined if not found
      */
     function getPropertyName(node) {
-      var isDirectProp = DIRECT_PROPS_REGEX.test(sourceCode.getText(node));
-      var isInClassComponent = utils.getParentES6Component() || utils.getParentES5Component();
-      var isNotInConstructor = !inConstructor();
-      var isNotInComponentWillReceiveProps = !inComponentWillReceiveProps();
+      const isDirectProp = DIRECT_PROPS_REGEX.test(sourceCode.getText(node));
+      const isInClassComponent = utils.getParentES6Component() || utils.getParentES5Component();
+      const isNotInConstructor = !inConstructor();
+      const isNotInComponentWillReceiveProps = !inComponentWillReceiveProps();
       if (isDirectProp && isInClassComponent && isNotInConstructor && isNotInComponentWillReceiveProps) {
         return void 0;
       }
       if (!isDirectProp) {
         node = node.parent;
       }
-      var property = node.property;
+      const property = node.property;
       if (property) {
         switch (property.type) {
           case 'Identifier':
@@ -583,10 +583,10 @@ module.exports = {
      */
     function markPropTypesAsUsed(node, parentNames) {
       parentNames = parentNames || [];
-      var type;
-      var name;
-      var allNames;
-      var properties;
+      let type;
+      let name;
+      let allNames;
+      let properties;
       switch (node.type) {
         case 'MemberExpression':
           name = getPropertyName(node);
@@ -614,15 +614,15 @@ module.exports = {
           properties = node.params[0].properties;
           break;
         case 'VariableDeclarator':
-          for (var i = 0, j = node.id.properties.length; i < j; i++) {
+          for (let i = 0, j = node.id.properties.length; i < j; i++) {
             // let {props: {firstname}} = this
-            var thisDestructuring = (
+            const thisDestructuring = (
               !hasSpreadOperator(node.id.properties[i]) &&
               (PROPS_REGEX.test(node.id.properties[i].key.name) || PROPS_REGEX.test(node.id.properties[i].key.value)) &&
               node.id.properties[i].value.type === 'ObjectPattern'
             );
             // let {firstname} = props
-            var directDestructuring =
+            const directDestructuring =
               PROPS_REGEX.test(node.init.name) &&
               (utils.getParentStatelessComponent() || inConstructor() || inComponentWillReceiveProps())
             ;
@@ -642,8 +642,8 @@ module.exports = {
           throw new Error(`${node.type} ASTNodes are not handled by markPropTypesAsUsed`);
       }
 
-      var component = components.get(utils.getParentComponent());
-      var usedPropTypes = (component && component.usedPropTypes || []).slice();
+      const component = components.get(utils.getParentComponent());
+      const usedPropTypes = (component && component.usedPropTypes || []).slice();
 
       switch (type) {
         case 'direct':
@@ -652,7 +652,7 @@ module.exports = {
             break;
           }
 
-          var isDirectProp = DIRECT_PROPS_REGEX.test(sourceCode.getText(node));
+          const isDirectProp = DIRECT_PROPS_REGEX.test(sourceCode.getText(node));
 
           usedPropTypes.push({
             name: name,
@@ -665,13 +665,13 @@ module.exports = {
           });
           break;
         case 'destructuring':
-          for (var k = 0, l = properties.length; k < l; k++) {
+          for (let k = 0, l = properties.length; k < l; k++) {
             if (hasSpreadOperator(properties[k]) || properties[k].computed) {
               continue;
             }
-            var propName = getKeyValue(properties[k]);
+            const propName = getKeyValue(properties[k]);
 
-            var currentNode = node;
+            let currentNode = node;
             allNames = [];
             while (currentNode.property && !PROPS_REGEX.test(currentNode.property.name)) {
               allNames.unshift(currentNode.property.name);
@@ -703,13 +703,13 @@ module.exports = {
      * @param {propTypes} node The AST node containing the proptypes
      */
     function markPropTypesAsDeclared(node, propTypes) {
-      var componentNode = node;
+      let componentNode = node;
       while (componentNode && !components.get(componentNode)) {
         componentNode = componentNode.parent;
       }
-      var component = components.get(componentNode);
-      var declaredPropTypes = component && component.declaredPropTypes || {};
-      var ignorePropsValidation = false;
+      const component = components.get(componentNode);
+      const declaredPropTypes = component && component.declaredPropTypes || {};
+      let ignorePropsValidation = false;
 
       switch (propTypes && propTypes.type) {
         case 'ObjectTypeAnnotation':
@@ -731,7 +731,7 @@ module.exports = {
           });
           break;
         case 'MemberExpression':
-          var curDeclaredPropTypes = declaredPropTypes;
+          let curDeclaredPropTypes = declaredPropTypes;
           // Walk the list of properties, until we reach the assignment
           // ie: ClassX.propTypes.a.b.c = ...
           while (
@@ -741,7 +741,7 @@ module.exports = {
             propTypes.property &&
             curDeclaredPropTypes
           ) {
-            var propName = propTypes.property.name;
+            const propName = propTypes.property.name;
             if (propName in curDeclaredPropTypes) {
               curDeclaredPropTypes = curDeclaredPropTypes[propName].children;
               propTypes = propTypes.parent;
@@ -759,12 +759,12 @@ module.exports = {
           }
           break;
         case 'Identifier':
-          var variablesInScope = variable.variablesInScope(context);
-          for (var i = 0, j = variablesInScope.length; i < j; i++) {
+          const variablesInScope = variable.variablesInScope(context);
+          for (let i = 0, j = variablesInScope.length; i < j; i++) {
             if (variablesInScope[i].name !== propTypes.name) {
               continue;
             }
-            var defInScope = variablesInScope[i].defs[variablesInScope[i].defs.length - 1];
+            const defInScope = variablesInScope[i].defs[variablesInScope[i].defs.length - 1];
             markPropTypesAsDeclared(node, defInScope.node && defInScope.node.init);
             return;
           }
@@ -797,8 +797,8 @@ module.exports = {
      * @param {Object} component The component to process
      */
     function reportUndeclaredPropTypes(component) {
-      var allNames;
-      for (var i = 0, j = component.usedPropTypes.length; i < j; i++) {
+      let allNames;
+      for (let i = 0, j = component.usedPropTypes.length; i < j; i++) {
         allNames = component.usedPropTypes[i].allNames;
         if (
           isIgnored(allNames[0]) ||
@@ -826,7 +826,7 @@ module.exports = {
      * @returns {ASTNode} The resolved type annotation for the node.
      */
     function resolveTypeAnnotation(node) {
-      var annotation = node.typeAnnotation || node;
+      let annotation = node.typeAnnotation || node;
       while (annotation && (annotation.type === 'TypeAnnotation' || annotation.type === 'NullableTypeAnnotation')) {
         annotation = annotation.typeAnnotation;
       }
@@ -843,7 +843,7 @@ module.exports = {
      * @returns {ASTNode} The resolved type annotation for the node.
      */
     function resolveSuperParameterPropsType(node) {
-      var annotation = node.superTypeParameters.params[1];
+      let annotation = node.superTypeParameters.params[1];
       while (annotation && (annotation.type === 'TypeAnnotation' || annotation.type === 'NullableTypeAnnotation')) {
         annotation = annotation.typeAnnotation;
       }
@@ -858,7 +858,7 @@ module.exports = {
      *   FunctionDeclaration, or FunctionExpression
      */
     function markDestructuredFunctionArgumentsAsUsed(node) {
-      var destructuring = node.params && node.params[0] && node.params[0].type === 'ObjectPattern';
+      const destructuring = node.params && node.params[0] && node.params[0].type === 'ObjectPattern';
       if (destructuring && components.get(node)) {
         markPropTypesAsUsed(node);
       }
@@ -904,11 +904,11 @@ module.exports = {
       },
 
       VariableDeclarator: function(node) {
-        var destructuring = node.init && node.id && node.id.type === 'ObjectPattern';
+        const destructuring = node.init && node.id && node.id.type === 'ObjectPattern';
         // let {props: {firstname}} = this
-        var thisDestructuring = destructuring && node.init.type === 'ThisExpression';
+        const thisDestructuring = destructuring && node.init.type === 'ThisExpression';
         // let {firstname} = props
-        var directDestructuring =
+        const directDestructuring =
           destructuring &&
           PROPS_REGEX.test(node.init.name) &&
           (utils.getParentStatelessComponent() || inConstructor() || inComponentWillReceiveProps())
@@ -932,7 +932,7 @@ module.exports = {
       },
 
       MemberExpression: function(node) {
-        var type;
+        let type;
         if (isPropTypesUsage(node)) {
           type = 'usage';
         } else if (isPropTypesDeclaration(node.property)) {
@@ -944,7 +944,7 @@ module.exports = {
             markPropTypesAsUsed(node);
             break;
           case 'declaration':
-            var component = utils.getRelatedComponent(node);
+            const component = utils.getRelatedComponent(node);
             if (!component) {
               return;
             }
@@ -960,7 +960,7 @@ module.exports = {
           return;
         }
 
-        var i = node.value.body.body.length - 1;
+        let i = node.value.body.body.length - 1;
         for (; i >= 0; i--) {
           if (node.value.body.body[i].type === 'ReturnStatement') {
             break;
@@ -1000,9 +1000,9 @@ module.exports = {
 
       'Program:exit': function() {
         stack = null;
-        var list = components.list();
+        const list = components.list();
         // Report undeclared proptypes for all classes
-        for (var component in list) {
+        for (const component in list) {
           if (!has(list, component) || !mustBeValidated(list[component])) {
             continue;
           }
diff --git a/lib/rules/react-in-jsx-scope.js b/lib/rules/react-in-jsx-scope.js
index c6e7992628..5dfa4c5a1f 100644
--- a/lib/rules/react-in-jsx-scope.js
+++ b/lib/rules/react-in-jsx-scope.js
@@ -4,8 +4,8 @@
  */
 'use strict';
 
-var variableUtil = require('../util/variable');
-var pragmaUtil = require('../util/pragma');
+const variableUtil = require('../util/variable');
+const pragmaUtil = require('../util/pragma');
 
 // -----------------------------------------------------------------------------
 // Rule Definition
@@ -22,13 +22,13 @@ module.exports = {
   },
 
   create: function(context) {
-    var pragma = pragmaUtil.getFromContext(context);
-    var NOT_DEFINED_MESSAGE = '\'{{name}}\' must be in scope when using JSX';
+    const pragma = pragmaUtil.getFromContext(context);
+    const NOT_DEFINED_MESSAGE = '\'{{name}}\' must be in scope when using JSX';
 
     return {
 
       JSXOpeningElement: function(node) {
-        var variables = variableUtil.variablesInScope(context);
+        const variables = variableUtil.variablesInScope(context);
         if (variableUtil.findVariable(variables, pragma)) {
           return;
         }
diff --git a/lib/rules/require-default-props.js b/lib/rules/require-default-props.js
index 9364cf0fd6..1fbd882991 100644
--- a/lib/rules/require-default-props.js
+++ b/lib/rules/require-default-props.js
@@ -4,10 +4,10 @@
  */
 'use strict';
 
-var has = require('has');
-var Components = require('../util/Components');
-var variableUtil = require('../util/variable');
-var annotations = require('../util/annotations');
+const has = require('has');
+const Components = require('../util/Components');
+const variableUtil = require('../util/variable');
+const annotations = require('../util/annotations');
 
 const QUOTES_REGEX = /^["']|["']$/g;
 
@@ -26,8 +26,8 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components, utils) {
-    var sourceCode = context.getSourceCode();
-    var propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
+    const sourceCode = context.getSourceCode();
+    const propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
 
     /**
      * Get properties name
@@ -42,7 +42,7 @@ module.exports = {
       // Special case for class properties
       // (babel-eslint@5 does not expose property name so we have to rely on tokens)
       } else if (node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         return tokens[1] && tokens[1].type === 'Identifier' ? tokens[1].value : tokens[0].value;
       }
       return '';
@@ -81,7 +81,7 @@ module.exports = {
      * @returns {ASTNode|null} Return null if the variable could not be found, ASTNode otherwise.
      */
     function findVariableByName(name) {
-      var variable = variableUtil.variablesInScope(context).find(function(item) {
+      const variable = variableUtil.variablesInScope(context).find(function(item) {
         return item.name === name;
       });
 
@@ -147,7 +147,7 @@ module.exports = {
      * @returns {Object[]}        Array of PropType object representations, to be consumed by `addPropTypesToComponent`.
      */
     function getPropTypesFromObjectExpression(objectExpression) {
-      var props = objectExpression.properties.filter(function(property) {
+      const props = objectExpression.properties.filter(function(property) {
         return property.type !== 'ExperimentalSpreadProperty';
       });
 
@@ -166,11 +166,11 @@ module.exports = {
      * @returns {Object[]}     Array of PropType object representations, to be consumed by `addPropTypesToComponent`.
      */
     function getPropTypesFromTypeAnnotation(node) {
-      var properties;
+      let properties;
 
       switch (node.typeAnnotation.type) {
         case 'GenericTypeAnnotation':
-          var annotation = resolveGenericTypeAnnotation(node.typeAnnotation);
+          let annotation = resolveGenericTypeAnnotation(node.typeAnnotation);
 
           if (annotation && annotation.id) {
             annotation = findVariableByName(annotation.id.name);
@@ -180,7 +180,7 @@ module.exports = {
           break;
 
         case 'UnionTypeAnnotation':
-          var union = resolveUnionTypeAnnotation(node.typeAnnotation);
+          const union = resolveUnionTypeAnnotation(node.typeAnnotation);
           properties = union.reduce(function(acc, curr) {
             if (!curr) {
               return acc;
@@ -199,14 +199,14 @@ module.exports = {
           break;
       }
 
-      var props = properties.filter(function(property) {
+      const props = properties.filter(function(property) {
         return property.type === 'ObjectTypeProperty';
       });
 
       return props.map(function(property) {
         // the `key` property is not present in ObjectTypeProperty nodes, so we need to get the key name manually.
-        var tokens = context.getFirstTokens(property, 1);
-        var name = tokens[0].value;
+        const tokens = context.getFirstTokens(property, 1);
+        const name = tokens[0].value;
 
         return {
           name: name,
@@ -224,7 +224,7 @@ module.exports = {
      *                                     from this ObjectExpression can't be resolved.
      */
     function getDefaultPropsFromObjectExpression(objectExpression) {
-      var hasSpread = objectExpression.properties.find(function(property) {
+      const hasSpread = objectExpression.properties.find(function(property) {
         return property.type === 'ExperimentalSpreadProperty';
       });
 
@@ -257,7 +257,7 @@ module.exports = {
      * @returns {void}
      */
     function addPropTypesToComponent(component, propTypes) {
-      var props = component.propTypes || [];
+      const props = component.propTypes || [];
 
       components.set(component.node, {
         propTypes: props.concat(propTypes)
@@ -282,7 +282,7 @@ module.exports = {
         return;
       }
 
-      var defaults = component.defaultProps || {};
+      const defaults = component.defaultProps || {};
 
       defaultProps.forEach(function(defaultProp) {
         defaults[defaultProp] = true;
@@ -304,7 +304,7 @@ module.exports = {
       }
 
       // find component this props annotation belongs to
-      var component = components.get(utils.getParentStatelessComponent());
+      const component = components.get(utils.getParentStatelessComponent());
       if (!component) {
         return;
       }
@@ -314,7 +314,7 @@ module.exports = {
 
     function handlePropTypeAnnotationClassProperty(node) {
       // find component this props annotation belongs to
-      var component = components.get(utils.getParentES6Component());
+      const component = components.get(utils.getParentES6Component());
       if (!component) {
         return;
       }
@@ -362,15 +362,15 @@ module.exports = {
 
     return {
       MemberExpression: function(node) {
-        var isPropType = isPropTypesDeclaration(node);
-        var isDefaultProp = isDefaultPropsDeclaration(node);
+        const isPropType = isPropTypesDeclaration(node);
+        const isDefaultProp = isDefaultPropsDeclaration(node);
 
         if (!isPropType && !isDefaultProp) {
           return;
         }
 
         // find component this propTypes/defaultProps belongs to
-        var component = utils.getRelatedComponent(node);
+        const component = utils.getRelatedComponent(node);
         if (!component) {
           return;
         }
@@ -385,7 +385,7 @@ module.exports = {
         //
         // MyComponent.propTypes = myPropTypes;
         if (node.parent.type === 'AssignmentExpression') {
-          var expression = resolveNodeValue(node.parent.right);
+          const expression = resolveNodeValue(node.parent.right);
           if (!expression || expression.type !== 'ObjectExpression') {
             // If a value can't be found, we mark the defaultProps declaration as "unresolved", because
             // we should ignore this component and not report any errors for it, to avoid false-positives
@@ -444,25 +444,25 @@ module.exports = {
           return;
         }
 
-        var isPropType = isPropTypesDeclaration(node);
-        var isDefaultProp = isDefaultPropsDeclaration(node);
+        const isPropType = isPropTypesDeclaration(node);
+        const isDefaultProp = isDefaultPropsDeclaration(node);
 
         if (!isPropType && !isDefaultProp) {
           return;
         }
 
         // find component this propTypes/defaultProps belongs to
-        var component = components.get(utils.getParentES6Component());
+        const component = components.get(utils.getParentES6Component());
         if (!component) {
           return;
         }
 
-        var returnStatement = utils.findReturnStatement(node);
+        const returnStatement = utils.findReturnStatement(node);
         if (!returnStatement) {
           return;
         }
 
-        var expression = resolveNodeValue(returnStatement.argument);
+        const expression = resolveNodeValue(returnStatement.argument);
         if (!expression || expression.type !== 'ObjectExpression') {
           return;
         }
@@ -500,20 +500,20 @@ module.exports = {
           return;
         }
 
-        var isPropType = getPropertyName(node) === 'propTypes';
-        var isDefaultProp = getPropertyName(node) === 'defaultProps' || getPropertyName(node) === 'getDefaultProps';
+        const isPropType = getPropertyName(node) === 'propTypes';
+        const isDefaultProp = getPropertyName(node) === 'defaultProps' || getPropertyName(node) === 'getDefaultProps';
 
         if (!isPropType && !isDefaultProp) {
           return;
         }
 
         // find component this propTypes/defaultProps belongs to
-        var component = components.get(utils.getParentES6Component());
+        const component = components.get(utils.getParentES6Component());
         if (!component) {
           return;
         }
 
-        var expression = resolveNodeValue(node.value);
+        const expression = resolveNodeValue(node.value);
         if (!expression || expression.type !== 'ObjectExpression') {
           return;
         }
@@ -541,7 +541,7 @@ module.exports = {
       // });
       ObjectExpression: function(node) {
         // find component this propTypes/defaultProps belongs to
-        var component = utils.isES5Component(node) && components.get(node);
+        const component = utils.isES5Component(node) && components.get(node);
         if (!component) {
           return;
         }
@@ -552,8 +552,8 @@ module.exports = {
             return;
           }
 
-          var isPropType = isPropTypesDeclaration(property);
-          var isDefaultProp = isDefaultPropsDeclaration(property);
+          const isPropType = isPropTypesDeclaration(property);
+          const isDefaultProp = isDefaultPropsDeclaration(property);
 
           if (!isPropType && !isDefaultProp) {
             return;
@@ -565,7 +565,7 @@ module.exports = {
           }
 
           if (isDefaultProp && property.value.type === 'FunctionExpression') {
-            var returnStatement = utils.findReturnStatement(property);
+            const returnStatement = utils.findReturnStatement(property);
             if (!returnStatement || returnStatement.argument.type !== 'ObjectExpression') {
               return;
             }
@@ -581,9 +581,9 @@ module.exports = {
       FunctionExpression: handleStatelessComponent,
 
       'Program:exit': function() {
-        var list = components.list();
+        const list = components.list();
 
-        for (var component in list) {
+        for (const component in list) {
           if (!has(list, component)) {
             continue;
           }
diff --git a/lib/rules/require-optimization.js b/lib/rules/require-optimization.js
index 5b3a78d51e..0cd817e5fa 100644
--- a/lib/rules/require-optimization.js
+++ b/lib/rules/require-optimization.js
@@ -4,8 +4,8 @@
  */
 'use strict';
 
-var has = require('has');
-var Components = require('../util/Components');
+const has = require('has');
+const Components = require('../util/Components');
 
 module.exports = {
   meta: {
@@ -30,18 +30,18 @@ module.exports = {
   },
 
   create: Components.detect(function (context, components, utils) {
-    var MISSING_MESSAGE = 'Component is not optimized. Please add a shouldComponentUpdate method.';
-    var configuration = context.options[0] || {};
-    var allowDecorators = configuration.allowDecorators || [];
+    const MISSING_MESSAGE = 'Component is not optimized. Please add a shouldComponentUpdate method.';
+    const configuration = context.options[0] || {};
+    const allowDecorators = configuration.allowDecorators || [];
 
     /**
      * Checks to see if our component is decorated by PureRenderMixin via reactMixin
      * @param {ASTNode} node The AST node being checked.
      * @returns {Boolean} True if node is decorated with a PureRenderMixin, false if not.
      */
-    var hasPureRenderDecorator = function (node) {
+    const hasPureRenderDecorator = function (node) {
       if (node.decorators && node.decorators.length) {
-        for (var i = 0, l = node.decorators.length; i < l; i++) {
+        for (let i = 0, l = node.decorators.length; i < l; i++) {
           if (
             node.decorators[i].expression &&
             node.decorators[i].expression.callee &&
@@ -66,12 +66,12 @@ module.exports = {
      * @param {ASTNode} node The AST node being checked.
      * @returns {Boolean} True if node is decorated name with a custom decorated, false if not.
      */
-    var hasCustomDecorator = function (node) {
-      var allowLength = allowDecorators.length;
+    const hasCustomDecorator = function (node) {
+      const allowLength = allowDecorators.length;
 
       if (allowLength && node.decorators && node.decorators.length) {
-        for (var i = 0; i < allowLength; i++) {
-          for (var j = 0, l = node.decorators.length; j < l; j++) {
+        for (let i = 0; i < allowLength; i++) {
+          for (let j = 0, l = node.decorators.length; j < l; j++) {
             if (
               node.decorators[j].expression &&
               node.decorators[j].expression.name === allowDecorators[i]
@@ -90,7 +90,7 @@ module.exports = {
      * @param {ASTNode} node The AST node being checked.
      * @returns {Boolean} True if we are declaring a shouldComponentUpdate method, false if not.
      */
-    var isSCUDeclarеd = function (node) {
+    const isSCUDeclarеd = function (node) {
       return Boolean(
         node &&
         node.name === 'shouldComponentUpdate'
@@ -102,10 +102,10 @@ module.exports = {
      * @param {ASTNode} node The AST node being checked.
      * @returns {Boolean} True if we are declaring a PureRenderMixin method, false if not.
      */
-    var isPureRenderDeclared = function (node) {
-      var hasPR = false;
+    const isPureRenderDeclared = function (node) {
+      let hasPR = false;
       if (node.value && node.value.elements) {
-        for (var i = 0, l = node.value.elements.length; i < l; i++) {
+        for (let i = 0, l = node.value.elements.length; i < l; i++) {
           if (node.value.elements[i].name === 'PureRenderMixin') {
             hasPR = true;
             break;
@@ -124,7 +124,7 @@ module.exports = {
      * Mark shouldComponentUpdate as declared
      * @param {ASTNode} node The AST node being checked.
      */
-    var markSCUAsDeclared = function (node) {
+    const markSCUAsDeclared = function (node) {
       components.set(node, {
         hasSCU: true
       });
@@ -134,7 +134,7 @@ module.exports = {
      * Reports missing optimization for a given component
      * @param {Object} component The component to process
      */
-    var reportMissingOptimization = function (component) {
+    const reportMissingOptimization = function (component) {
       context.report({
         node: component.node,
         message: MISSING_MESSAGE,
@@ -148,9 +148,9 @@ module.exports = {
      * Checks if we are declaring function in class
      * @returns {Boolean} True if we are declaring function in class, false if not.
      */
-    var isFunctionInClass = function () {
-      var blockNode;
-      var scope = context.getScope();
+    const isFunctionInClass = function () {
+      let blockNode;
+      let scope = context.getScope();
       while (scope) {
         blockNode = scope.block;
         if (blockNode && blockNode.type === 'ClassDeclaration') {
@@ -202,7 +202,7 @@ module.exports = {
 
       ObjectExpression: function (node) {
         // Search for the shouldComponentUpdate declaration
-        for (var i = 0, l = node.properties.length; i < l; i++) {
+        for (let i = 0, l = node.properties.length; i < l; i++) {
           if (
             !node.properties[i].key || (
               !isSCUDeclarеd(node.properties[i].key) &&
@@ -216,10 +216,10 @@ module.exports = {
       },
 
       'Program:exit': function () {
-        var list = components.list();
+        const list = components.list();
 
         // Report missing shouldComponentUpdate for all components
-        for (var component in list) {
+        for (const component in list) {
           if (!has(list, component) || list[component].hasSCU) {
             continue;
           }
diff --git a/lib/rules/require-render-return.js b/lib/rules/require-render-return.js
index dc5b96de24..6ca234c3e8 100644
--- a/lib/rules/require-render-return.js
+++ b/lib/rules/require-render-return.js
@@ -4,8 +4,8 @@
  */
 'use strict';
 
-var has = require('has');
-var Components = require('../util/Components');
+const has = require('has');
+const Components = require('../util/Components');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -57,7 +57,7 @@ module.exports = {
       // Special case for class properties
       // (babel-eslint does not expose property name so we have to rely on tokens)
       if (node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         return tokens[1] && tokens[1].type === 'Identifier' ? tokens[1].value : tokens[0].value;
       } else if (['MethodDefinition', 'Property'].indexOf(node.type) !== -1) {
         return node.key.name;
@@ -71,8 +71,8 @@ module.exports = {
      * @returns {Boolean} True if there is a render method, false if not
      */
     function hasRenderMethod(node) {
-      var properties = getComponentProperties(node);
-      for (var i = 0, j = properties.length; i < j; i++) {
+      const properties = getComponentProperties(node);
+      for (let i = 0, j = properties.length; i < j; i++) {
         if (getPropertyName(properties[i]) !== 'render' || !properties[i].value) {
           continue;
         }
@@ -83,9 +83,9 @@ module.exports = {
 
     return {
       ReturnStatement: function(node) {
-        var ancestors = context.getAncestors(node).reverse();
-        var depth = 0;
-        for (var i = 0, j = ancestors.length; i < j; i++) {
+        const ancestors = context.getAncestors(node).reverse();
+        let depth = 0;
+        for (let i = 0, j = ancestors.length; i < j; i++) {
           if (/Function(Expression|Declaration)$/.test(ancestors[i].type)) {
             depth++;
           }
@@ -108,8 +108,8 @@ module.exports = {
       },
 
       'Program:exit': function() {
-        var list = components.list();
-        for (var component in list) {
+        const list = components.list();
+        for (const component in list) {
           if (
             !has(list, component) ||
             !hasRenderMethod(list[component].node) ||
diff --git a/lib/rules/self-closing-comp.js b/lib/rules/self-closing-comp.js
index 20f82c26af..4c49f66147 100644
--- a/lib/rules/self-closing-comp.js
+++ b/lib/rules/self-closing-comp.js
@@ -34,7 +34,7 @@ module.exports = {
   },
 
   create: function(context) {
-    var tagConvention = /^[a-z]|\-/;
+    const tagConvention = /^[a-z]|\-/;
     function isTagName(name) {
       return tagConvention.test(name);
     }
@@ -44,7 +44,7 @@ module.exports = {
     }
 
     function hasChildren(node) {
-      var childrens = node.parent.children;
+      const childrens = node.parent.children;
       if (
         !childrens.length ||
         (childrens.length === 1 && childrens[0].type === 'Literal' && !childrens[0].value.replace(/(?!\xA0)\s/g, ''))
@@ -55,7 +55,7 @@ module.exports = {
     }
 
     function isShouldBeSelfClosed(node) {
-      var configuration = context.options[0] || {component: true, html: true};
+      const configuration = context.options[0] || {component: true, html: true};
       return (
         configuration.component && isComponent(node) ||
         configuration.html && isTagName(node.name.name)
@@ -77,12 +77,12 @@ module.exports = {
           message: 'Empty components are self-closing',
           fix: function(fixer) {
             // Represents the last character of the JSXOpeningElement, the '>' character
-            var openingElementEnding = node.end - 1;
+            const openingElementEnding = node.end - 1;
             // Represents the last character of the JSXClosingElement, the '>' character
-            var closingElementEnding = node.parent.closingElement.end;
+            const closingElementEnding = node.parent.closingElement.end;
 
             // Replace />.*<\/.*>/ with '/>'
-            var range = [openingElementEnding, closingElementEnding];
+            const range = [openingElementEnding, closingElementEnding];
             return fixer.replaceTextRange(range, ' />');
           }
         });
diff --git a/lib/rules/sort-comp.js b/lib/rules/sort-comp.js
index 5def596138..f50916137b 100644
--- a/lib/rules/sort-comp.js
+++ b/lib/rules/sort-comp.js
@@ -4,10 +4,10 @@
  */
 'use strict';
 
-var has = require('has');
-var util = require('util');
+const has = require('has');
+const util = require('util');
 
-var Components = require('../util/Components');
+const Components = require('../util/Components');
 
 /**
  * Get the methods order from the default config and the user config
@@ -18,12 +18,12 @@ var Components = require('../util/Components');
 function getMethodsOrder(defaultConfig, userConfig) {
   userConfig = userConfig || {};
 
-  var groups = util._extend(defaultConfig.groups, userConfig.groups);
-  var order = userConfig.order || defaultConfig.order;
+  const groups = util._extend(defaultConfig.groups, userConfig.groups);
+  const order = userConfig.order || defaultConfig.order;
 
-  var config = [];
-  var entry;
-  for (var i = 0, j = order.length; i < j; i++) {
+  let config = [];
+  let entry;
+  for (let i = 0, j = order.length; i < j; i++) {
     entry = order[i];
     if (has(groups, entry)) {
       config = config.concat(groups[entry]);
@@ -73,11 +73,11 @@ module.exports = {
   },
 
   create: Components.detect(function(context, components) {
-    var errors = {};
+    const errors = {};
 
-    var MISPOSITION_MESSAGE = '{{propA}} should be placed {{position}} {{propB}}';
+    const MISPOSITION_MESSAGE = '{{propA}} should be placed {{position}} {{propB}}';
 
-    var methodsOrder = getMethodsOrder({
+    const methodsOrder = getMethodsOrder({
       order: [
         'static-methods',
         'lifecycle',
@@ -113,7 +113,7 @@ module.exports = {
     // Public
     // --------------------------------------------------------------------------
 
-    var regExpRegExp = /\/(.*)\/([g|y|i|m]*)/;
+    const regExpRegExp = /\/(.*)\/([g|y|i|m]*)/;
 
     /**
      * Get indexes of the matching patterns in methods order configuration
@@ -121,11 +121,11 @@ module.exports = {
      * @returns {Array} The matching patterns indexes. Return [Infinity] if there is no match.
      */
     function getRefPropIndexes(method) {
-      var isRegExp;
-      var matching;
-      var i;
-      var j;
-      var indexes = [];
+      let isRegExp;
+      let matching;
+      let i;
+      let j;
+      const indexes = [];
 
       if (method.static) {
         for (i = 0, j = methodsOrder.length; i < j; i++) {
@@ -188,7 +188,7 @@ module.exports = {
       // Special case for class properties
       // (babel-eslint does not expose property name so we have to rely on tokens)
       if (node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         return tokens[1] && tokens[1].type === 'Identifier' ? tokens[1].value : tokens[0].value;
       }
 
@@ -235,11 +235,11 @@ module.exports = {
      * Dedupe errors, only keep the ones with the highest score and delete the others
      */
     function dedupeErrors() {
-      for (var i in errors) {
+      for (const i in errors) {
         if (!has(errors, i)) {
           continue;
         }
-        var index = errors[i].closest.ref.index;
+        const index = errors[i].closest.ref.index;
         if (!errors[index]) {
           continue;
         }
@@ -257,11 +257,11 @@ module.exports = {
     function reportErrors() {
       dedupeErrors();
 
-      var nodeA;
-      var nodeB;
-      var indexA;
-      var indexB;
-      for (var i in errors) {
+      let nodeA;
+      let nodeB;
+      let indexA;
+      let indexB;
+      for (const i in errors) {
         if (!has(errors, i)) {
           continue;
         }
@@ -309,20 +309,20 @@ module.exports = {
      * @returns {Object} Object containing a correct true/false flag and the correct indexes for the two properties.
      */
     function comparePropsOrder(propertiesInfos, propA, propB) {
-      var i;
-      var j;
-      var k;
-      var l;
-      var refIndexA;
-      var refIndexB;
+      let i;
+      let j;
+      let k;
+      let l;
+      let refIndexA;
+      let refIndexB;
 
       // Get references indexes (the correct position) for given properties
-      var refIndexesA = getRefPropIndexes(propA);
-      var refIndexesB = getRefPropIndexes(propB);
+      const refIndexesA = getRefPropIndexes(propA);
+      const refIndexesB = getRefPropIndexes(propB);
 
       // Get current indexes for given properties
-      var classIndexA = propertiesInfos.indexOf(propA);
-      var classIndexB = propertiesInfos.indexOf(propB);
+      const classIndexA = propertiesInfos.indexOf(propA);
+      const classIndexB = propertiesInfos.indexOf(propB);
 
       // Loop around the references indexes for the 1st property
       for (i = 0, j = refIndexesA.length; i < j; i++) {
@@ -362,7 +362,7 @@ module.exports = {
      * @param {Array} properties Array containing all the properties.
      */
     function checkPropsOrder(properties) {
-      var propertiesInfos = properties.map(function(node) {
+      const propertiesInfos = properties.map(function(node) {
         return {
           name: getPropertyName(node),
           static: node.static,
@@ -370,13 +370,13 @@ module.exports = {
         };
       });
 
-      var i;
-      var j;
-      var k;
-      var l;
-      var propA;
-      var propB;
-      var order;
+      let i;
+      let j;
+      let k;
+      let l;
+      let propA;
+      let propB;
+      let order;
 
       // Loop around the properties
       for (i = 0, j = propertiesInfos.length; i < j; i++) {
@@ -408,12 +408,12 @@ module.exports = {
 
     return {
       'Program:exit': function() {
-        var list = components.list();
-        for (var component in list) {
+        const list = components.list();
+        for (const component in list) {
           if (!has(list, component)) {
             continue;
           }
-          var properties = getComponentProperties(list[component].node);
+          const properties = getComponentProperties(list[component].node);
           checkPropsOrder(properties);
         }
 
diff --git a/lib/rules/sort-prop-types.js b/lib/rules/sort-prop-types.js
index c3eabddbc6..ad25422dde 100644
--- a/lib/rules/sort-prop-types.js
+++ b/lib/rules/sort-prop-types.js
@@ -3,7 +3,7 @@
  */
 'use strict';
 
-var variableUtil = require('../util/variable');
+const variableUtil = require('../util/variable');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -35,12 +35,12 @@ module.exports = {
   },
 
   create: function(context) {
-    var sourceCode = context.getSourceCode();
-    var configuration = context.options[0] || {};
-    var requiredFirst = configuration.requiredFirst || false;
-    var callbacksLast = configuration.callbacksLast || false;
-    var ignoreCase = configuration.ignoreCase || false;
-    var propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
+    const sourceCode = context.getSourceCode();
+    const configuration = context.options[0] || {};
+    const requiredFirst = configuration.requiredFirst || false;
+    const callbacksLast = configuration.callbacksLast || false;
+    const ignoreCase = configuration.ignoreCase || false;
+    const propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
 
     /**
      * Checks if node is `propTypes` declaration
@@ -51,7 +51,7 @@ module.exports = {
       // Special case for class properties
       // (babel-eslint does not expose property name so we have to rely on tokens)
       if (node.type === 'ClassProperty') {
-        var tokens = context.getFirstTokens(node, 2);
+        const tokens = context.getFirstTokens(node, 2);
         return (tokens[0] && tokens[0].value === 'propTypes') ||
                (tokens[1] && tokens[1].value === 'propTypes');
       }
@@ -89,12 +89,12 @@ module.exports = {
           return decls[idx + 1];
         }
 
-        var prevPropName = getKey(prev);
-        var currentPropName = getKey(curr);
-        var previousIsRequired = isRequiredProp(prev);
-        var currentIsRequired = isRequiredProp(curr);
-        var previousIsCallback = isCallbackPropName(prevPropName);
-        var currentIsCallback = isCallbackPropName(currentPropName);
+        let prevPropName = getKey(prev);
+        let currentPropName = getKey(curr);
+        const previousIsRequired = isRequiredProp(prev);
+        const currentIsRequired = isRequiredProp(curr);
+        const previousIsCallback = isCallbackPropName(prevPropName);
+        const currentIsCallback = isCallbackPropName(currentPropName);
 
         if (ignoreCase) {
           prevPropName = prevPropName.toLowerCase();
@@ -169,8 +169,8 @@ module.exports = {
         if (!isPropTypesDeclaration(node.property)) {
           return;
         }
-        var right = node.parent.right;
-        var declarations;
+        const right = node.parent.right;
+        let declarations;
         switch (right && right.type) {
           case 'CallExpression':
             if (
@@ -184,7 +184,7 @@ module.exports = {
             declarations = right.properties;
             break;
           case 'Identifier':
-            var variable = variableUtil.variablesInScope(context).find(function (item) {
+            const variable = variableUtil.variablesInScope(context).find(function (item) {
               return item.name === right.name;
             });
             if (
diff --git a/lib/rules/style-prop-object.js b/lib/rules/style-prop-object.js
index 1dad301562..3a5b5f9989 100644
--- a/lib/rules/style-prop-object.js
+++ b/lib/rules/style-prop-object.js
@@ -4,7 +4,7 @@
  */
 'use strict';
 
-var variableUtil = require('../util/variable');
+const variableUtil = require('../util/variable');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -32,7 +32,7 @@ module.exports = {
      * @param {object} node A Identifier node
      */
     function checkIdentifiers(node) {
-      var variable = variableUtil.variablesInScope(context).find(function (item) {
+      const variable = variableUtil.variablesInScope(context).find(function (item) {
         return item.name === node.name;
       });
 
@@ -54,7 +54,7 @@ module.exports = {
           && node.arguments.length > 1
         ) {
           if (node.arguments[1].type === 'ObjectExpression') {
-            var style = node.arguments[1].properties.find(function(property) {
+            const style = node.arguments[1].properties.find(function(property) {
               return property.key && property.key.name === 'style' && !property.computed;
             });
             if (style) {
diff --git a/lib/util/Components.js b/lib/util/Components.js
index 712bcffa81..31f634ea3e 100644
--- a/lib/util/Components.js
+++ b/lib/util/Components.js
@@ -4,11 +4,11 @@
  */
 'use strict';
 
-var has = require('has');
-var util = require('util');
-var doctrine = require('doctrine');
-var variableUtil = require('./variable');
-var pragmaUtil = require('./pragma');
+const has = require('has');
+const util = require('util');
+const doctrine = require('doctrine');
+const variableUtil = require('./variable');
+const pragmaUtil = require('./pragma');
 
 /**
  * Components
@@ -29,7 +29,7 @@ function Components() {
  * @returns {Object} Added component object
  */
 Components.prototype.add = function(node, confidence) {
-  var id = this._getId(node);
+  const id = this._getId(node);
   if (this._list[id]) {
     if (confidence === 0 || this._list[id].confidence === 0) {
       this._list[id].confidence = 0;
@@ -52,7 +52,7 @@ Components.prototype.add = function(node, confidence) {
  * @returns {Object} Component object, undefined if the component is not found
  */
 Components.prototype.get = function(node) {
-  var id = this._getId(node);
+  const id = this._getId(node);
   return this._list[id];
 };
 
@@ -69,7 +69,7 @@ Components.prototype.set = function(node, props) {
   if (!node) {
     return;
   }
-  var id = this._getId(node);
+  const id = this._getId(node);
   this._list[id] = util._extend(this._list[id], props);
 };
 
@@ -80,15 +80,15 @@ Components.prototype.set = function(node, props) {
  * @returns {Object} Components list
  */
 Components.prototype.list = function() {
-  var list = {};
-  var usedPropTypes = {};
+  const list = {};
+  const usedPropTypes = {};
   // Find props used in components for which we are not confident
-  for (var i in this._list) {
+  for (const i in this._list) {
     if (!has(this._list, i) || this._list[i].confidence >= 2) {
       continue;
     }
-    var component = null;
-    var node = null;
+    let component = null;
+    let node = null;
     node = this._list[i].node;
     while (!component && node.parent) {
       node = node.parent;
@@ -108,11 +108,11 @@ Components.prototype.list = function() {
     }
   }
   // Assign used props in not confident components to the parent component
-  for (var j in this._list) {
+  for (const j in this._list) {
     if (!has(this._list, j) || this._list[j].confidence < 2) {
       continue;
     }
-    var id = this._getId(this._list[j].node);
+    const id = this._getId(this._list[j].node);
     list[j] = this._list[j];
     if (usedPropTypes[id]) {
       list[j].usedPropTypes = (list[j].usedPropTypes || []).concat(usedPropTypes[id]);
@@ -128,8 +128,8 @@ Components.prototype.list = function() {
  * @returns {Number} Components list length
  */
 Components.prototype.length = function() {
-  var length = 0;
-  for (var i in this._list) {
+  let length = 0;
+  for (const i in this._list) {
     if (!has(this._list, i) || this._list[i].confidence < 2) {
       continue;
     }
@@ -139,13 +139,13 @@ Components.prototype.length = function() {
 };
 
 function componentRule(rule, context) {
-  var createClass = pragmaUtil.getCreateClassFromContext(context);
-  var pragma = pragmaUtil.getFromContext(context);
-  var sourceCode = context.getSourceCode();
-  var components = new Components();
+  const createClass = pragmaUtil.getCreateClassFromContext(context);
+  const pragma = pragmaUtil.getFromContext(context);
+  const sourceCode = context.getSourceCode();
+  const components = new Components();
 
   // Utilities for component detection
-  var utils = {
+  const utils = {
 
     /**
      * Check if the node is a React ES5 component
@@ -184,18 +184,18 @@ function componentRule(rule, context) {
      * @returns {Boolean} True if the node is explicitly declared as a descendant of a React Component, false if not
      */
     isExplicitComponent: function(node) {
-      var comment = sourceCode.getJSDocComment(node);
+      const comment = sourceCode.getJSDocComment(node);
 
       if (comment === null) {
         return false;
       }
 
-      var commentAst = doctrine.parse(comment.value, {
+      const commentAst = doctrine.parse(comment.value, {
         unwrap: true,
         tags: ['extends', 'augments']
       });
 
-      var relevantTags = commentAst.tags.filter(function(tag) {
+      const relevantTags = commentAst.tags.filter(function(tag) {
         return tag.name === 'React.Component' || tag.name === 'React.PureComponent';
       });
 
@@ -221,10 +221,10 @@ function componentRule(rule, context) {
      * @returns {Boolean} True if createElement is destructured from React
      */
     hasDestructuredReactCreateElement: function() {
-      var variables = variableUtil.variablesInScope(context);
-      var variable = variableUtil.getVariable(variables, 'createElement');
+      const variables = variableUtil.variablesInScope(context);
+      const variable = variableUtil.getVariable(variables, 'createElement');
       if (variable) {
-        var map = variable.scope.set;
+        const map = variable.scope.set;
         if (map.has('React')) {
           return true;
         }
@@ -239,7 +239,7 @@ function componentRule(rule, context) {
      * @returns {Boolean} True if React.createElement called
      */
     isReactCreateElement: function(node) {
-      var calledOnReact = (
+      const calledOnReact = (
         node &&
         node.callee &&
         node.callee.object &&
@@ -248,7 +248,7 @@ function componentRule(rule, context) {
         node.callee.property.name === 'createElement'
       );
 
-      var calledDirectly = (
+      const calledDirectly = (
         node &&
         node.callee &&
         node.callee.name === 'createElement'
@@ -268,8 +268,8 @@ function componentRule(rule, context) {
      * @returns {Boolean} True if the node is returning JSX, false if not
      */
     isReturningJSX: function(ASTnode, strict) {
-      var property;
-      var node = ASTnode;
+      let property;
+      let node = ASTnode;
       switch (node.type) {
         case 'ReturnStatement':
           property = 'argument';
@@ -285,26 +285,26 @@ function componentRule(rule, context) {
           property = 'argument';
       }
 
-      var returnsConditionalJSXConsequent =
+      const returnsConditionalJSXConsequent =
         node[property] &&
         node[property].type === 'ConditionalExpression' &&
         node[property].consequent.type === 'JSXElement'
       ;
-      var returnsConditionalJSXAlternate =
+      const returnsConditionalJSXAlternate =
         node[property] &&
         node[property].type === 'ConditionalExpression' &&
         node[property].alternate.type === 'JSXElement'
       ;
-      var returnsConditionalJSX =
+      const returnsConditionalJSX =
         strict ?
           (returnsConditionalJSXConsequent && returnsConditionalJSXAlternate) :
           (returnsConditionalJSXConsequent || returnsConditionalJSXAlternate);
 
-      var returnsJSX =
+      const returnsJSX =
         node[property] &&
         node[property].type === 'JSXElement'
       ;
-      var returnsReactCreateElement = this.isReactCreateElement(node[property]);
+      const returnsReactCreateElement = this.isReactCreateElement(node[property]);
 
       return Boolean(
         returnsConditionalJSX ||
@@ -322,7 +322,7 @@ function componentRule(rule, context) {
       if (!node.value || !node.value.body || !node.value.body.body) {
         return false;
       }
-      var i = node.value.body.body.length - 1;
+      let i = node.value.body.body.length - 1;
       for (; i >= 0; i--) {
         if (node.value.body.body[i].type === 'ReturnStatement') {
           return node.value.body.body[i];
@@ -350,9 +350,9 @@ function componentRule(rule, context) {
      * @returns {ASTNode} component node, null if we are not in a component
      */
     getParentES5Component: function() {
-      var scope = context.getScope();
+      let scope = context.getScope();
       while (scope) {
-        var node = scope.block && scope.block.parent && scope.block.parent.parent;
+        const node = scope.block && scope.block.parent && scope.block.parent.parent;
         if (node && utils.isES5Component(node)) {
           return node;
         }
@@ -367,11 +367,11 @@ function componentRule(rule, context) {
      * @returns {ASTNode} component node, null if we are not in a component
      */
     getParentES6Component: function() {
-      var scope = context.getScope();
+      let scope = context.getScope();
       while (scope && scope.type !== 'class') {
         scope = scope.upper;
       }
-      var node = scope && scope.block;
+      const node = scope && scope.block;
       if (!node || !utils.isES6Component(node)) {
         return null;
       }
@@ -384,15 +384,15 @@ function componentRule(rule, context) {
      * @returns {ASTNode} component node, null if we are not in a component
      */
     getParentStatelessComponent: function() {
-      var scope = context.getScope();
+      let scope = context.getScope();
       while (scope) {
-        var node = scope.block;
-        var isClass = node.type === 'ClassExpression';
-        var isFunction = /Function/.test(node.type); // Functions
-        var isMethod = node.parent && node.parent.type === 'MethodDefinition'; // Classes methods
-        var isArgument = node.parent && node.parent.type === 'CallExpression'; // Arguments (callback, etc.)
+        const node = scope.block;
+        const isClass = node.type === 'ClassExpression';
+        const isFunction = /Function/.test(node.type); // Functions
+        const isMethod = node.parent && node.parent.type === 'MethodDefinition'; // Classes methods
+        const isArgument = node.parent && node.parent.type === 'CallExpression'; // Arguments (callback, etc.)
         // Attribute Expressions inside JSX Elements (<button onClick={() => props.handleClick()}></button>)
-        var isJSXExpressionContainer = node.parent && node.parent.type === 'JSXExpressionContainer';
+        const isJSXExpressionContainer = node.parent && node.parent.type === 'JSXExpressionContainer';
         // Stop moving up if we reach a class or an argument (like a callback)
         if (isClass || isArgument) {
           return null;
@@ -413,14 +413,13 @@ function componentRule(rule, context) {
      * @returns {ASTNode} component node, null if we cannot find the component
      */
     getRelatedComponent: function(node) {
-      var i;
-      var j;
-      var k;
-      var l;
-      var componentName;
-      var componentNode;
+      let i;
+      let j;
+      let k;
+      let l;
+      let componentNode;
       // Get the component path
-      var componentPath = [];
+      const componentPath = [];
       while (node) {
         if (node.property && node.property.type === 'Identifier') {
           componentPath.push(node.property.name);
@@ -431,15 +430,15 @@ function componentRule(rule, context) {
         node = node.object;
       }
       componentPath.reverse();
-      componentName = componentPath.slice(0, componentPath.length - 1).join('.');
+      const componentName = componentPath.slice(0, componentPath.length - 1).join('.');
 
       // Find the variable in the current scope
-      var variableName = componentPath.shift();
+      const variableName = componentPath.shift();
       if (!variableName) {
         return null;
       }
-      var variableInScope;
-      var variables = variableUtil.variablesInScope(context);
+      let variableInScope;
+      const variables = variableUtil.variablesInScope(context);
       for (i = 0, j = variables.length; i < j; i++) {
         if (variables[i].name === variableName) {
           variableInScope = variables[i];
@@ -451,8 +450,8 @@ function componentRule(rule, context) {
       }
 
       // Try to find the component using variable references
-      var refs = variableInScope.references;
-      var refId;
+      const refs = variableInScope.references;
+      let refId;
       for (i = 0, j = refs.length; i < j; i++) {
         refId = refs[i].identifier;
         if (refId.parent && refId.parent.type === 'MemberExpression') {
@@ -475,8 +474,8 @@ function componentRule(rule, context) {
       }
 
       // Try to find the component using variable declarations
-      var defInScope;
-      var defs = variableInScope.defs;
+      let defInScope;
+      const defs = variableInScope.defs;
       for (i = 0, j = defs.length; i < j; i++) {
         if (defs[i].type === 'ClassName' || defs[i].type === 'FunctionName' || defs[i].type === 'Variable') {
           defInScope = defs[i];
@@ -511,7 +510,7 @@ function componentRule(rule, context) {
   };
 
   // Component detection instructions
-  var detectionInstructions = {
+  const detectionInstructions = {
     ClassExpression: function(node) {
       if (!utils.isES6Component(node)) {
         return;
@@ -546,7 +545,7 @@ function componentRule(rule, context) {
         components.add(node, 0);
         return;
       }
-      var component = utils.getParentComponent();
+      const component = utils.getParentComponent();
       if (
         !component ||
         (component.parent && component.parent.type === 'JSXExpressionContainer')
@@ -575,7 +574,7 @@ function componentRule(rule, context) {
         components.add(node, 0);
         return;
       }
-      var component = utils.getParentComponent();
+      const component = utils.getParentComponent();
       if (
         !component ||
         (component.parent && component.parent.type === 'JSXExpressionContainer')
@@ -592,7 +591,7 @@ function componentRule(rule, context) {
     },
 
     ThisExpression: function(node) {
-      var component = utils.getParentComponent();
+      const component = utils.getParentComponent();
       if (!component || !/Function/.test(component.type) || !node.parent.property) {
         return;
       }
@@ -606,7 +605,7 @@ function componentRule(rule, context) {
       }
       node = utils.getParentComponent();
       if (!node) {
-        var scope = context.getScope();
+        const scope = context.getScope();
         components.add(scope.block, 1);
         return;
       }
@@ -615,8 +614,8 @@ function componentRule(rule, context) {
   };
 
   // Update the provided rule instructions to add the component detection
-  var ruleInstructions = rule(context, components, utils);
-  var updatedRuleInstructions = util._extend({}, ruleInstructions);
+  const ruleInstructions = rule(context, components, utils);
+  const updatedRuleInstructions = util._extend({}, ruleInstructions);
   Object.keys(detectionInstructions).forEach(function(instruction) {
     updatedRuleInstructions[instruction] = function(node) {
       detectionInstructions[instruction](node);
diff --git a/lib/util/annotations.js b/lib/util/annotations.js
index 28c5c50382..47f53fe56c 100644
--- a/lib/util/annotations.js
+++ b/lib/util/annotations.js
@@ -15,10 +15,10 @@ function isAnnotatedFunctionPropsDeclaration(node, context) {
     return false;
   }
 
-  var tokens = context.getFirstTokens(node.params[0], 2);
-  var isAnnotated = node.params[0].typeAnnotation;
-  var isDestructuredProps = node.params[0].type === 'ObjectPattern';
-  var isProps = tokens[0].value === 'props' || (tokens[1] && tokens[1].value === 'props');
+  const tokens = context.getFirstTokens(node.params[0], 2);
+  const isAnnotated = node.params[0].typeAnnotation;
+  const isDestructuredProps = node.params[0].type === 'ObjectPattern';
+  const isProps = tokens[0].value === 'props' || (tokens[1] && tokens[1].value === 'props');
 
   return (isAnnotated && (isDestructuredProps || isProps));
 }
diff --git a/lib/util/getTokenBeforeClosingBracket.js b/lib/util/getTokenBeforeClosingBracket.js
index afaef26ddc..a727c1a7b1 100644
--- a/lib/util/getTokenBeforeClosingBracket.js
+++ b/lib/util/getTokenBeforeClosingBracket.js
@@ -6,7 +6,7 @@
  * @returns {Token} The token before the closing bracket.
  */
 function getTokenBeforeClosingBracket(node) {
-  var attributes = node.attributes;
+  const attributes = node.attributes;
   if (attributes.length === 0) {
     return node.name;
   }
diff --git a/lib/util/makeNoMethodSetStateRule.js b/lib/util/makeNoMethodSetStateRule.js
index 28e014d114..361c8e27da 100644
--- a/lib/util/makeNoMethodSetStateRule.js
+++ b/lib/util/makeNoMethodSetStateRule.js
@@ -23,7 +23,7 @@ function makeNoMethodSetStateRule(methodName) {
     },
 
     create: function(context) {
-      var mode = context.options[0] || 'allow-in-func';
+      const mode = context.options[0] || 'allow-in-func';
 
       // --------------------------------------------------------------------------
       // Public
@@ -32,7 +32,7 @@ function makeNoMethodSetStateRule(methodName) {
       return {
 
         CallExpression: function(node) {
-          var callee = node.callee;
+          const callee = node.callee;
           if (
             callee.type !== 'MemberExpression' ||
             callee.object.type !== 'ThisExpression' ||
@@ -40,9 +40,9 @@ function makeNoMethodSetStateRule(methodName) {
           ) {
             return;
           }
-          var ancestors = context.getAncestors(callee).reverse();
-          var depth = 0;
-          for (var i = 0, j = ancestors.length; i < j; i++) {
+          const ancestors = context.getAncestors(callee).reverse();
+          let depth = 0;
+          for (let i = 0, j = ancestors.length; i < j; i++) {
             if (/Function(Expression|Declaration)$/.test(ancestors[i].type)) {
               depth++;
             }
diff --git a/lib/util/pragma.js b/lib/util/pragma.js
index e982d6159f..ddaef20983 100644
--- a/lib/util/pragma.js
+++ b/lib/util/pragma.js
@@ -4,13 +4,13 @@
  */
 'use strict';
 
-var JSX_ANNOTATION_REGEX = /^\*\s*@jsx\s+([^\s]+)/;
+const JSX_ANNOTATION_REGEX = /^\*\s*@jsx\s+([^\s]+)/;
 // Does not check for reserved keywords or unicode characters
-var JS_IDENTIFIER_REGEX = /^[_$a-zA-Z][_$a-zA-Z0-9]*$/;
+const JS_IDENTIFIER_REGEX = /^[_$a-zA-Z][_$a-zA-Z0-9]*$/;
 
 
 function getCreateClassFromContext(context) {
-  var pragma = 'createReactClass';
+  let pragma = 'createReactClass';
   // .eslintrc shared settings (http://eslint.org/docs/user-guide/configuring#adding-shared-settings)
   if (context.settings.react && context.settings.react.createClass) {
     pragma = context.settings.react.createClass;
@@ -22,15 +22,15 @@ function getCreateClassFromContext(context) {
 }
 
 function getFromContext(context) {
-  var pragma = 'React';
+  let pragma = 'React';
 
-  var sourceCode = context.getSourceCode();
-  var pragmaNode = sourceCode.getAllComments().find(function(node) {
+  const sourceCode = context.getSourceCode();
+  const pragmaNode = sourceCode.getAllComments().find(function(node) {
     return JSX_ANNOTATION_REGEX.test(node.value);
   });
 
   if (pragmaNode) {
-    var matches = JSX_ANNOTATION_REGEX.exec(pragmaNode.value);
+    const matches = JSX_ANNOTATION_REGEX.exec(pragmaNode.value);
     pragma = matches[1].split('.')[0];
   // .eslintrc shared settings (http://eslint.org/docs/user-guide/configuring#adding-shared-settings)
   } else if (context.settings.react && context.settings.react.pragma) {
diff --git a/lib/util/variable.js b/lib/util/variable.js
index 6ec67c686e..1480210a52 100644
--- a/lib/util/variable.js
+++ b/lib/util/variable.js
@@ -37,8 +37,8 @@ function getVariable(variables, name) {
  * @returns {Array} The variables list
  */
 function variablesInScope(context) {
-  var scope = context.getScope();
-  var variables = scope.variables;
+  let scope = context.getScope();
+  let variables = scope.variables;
 
   while (scope.type !== 'global') {
     scope = scope.upper;
diff --git a/lib/util/version.js b/lib/util/version.js
index f173ed12e6..b9736758a8 100644
--- a/lib/util/version.js
+++ b/lib/util/version.js
@@ -5,7 +5,7 @@
 'use strict';
 
 function getFromContext(context) {
-  var confVer = '999.999.999';
+  let confVer = '999.999.999';
   // .eslintrc shared settings (http://eslint.org/docs/user-guide/configuring#adding-shared-settings)
   if (context.settings.react && context.settings.react.version) {
     confVer = context.settings.react.version;
@@ -17,13 +17,13 @@ function getFromContext(context) {
 }
 
 function test(context, methodVer) {
-  var confVer = getFromContext(context);
+  const confVer = getFromContext(context);
   methodVer = methodVer.split('.').map(function(part) {
     return Number(part);
   });
-  var higherMajor = methodVer[0] < confVer[0];
-  var higherMinor = methodVer[0] === confVer[0] && methodVer[1] < confVer[1];
-  var higherOrEqualPatch = methodVer[0] === confVer[0] && methodVer[1] === confVer[1] && methodVer[2] <= confVer[2];
+  const higherMajor = methodVer[0] < confVer[0];
+  const higherMinor = methodVer[0] === confVer[0] && methodVer[1] < confVer[1];
+  const higherOrEqualPatch = methodVer[0] === confVer[0] && methodVer[1] === confVer[1] && methodVer[2] <= confVer[2];
 
   return higherMajor || higherMinor || higherOrEqualPatch;
 }
diff --git a/tests/index.js b/tests/index.js
index 12411e6d15..970c42b6ef 100644
--- a/tests/index.js
+++ b/tests/index.js
@@ -1,13 +1,13 @@
 /* eslint-env mocha */
 'use strict';
 
-var plugin = require('..');
+const plugin = require('..');
 
-var assert = require('assert');
-var fs = require('fs');
-var path = require('path');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
 
-var ruleFiles = fs.readdirSync(path.resolve(__dirname, '../lib/rules/'))
+const ruleFiles = fs.readdirSync(path.resolve(__dirname, '../lib/rules/'))
   .map(function(f) {
     return path.basename(f, '.js');
   });
@@ -26,8 +26,8 @@ describe('all rule files should be exported by the plugin', function() {
 describe('deprecated rules', function() {
   it('marks all deprecated rules as deprecated', function() {
     ruleFiles.forEach(function(ruleName) {
-      var inDeprecatedRules = Boolean(plugin.deprecatedRules[ruleName]);
-      var isDeprecated = plugin.rules[ruleName].meta.deprecated;
+      const inDeprecatedRules = Boolean(plugin.deprecatedRules[ruleName]);
+      const isDeprecated = plugin.rules[ruleName].meta.deprecated;
       if (inDeprecatedRules) {
         assert(isDeprecated, `${ruleName} metadata should mark it as deprecated`);
       } else {
@@ -42,13 +42,13 @@ describe('configurations', function() {
     assert(plugin.configs.recommended);
     Object.keys(plugin.configs.recommended.rules).forEach(function (configName) {
       assert.equal(configName.indexOf('react/'), 0);
-      var ruleName = configName.substring('react/'.length);
+      const ruleName = configName.substring('react/'.length);
       assert(plugin.rules[ruleName]);
     });
 
     ruleFiles.forEach(function(ruleName) {
-      var inRecommendedConfig = Boolean(plugin.configs.recommended.rules[`react/${ruleName}`]);
-      var isRecommended = plugin.rules[ruleName].meta.docs.recommended;
+      const inRecommendedConfig = Boolean(plugin.configs.recommended.rules[`react/${ruleName}`]);
+      const isRecommended = plugin.rules[ruleName].meta.docs.recommended;
       if (inRecommendedConfig) {
         assert(isRecommended, `${ruleName} metadata should mark it as recommended`);
       } else {
@@ -63,8 +63,8 @@ describe('configurations', function() {
       assert.equal(plugin.configs.all.rules[configName], 2);
     });
     ruleFiles.forEach(function(ruleName) {
-      var inDeprecatedRules = Boolean(plugin.deprecatedRules[ruleName]);
-      var inAllConfig = Boolean(plugin.configs.all.rules[`react/${ruleName}`]);
+      const inDeprecatedRules = Boolean(plugin.deprecatedRules[ruleName]);
+      const inAllConfig = Boolean(plugin.configs.all.rules[`react/${ruleName}`]);
       assert(inDeprecatedRules ^ inAllConfig);
     });
   });
diff --git a/tests/lib/rules/default-props-match-prop-types.js b/tests/lib/rules/default-props-match-prop-types.js
index 9ea4b12a58..e7684558f4 100644
--- a/tests/lib/rules/default-props-match-prop-types.js
+++ b/tests/lib/rules/default-props-match-prop-types.js
@@ -9,12 +9,12 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/default-props-match-prop-types');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/default-props-match-prop-types');
+const RuleTester = require('eslint').RuleTester;
 
 require('babel-eslint');
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 6,
   sourceType: 'module',
   ecmaFeatures: {
@@ -23,7 +23,7 @@ var parserOptions = {
   }
 };
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 
 // ------------------------------------------------------------------------------
 // Tests
diff --git a/tests/lib/rules/display-name.js b/tests/lib/rules/display-name.js
index f11a005665..48c8f671b4 100644
--- a/tests/lib/rules/display-name.js
+++ b/tests/lib/rules/display-name.js
@@ -8,12 +8,12 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/display-name');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/display-name');
+const RuleTester = require('eslint').RuleTester;
 
 require('babel-eslint');
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('display-name', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/forbid-component-props.js b/tests/lib/rules/forbid-component-props.js
index ba4d2630ba..dc7012ab7f 100644
--- a/tests/lib/rules/forbid-component-props.js
+++ b/tests/lib/rules/forbid-component-props.js
@@ -7,10 +7,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/forbid-component-props');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/forbid-component-props');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,10 +25,10 @@ require('babel-eslint');
 // Tests
 // -----------------------------------------------------------------------------
 
-var CLASSNAME_ERROR_MESSAGE = 'Prop `className` is forbidden on Components';
-var STYLE_ERROR_MESSAGE = 'Prop `style` is forbidden on Components';
+const CLASSNAME_ERROR_MESSAGE = 'Prop `className` is forbidden on Components';
+const STYLE_ERROR_MESSAGE = 'Prop `style` is forbidden on Components';
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('forbid-component-props', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/forbid-elements.js b/tests/lib/rules/forbid-elements.js
index 080a441885..f9d0ca56c3 100644
--- a/tests/lib/rules/forbid-elements.js
+++ b/tests/lib/rules/forbid-elements.js
@@ -7,10 +7,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/forbid-elements');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/forbid-elements');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,7 +25,7 @@ require('babel-eslint');
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('forbid-elements', rule, {
   valid: [
     {
diff --git a/tests/lib/rules/forbid-foreign-prop-types.js b/tests/lib/rules/forbid-foreign-prop-types.js
index 74f4c89b30..6dcc03012c 100644
--- a/tests/lib/rules/forbid-foreign-prop-types.js
+++ b/tests/lib/rules/forbid-foreign-prop-types.js
@@ -7,10 +7,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/forbid-foreign-prop-types');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/forbid-foreign-prop-types');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,9 +25,9 @@ require('babel-eslint');
 // Tests
 // -----------------------------------------------------------------------------
 
-var ERROR_MESSAGE = 'Using another component\'s propTypes is forbidden';
+const ERROR_MESSAGE = 'Using another component\'s propTypes is forbidden';
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('forbid-foreign-prop-types', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/forbid-prop-types.js b/tests/lib/rules/forbid-prop-types.js
index 3cd9f2539b..604509beab 100644
--- a/tests/lib/rules/forbid-prop-types.js
+++ b/tests/lib/rules/forbid-prop-types.js
@@ -7,10 +7,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/forbid-prop-types');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/forbid-prop-types');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,12 +25,12 @@ require('babel-eslint');
 // Tests
 // -----------------------------------------------------------------------------
 
-var ANY_ERROR_MESSAGE = 'Prop type `any` is forbidden';
-var ARRAY_ERROR_MESSAGE = 'Prop type `array` is forbidden';
-var NUMBER_ERROR_MESSAGE = 'Prop type `number` is forbidden';
-var OBJECT_ERROR_MESSAGE = 'Prop type `object` is forbidden';
+const ANY_ERROR_MESSAGE = 'Prop type `any` is forbidden';
+const ARRAY_ERROR_MESSAGE = 'Prop type `array` is forbidden';
+const NUMBER_ERROR_MESSAGE = 'Prop type `number` is forbidden';
+const OBJECT_ERROR_MESSAGE = 'Prop type `object` is forbidden';
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('forbid-prop-types', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/jsx-boolean-value.js b/tests/lib/rules/jsx-boolean-value.js
index d737ef8d5f..90c0d7cc3d 100644
--- a/tests/lib/rules/jsx-boolean-value.js
+++ b/tests/lib/rules/jsx-boolean-value.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-boolean-value');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-boolean-value');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-boolean-value', rule, {
   valid: [
     {code: '<App foo />;', options: ['never']},
diff --git a/tests/lib/rules/jsx-closing-bracket-location.js b/tests/lib/rules/jsx-closing-bracket-location.js
index e84db0da7f..ab433ae986 100644
--- a/tests/lib/rules/jsx-closing-bracket-location.js
+++ b/tests/lib/rules/jsx-closing-bracket-location.js
@@ -8,9 +8,9 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-closing-bracket-location');
-var RuleTester = require('eslint').RuleTester;
-var parserOptions = {
+const rule = require('../../../lib/rules/jsx-closing-bracket-location');
+const RuleTester = require('eslint').RuleTester;
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -18,15 +18,15 @@ var parserOptions = {
     jsx: true
   }
 };
-var MESSAGE_AFTER_PROPS = [{message: 'The closing bracket must be placed after the last prop'}];
-var MESSAGE_AFTER_TAG = [{message: 'The closing bracket must be placed after the opening tag'}];
+const MESSAGE_AFTER_PROPS = [{message: 'The closing bracket must be placed after the last prop'}];
+const MESSAGE_AFTER_TAG = [{message: 'The closing bracket must be placed after the opening tag'}];
 
-var MESSAGE_PROPS_ALIGNED = 'The closing bracket must be aligned with the last prop';
-var MESSAGE_TAG_ALIGNED = 'The closing bracket must be aligned with the opening tag';
-var MESSAGE_LINE_ALIGNED = 'The closing bracket must be aligned with the line containing the opening tag';
+const MESSAGE_PROPS_ALIGNED = 'The closing bracket must be aligned with the last prop';
+const MESSAGE_TAG_ALIGNED = 'The closing bracket must be aligned with the opening tag';
+const MESSAGE_LINE_ALIGNED = 'The closing bracket must be aligned with the line containing the opening tag';
 
-var messageWithDetails = function(message, expectedColumn, expectedNextLine) {
-  var details = ` (expected column ${expectedColumn}${expectedNextLine ? ' on the next line)' : ')'}`;
+const messageWithDetails = function(message, expectedColumn, expectedNextLine) {
+  const details = ` (expected column ${expectedColumn}${expectedNextLine ? ' on the next line)' : ')'}`;
   return message + details;
 };
 
@@ -34,7 +34,7 @@ var messageWithDetails = function(message, expectedColumn, expectedNextLine) {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-closing-bracket-location', rule, {
   valid: [{
     code: [
diff --git a/tests/lib/rules/jsx-curly-spacing.js b/tests/lib/rules/jsx-curly-spacing.js
index a5da5215be..17fbcf1e94 100644
--- a/tests/lib/rules/jsx-curly-spacing.js
+++ b/tests/lib/rules/jsx-curly-spacing.js
@@ -9,9 +9,9 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-curly-spacing');
-var RuleTester = require('eslint').RuleTester;
-var parserOptions = {
+const rule = require('../../../lib/rules/jsx-curly-spacing');
+const RuleTester = require('eslint').RuleTester;
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-curly-spacing', rule, {
   valid: [{
     code: '<App foo={bar} />;'
diff --git a/tests/lib/rules/jsx-equals-spacing.js b/tests/lib/rules/jsx-equals-spacing.js
index a5edb4b518..af71e1919b 100644
--- a/tests/lib/rules/jsx-equals-spacing.js
+++ b/tests/lib/rules/jsx-equals-spacing.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-equals-spacing');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-equals-spacing');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-equals-spacing', rule, {
   valid: [{
     code: '<App />'
diff --git a/tests/lib/rules/jsx-filename-extension.js b/tests/lib/rules/jsx-filename-extension.js
index 5db5a69fee..d05f56a146 100644
--- a/tests/lib/rules/jsx-filename-extension.js
+++ b/tests/lib/rules/jsx-filename-extension.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-filename-extension');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-filename-extension');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,14 +24,14 @@ var parserOptions = {
 // Code Snippets
 // ------------------------------------------------------------------------------
 
-var withJSX = 'module.exports = function MyComponent() { return <div>\n<div />\n</div>; }';
-var withoutJSX = 'module.exports = {}';
+const withJSX = 'module.exports = function MyComponent() { return <div>\n<div />\n</div>; }';
+const withoutJSX = 'module.exports = {}';
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-filename-extension', rule, {
 
   valid: [
diff --git a/tests/lib/rules/jsx-first-prop-new-line.js b/tests/lib/rules/jsx-first-prop-new-line.js
index c40fccbbe9..8a8c80a1f9 100644
--- a/tests/lib/rules/jsx-first-prop-new-line.js
+++ b/tests/lib/rules/jsx-first-prop-new-line.js
@@ -8,10 +8,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-first-prop-new-line');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-first-prop-new-line');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-first-prop-new-line', rule, {
 
   valid: [
diff --git a/tests/lib/rules/jsx-handler-names.js b/tests/lib/rules/jsx-handler-names.js
index ee61f91f34..35010d26d5 100644
--- a/tests/lib/rules/jsx-handler-names.js
+++ b/tests/lib/rules/jsx-handler-names.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-handler-names');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-handler-names');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-handler-names', rule, {
   valid: [{
     code: [
diff --git a/tests/lib/rules/jsx-indent-props.js b/tests/lib/rules/jsx-indent-props.js
index 834a67b197..37616b09d2 100644
--- a/tests/lib/rules/jsx-indent-props.js
+++ b/tests/lib/rules/jsx-indent-props.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-indent-props');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-indent-props');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-indent-props', rule, {
   valid: [{
     code: [
diff --git a/tests/lib/rules/jsx-indent.js b/tests/lib/rules/jsx-indent.js
index be011a711b..a65dfad16f 100644
--- a/tests/lib/rules/jsx-indent.js
+++ b/tests/lib/rules/jsx-indent.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-indent');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-indent');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-indent', rule, {
   valid: [{
     code: [
diff --git a/tests/lib/rules/jsx-key.js b/tests/lib/rules/jsx-key.js
index df2a373f95..4bea4bd5ee 100644
--- a/tests/lib/rules/jsx-key.js
+++ b/tests/lib/rules/jsx-key.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-key');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-key');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-key', rule, {
   valid: [
     {code: 'fn()'},
diff --git a/tests/lib/rules/jsx-max-props-per-line.js b/tests/lib/rules/jsx-max-props-per-line.js
index 1966e5e657..7c5ae4817b 100644
--- a/tests/lib/rules/jsx-max-props-per-line.js
+++ b/tests/lib/rules/jsx-max-props-per-line.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-max-props-per-line');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-max-props-per-line');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-max-props-per-line', rule, {
   valid: [{
     code: '<App />'
diff --git a/tests/lib/rules/jsx-no-bind.js b/tests/lib/rules/jsx-no-bind.js
index 2d4ef2f7b2..8296f5e45d 100644
--- a/tests/lib/rules/jsx-no-bind.js
+++ b/tests/lib/rules/jsx-no-bind.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-no-bind');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-no-bind');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,7 +25,7 @@ var parserOptions = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-no-bind', rule, {
 
   valid: [
diff --git a/tests/lib/rules/jsx-no-comment-textnodes.js b/tests/lib/rules/jsx-no-comment-textnodes.js
index 99e3ee35f4..93aa0bb0af 100644
--- a/tests/lib/rules/jsx-no-comment-textnodes.js
+++ b/tests/lib/rules/jsx-no-comment-textnodes.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-no-comment-textnodes');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-no-comment-textnodes');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-no-comment-textnodes', rule, {
 
   valid: [
diff --git a/tests/lib/rules/jsx-no-duplicate-props.js b/tests/lib/rules/jsx-no-duplicate-props.js
index 6f42601682..1344391acb 100644
--- a/tests/lib/rules/jsx-no-duplicate-props.js
+++ b/tests/lib/rules/jsx-no-duplicate-props.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-no-duplicate-props');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-no-duplicate-props');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,14 +25,14 @@ var parserOptions = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 
-var expectedError = {
+const expectedError = {
   message: 'No duplicate props allowed',
   type: 'JSXAttribute'
 };
 
-var ignoreCaseArgs = [{
+const ignoreCaseArgs = [{
   ignoreCase: true
 }];
 
diff --git a/tests/lib/rules/jsx-no-literals.js b/tests/lib/rules/jsx-no-literals.js
index da832058e9..54a09a3661 100644
--- a/tests/lib/rules/jsx-no-literals.js
+++ b/tests/lib/rules/jsx-no-literals.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-no-literals');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-no-literals');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-no-literals', rule, {
 
   valid: [
diff --git a/tests/lib/rules/jsx-no-target-blank.js b/tests/lib/rules/jsx-no-target-blank.js
index c8ee8f17a6..ecd2c6d693 100644
--- a/tests/lib/rules/jsx-no-target-blank.js
+++ b/tests/lib/rules/jsx-no-target-blank.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-no-target-blank');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-no-target-blank');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-no-target-blank', rule, {
   valid: [
     {code: '<a href="foobar"></a>'},
diff --git a/tests/lib/rules/jsx-no-undef.js b/tests/lib/rules/jsx-no-undef.js
index 0d03628f9f..2efc51371c 100644
--- a/tests/lib/rules/jsx-no-undef.js
+++ b/tests/lib/rules/jsx-no-undef.js
@@ -9,11 +9,11 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var eslint = require('eslint');
-var rule = require('../../../lib/rules/jsx-no-undef');
-var RuleTester = eslint.RuleTester;
+const eslint = require('eslint');
+const rule = require('../../../lib/rules/jsx-no-undef');
+const RuleTester = eslint.RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   ecmaFeatures: {
     experimentalObjectRestSpread: true,
@@ -25,8 +25,8 @@ var parserOptions = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
-var linter = ruleTester.linter || eslint.linter;
+const ruleTester = new RuleTester({parserOptions});
+const linter = ruleTester.linter || eslint.linter;
 linter.defineRule('no-undef', require('eslint/lib/rules/no-undef'));
 ruleTester.run('jsx-no-undef', rule, {
   valid: [{
diff --git a/tests/lib/rules/jsx-pascal-case.js b/tests/lib/rules/jsx-pascal-case.js
index 1309b2b1b2..06a7b93f80 100644
--- a/tests/lib/rules/jsx-pascal-case.js
+++ b/tests/lib/rules/jsx-pascal-case.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-pascal-case');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-pascal-case');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-pascal-case', rule, {
   valid: [{
     code: '<testComponent />'
diff --git a/tests/lib/rules/jsx-sort-props.js b/tests/lib/rules/jsx-sort-props.js
index 472cb046f1..08628da9dc 100644
--- a/tests/lib/rules/jsx-sort-props.js
+++ b/tests/lib/rules/jsx-sort-props.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-sort-props');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-sort-props');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,74 +25,74 @@ var parserOptions = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 
-var expectedError = {
+const expectedError = {
   message: 'Props should be sorted alphabetically',
   type: 'JSXAttribute'
 };
-var expectedCallbackError = {
+const expectedCallbackError = {
   message: 'Callbacks must be listed after all other props',
   type: 'JSXAttribute'
 };
-var expectedShorthandFirstError = {
+const expectedShorthandFirstError = {
   message: 'Shorthand props must be listed before all other props',
   type: 'JSXAttribute'
 };
-var expectedShorthandLastError = {
+const expectedShorthandLastError = {
   message: 'Shorthand props must be listed after all other props',
   type: 'JSXAttribute'
 };
-var expectedReservedFirstError = {
+const expectedReservedFirstError = {
   message: 'Reserved props must be listed before all other props',
   type: 'JSXAttribute'
 };
-var expectedEmptyReservedFirstError = {
+const expectedEmptyReservedFirstError = {
   message: 'A customized reserved first list must not be empty'
 };
-var expectedInvalidReservedFirstError = {
+const expectedInvalidReservedFirstError = {
   message: 'A customized reserved first list must only contain a subset of React reserved props. Remove: notReserved'
 };
-var callbacksLastArgs = [{
+const callbacksLastArgs = [{
   callbacksLast: true
 }];
-var ignoreCaseAndCallbackLastArgs = [{
+const ignoreCaseAndCallbackLastArgs = [{
   callbacksLast: true,
   ignoreCase: true
 }];
-var shorthandFirstArgs = [{
+const shorthandFirstArgs = [{
   shorthandFirst: true
 }];
-var shorthandLastArgs = [{
+const shorthandLastArgs = [{
   shorthandLast: true
 }];
-var shorthandAndCallbackLastArgs = [{
+const shorthandAndCallbackLastArgs = [{
   callbacksLast: true,
   shorthandLast: true
 }];
-var ignoreCaseArgs = [{
+const ignoreCaseArgs = [{
   ignoreCase: true
 }];
-var noSortAlphabeticallyArgs = [{
+const noSortAlphabeticallyArgs = [{
   noSortAlphabetically: true
 }];
-var sortAlphabeticallyArgs = [{
+const sortAlphabeticallyArgs = [{
   noSortAlphabetically: false
 }];
-var reservedFirstAsBooleanArgs = [{
+const reservedFirstAsBooleanArgs = [{
   reservedFirst: true
 }];
-var reservedFirstAsArrayArgs = [{
+const reservedFirstAsArrayArgs = [{
   reservedFirst: ['children', 'dangerouslySetInnerHTML', 'key']
 }];
-var reservedFirstWithNoSortAlphabeticallyArgs = [{
+const reservedFirstWithNoSortAlphabeticallyArgs = [{
   noSortAlphabetically: true,
   reservedFirst: true
 }];
-var reservedFirstAsEmptyArrayArgs = [{
+const reservedFirstAsEmptyArrayArgs = [{
   reservedFirst: []
 }];
-var reservedFirstAsInvalidArrayArgs = [{
+const reservedFirstAsInvalidArrayArgs = [{
   reservedFirst: ['notReserved']
 }];
 
diff --git a/tests/lib/rules/jsx-space-before-closing.js b/tests/lib/rules/jsx-space-before-closing.js
index 0f31134d0b..ec24f5b8ab 100644
--- a/tests/lib/rules/jsx-space-before-closing.js
+++ b/tests/lib/rules/jsx-space-before-closing.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-space-before-closing');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-space-before-closing');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-space-before-closing', rule, {
   valid: [{
     code: '<App />'
diff --git a/tests/lib/rules/jsx-tag-spacing.js b/tests/lib/rules/jsx-tag-spacing.js
index 782f1044a2..beeefb8fa1 100644
--- a/tests/lib/rules/jsx-tag-spacing.js
+++ b/tests/lib/rules/jsx-tag-spacing.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-tag-spacing');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-tag-spacing');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -55,7 +55,7 @@ function afterOpeningOptions(option) {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-tag-spacing', rule, {
   valid: [{
     code: '<App />'
diff --git a/tests/lib/rules/jsx-uses-react.js b/tests/lib/rules/jsx-uses-react.js
index 33a7e64ebb..ac21864b2a 100644
--- a/tests/lib/rules/jsx-uses-react.js
+++ b/tests/lib/rules/jsx-uses-react.js
@@ -9,11 +9,11 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var eslint = require('eslint');
-var rule = require('eslint/lib/rules/no-unused-vars');
-var RuleTester = eslint.RuleTester;
+const eslint = require('eslint');
+const rule = require('eslint/lib/rules/no-unused-vars');
+const RuleTester = eslint.RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -22,7 +22,7 @@ var parserOptions = {
   }
 };
 
-var settings = {
+const settings = {
   react: {
     pragma: 'Foo'
   }
@@ -32,8 +32,8 @@ var settings = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
-var linter = ruleTester.linter || eslint.linter;
+const ruleTester = new RuleTester({parserOptions});
+const linter = ruleTester.linter || eslint.linter;
 linter.defineRule('jsx-uses-react', require('../../../lib/rules/jsx-uses-react'));
 ruleTester.run('no-unused-vars', rule, {
   valid: [
diff --git a/tests/lib/rules/jsx-uses-vars.js b/tests/lib/rules/jsx-uses-vars.js
index 28d56b53f8..ea5af70fe9 100644
--- a/tests/lib/rules/jsx-uses-vars.js
+++ b/tests/lib/rules/jsx-uses-vars.js
@@ -9,12 +9,12 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var eslint = require('eslint');
-var ruleNoUnusedVars = require('eslint/lib/rules/no-unused-vars');
-var rulePreferConst = require('eslint/lib/rules/prefer-const');
-var RuleTester = eslint.RuleTester;
+const eslint = require('eslint');
+const ruleNoUnusedVars = require('eslint/lib/rules/no-unused-vars');
+const rulePreferConst = require('eslint/lib/rules/prefer-const');
+const RuleTester = eslint.RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -29,8 +29,8 @@ require('babel-eslint');
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
-var linter = ruleTester.linter || eslint.linter;
+const ruleTester = new RuleTester({parserOptions});
+const linter = ruleTester.linter || eslint.linter;
 linter.defineRule('jsx-uses-vars', require('../../../lib/rules/jsx-uses-vars'));
 ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
   valid: [
diff --git a/tests/lib/rules/jsx-wrap-multilines.js b/tests/lib/rules/jsx-wrap-multilines.js
index 45e926b547..3d3b7bdc1d 100644
--- a/tests/lib/rules/jsx-wrap-multilines.js
+++ b/tests/lib/rules/jsx-wrap-multilines.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/jsx-wrap-multilines');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/jsx-wrap-multilines');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Code Snippets
 // ------------------------------------------------------------------------------
 
-var RETURN_SINGLE_LINE = `
+const RETURN_SINGLE_LINE = `
   var Hello = createReactClass({
     render: function() {
       return <p>Hello {this.props.name}</p>;
@@ -32,7 +32,7 @@ var RETURN_SINGLE_LINE = `
   });
 `;
 
-var RETURN_PAREN = `
+const RETURN_PAREN = `
   var Hello = createReactClass({
     render: function() {
       return (<div>
@@ -42,7 +42,7 @@ var RETURN_PAREN = `
   });
 `;
 
-var RETURN_NO_PAREN = `
+const RETURN_NO_PAREN = `
   var Hello = createReactClass({
     render: function() {
       return <div>
@@ -52,9 +52,9 @@ var RETURN_NO_PAREN = `
   });
 `;
 
-var DECLARATION_TERNARY_SINGLE_LINE = 'var hello = foo ? <p>Hello</p> : <p>Hi</p>;';
+const DECLARATION_TERNARY_SINGLE_LINE = 'var hello = foo ? <p>Hello</p> : <p>Hi</p>;';
 
-var DECLARATION_TERNARY_PAREN = `
+const DECLARATION_TERNARY_PAREN = `
   var hello = foo ? (<div>
     <p>Hello</p>
   </div>) : (<div>
@@ -62,7 +62,7 @@ var DECLARATION_TERNARY_PAREN = `
   </div>);
 `;
 
-var DECLARATION_TERNARY_NO_PAREN = `
+const DECLARATION_TERNARY_NO_PAREN = `
   var hello = foo ? <div>
     <p>Hello</p>
   </div> : <div>
@@ -70,9 +70,9 @@ var DECLARATION_TERNARY_NO_PAREN = `
   </div>;
 `;
 
-var ASSIGNMENT_TERNARY_SINGLE_LINE = 'var hello; hello = foo ? <p>Hello</p> : <p>Hi</p>;';
+const ASSIGNMENT_TERNARY_SINGLE_LINE = 'var hello; hello = foo ? <p>Hello</p> : <p>Hi</p>;';
 
-var ASSIGNMENT_TERNARY_PAREN = `
+const ASSIGNMENT_TERNARY_PAREN = `
   var hello;
   hello = foo ? (<div>
     <p>Hello</p>
@@ -81,7 +81,7 @@ var ASSIGNMENT_TERNARY_PAREN = `
   </div>);
 `;
 
-var ASSIGNMENT_TERNARY_NO_PAREN = `
+const ASSIGNMENT_TERNARY_NO_PAREN = `
   var hello;
   hello = foo ? <div>
     <p>Hello</p>
@@ -90,45 +90,45 @@ var ASSIGNMENT_TERNARY_NO_PAREN = `
   </div>;
 `;
 
-var DECLARATION_SINGLE_LINE = 'var hello = <p>Hello</p>;';
+const DECLARATION_SINGLE_LINE = 'var hello = <p>Hello</p>;';
 
-var DECLARATION_PAREN = `
+const DECLARATION_PAREN = `
   var hello = (<div>
     <p>Hello</p>
   </div>);
 `;
 
-var DECLARATION_NO_PAREN = `
+const DECLARATION_NO_PAREN = `
   var hello = <div>
     <p>Hello</p>
   </div>;
 `;
 
-var ASSIGNMENT_SINGLE_LINE = 'var hello; hello = <p>Hello</p>;';
+const ASSIGNMENT_SINGLE_LINE = 'var hello; hello = <p>Hello</p>;';
 
-var ASSIGNMENT_PAREN = `
+const ASSIGNMENT_PAREN = `
   var hello;
   hello = (<div>
     <p>Hello</p>
   </div>);
 `;
 
-var ASSIGNMENT_NO_PAREN = `
+const ASSIGNMENT_NO_PAREN = `
   var hello;
   hello = <div>
     <p>Hello</p>
   </div>;
 `;
 
-var ARROW_SINGLE_LINE = 'var hello = () => <p>Hello</p>;';
+const ARROW_SINGLE_LINE = 'var hello = () => <p>Hello</p>;';
 
-var ARROW_PAREN = `
+const ARROW_PAREN = `
   var hello = () => (<div>
     <p>Hello</p>
   </div>);
 `;
 
-var ARROW_NO_PAREN = `
+const ARROW_NO_PAREN = `
   var hello = () => <div>
     <p>Hello</p>
   </div>;
@@ -138,7 +138,7 @@ var ARROW_NO_PAREN = `
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('jsx-wrap-multilines', rule, {
 
   valid: [
diff --git a/tests/lib/rules/no-array-index-key.js b/tests/lib/rules/no-array-index-key.js
index fbf41deb8b..8251777008 100644
--- a/tests/lib/rules/no-array-index-key.js
+++ b/tests/lib/rules/no-array-index-key.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-array-index-key');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-array-index-key');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,7 +25,7 @@ var parserOptions = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-array-index-key', rule, {
   valid: [
     {code: '<Foo key="foo" />;'},
diff --git a/tests/lib/rules/no-children-prop.js b/tests/lib/rules/no-children-prop.js
index 3269ccc833..b47e141e1b 100644
--- a/tests/lib/rules/no-children-prop.js
+++ b/tests/lib/rules/no-children-prop.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-children-prop');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-children-prop');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -21,14 +21,14 @@ var parserOptions = {
   }
 };
 
-var JSX_ERROR = 'Do not pass children as props. Instead, nest children between the opening and closing tags.';
-var CREATE_ELEMENT_ERROR = 'Do not pass children as props. Instead, pass them as additional arguments to React.createElement.';
+const JSX_ERROR = 'Do not pass children as props. Instead, nest children between the opening and closing tags.';
+const CREATE_ELEMENT_ERROR = 'Do not pass children as props. Instead, pass them as additional arguments to React.createElement.';
 
 // -----------------------------------------------------------------------------
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-children-prop', rule, {
   valid: [
     {
diff --git a/tests/lib/rules/no-danger-with-children.js b/tests/lib/rules/no-danger-with-children.js
index de0a7abab7..954c345677 100644
--- a/tests/lib/rules/no-danger-with-children.js
+++ b/tests/lib/rules/no-danger-with-children.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-danger-with-children');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-danger-with-children');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-danger-with-children', rule, {
   valid: [
     {
diff --git a/tests/lib/rules/no-danger.js b/tests/lib/rules/no-danger.js
index 82722f70a9..a138144fa4 100644
--- a/tests/lib/rules/no-danger.js
+++ b/tests/lib/rules/no-danger.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-danger');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-danger');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,7 +25,7 @@ var parserOptions = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-danger', rule, {
   valid: [
     {code: '<App />;'},
diff --git a/tests/lib/rules/no-deprecated.js b/tests/lib/rules/no-deprecated.js
index 86aa688eeb..94b2f0a7d1 100644
--- a/tests/lib/rules/no-deprecated.js
+++ b/tests/lib/rules/no-deprecated.js
@@ -9,10 +9,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-deprecated');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-deprecated');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -27,7 +27,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-deprecated', rule, {
 
   valid: [
diff --git a/tests/lib/rules/no-did-mount-set-state.js b/tests/lib/rules/no-did-mount-set-state.js
index 16a328f229..49999db5a8 100644
--- a/tests/lib/rules/no-did-mount-set-state.js
+++ b/tests/lib/rules/no-did-mount-set-state.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-did-mount-set-state');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-did-mount-set-state');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-did-mount-set-state', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-did-update-set-state.js b/tests/lib/rules/no-did-update-set-state.js
index 7c24339c4c..610278b595 100644
--- a/tests/lib/rules/no-did-update-set-state.js
+++ b/tests/lib/rules/no-did-update-set-state.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-did-update-set-state');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-did-update-set-state');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-did-update-set-state', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-direct-mutation-state.js b/tests/lib/rules/no-direct-mutation-state.js
index 515944c76e..6886125cc5 100644
--- a/tests/lib/rules/no-direct-mutation-state.js
+++ b/tests/lib/rules/no-direct-mutation-state.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-direct-mutation-state');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-direct-mutation-state');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-direct-mutation-state', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-find-dom-node.js b/tests/lib/rules/no-find-dom-node.js
index 4c864ba064..8191af9e8f 100644
--- a/tests/lib/rules/no-find-dom-node.js
+++ b/tests/lib/rules/no-find-dom-node.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-find-dom-node');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-find-dom-node');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-find-dom-node', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-is-mounted.js b/tests/lib/rules/no-is-mounted.js
index 1c75b496c3..55f45b4110 100644
--- a/tests/lib/rules/no-is-mounted.js
+++ b/tests/lib/rules/no-is-mounted.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-is-mounted');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-is-mounted');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-is-mounted', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-multi-comp.js b/tests/lib/rules/no-multi-comp.js
index 9ae1264ae1..572cc7c053 100644
--- a/tests/lib/rules/no-multi-comp.js
+++ b/tests/lib/rules/no-multi-comp.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-multi-comp');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-multi-comp');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-multi-comp', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-redundant-should-component-update.js b/tests/lib/rules/no-redundant-should-component-update.js
index 64a267998e..3ae7280434 100644
--- a/tests/lib/rules/no-redundant-should-component-update.js
+++ b/tests/lib/rules/no-redundant-should-component-update.js
@@ -8,10 +8,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-redundant-should-component-update');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-redundant-should-component-update');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 6,
   ecmaFeatures: {
     experimentalObjectRestSpread: true,
@@ -27,7 +27,7 @@ function errorMessage(node) {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester();
+const ruleTester = new RuleTester();
 ruleTester.run('no-redundant-should-component-update', rule, {
   valid: [
     {
diff --git a/tests/lib/rules/no-render-return-value.js b/tests/lib/rules/no-render-return-value.js
index d49b4734ed..fba9541cb7 100644
--- a/tests/lib/rules/no-render-return-value.js
+++ b/tests/lib/rules/no-render-return-value.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-render-return-value');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-render-return-value');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-render-return-value', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-set-state.js b/tests/lib/rules/no-set-state.js
index 5787ba05c2..9effbd1c8f 100644
--- a/tests/lib/rules/no-set-state.js
+++ b/tests/lib/rules/no-set-state.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-set-state');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-set-state');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-set-state', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-string-refs.js b/tests/lib/rules/no-string-refs.js
index 64d3f7b49f..d1c0ac7540 100644
--- a/tests/lib/rules/no-string-refs.js
+++ b/tests/lib/rules/no-string-refs.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-string-refs');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-string-refs');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-refs', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/no-unescaped-entities.js b/tests/lib/rules/no-unescaped-entities.js
index cf2c190c69..6d0f0a186c 100644
--- a/tests/lib/rules/no-unescaped-entities.js
+++ b/tests/lib/rules/no-unescaped-entities.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-unescaped-entities');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-unescaped-entities');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-unescaped-entities', rule, {
 
   valid: [
diff --git a/tests/lib/rules/no-unknown-property.js b/tests/lib/rules/no-unknown-property.js
index d861081dc9..eb079fd614 100644
--- a/tests/lib/rules/no-unknown-property.js
+++ b/tests/lib/rules/no-unknown-property.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-unknown-property');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-unknown-property');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,7 +25,7 @@ var parserOptions = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-unknown-property', rule, {
   valid: [
     {code: '<App class="bar" />;'},
diff --git a/tests/lib/rules/no-unused-prop-types.js b/tests/lib/rules/no-unused-prop-types.js
index a028683614..1984159c2f 100644
--- a/tests/lib/rules/no-unused-prop-types.js
+++ b/tests/lib/rules/no-unused-prop-types.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-unused-prop-types');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-unused-prop-types');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -20,7 +20,7 @@ var parserOptions = {
   }
 };
 
-var settings = {
+const settings = {
   react: {
     pragma: 'Foo'
   }
@@ -32,7 +32,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-unused-prop-types', rule, {
 
   valid: [
diff --git a/tests/lib/rules/no-will-update-set-state.js b/tests/lib/rules/no-will-update-set-state.js
index 0450261bc4..3b6fdf3a67 100644
--- a/tests/lib/rules/no-will-update-set-state.js
+++ b/tests/lib/rules/no-will-update-set-state.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/no-will-update-set-state');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-will-update-set-state');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('no-will-update-set-state', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/prefer-es6-class.js b/tests/lib/rules/prefer-es6-class.js
index 1f39cdeb4e..cee4e7172d 100644
--- a/tests/lib/rules/prefer-es6-class.js
+++ b/tests/lib/rules/prefer-es6-class.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/prefer-es6-class');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/prefer-es6-class');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('prefer-es6-class', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/prefer-stateless-function.js b/tests/lib/rules/prefer-stateless-function.js
index e27a0b8dab..0f1768f2cd 100644
--- a/tests/lib/rules/prefer-stateless-function.js
+++ b/tests/lib/rules/prefer-stateless-function.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/prefer-stateless-function');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/prefer-stateless-function');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('prefer-stateless-function', rule, {
 
   valid: [
diff --git a/tests/lib/rules/prop-types.js b/tests/lib/rules/prop-types.js
index e5d1138463..bc6ec6fefd 100644
--- a/tests/lib/rules/prop-types.js
+++ b/tests/lib/rules/prop-types.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/prop-types');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/prop-types');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -20,7 +20,7 @@ var parserOptions = {
   }
 };
 
-var settings = {
+const settings = {
   react: {
     pragma: 'Foo'
   }
@@ -32,7 +32,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('prop-types', rule, {
 
   valid: [
diff --git a/tests/lib/rules/react-in-jsx-scope.js b/tests/lib/rules/react-in-jsx-scope.js
index 8e8d97ffa1..20694149a7 100644
--- a/tests/lib/rules/react-in-jsx-scope.js
+++ b/tests/lib/rules/react-in-jsx-scope.js
@@ -9,10 +9,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/react-in-jsx-scope');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/react-in-jsx-scope');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -21,7 +21,7 @@ var parserOptions = {
   }
 };
 
-var settings = {
+const settings = {
   react: {
     pragma: 'Foo'
   }
@@ -31,7 +31,7 @@ var settings = {
 // Tests
 // -----------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('react-in-jsx-scope', rule, {
   valid: [
     {code: 'var React, App; <App />;'},
diff --git a/tests/lib/rules/require-default-props.js b/tests/lib/rules/require-default-props.js
index 8ed8f7d37a..b19b2b452d 100644
--- a/tests/lib/rules/require-default-props.js
+++ b/tests/lib/rules/require-default-props.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/require-default-props');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/require-default-props');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -22,7 +22,7 @@ var parserOptions = {
 
 require('babel-eslint');
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 
 // ------------------------------------------------------------------------------
 // Tests
diff --git a/tests/lib/rules/require-optimization.js b/tests/lib/rules/require-optimization.js
index 49fad7e6fa..089a83c12f 100644
--- a/tests/lib/rules/require-optimization.js
+++ b/tests/lib/rules/require-optimization.js
@@ -4,10 +4,10 @@
  */
 'use strict';
 
-var rule = require('../../../lib/rules/require-optimization');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/require-optimization');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -16,9 +16,9 @@ var parserOptions = {
   }
 };
 
-var MESSAGE = 'Component is not optimized. Please add a shouldComponentUpdate method.';
+const MESSAGE = 'Component is not optimized. Please add a shouldComponentUpdate method.';
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('react-require-optimization', rule, {
   valid: [{
     code: [
diff --git a/tests/lib/rules/require-render-return.js b/tests/lib/rules/require-render-return.js
index be4d374450..b3d7d585b8 100644
--- a/tests/lib/rules/require-render-return.js
+++ b/tests/lib/rules/require-render-return.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/require-render-return');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/require-render-return');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('require-render-return', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/self-closing-comp.js b/tests/lib/rules/self-closing-comp.js
index 80082b7a40..d1b9cad0c5 100644
--- a/tests/lib/rules/self-closing-comp.js
+++ b/tests/lib/rules/self-closing-comp.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/self-closing-comp');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/self-closing-comp');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('self-closing-comp', rule, {
 
   valid: [
diff --git a/tests/lib/rules/sort-comp.js b/tests/lib/rules/sort-comp.js
index b4fe1a306f..f123fe0c2e 100644
--- a/tests/lib/rules/sort-comp.js
+++ b/tests/lib/rules/sort-comp.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/sort-comp');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/sort-comp');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -26,7 +26,7 @@ require('babel-eslint');
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('sort-comp', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/sort-prop-types.js b/tests/lib/rules/sort-prop-types.js
index 9fcc7a6c55..ce97b0a07c 100644
--- a/tests/lib/rules/sort-prop-types.js
+++ b/tests/lib/rules/sort-prop-types.js
@@ -7,10 +7,10 @@
 // Requirements
 // -----------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/sort-prop-types');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/sort-prop-types');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -25,9 +25,9 @@ require('babel-eslint');
 // Tests
 // -----------------------------------------------------------------------------
 
-var ERROR_MESSAGE = 'Prop types declarations should be sorted alphabetically';
+const ERROR_MESSAGE = 'Prop types declarations should be sorted alphabetically';
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('sort-prop-types', rule, {
 
   valid: [{
diff --git a/tests/lib/rules/style-prop-object.js b/tests/lib/rules/style-prop-object.js
index 880cd99a27..c44c9d7dfb 100644
--- a/tests/lib/rules/style-prop-object.js
+++ b/tests/lib/rules/style-prop-object.js
@@ -8,10 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-var rule = require('../../../lib/rules/style-prop-object');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/style-prop-object');
+const RuleTester = require('eslint').RuleTester;
 
-var parserOptions = {
+const parserOptions = {
   ecmaVersion: 8,
   sourceType: 'module',
   ecmaFeatures: {
@@ -24,7 +24,7 @@ var parserOptions = {
 // Tests
 // ------------------------------------------------------------------------------
 
-var ruleTester = new RuleTester({parserOptions});
+const ruleTester = new RuleTester({parserOptions});
 ruleTester.run('style-prop-object', rule, {
   valid: [
     {