Hello. I have tried several different ways to get the linter to ignore this error but am unsure what the correct answer is.

"A value of type ‘{0}’ can’t be assigned to a variable of type ‘{1}’" I have tried:

   invalid_assignment: true
   invalid_assignment: false
   invalid_assignment: ignore
   invalid_assignment: warn

Nothing seems to prevent this from being a compile error in my project except removing [lint: ^1.0.0] completely What am I doing wrong? What do I need to do to use?

Nice linter! Really appreciate the explanation for every rule choice.

According to some resources, const is in some cases optional. Meaning it gets added by the runtime and you do not gain any performance benefits by adding const. But I am not 100% sure, as in some cases it ensures that const is definitely used and thus has better performance.

IMO I would leave const out, trust the DartVM to optimize most of it and for that **VERY expensive ** constructor I would leave it to the developer to add it in.

This should clean up code in flutter a lot, since a lot of widgets can be const.

Some resources:

const is optional inside of a constant context.

Dart2 Migration guide: https://dart.dev/dart-2

In short, even without the keyword, we can still unambiguously recognize the expressions that create objects. In that sense, the keywords are superfluous.

Similarly, it may be important for developers to ensure that certain expressions are constant, because of the improved performance and the guaranteed canonicalization.

https://github.com/dart-lang/sdk/blob/master/docs/language/informal/implicit-creation.md

Here are some very good examples on where it is optional:

https://stackoverflow.com/questions/52581148/when-is-const-optional-in-dart-2

I am using VSCode and I added lint:^1.2.0 as a dev_dependencies.

Now trying to import analysis_options_package.yaml as shown below breaks the flutter analyze.

include: package:lint/analysis_options_package.yaml

Following warning is raise by flutter analyze.

warning - The include file package:lint/analysis_options_package.yaml in
       C:\my\local\path\to\analysis_options.yaml cannot be found -
       analysis_options.yaml:1:11 - include_file_not_found

Should it be added to normal dependencies instead dev_dependecies? In my case that didn't help either. Not sure if I am missing any step.

So I'm getting avoid_redundant_argument_values but this is how Flutter widgets work in the UI for example flutter crossAxisAlignment shouldn't this be removed from the lint to set to false by default

In the pub.dev install section of this package it is written to insert the dependency under dependencies. As this dependency is not running while the software is running (as far as I know) it should be placed under dev_dependencies.

Is it ok to place it under dev_dependencies and if it does can we change it in the pub.dev install page for the incoming users?

Since Flutter source code full of {Key? key, required ...} constructors, it would be better excluding this specific case.

Flutter example:

const Padding({
    Key? key,
    required this.padding,
    Widget? child,
  }) : assert(padding != null),
       super(key: key, child: child);

I am creating this issue after my comment here: https://github.com/passsy/dart-lint/issues/3#issuecomment-571707108

After further testing, I have discovered that the comment ins the analysis_options.yaml file break the possibility of customization. This may occur due to some YAML library parsing problems, maybe some undocumented handling of comment nodes, no idea.

I have done the following to determine this:

1. Try to use pedenatic package and extend the rules adding and disabling - this works - pedantic has no comments in their files
2. Copy the analysis_options.yaml file of this library to a local project file - customization does not work
3. Remove all comments form the local file - customization works

Hello,

I didn't find the reason, but the linter got confused around my import for no special reason (no double enum / class with the same name) and i got the following behavior which is funny :

Enum is type DownloadType (good)

Enum instance variable is dynamic...

When playing with import order this issue disappear but as I used this rule : directives_ordering I can't. If i remove the comma just after DownloadType downloadType, error disappear... So seems like parsing error from the linter.

# Might cause frame drops because of synchronous file access on mobile, especially on older phones with slow storage.
# There are no known measurements sync access does *not* drop frames.
#
# https://dart-lang.github.io/linter/lints/avoid_slow_async_io.html
# - avoid_slow_async_io

From the comments, I guess we should enable this rule?

While developing a Flutter plugin, after adding

dev_dependencies:
  lint: 1.6.0

I'm getting a warning indicating that the analysis_options file cannot be found.

warning: The include file package:lint/analysis_options_package.yaml in /my/local/path/to/analysis_options.yaml cannot be found. (include_file_not_found at [my_project] analysis_options.yaml:1)

I want to disable the lint: "The argument type 'dynamic' can't be assigned to the parameter type x" but I can't find it.

Update I used this and the problem is solved!

analyzer:
  strong-mode:
    implicit-casts: true

For coding dojos, examples and quick prototypes a more relaxed set of rules would be great.

For that kind of apps it's irrelevant if const or prints are added or not.

I think these 2 errors contradict each other

lint: ^1.6.0

abstract class IContent {
  final String? name;
  IContent({
    this.name,
  });
}

class Content extends IContent {
  // 2 conflicting errors
  // Annotate overridden members.dart(annotate_overrides)
  // Don't override fields.dart(overridden_fields)
  final String? name;
}

I got massive errors from the analyzer includes:

• argument_type_not_assignable
• field_initializer_not_assignable

Most of them are from the Map<String, dynamic> json parsing to a model class.

I tried to turn them off in the analysis_options.yaml, but it didn't help.

Enables unawaited_futures.

Where Futures are intentionally not awaited, users can disable this lint with fireAndForget which exists as top-level function and extension. It is identical to unawaited from pedantic.

Future<void> logAsync(String msg) async { /*...*/ }

Future<void> someOperation() async {
  await doSomething();

  // Warning: `Future` results in `async` function bodies must be `await`ed or marked `unawaited` using `package:pedantic`.
  logAsync('success');

  // The fireAndForget() extensions signals that await is intentionally missing
  logAsync('success').fireAndForget();

  // The fireAndForget() function signals that await is intentionally missing
  fireAndForget(logAsync('success'));
}

I explicitly did not name it unawaited as it causes naming conflicts. That's the main reason why unawaited was removed from meta again.

Fixes #26

Alternative names

• notAwaited
• runInParallel
• ignoreUnawaitedFuture

When using lint 1.5.1

In the following switch statement there are two cases that both check if char = ' '.

The lint incorrectly marks the second test as invariant_booleans as it sees the if char = ' ' in the first case and assume that the test protects the second case from having a space.

If you change the first char = ' ' in the first case to anything else the warning goes away.

The lint should not fire in this scenario.

 enum _ParseState { starting, inQuote, inWord }

  /// parses the given command breaking them done into words
void _parse2(String commandLine) {
    var state = _ParseState.starting;

    for (var i = 0; i < commandLine.length; i++) {
      final char = commandLine[i];

      switch (state) {
        case _ParseState.starting:
          if (char == ' ') {
            break;
          }
          break;

        case _ParseState.inWord:
          if (char == ' ')
          {
            break;
          }
      }
    }
  }