mirror of
https://git.proxmox.com/git/pve-eslint
synced 2025-08-24 22:28:47 +00:00
824 lines
26 KiB
JavaScript
824 lines
26 KiB
JavaScript
/**
|
|
* @fileoverview Tests for arrow-body-style
|
|
* @author Alberto Rodríguez
|
|
*/
|
|
"use strict";
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const rule = require("../../../lib/rules/arrow-body-style"),
|
|
{ RuleTester } = require("../../../lib/rule-tester");
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Tests
|
|
//------------------------------------------------------------------------------
|
|
|
|
const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
|
|
|
|
ruleTester.run("arrow-body-style", rule, {
|
|
valid: [
|
|
"var foo = () => {};",
|
|
"var foo = () => 0;",
|
|
"var addToB = (a) => { b = b + a };",
|
|
"var foo = () => { /* do nothing */ };",
|
|
"var foo = () => {\n /* do nothing */ \n};",
|
|
"var foo = (retv, name) => {\nretv[name] = true;\nreturn retv;\n};",
|
|
"var foo = () => ({});",
|
|
"var foo = () => bar();",
|
|
"var foo = () => { bar(); };",
|
|
"var foo = () => { b = a };",
|
|
"var foo = () => { bar: 1 };",
|
|
{ code: "var foo = () => { return 0; };", options: ["always"] },
|
|
{ code: "var foo = () => { return bar(); };", options: ["always"] },
|
|
{ code: "var foo = () => 0;", options: ["never"] },
|
|
{ code: "var foo = () => ({ foo: 0 });", options: ["never"] },
|
|
{ code: "var foo = () => {};", options: ["as-needed", { requireReturnForObjectLiteral: true }] },
|
|
{ code: "var foo = () => 0;", options: ["as-needed", { requireReturnForObjectLiteral: true }] },
|
|
{ code: "var addToB = (a) => { b = b + a };", options: ["as-needed", { requireReturnForObjectLiteral: true }] },
|
|
{ code: "var foo = () => { /* do nothing */ };", options: ["as-needed", { requireReturnForObjectLiteral: true }] },
|
|
{ code: "var foo = () => {\n /* do nothing */ \n};", options: ["as-needed", { requireReturnForObjectLiteral: true }] },
|
|
{ code: "var foo = (retv, name) => {\nretv[name] = true;\nreturn retv;\n};", options: ["as-needed", { requireReturnForObjectLiteral: true }] },
|
|
{ code: "var foo = () => bar();", options: ["as-needed", { requireReturnForObjectLiteral: true }] },
|
|
{ code: "var foo = () => { bar(); };", options: ["as-needed", { requireReturnForObjectLiteral: true }] },
|
|
{ code: "var foo = () => { return { bar: 0 }; };", options: ["as-needed", { requireReturnForObjectLiteral: true }] }
|
|
],
|
|
invalid: [
|
|
{
|
|
code: "for (var foo = () => { return a in b ? bar : () => {} } ;;);",
|
|
output: "for (var foo = () => (a in b ? bar : () => {}) ;;);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 22,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "a in b; for (var f = () => { return c };;);",
|
|
output: "a in b; for (var f = () => c;;);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 28,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (a = b => { return c in d ? e : f } ;;);",
|
|
output: "for (a = b => (c in d ? e : f) ;;);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 15,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (var f = () => { return a };;);",
|
|
output: "for (var f = () => a;;);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 20,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (var f;f = () => { return a };);",
|
|
output: "for (var f;f = () => a;);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 22,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (var f = () => { return a in c };;);",
|
|
output: "for (var f = () => (a in c);;);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 20,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (var f;f = () => { return a in c };);",
|
|
output: "for (var f;f = () => a in c;);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 22,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (;;){var f = () => { return a in c }}",
|
|
output: "for (;;){var f = () => a in c}",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 24,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (a = b => { return c = d in e } ;;);",
|
|
output: "for (a = b => (c = d in e) ;;);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 15,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (var a;;a = b => { return c = d in e } );",
|
|
output: "for (var a;;a = b => c = d in e );",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 22,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (let a = (b, c, d) => { return vb && c in d; }; ;);",
|
|
output: "for (let a = (b, c, d) => (vb && c in d); ;);",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 27,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (let a = (b, c, d) => { return v in b && c in d; }; ;);",
|
|
output: "for (let a = (b, c, d) => (v in b && c in d); ;);",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 27,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "function foo(){ for (let a = (b, c, d) => { return v in b && c in d; }; ;); }",
|
|
output: "function foo(){ for (let a = (b, c, d) => (v in b && c in d); ;); }",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 43,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for ( a = (b, c, d) => { return v in b && c in d; }; ;);",
|
|
output: "for ( a = (b, c, d) => (v in b && c in d); ;);",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 24,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for ( a = (b) => { return (c in d) }; ;);",
|
|
output: "for ( a = (b) => (c in d); ;);",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 18,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (let a = (b, c, d) => { return vb in dd ; }; ;);",
|
|
output: "for (let a = (b, c, d) => (vb in dd ); ;);",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 27,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "for (let a = (b, c, d) => { return vb in c in dd ; }; ;);",
|
|
output: "for (let a = (b, c, d) => (vb in c in dd ); ;);",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 27,
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "do{let a = () => {return f in ff}}while(true){}",
|
|
output: "do{let a = () => f in ff}while(true){}",
|
|
errors: [{
|
|
line: 1,
|
|
column: 18,
|
|
messageId: "unexpectedSingleBlock"
|
|
}]
|
|
},
|
|
{
|
|
code: "do{for (let a = (b, c, d) => { return vb in c in dd ; }; ;);}while(true){}",
|
|
output: "do{for (let a = (b, c, d) => (vb in c in dd ); ;);}while(true){}",
|
|
errors: [{
|
|
line: 1,
|
|
column: 30,
|
|
messageId: "unexpectedSingleBlock"
|
|
}]
|
|
},
|
|
{
|
|
code: "scores.map(score => { return x in +(score / maxScore).toFixed(2)});",
|
|
output: "scores.map(score => x in +(score / maxScore).toFixed(2));",
|
|
errors: [{
|
|
line: 1,
|
|
column: 21,
|
|
messageId: "unexpectedSingleBlock"
|
|
}]
|
|
},
|
|
{
|
|
code: "const fn = (a, b) => { return a + x in Number(b) };",
|
|
output: "const fn = (a, b) => a + x in Number(b);",
|
|
errors: [{
|
|
line: 1,
|
|
column: 22,
|
|
messageId: "unexpectedSingleBlock"
|
|
}]
|
|
},
|
|
{
|
|
code: "var foo = () => 0",
|
|
output: "var foo = () => {return 0}",
|
|
options: ["always"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
endLine: 1,
|
|
endColumn: 18,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => 0;",
|
|
output: "var foo = () => {return 0};",
|
|
options: ["always"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => ({});",
|
|
output: "var foo = () => {return {}};",
|
|
options: ["always"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 18,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => ( {});",
|
|
output: "var foo = () => {return {}};",
|
|
options: ["always"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 20,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "(() => ({}))",
|
|
output: "(() => {return {}})",
|
|
options: ["always"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 9,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "(() => ( {}))",
|
|
output: "(() => {return {}})",
|
|
options: ["always"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 10,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return 0; };",
|
|
output: "var foo = () => 0;",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return 0 };",
|
|
output: "var foo = () => 0;",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return bar(); };",
|
|
output: "var foo = () => bar();",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => {};",
|
|
output: null,
|
|
options: ["never"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedEmptyBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => {\nreturn 0;\n};",
|
|
output: "var foo = () => 0;",
|
|
options: ["never"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return { bar: 0 }; };",
|
|
output: "var foo = () => ({ bar: 0 });",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedObjectBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return ({ bar: 0 }); };",
|
|
output: "var foo = () => ({ bar: 0 });",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return a, b }",
|
|
output: "var foo = () => (a, b)",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return };",
|
|
output: null, // not fixed
|
|
options: ["as-needed", { requireReturnForObjectLiteral: true }],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return; };",
|
|
output: null, // not fixed
|
|
options: ["as-needed", { requireReturnForObjectLiteral: true }],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return ( /* a */ {ok: true} /* b */ ) };",
|
|
output: "var foo = () => ( /* a */ {ok: true} /* b */ );",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return '{' };",
|
|
output: "var foo = () => '{';",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return { bar: 0 }.bar; };",
|
|
output: "var foo = () => ({ bar: 0 }.bar);",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedObjectBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = (retv, name) => {\nretv[name] = true;\nreturn retv;\n};",
|
|
output: null, // not fixed
|
|
options: ["never"],
|
|
errors: [
|
|
{ line: 1, column: 27, type: "ArrowFunctionExpression", messageId: "unexpectedOtherBlock" }
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return 0; };",
|
|
output: "var foo = () => 0;",
|
|
options: ["as-needed", { requireReturnForObjectLiteral: true }],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => { return bar(); };",
|
|
output: "var foo = () => bar();",
|
|
options: ["as-needed", { requireReturnForObjectLiteral: true }],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => ({});",
|
|
output: "var foo = () => {return {}};",
|
|
options: ["as-needed", { requireReturnForObjectLiteral: true }],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 18,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => ({ bar: 0 });",
|
|
output: "var foo = () => {return { bar: 0 }};",
|
|
options: ["as-needed", { requireReturnForObjectLiteral: true }],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 18,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => (((((((5)))))));",
|
|
output: "var foo = () => {return (((((((5)))))))};",
|
|
options: ["always"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 24,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
|
|
// Not fixed; fixing would cause ASI issues.
|
|
code:
|
|
"var foo = () => { return bar }\n" +
|
|
"[1, 2, 3].map(foo)",
|
|
output: null,
|
|
options: ["never"],
|
|
errors: [
|
|
{ line: 1, column: 17, type: "ArrowFunctionExpression", messageId: "unexpectedSingleBlock" }
|
|
]
|
|
},
|
|
{
|
|
|
|
|
|
// Not fixed; fixing would cause ASI issues.
|
|
code:
|
|
"var foo = () => { return bar }\n" +
|
|
"(1).toString();",
|
|
output: null,
|
|
options: ["never"],
|
|
errors: [
|
|
{ line: 1, column: 17, type: "ArrowFunctionExpression", messageId: "unexpectedSingleBlock" }
|
|
]
|
|
},
|
|
{
|
|
|
|
// Fixing here is ok because the arrow function has a semicolon afterwards.
|
|
code:
|
|
"var foo = () => { return bar };\n" +
|
|
"[1, 2, 3].map(foo)",
|
|
output:
|
|
"var foo = () => bar;\n" +
|
|
"[1, 2, 3].map(foo)",
|
|
options: ["never"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = /* a */ ( /* b */ ) /* c */ => /* d */ { /* e */ return /* f */ 5 /* g */ ; /* h */ } /* i */ ;",
|
|
output: "var foo = /* a */ ( /* b */ ) /* c */ => /* d */ /* e */ /* f */ 5 /* g */ /* h */ /* i */ ;",
|
|
options: ["as-needed"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 50,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = /* a */ ( /* b */ ) /* c */ => /* d */ ( /* e */ 5 /* f */ ) /* g */ ;",
|
|
output: "var foo = /* a */ ( /* b */ ) /* c */ => /* d */ {return ( /* e */ 5 /* f */ )} /* g */ ;",
|
|
options: ["always"],
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 60,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "expectedBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => {\nreturn bar;\n};",
|
|
output: "var foo = () => bar;",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
endLine: 3,
|
|
endColumn: 2,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => {\nreturn bar;};",
|
|
output: "var foo = () => bar;",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
endLine: 2,
|
|
endColumn: 13,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => {return bar;\n};",
|
|
output: "var foo = () => bar;",
|
|
errors: [
|
|
{
|
|
line: 1,
|
|
column: 17,
|
|
endLine: 2,
|
|
endColumn: 2,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: `
|
|
var foo = () => {
|
|
return foo
|
|
.bar;
|
|
};
|
|
`,
|
|
output: `
|
|
var foo = () => foo
|
|
.bar;
|
|
`,
|
|
errors: [
|
|
{
|
|
line: 2,
|
|
column: 31,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedSingleBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: `
|
|
var foo = () => {
|
|
return {
|
|
bar: 1,
|
|
baz: 2
|
|
};
|
|
};
|
|
`,
|
|
output: `
|
|
var foo = () => ({
|
|
bar: 1,
|
|
baz: 2
|
|
});
|
|
`,
|
|
errors: [
|
|
{
|
|
line: 2,
|
|
column: 31,
|
|
endLine: 7,
|
|
endColumn: 16,
|
|
type: "ArrowFunctionExpression",
|
|
messageId: "unexpectedObjectBlock"
|
|
}
|
|
]
|
|
},
|
|
{
|
|
code: "var foo = () => ({foo: 1}).foo();",
|
|
output: "var foo = () => {return {foo: 1}.foo()};",
|
|
options: ["always"],
|
|
errors: [{ messageId: "expectedBlock" }]
|
|
},
|
|
{
|
|
code: "var foo = () => ({foo: 1}.foo());",
|
|
output: "var foo = () => {return {foo: 1}.foo()};",
|
|
options: ["always"],
|
|
errors: [{ messageId: "expectedBlock" }]
|
|
},
|
|
{
|
|
code: "var foo = () => ( {foo: 1} ).foo();",
|
|
output: "var foo = () => {return {foo: 1} .foo()};",
|
|
options: ["always"],
|
|
errors: [{ messageId: "expectedBlock" }]
|
|
},
|
|
{
|
|
code: `
|
|
var foo = () => ({
|
|
bar: 1,
|
|
baz: 2
|
|
});
|
|
`,
|
|
output: `
|
|
var foo = () => {return {
|
|
bar: 1,
|
|
baz: 2
|
|
}};
|
|
`,
|
|
options: ["always"],
|
|
errors: [{ messageId: "expectedBlock" }]
|
|
},
|
|
{
|
|
code: `
|
|
parsedYears = _map(years, (year) => (
|
|
{
|
|
index : year,
|
|
title : splitYear(year)
|
|
}
|
|
));
|
|
`,
|
|
output: `
|
|
parsedYears = _map(years, (year) => {
|
|
return {
|
|
index : year,
|
|
title : splitYear(year)
|
|
}
|
|
});
|
|
`,
|
|
options: ["always"],
|
|
errors: [{ messageId: "expectedBlock" }]
|
|
},
|
|
|
|
// https://github.com/eslint/eslint/issues/14633
|
|
{
|
|
code: "const createMarker = (color) => ({ latitude, longitude }, index) => {};",
|
|
output: "const createMarker = (color) => {return ({ latitude, longitude }, index) => {}};",
|
|
options: ["always"],
|
|
errors: [{ messageId: "expectedBlock" }]
|
|
}
|
|
]
|
|
});
|