The parameter can’t have a value of ‘null’ because of its type in Dart

Dart is a modern, general-purpose programming language developed by Google. It’s designed to be highly productive and easy to use, with a strong focus on concurrency and asynchronous programming. One of the features that makes Dart so appealing is its null safety feature. Null safety helps prevent runtime errors caused by null or uninitialized values.

Why This Happens

The reason this happens is because with null safety enabled, your non-nullable parameter factor or key cannot be null. In the function and the constructor, these values might be null when the function is called without the named parameter: calculate() or Foo(). However, because the types (int and Key) are non-nullable, this is invalid code – they must never be null.

Solutions

There are essentially three ways of solving this:

1. Required

This is probably the most common solution to this problem and it indicates that a variable has to be set. This means that if we have (notice the required keyword):

void calculate({required int factor}) {
  // ...
}

We indicate that the factor parameter must always be specified, which solves the problem because only calculate(factor: 42) et al. will be valid calls of the function.

2. Default value

Another solution is providing a default value. If our parameter has a default value, we can safely not specify the parameter when calling the function because the default value will be used instead:

void calculate({int factor = 42}) {
  // ...
}

Now, a calculate() call will use 42 as the factor, which is obviously non-null.

3. Nullable parameter

The third solution is something that you really want to consider, i.e. do you want to have a nullable parameter? If so, you will have to null check the parameter when using it in your function. However, it is the way you would most commonly want to solve the Key key issue because you do not always want to provide a key to your widget in Flutter (note the nullable Key? type):

class Foo extends StatelessWidget {
  const Foo({Key? key}): super(key: key);

  // ...
}

Now, you can safely construct Foo() without providing a key.

Note on Positional Parameters

It’s worth noting that the same applies to positional parameters, i.e. they can be made nullable or non-nullable, however, they cannot be annotated with required and cannot have default values as they are always required to be passed.

void foo(int param1) {} // foo(null) is invalid.

void bar(int? param1) {} // bar(null) is valid.

Example Use Case

It’s the main reason why non-nullable feature is added to Dart. Since, you’re passing Key to super class, which could be null, so you want to make sure it’s non-null. What you can do is either not use the key at all or provide a default value to it or make it required. Like:

MyPage({Key key = const Key("any_key")}) : super(key: key);

or

MyPage({required Key key}) : super(key: key);