What is the purpose of assigning `const` value to a `final` variable in dart?

Question

So I was doing the first example for Flutter, and under Step 4: Create an infinite scrolling ListView,

I encountered this piece of code:

class RandomWordsState extends State<RandomWords> {
  final _suggestions = <WordPair>[];

  final _biggerFont = const TextStyle(fontSize: 18.0);
  ...
} 

But I found the following line a little spooky.

final _biggerFont = const TextStyle(fontSize: 18.0);

My question is, what is the purpose of assigning a constant value to a final variable?

I know that

Compile-time constants are canonicalized,i.e. no matter how many times you write const MyObj(0, 0),you only create one object.

This may sound useful, but you can simply create the const variable to hold the value and use that variable instead.

Well, don't you think it's kinda redundant? I get it that the developers at Flutter wanted to create a compile-time constant object, but hey! you are assigning that value to a final variable. Which is somewhat the same thing.

Any thoughts?

UPDATE

I googled some definitions, I found that

const constructors cannot have a body and It's class must not have any non-final fields

So is this the reason why we used the const keyword? Because if you'll look at the TextStyle class's design, you'll realize that they have done the exact same thing here.

Answer 1

I personally think

final _biggerFont = const TextStyle(fontSize: 18.0);

looks like a mistake, and that that alone is reason enough to change it.

The member is only used inside the same class, so there is no reason not to make it static. Then it will not take up one extra memory location for each instance of the class, all pointing to the same value. (That's assuming the compiler doesn't recognize the field as always having the same value, and just inlines the value everywhere).

If the member is static, it might as well also be const, so I'd write it as:

static const _biggerFont = TextStyle(fontSize: 18.0);

This assumes that the code is what I found by searching for final _biggerFont = const.

If there is a subclass in the same library which overrides _biggerFont, then it does need to be an instance variable. It could still be a getter instead of a field, then. Whether that's an efficiency improvement depends on how the class is used, and how well a compiler optimizes a final field that always has the same value.

In any case, creating a private instance member which always has the same constant value looks like something that should just be a static constant to begin with, and code that looks like a mistake is confusing to read. I'd rewrite it (or document it) just for that reason - to avoid the reader being confused about why it is the way it is.

Answer 2

const values are canonicalized.

This means no matter how often your code contains

final _biggerFont = const TextStyle(fontSize: 18.0);

there will only a single const TextStyle(fontSize: 18.0) instance.

Using const for class' fields requires static, this would not allow to access its value using a reference to an instance of RandomWordsState.

There are different preferences for classes with const constructors

http://dart-lang.github.io/linter/lints/avoid_field_initializers_in_const_classes.html

AVOID field initializers in const classes.

Instead of final x = const expr;, you should write get x => const expr; and not allocate a useless field. As of April 2018 this is true for the VM, but not for code that will be compiled to JS.

and top-level fields

http://dart-lang.github.io/linter/lints/prefer_const_declarations.html

PREFER using const for const declarations.

Const declarations are more hot-reload friendly and allow to use const constructors if an instantiation references this declaration.

The IDE also suggests to replace final with const for local variables that are initialized with constant values

I haven't found where this suggestion comes from, but it makes sense because local variables can be const without static