* Add missing return to fix analysis error with 2.1.0-dev.0.0.

* Add a few more missing returns

* Format files

* Use toFilePath() instead of .path on Uri to support Windows

Fixes #918.

- Use `??`, `??=`, and `?.` instead of explicit `== null`.
- Use consistent single quotes

Towards #915

The CFE will already reject this code if it is incorrect, we don't need
to also check for syntax errors.

- Remove the explict checks for `const`
- Remove the explicit checks for using valid constructor names and
  argument types.
- Update test to remove most of the `const` in examples. Retain const
  constructor calls since we can't yet parse the resulting expression if
  it is omitted.
- Remove tests for the removed explicit checks.

Decoding input bytes by doing `.map(utf8.decode)` assumes that input byte chunks are split at encoded code-unit boundaries.
It's safer to use `.transform(utf8.decoder)` which allows encodings to be split accross input chunks.

Also changed `.listen(f).asFuture()` to the equivalent `.forEach(f)`.

* allow serving files outside the precompiled directory, so that symlinks can be supported

* update pubspec/changelog

* change version to 1.3.0

- Update expectation now that dart2js produces different color output.
- Skip tests against a graceful fallback for invalid code that can no
  longer parse.

* support loading .vm.app.dill files in precompiled mode

* add a test for loading from dill files

* update pubspec/changelog for 1.2.0 release

Fixes #889.

Updated test to make new output of Type mismatch errors
Update usage of isInstanceOf to TypeMatcher

Closes #842 

See https://github.com/dart-lang/sdk/issues/33388

The latest version of `stream_channel` made the type explicit on the
method signature whereas before it was implicit with an `as` cast inside
the method. Most clients wouldn't be impacted is but this package is
because of it's use of `implicit-casts: false`.

We no longer use `mapMap` so the hints aren't printed. Fix the tests to
allow for the "Compiled" message from dart2js. Update the reason for
skipping one test which has an incorrect line number - we will need to
investigate why this line is wrong.

Allow Matcher usage in the `_print` call since the "Compiled" message is
unpredictable.

Follow-up to https://github.com/dart-lang/test/pull/869

Searched for lines matching `var \w+;`. This is a much weaker version of
no-implicit-dynamic. This catches a bunch of places where we otherwise
had dynamic calls and tightens up types a bit. Where we are relying on
being able to parse to multiple types and then throw a specific
excpetion or return null on bad types I added an explicit `dynamic`.

This isn't something we _can_ fix because user specific (json serializable) types can be sent across the channel.

- Fix syntax for upgrading errors in the analysis options
- Ignore todo hints since they are very noisy
- Enable check for implicit casts
- Fix a bunch of implicit casts in the test directory

More towards #842

- Export @Retry annotation (this is technically broken now but the corresponding tests only fail under preview-dart-2)
- Fix type issue with mapping over dynamic values

There are still errors in tests which may be harder to fix so we can't
check in the change to analysis options.

This should make it easier to diagnose Dart 2 semantic issues as more of
the places where there can be failures are explicit.

Most of the changes are just adding explicit `as` statements and keeping
the semantics that already existed. In a few places an uninitialized
`var` is given a type, and in others a reused variable name with
different types is split into multiple variables.

The changes in the frontend code are the most risky, since some users
might still be using that code in a non Dart 2 runtime and relying on
looseness which is lost with an explicit cast.

Pin to the dev.60 SDK for now since there are failures on the newer SDK.

The typedef was misused to mean either `Function` or `Function()` in
various places and worked because the difference was not checked. The
doc comment was also incorrect because there were places it was used
where a return value was explicitly necessary. Replace with an inline
function type definition using the appropriate choice for the location.

Where possible also replace with Function types that flow through the
required return types.