Add babel semi (babel/eslint-plugin-babel#121)

* Add semi from eslint

* Add ClassProperty support to semi rule

Fixes babel/eslint-plugin-babel#43

eslint/babel-eslint-plugin/README.md

@@ -32,7 +32,8 @@ original ones as well!).
     "babel/object-curly-spacing": 1,
     "babel/no-await-in-loop": 1,
     "babel/flow-object-type": 1,
-    "babel/no-invalid-this": 1
+    "babel/no-invalid-this": 1,
+    "babel/semi": 1
   }
 }
 ```
@@ -45,6 +46,7 @@ Each rule corresponds to a core `eslint` rule, and has the same options.
 - `babel/new-cap`: Ignores capitalized decorators (`@Decorator`)
 - `babel/object-curly-spacing`: doesn't complain about `export x from "mod";` or `export * as x from "mod";` (🛠 )
 - `babel/no-invalid-this`: doesn't fail when inside class properties (`class A { a = this.b; }`)
+- `babel/semi`: Includes class properties (🛠 )
 
 The following rules are not in `eslint`, but are relevant only to syntax that is not specified by
 the current JavaScript standard or supported by `eslint`.

eslint/babel-eslint-plugin/index.js

@@ -12,6 +12,7 @@ module.exports = {
     'flow-object-type': require('./rules/flow-object-type'),
     'func-params-comma-dangle': require('./rules/func-params-comma-dangle'),
     'no-invalid-this': require('./rules/no-invalid-this'),
+    'semi': require('./rules/semi'),
   },
   rulesConfig: {
     'generator-star-spacing': 0,
@@ -24,5 +25,6 @@ module.exports = {
     'flow-object-type': 0,
     'func-params-comma-dangle': 0,
     'no-invalid-this': 0,
+    'semi': 0,
   }
 };

eslint/babel-eslint-plugin/rules/semi.js

@@ -0,0 +1,225 @@
+/**
+ * @fileoverview Rule to flag missing semicolons.
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "require or disallow semicolons instead of ASI",
+            category: "Stylistic Issues",
+            recommended: false
+        },
+
+        fixable: "code",
+
+        schema: {
+            anyOf: [
+                {
+                    type: "array",
+                    items: [
+                        {
+                            enum: ["never"]
+                        }
+                    ],
+                    minItems: 0,
+                    maxItems: 1
+                },
+                {
+                    type: "array",
+                    items: [
+                        {
+                            enum: ["always"]
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                omitLastInOneLineBlock: { type: "boolean" }
+                            },
+                            additionalProperties: false
+                        }
+                    ],
+                    minItems: 0,
+                    maxItems: 2
+                }
+            ]
+        }
+    },
+
+    create(context) {
+
+        const OPT_OUT_PATTERN = /^[-[(/+`]/; // One of [(/+-`
+        const options = context.options[1];
+        const never = context.options[0] === "never",
+            exceptOneLine = options && options.omitLastInOneLineBlock === true,
+            sourceCode = context.getSourceCode();
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        /**
+         * Reports a semicolon error with appropriate location and message.
+         * @param {ASTNode} node The node with an extra or missing semicolon.
+         * @param {boolean} missing True if the semicolon is missing.
+         * @returns {void}
+         */
+        function report(node, missing) {
+            const lastToken = sourceCode.getLastToken(node);
+            let message,
+                fix,
+                loc = lastToken.loc;
+
+            if (!missing) {
+                message = "Missing semicolon.";
+                loc = loc.end;
+                fix = function(fixer) {
+                    return fixer.insertTextAfter(lastToken, ";");
+                };
+            } else {
+                message = "Extra semicolon.";
+                loc = loc.start;
+                fix = function(fixer) {
+                    return fixer.remove(lastToken);
+                };
+            }
+
+            context.report({
+                node,
+                loc,
+                message,
+                fix
+            });
+
+        }
+
+        /**
+         * Checks whether a token is a semicolon punctuator.
+         * @param {Token} token The token.
+         * @returns {boolean} True if token is a semicolon punctuator.
+         */
+        function isSemicolon(token) {
+            return (token.type === "Punctuator" && token.value === ";");
+        }
+
+        /**
+         * Check if a semicolon is unnecessary, only true if:
+         *   - next token is on a new line and is not one of the opt-out tokens
+         *   - next token is a valid statement divider
+         * @param {Token} lastToken last token of current node.
+         * @returns {boolean} whether the semicolon is unnecessary.
+         */
+        function isUnnecessarySemicolon(lastToken) {
+            if (!isSemicolon(lastToken)) {
+                return false;
+            }
+
+            const nextToken = sourceCode.getTokenAfter(lastToken);
+
+            if (!nextToken) {
+                return true;
+            }
+
+            const lastTokenLine = lastToken.loc.end.line;
+            const nextTokenLine = nextToken.loc.start.line;
+            const isOptOutToken = OPT_OUT_PATTERN.test(nextToken.value) && nextToken.value !== "++" && nextToken.value !== "--";
+            const isDivider = (nextToken.value === "}" || nextToken.value === ";");
+
+            return (lastTokenLine !== nextTokenLine && !isOptOutToken) || isDivider;
+        }
+
+        /**
+         * Checks a node to see if it's in a one-liner block statement.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} whether the node is in a one-liner block statement.
+         */
+        function isOneLinerBlock(node) {
+            const nextToken = sourceCode.getTokenAfter(node);
+
+            if (!nextToken || nextToken.value !== "}") {
+                return false;
+            }
+
+            const parent = node.parent;
+
+            return parent && parent.type === "BlockStatement" &&
+              parent.loc.start.line === parent.loc.end.line;
+        }
+
+        /**
+         * Checks a node to see if it's followed by a semicolon.
+         * @param {ASTNode} node The node to check.
+         * @returns {void}
+         */
+        function checkForSemicolon(node) {
+            const lastToken = sourceCode.getLastToken(node);
+
+            if (never) {
+                if (isUnnecessarySemicolon(lastToken)) {
+                    report(node, true);
+                }
+            } else {
+                if (!isSemicolon(lastToken)) {
+                    if (!exceptOneLine || !isOneLinerBlock(node)) {
+                        report(node);
+                    }
+                } else {
+                    if (exceptOneLine && isOneLinerBlock(node)) {
+                        report(node, true);
+                    }
+                }
+            }
+        }
+
+        /**
+         * Checks to see if there's a semicolon after a variable declaration.
+         * @param {ASTNode} node The node to check.
+         * @returns {void}
+         */
+        function checkForSemicolonForVariableDeclaration(node) {
+            const ancestors = context.getAncestors(),
+                parentIndex = ancestors.length - 1,
+                parent = ancestors[parentIndex];
+
+            if ((parent.type !== "ForStatement" || parent.init !== node) &&
+                (!/^For(?:In|Of)Statement/.test(parent.type) || parent.left !== node)
+            ) {
+                checkForSemicolon(node);
+            }
+        }
+
+        //--------------------------------------------------------------------------
+        // Public API
+        //--------------------------------------------------------------------------
+
+        return {
+            VariableDeclaration: checkForSemicolonForVariableDeclaration,
+            ExpressionStatement: checkForSemicolon,
+            ReturnStatement: checkForSemicolon,
+            ThrowStatement: checkForSemicolon,
+            DoWhileStatement: checkForSemicolon,
+            DebuggerStatement: checkForSemicolon,
+            BreakStatement: checkForSemicolon,
+            ContinueStatement: checkForSemicolon,
+            ImportDeclaration: checkForSemicolon,
+            ExportAllDeclaration: checkForSemicolon,
+            ClassProperty: checkForSemicolon,
+            ExportNamedDeclaration(node) {
+                if (!node.declaration) {
+                    checkForSemicolon(node);
+                }
+            },
+            ExportDefaultDeclaration(node) {
+                if (!/(?:Class|Function)Declaration/.test(node.declaration.type)) {
+                    checkForSemicolon(node);
+                }
+            }
+        };
+
+    }
+};

eslint/babel-eslint-plugin/tests/rules/semi.js

@@ -0,0 +1,191 @@
+/* eslnit-disable */
+/**
+ * @fileoverview Tests for semi rule.
+ * @author Nicholas C. Zakas
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const rule = require("../../rules/semi"),
+    RuleTester = require("../RuleTester");
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("semi", rule, {
+    valid: [
+        "var x = 5;",
+        "var x =5, y;",
+        "foo();",
+        "x = foo();",
+        "setTimeout(function() {foo = \"bar\"; });",
+        "setTimeout(function() {foo = \"bar\";});",
+        "for (var a in b){}",
+        "for (var i;;){}",
+        "if (true) {}\n;[global, extended].forEach(function(){});",
+        "throw new Error('foo');",
+        { code: "throw new Error('foo')", options: ["never"] },
+        { code: "var x = 5", options: ["never"] },
+        { code: "var x =5, y", options: ["never"] },
+        { code: "foo()", options: ["never"] },
+        { code: "debugger", options: ["never"] },
+        { code: "for (var a in b){}", options: ["never"] },
+        { code: "for (var i;;){}", options: ["never"] },
+        { code: "x = foo()", options: ["never"] },
+        { code: "if (true) {}\n;[global, extended].forEach(function(){})", options: ["never"] },
+        { code: "(function bar() {})\n;(function foo(){})", options: ["never"] },
+        { code: ";/foo/.test('bar')", options: ["never"] },
+        { code: ";+5", options: ["never"] },
+        { code: ";-foo()", options: ["never"] },
+        { code: "a++\nb++", options: ["never"] },
+        { code: "a++; b++", options: ["never"] },
+        { code: "for (let thing of {}) {\n  console.log(thing);\n}", parserOptions: { ecmaVersion: 6 } },
+        { code: "do{}while(true)", options: ["never"] },
+        { code: "do{}while(true);", options: ["always"] },
+
+        { code: "if (foo) { bar() }", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "if (foo) { bar(); baz() }", options: ["always", { omitLastInOneLineBlock: true }] },
+
+
+        // method definitions don't have a semicolon.
+        { code: "class A { a() {} b() {} }", parserOptions: { ecmaVersion: 6 } },
+        { code: "var A = class { a() {} b() {} };", parserOptions: { ecmaVersion: 6 } },
+
+        { code: "import theDefault, { named1, named2 } from 'src/mylib';", parserOptions: { sourceType: "module" } },
+        { code: "import theDefault, { named1, named2 } from 'src/mylib'", options: ["never"], parserOptions: { sourceType: "module" } },
+
+        // exports, "always"
+        { code: "export * from 'foo';", parserOptions: { sourceType: "module" } },
+        { code: "export { foo } from 'foo';", parserOptions: { sourceType: "module" } },
+        { code: "export { foo };", parserOptions: { sourceType: "module" } },
+        { code: "export var foo;", parserOptions: { sourceType: "module" } },
+        { code: "export function foo () { }", parserOptions: { sourceType: "module" } },
+        { code: "export function* foo () { }", parserOptions: { sourceType: "module" } },
+        { code: "export class Foo { }", parserOptions: { sourceType: "module" } },
+        { code: "export let foo;", parserOptions: { sourceType: "module" } },
+        { code: "export const FOO = 42;", parserOptions: { sourceType: "module" } },
+        { code: "export default function() { }", parserOptions: { sourceType: "module" } },
+        { code: "export default function* () { }", parserOptions: { sourceType: "module" } },
+        { code: "export default class { }", parserOptions: { sourceType: "module" } },
+        { code: "export default foo || bar;", parserOptions: { sourceType: "module" } },
+        { code: "export default (foo) => foo.bar();", parserOptions: { sourceType: "module" } },
+        { code: "export default foo = 42;", parserOptions: { sourceType: "module" } },
+        { code: "export default foo += 42;", parserOptions: { sourceType: "module" } },
+
+        // exports, "never"
+        { code: "export * from 'foo'", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export { foo } from 'foo'", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export { foo }", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export var foo", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export function foo () { }", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export function* foo () { }", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export class Foo { }", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export let foo", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export const FOO = 42", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export default function() { }", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export default function* () { }", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export default class { }", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export default foo || bar", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export default (foo) => foo.bar()", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export default foo = 42", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "export default foo += 42", options: ["never"], parserOptions: { sourceType: "module" } },
+        { code: "++\nfoo;", options: ["always"] },
+        { code: "var a = b;\n+ c", options: ["never"] },
+
+        // https://github.com/eslint/eslint/issues/7782
+        { code: "var a = b;\n/foo/.test(c)", options: ["never"] },
+        { code: "var a = b;\n`foo`", options: ["never"], parserOptions: { ecmaVersion: 6 } },
+
+        // babel
+        "class Foo { bar = 'example'; }",
+        "class Foo { static bar = 'example'; }",
+
+        // babel, "never"
+        { code: "class Foo { bar = 'example' }", options: ["never"] },
+        { code: "class Foo { static bar = 'example' }", options: ["never"] }
+    ],
+    invalid: [
+        { code: "import * as utils from './utils'", output: "import * as utils from './utils';", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ImportDeclaration", column: 33 }] },
+        { code: "import { square, diag } from 'lib'", output: "import { square, diag } from 'lib';", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ImportDeclaration" }] },
+        { code: "import { default as foo } from 'lib'", output: "import { default as foo } from 'lib';", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ImportDeclaration" }] },
+        { code: "import 'src/mylib'", output: "import 'src/mylib';", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ImportDeclaration" }] },
+        { code: "import theDefault, { named1, named2 } from 'src/mylib'", output: "import theDefault, { named1, named2 } from 'src/mylib';", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ImportDeclaration" }] },
+        { code: "function foo() { return [] }", output: "function foo() { return []; }", errors: [{ message: "Missing semicolon.", type: "ReturnStatement" }] },
+        { code: "while(true) { break }", output: "while(true) { break; }", errors: [{ message: "Missing semicolon.", type: "BreakStatement" }] },
+        { code: "while(true) { continue }", output: "while(true) { continue; }", errors: [{ message: "Missing semicolon.", type: "ContinueStatement" }] },
+        { code: "let x = 5", output: "let x = 5;", parserOptions: { ecmaVersion: 6 }, errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "var x = 5", output: "var x = 5;", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "var x = 5, y", output: "var x = 5, y;", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "debugger", output: "debugger;", errors: [{ message: "Missing semicolon.", type: "DebuggerStatement" }] },
+        { code: "foo()", output: "foo();", errors: [{ message: "Missing semicolon.", type: "ExpressionStatement" }] },
+        { code: "var x = 5, y", output: "var x = 5, y;", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "for (var a in b) var i ", output: "for (var a in b) var i; ", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "for (;;){var i}", output: "for (;;){var i;}", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "for (;;) var i ", output: "for (;;) var i; ", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "for (var j;;) {var i}", output: "for (var j;;) {var i;}", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "var foo = {\n bar: baz\n}", output: "var foo = {\n bar: baz\n};", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration", line: 3 }] },
+        { code: "var foo\nvar bar;", output: "var foo;\nvar bar;", errors: [{ message: "Missing semicolon.", type: "VariableDeclaration", line: 1 }] },
+        { code: "throw new Error('foo')", output: "throw new Error('foo');", errors: [{ message: "Missing semicolon.", type: "ThrowStatement", line: 1 }] },
+        { code: "do{}while(true)", output: "do{}while(true);", errors: [{ message: "Missing semicolon.", type: "DoWhileStatement", line: 1 }] },
+
+        { code: "throw new Error('foo');", output: "throw new Error('foo')", options: ["never"], errors: [{ message: "Extra semicolon.", type: "ThrowStatement", column: 23 }] },
+        { code: "function foo() { return []; }", output: "function foo() { return [] }", options: ["never"], errors: [{ message: "Extra semicolon.", type: "ReturnStatement" }] },
+        { code: "while(true) { break; }", output: "while(true) { break }", options: ["never"], errors: [{ message: "Extra semicolon.", type: "BreakStatement" }] },
+        { code: "while(true) { continue; }", output: "while(true) { continue }", options: ["never"], errors: [{ message: "Extra semicolon.", type: "ContinueStatement" }] },
+        { code: "let x = 5;", output: "let x = 5", parserOptions: { ecmaVersion: 6 }, options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "var x = 5;", output: "var x = 5", options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "var x = 5, y;", output: "var x = 5, y", options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "debugger;", output: "debugger", options: ["never"], errors: [{ message: "Extra semicolon.", type: "DebuggerStatement" }] },
+        { code: "foo();", output: "foo()", options: ["never"], errors: [{ message: "Extra semicolon.", type: "ExpressionStatement" }] },
+        { code: "var x = 5, y;", output: "var x = 5, y", options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "for (var a in b) var i; ", output: "for (var a in b) var i ", options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "for (;;){var i;}", output: "for (;;){var i}", options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "for (;;) var i; ", output: "for (;;) var i ", options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "for (var j;;) {var i;}", output: "for (var j;;) {var i}", options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "var foo = {\n bar: baz\n};", output: "var foo = {\n bar: baz\n}", options: ["never"], errors: [{ message: "Extra semicolon.", type: "VariableDeclaration", line: 3 }] },
+        { code: "import theDefault, { named1, named2 } from 'src/mylib';", output: "import theDefault, { named1, named2 } from 'src/mylib'", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "ImportDeclaration" }] },
+        { code: "do{}while(true);", output: "do{}while(true)", options: ["never"], errors: [{ message: "Extra semicolon.", type: "DoWhileStatement", line: 1 }] },
+
+        { code: "if (foo) { bar()\n }", options: ["always", { omitLastInOneLineBlock: true }], errors: [{ message: "Missing semicolon." }] },
+        { code: "if (foo) {\n bar() }", options: ["always", { omitLastInOneLineBlock: true }], errors: [{ message: "Missing semicolon." }] },
+        { code: "if (foo) {\n bar(); baz() }", options: ["always", { omitLastInOneLineBlock: true }], errors: [{ message: "Missing semicolon." }] },
+        { code: "if (foo) { bar(); }", options: ["always", { omitLastInOneLineBlock: true }], errors: [{ message: "Extra semicolon." }] },
+
+
+        // exports, "always"
+        { code: "export * from 'foo'", output: "export * from 'foo';", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ExportAllDeclaration" }] },
+        { code: "export { foo } from 'foo'", output: "export { foo } from 'foo';", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ExportNamedDeclaration" }] },
+        { code: "export { foo }", output: "export { foo };", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ExportNamedDeclaration" }] },
+        { code: "export var foo", output: "export var foo;", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "export let foo", output: "export let foo;", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "export const FOO = 42", output: "export const FOO = 42;", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "VariableDeclaration" }] },
+        { code: "export default foo || bar", output: "export default foo || bar;", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ExportDefaultDeclaration" }] },
+        { code: "export default (foo) => foo.bar()", output: "export default (foo) => foo.bar();", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ExportDefaultDeclaration" }] },
+        { code: "export default foo = 42", output: "export default foo = 42;", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ExportDefaultDeclaration" }] },
+        { code: "export default foo += 42", output: "export default foo += 42;", parserOptions: { sourceType: "module" }, errors: [{ message: "Missing semicolon.", type: "ExportDefaultDeclaration" }] },
+
+        // exports, "never"
+        { code: "export * from 'foo';", output: "export * from 'foo'", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "ExportAllDeclaration" }] },
+        { code: "export { foo } from 'foo';", output: "export { foo } from 'foo'", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "ExportNamedDeclaration" }] },
+        { code: "export { foo };", output: "export { foo }", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "ExportNamedDeclaration" }] },
+        { code: "export var foo;", output: "export var foo", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "export let foo;", output: "export let foo", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "export const FOO = 42;", output: "export const FOO = 42", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "VariableDeclaration" }] },
+        { code: "export default foo || bar;", output: "export default foo || bar", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "ExportDefaultDeclaration" }] },
+        { code: "export default (foo) => foo.bar();", output: "export default (foo) => foo.bar()", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "ExportDefaultDeclaration" }] },
+        { code: "export default foo = 42;", output: "export default foo = 42", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "ExportDefaultDeclaration" }] },
+        { code: "export default foo += 42;", output: "export default foo += 42", options: ["never"], parserOptions: { sourceType: "module" }, errors: [{ message: "Extra semicolon.", type: "ExportDefaultDeclaration" }] },
+        { code: "a;\n++b", output: "a\n++b", options: ["never"], errors: [{ message: "Extra semicolon." }] },
+
+        // babel
+        { code: "class Foo { bar = 'example' }", errors: [{ message: "Missing semicolon." }] },
+        { code: "class Foo { static bar = 'example' }", errors: [{ message: "Missing semicolon." }] },
+
+        // babel, "never"
+        { code: "class Foo { bar = 'example'; }", options: ["never"], errors: [{ message: "Extra semicolon." }] },
+        { code: "class Foo { static bar = 'example'; }", options: ["never"], errors: [{ message: "Extra semicolon." }] }
+    ]
+});