Start implementing logic for determining when formal parameters need type checks.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
@@ skipping 2360 matching lines @@
   final bool _implicitlyTyped;
 
   final int _functionNestingLevel;
 
   bool _mutatedInClosure = false;
 
   bool _mutatedAnywhere = false;
 
   final bool _isLocalFunction;
 
+  /// If this variable declaration represents a formal parameter, indicates
+  /// whether uses of it need to be type-checked due to the covariance of class
+  /// type parameters.
+  ///
+  /// TODO(paulberry): replace this with an enum so that it can represent
+  /// "unsafe" parameters as well.
+  ///
+  /// TODO(paulberry): remove this once there is a corresponding annotation in
+  /// the kernel representation.
+  bool isSemiSafe = false;

[ahe, 2017/08/23 09:55:58]

As for the future direction, I suggest these are represented as annotations
similarly to how we encode native functions.

Unfortunately, we haven't yet implemented metadata on VariableDeclaration, see
issue https://github.com/dart-lang/sdk/issues/28434

[Paul Berry, 2017/08/23 17:09:10]

Let's talk with the kernel folks about this.  My gut feeling is that we
shouldn't use annotations for this, because annotations are meant for
information supplied by the user, whereas this information is supplied by the
front end and should be completely transparent to the user.

But I'm happy to go with whatever representation makes the most sense to the
kernel folks.

+
   KernelVariableDeclaration(String name, this._functionNestingLevel,
       {Expression initializer,
       DartType type,
       bool isFinal: false,
       bool isConst: false,
       bool isFieldFormal: false,
       bool isLocalFunction: false})
       : _implicitlyTyped = type == null,
         _isLocalFunction = isLocalFunction,
         super(name,
@@ skipping 116 matching lines @@
   accept(v) => unsupported("accept", -1, null);
 
   accept1(v, arg) => unsupported("accept1", -1, null);
 
   getStaticType(types) => unsupported("getStaticType", -1, null);
 
   transformChildren(v) => unsupported("transformChildren", -1, null);
 
   visitChildren(v) => unsupported("visitChildren", -1, null);
 }