Struct rslint_core::groups::errors::NoSetterReturn

pub struct NoSetterReturn {}

Disallow setters to return values.

Setters cannot return values. To be more precise, a setter that returns a value is not treated as an error, but we cannot use the returned value at all. Thus, if you write a setter that will return something, it is most likely either completely unnecessary or a possible error.

Note that return without a value is allowed because it is considered a control flow statement.

This rule checks setters in:

• Object literals
• Class declarations and class expressions
• Property descriptors in Object.create, Object.defineProperty, Object.defineProperties, and Reflect.defineProperty

Incorrect code examples

let foo = {
    set a(value) {
        this.val = value;
        // The setter always returns a value
        return value;
    }
};

class Foo {
    set a(value) {
        this.val = value;
        // The setter always returns a value
        return this.val;
    }
}

const Bar = class {
    static set a(value) {
        if (value < 0) {
            this.val = 0;
            // The setter returns `0` if the value is negative
            return 0;
        }
        this.val = value;
    }
};

Object.defineProperty(foo, "bar", {
    set(value) {
        if (value < 0) {
            // The setter returns `false` if the value is negative
            return false;
        }
        this.val = value;
    }
});

Correct code examples

let foo = {
    set a(value) {
        this.val = value;
    }
};

class Foo {
    set a(value) {
        this.val = value;
    }
}

const Bar = class {
    static set a(value) {
        if (value < 0) {
            this.val = 0;
            // Returning without a value is allowed
            return;
        }
        this.val = value;
    }
};

Object.defineProperty(foo, "bar", {
    set(value) {
        if (value < 0) {
            // Throwing an error is also allowed
            throw new Error("Negative value is not allowed.");
        }
        this.val = value;
    }
});

Implementations

impl NoSetterReturn

pub fn new() -> Self

Trait Implementations

impl Clone for NoSetterReturn

fn clone(&self) -> NoSetterReturn

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CstRule for NoSetterReturn

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 NoSetterReturn

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

Formats the value using the given formatter.

impl Default for NoSetterReturn

fn default() -> NoSetterReturn

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NoSetterReturn

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

Deserialize this value from the given Serde deserializer.

impl Rule for NoSetterReturn

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.

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

Optional docs for the rule, an empty string by default

fn tags(&self) -> &'static [Tag]

A list of tags present on this rule. Empty by default.

fn recommended(&self) -> bool

Whether this rule is recommended, this is a simple helper around Self::tags.

impl Serialize for NoSetterReturn

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

Serialize this value into the given Serde serializer.