useless `The argument type 'String?' can't be assigned to the parameter type 'String'.`

[stephane-archer]

class _SmartExposureAnalysisWidget extends StatelessWidget {
  const _SmartExposureAnalysisWidget({
    required this.pathImgSelectedLut,
    required this.imagePath,
    required this.previewGeneratorChangeNotifier,
  });

  final String? pathImgSelectedLut;
  final String? imagePath;
  final PreviewGeneratorChangeNotifier previewGeneratorChangeNotifier;

  @override
  Widget build(BuildContext context) {
    if (imagePath == null) {
      return const SizedBox.shrink();
    }
    if (pathImgSelectedLut == null) {
      return ExposureAnalysisWidget(
          imagePath, previewGeneratorChangeNotifier);
    }
    return ExposureAnalysisWidget(
        pathImgSelectedLut, previewGeneratorChangeNotifier);
  }
}

The argument type 'String?' can't be assigned to the parameter type 'String'.

Because imagePath is final and is checked for null in the build function, I don't see why I should have a ! or a local variable to avoid this error message.

Am I missing something?

[dart-github-bot]

Summary: Null-safe String? variables are passed to a function expecting non-nullable String arguments. The code already handles null checks; the error is misleading.

[stephane-archer]

here is the fixed code without using !, it seems really unecessary

class _SmartExposureAnalysisWidget extends StatelessWidget {
  const _SmartExposureAnalysisWidget({
    required String? pathImgSelectedLut,
    required String? imagePath,
    required this.previewGeneratorChangeNotifier,
  })  : _pathImgSelectedLut = pathImgSelectedLut,
        _imagePath = imagePath;

  final String? _pathImgSelectedLut;
  final String? _imagePath;
  final PreviewGeneratorChangeNotifier previewGeneratorChangeNotifier;

  @override
  Widget build(BuildContext context) {
    var imagePath = _imagePath;
    if (imagePath == null) {
      return const SizedBox.shrink();
    }
    var pathImgSelectedLut = _pathImgSelectedLut;
    if (pathImgSelectedLut == null) {
      return ExposureAnalysisWidget(imagePath, previewGeneratorChangeNotifier);
    }
    return ExposureAnalysisWidget(
        pathImgSelectedLut, previewGeneratorChangeNotifier);
  }
}

[FMorschel]

This happens because the analyzer can't promote variables from outside the function/method. If you assign it to a local variable and then make the test for nullability, you will see it working as you expected. @lrhn or @eernstg for the explanation for this I think

[lrhn]

The usual reason applies: The compiler won't promote anything that would make it a breaking change to change the implementation, or that isn't absolutely guaranteed to be stable.
A variable being final is not a promise to not change that variable to a getter, which can't be promoted, so you can't promote anything except local variables.
You'd have to make an API promise that the variable stays promotable before the compiler would trust it, which isn't currently possible.

(The one exception is a library private final variable that is not overridden inside the same library. And even then, it's only allowed to be promoted inside that library, because then the library author will immediately see if they break it.)

[stephane-archer]

thank you @lrhn for your explanation but sadly I don't understand why a local variable can be promoted while a member variable can't (inside the function scope)

Let's take this simple example:

class _MyWidget  {
  const _MyWidget({
    required String? imagePath,
  }) : _imagePath = imagePath;

  final String? _imagePath;

   String? get hello { // the getter can be null witch is normal
    return _imagePath;
   }

  // _imagePath can't be change because of final
  //  set world (String a) {
  //   _imagePath = a;
  //  }

  int build() {
    if (_imagePath == null) {
      // I don't see why this can not be promoted like a local variable in the build scope
     // I don't see why a member function can't be treated like local variables inside a function scope
      return 1;
    }
    _bar(_imagePath);
  }

  void _bar(String a){
    print(a);
  }
}

adding at the beginning of your function this line for a null check of your member variable feels wrong:

var imagePath= _imagePath;

[FMorschel]

@stephane-archer see:

class A {
  const A(this.v);
  final int? v;
}

class B extends A {
  B(super.v);

  int? v2 = 0;

  @override
  int? get v => v2;

  void foo() {
    if (v == null) {
      return;
    }
    v2 = null;
    // Now v is null
  }
}

[stephane-archer]

@FMorschel in class B you created an alias v for v2, there is nothing in B referencing final A.v.
if final A.v is null check it can be promoted like a local variable.

let me rewrite your code without "syntax sugar"

class A {
  const A(this.v);
  final int? v;
}

class B extends A {
  B(super.v);

  int? v2 = 0;

  void foo() {
    if (v2 != null) {
      return;
    }
    v2 = null;
    // Now v2 is null <- yes an assignment that can be null after a null check can't promote the member variable but how is this different than a local variable? 
  }
}

I don't see how an alias changes something. I think the compiler can make a difference between final A.v and B.v2 but aliased v by the user

[FMorschel]

This is because B.v is an extension for A.v.

Say foo was actually declared in A but with a call to another function bar.

Then in B you override bar to set the value for v2.

When you pass an instance of B in a place that is expecting A you would get a runtime error if that was promoting the property and you tried running foo (on my phone now, will edit this comment with a full example to show the above when I get to my PC).

---

Edit

@stephane-archer, see this updated version

void main() {
  final a1 = A(1);
  print(a1.foo());
  final a2 = B(1);
  print(a2.foo());
}

class A {
  const A(this.v);
  final int? v;

  int foo() {
    if (v == null) {
      return 0;
    }
    bar();
    return v;
  }

  void bar() {
    print('bar');
  }
}

class B extends A {
  B(super.v);

  int? v2 = 0;

  @override
  int? get v => v2;

  @override
  void bar() {
    v2 = null;
    print('bar2');
  }
}

[FMorschel]

A new comment to say that I've updated the comment above with the repro.

Also, about it. This can happen for example if you extend a class from a package and make one of its final fields a getter as the above. Now if the author had made a similar thing to what you asked, it would generate a runtime error.

That's what I was talking about, the safest thing to do is to create a local variable with that value and work with it instead.