falconGitHub

use-super-parameters

Same as use_super_parameters in Dart lints

Group
Style
Path
lint/style/use-super-parameters
Default
On (recommended)
Origin
Dart lints
Rule
507 of 512
recommended

Prefer super parameters when a constructor only forwards parameters to its superclass.

Super parameters remove repeated parameter declarations and explicit forwarding arguments. This rule reports a constructor once when its positional parameters can be converted together, or when an individual named parameter can be converted without changing its type contract. Parameters used in the constructor body and field-initializing formals are not suggested.

Available starting with Dart 2.17. For example, replace Child(int value) : super(value); with Child(super.value);.

Invalid

example.dartdart
// Parameters forwarded verbatim to super and used nowhere else.
class Base {
  Base(int a);
  Base.two(int a, int b);
  Base.named({int? x});
  Base.both(int a, {int? x});
}

class A extends Base {
  A(int a) : super(a);
}

class B extends Base {
  B(int a, int b) : super.two(a, b);
}

class C extends Base {
  C({int? x}) : super.named(x: x);
}

class D extends Base {
  D(int a) : super(a);
}

class E extends Base {
  E(int a) : super(a);
}

class ObjectBase {
  ObjectBase(Object e);
}

class CatchBinding extends ObjectBase {
  CatchBinding(Object e) : super(e) {
    try {} catch (e) {}
  }
}

class SkippedParameter extends Base {
  SkippedParameter(String unused, int value) : super(value);
}

class Multiline extends Base {
  Multiline(
    int value,
  ) : super(value);
}

class InitializerReference extends Base {
  final int saved;
  InitializerReference(int value) : saved = value, super(value);
}

class Primary(int value) extends Base {
  this : super(value);
}

class NamedConstructor extends Base {
  NamedConstructor.named(int value) : super(value);
}

class FieldWithNamed extends Base {
  final int field;
  FieldWithNamed(this.field, {int? x}) : super.both(field, x: x);
}

class SkippedParameters extends Base {
  SkippedParameters(String unused, int a, bool skipped, int b) : super.two(a, b);
}
Use `super` parameters instead of forwarding parameters to `super`.
9class A extends Base {
10 A(int a) : super(a);
Use `super` parameters instead of forwarding parameters to `super`.
13class B extends Base {
14 B(int a, int b) : super.two(a, b);
Use `super` parameters instead of forwarding parameters to `super`.
17class C extends Base {
18 C({int? x}) : super.named(x: x);
Use `super` parameters instead of forwarding parameters to `super`.
21class D extends Base {
22 D(int a) : super(a);
Use `super` parameters instead of forwarding parameters to `super`.
25class E extends Base {
26 E(int a) : super(a);
Use `super` parameters instead of forwarding parameters to `super`.
33class CatchBinding extends ObjectBase {
34 CatchBinding(Object e) : super(e) {
Use `super` parameters instead of forwarding parameters to `super`.
39class SkippedParameter extends Base {
40 SkippedParameter(String unused, int value) : super(value);
Use `super` parameters instead of forwarding parameters to `super`.
43class Multiline extends Base {
44 Multiline(
Use `super` parameters instead of forwarding parameters to `super`.
50 final int saved;
51 InitializerReference(int value) : saved = value, super(value);
Use `super` parameters instead of forwarding parameters to `super`.
53
54class Primary(int value) extends Base {
Use `super` parameters instead of forwarding parameters to `super`.
58class NamedConstructor extends Base {
59 NamedConstructor.named(int value) : super(value);
Use `super` parameters instead of forwarding parameters to `super`.
63 final int field;
64 FieldWithNamed(this.field, {int? x}) : super.both(field, x: x);
Use `super` parameters instead of forwarding parameters to `super`.
67class SkippedParameters extends Base {
68 SkippedParameters(String unused, int a, bool skipped, int b) : super.two(a, b);

Valid

example.dartdart
// Cases that must not be flagged.
class Base {
  Base(int a);
  Base.two(int a, int b);
}

class A extends Base {
  A(int a) : super(a) {
    print(a);
  }
}

class B extends Base {
  B(super.a);
}

class C extends Base {
  C(int value) : super(value + 1);
}

class D extends Base {
  D(int a, int b) : super.two(b, a);
}

class E extends Base {
  E(int a, int b) : super.two(a, b) {
    print(a);
    print(b);
  }
}

class PartialExpression extends Base {
  PartialExpression(int a, int b) : super.two(a, b + 1);
}
class FieldBlocker extends Base {
  final int field;
  FieldBlocker(this.field, int a) : super(a);
}
class NamedToPositional extends Base {
  NamedToPositional({required int a}) : super(a);
}
class WideBase {
  WideBase({num? value});
}
class NarrowParameter extends WideBase {
  NarrowParameter({int? value}) : super(value: value);
}

class NamedBase {
  NamedBase({int? value});
}

class FinalDeclaringPrimary({final int? value}) extends NamedBase {
  this : super(value: value);
}

class VarDeclaringPrimary({var int? value}) extends NamedBase {
  this : super(value: value);
}

class RepeatedArgument extends Base {
  RepeatedArgument(int a) : super.two(a, a);
}

Configure use-super-parameters

Set its severity in falcon.json. See the configuration guide.

falcon.jsonjson
{
  "linter": {
    "rules": {
      "style": {
        "use-super-parameters": "error"
      }
    }
  }
}

Or silence one occurrence with a suppression comment; the reason is required.

example.dartdart
// falcon-ignore lint/style/use-super-parameters: <reason>