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

pkg/front_end/lib/src/fasta/source/source_loader.dart

 // Copyright (c) 2016, 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.
 
 library fasta.source_loader;
 
 import 'dart:async' show Future;
 
 import 'dart:typed_data' show Uint8List;
 
-import 'package:kernel/ast.dart' show Arguments, Expression, Program;
+import 'package:front_end/src/fasta/kernel/kernel_library_builder.dart'
+    show KernelLibraryBuilder;
+
+import 'package:kernel/ast.dart' show Arguments, Class, Expression, Program;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
 import 'package:kernel/src/incremental_class_hierarchy.dart'
     show IncrementalClassHierarchy;
 
 import '../../../file_system.dart';
 
@@ skipping 467 matching lines @@
   }
 
   /// Performs the second phase of top level initializer inference, which is to
   /// visit fields and top level variables in topologically-sorted order and
   /// assign their types.
   void performInitializerInference() {
     typeInferenceEngine.finishTopLevel();
     ticker.logMs("Performed initializer inference");
   }
 
+  /// Annotates method formals that require runtime checks to restore soundness
+  /// as a result of the fact that Dart 2.0 treats all class type parameters as
+  /// covariant.
+  void computeFormalSafety() {
+    if (target.strongMode) {
+      var unorderedClasses = <Class>[];
+      builders.forEach((Uri uri, LibraryBuilder library) {

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

Can you pass in this list either from collectAllClasses or
collectAllSourceClasses in kernel_target?

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

Done.

+        if (library is KernelLibraryBuilder) {
+          var builtLibrary = library.target;
+          unorderedClasses.addAll(builtLibrary.classes);
+        }
+      });
+      for (var cls in hierarchy.getOrderedClasses(unorderedClasses)) {
+        typeInferenceEngine.computeFormalSafety(cls);
+      }
+      ticker.logMs("Computed formal checks");
+    }
+  }
+
   List<Uri> getDependencies() => sourceBytes.keys.toList();
 
   Expression instantiateInvocation(Expression receiver, String name,
       Arguments arguments, int offset, bool isSuper) {
     return target.backendTarget.instantiateInvocation(
         coreTypes, receiver, name, arguments, offset, isSuper);
   }
 
   Expression instantiateNoSuchMethodError(
       Expression receiver, String name, Arguments arguments, int offset,
@@ skipping 24 matching lines @@
   Expression throwCompileConstantError(Expression error) {
     return target.backendTarget.throwCompileConstantError(coreTypes, error);
   }
 
   Expression buildCompileTimeError(Message message, int offset, Uri uri) {
     String text = target.context
         .format(message.withLocation(uri, offset), Severity.error);
     return target.backendTarget.buildCompileTimeError(coreTypes, text, offset);
   }
 }