Struct rslint_core::groups::errors::NoUnexpectedMultiline

pub struct NoUnexpectedMultiline {}

Disallow confusing newlines in expressions.

JavaScript has automatic semicolon insertion, where newlines end statements, however, expressions can often span across newlines, therefore it can become a bit confusing at times and ambiguous. Take the following as an example:

let foo = bar
/bar/g.test("foo");

you would expect this to be a variable declaration and then a regex test, however, it is actually a division expression as such: `(bar / bar) / (g.test("foo")). This rule is aimed at preventing ambiguous and buggy expressions such like these. It disallows ambiguous tagged templates, property accesses, function calls, and division expressions.

Invalid Code Examples

var foo = bar
(1 || 2).baz();

var foo = 'bar'
[1, 2, 3].forEach(addNumber);

let x = function() {}
`foo`

let x = function() {}
x
`bar`

let x = foo
/regex/g.test(bar)

Correct Code Examples

var foo = bar;
(1 || 2).baz();

var foo = 'bar';
[1, 2, 3].forEach(addNumber);

let x = function() {};
`foo`

let x = function() {};
x;
`bar`

let x = foo;
/regex/g.test(bar)

Implementations

impl NoUnexpectedMultiline

pub fn new() -> Self

Trait Implementations

impl Clone for NoUnexpectedMultiline

fn clone(&self) -> NoUnexpectedMultiline

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CstRule for NoUnexpectedMultiline

fn check_node(&self, node: &SyntaxNode, ctx: &mut RuleCtx) -> Option<()>

Check an individual node in the syntax tree. You can use the match_ast macro to make matching a node to an ast node easier. The reason this uses nodes and not a visitor is because nodes are more flexible, converting them to an AST node has zero cost and you can easily traverse surrounding nodes. Defaults to doing nothing.

fn check_token(&self, token: &SyntaxToken, ctx: &mut RuleCtx) -> Option<()>

Check an individual token in the syntax tree. Defaults to doing nothing.

fn check_root(&self, root: &SyntaxNode, ctx: &mut RuleCtx) -> Option<()>

Check the root of the tree one time. This method is guaranteed to only be called once. The root's kind will be either SCRIPT or MODULE. Defaults to doing nothing.

impl Debug for NoUnexpectedMultiline

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NoUnexpectedMultiline

fn default() -> NoUnexpectedMultiline

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for NoUnexpectedMultiline

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Rule for NoUnexpectedMultiline

fn name(&self) -> &'static str

A unique, kebab-case name for the rule.

fn group(&self) -> &'static str

The name of the group this rule belongs to.

impl Serialize for NoUnexpectedMultiline

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.