[Super parameters] Super Key for Widgets

[AlexV525]

Describe the issue

When I was trying to migrate the key parameter to a super parameter, I got a linter hint that the key is never used.

Before:
After:

Could it be a false-positive? But the _MethodListView is a private class here, so it could be somehow valid in this case.

Expected behavior
I expected the key here not to be detected as unused, as providing the key parameter is a preferred rule in Flutter. And the previous style is valid since the key is actually used in the super call.

[bwilkerson]

@srawlins

[asashour]

I am suspecting there are two things:

• Is the parameter used in the method
• Is the parameter being passed in the caller invocation as an argument

Consider

class A {
  A({this.s});

  String? s;
}

class _B extends A {
  _B({super.s});
}

class _C extends A {
  _C({String? s}) : super(s: s);
}

class _D extends A {
  _D({String? s}) : super();
}

void f() {
  _B();
  _C();
  _D();
//  _B(s: 'a'); // uncomment this
//  _C(s: 'a');
//  _D(s: 'a');
}

the super.s in _B is marked as unused, however once the _B(s: 'a') is used, the parameter is considered used.

_C has always s considered used, because it it used to call the super constructor.

_D behaves as _B

From the documentation of the diagnostic

Assuming that no code in the library passes a value for y in any invocation of _m, the following code produces this diagnostic:

I am guessing the behavior of _B and _D is correct, but _C should actually be changed, so that it is considered used only when the parameter is passed in an invocation, and not just being used in the method body.

[AlexV525]

We're facing more of this when we apply the rule to production projects, as we have various file-read-only widgets that have the key argument.

I am guessing the behavior of _B and _D is correct, but _C should actually be changed, so that it is considered used only when the parameter is passed in an invocation, and not just being used in the method body.

Indeed. IMO private constructors have better callers finding like arguments usage. A super argument seems to be defined as a private field here.

[mraleph]

Duplicate of #49025