[kernel] Erase function type parameters to fake strong mode on the VM.

The VM does not support function type parameters at the moment, but we
can erase them at the last minute, to enable testing of other parts of
strong mode.

This also disables error checking in the SDK since the VM's
patch files are not in strong mode.

BUG=
[email protected]

Review URL: https://chromereviews.googleplex.com/518647013 .

Author: asgerf

pkg/kernel/lib/analyzer/loader.dart

@@ -535,20 +535,17 @@ class DartLoader implements ReferenceLevelLoader {
     var element = context.computeLibraryElement(source);
     context.resolveCompilationUnit(source, element);
     _buildLibraryBody(element, node);
-    for (var unit in element.units) {
-      LineInfo lines;
-      for (var error in context.computeErrors(unit.source)) {
-        if (error.errorCode is CompileTimeErrorCode ||
-            error.errorCode is ParserErrorCode ||
-            error.errorCode is ScannerErrorCode ||
-            error.errorCode is StrongModeCode) {
-          if (error.errorCode == ParserErrorCode.CONST_FACTORY &&
-              node.importUri.scheme == 'dart') {
-            // Ignore warnings about 'const' factories in the patched SDK.
-            continue;
+    if (node.importUri.scheme != 'dart') {
+      for (var unit in element.units) {
+        LineInfo lines;
+        for (var error in context.computeErrors(unit.source)) {
+          if (error.errorCode is CompileTimeErrorCode ||
+              error.errorCode is ParserErrorCode ||
+              error.errorCode is ScannerErrorCode ||
+              error.errorCode is StrongModeCode) {
+            lines ??= context.computeLineInfo(source);
+            errors.add(formatErrorMessage(error, source.shortName, lines));
           }
-          lines ??= context.computeLineInfo(source);
-          errors.add(formatErrorMessage(error, source.shortName, lines));
         }
       }
     }
@@ -689,8 +686,8 @@ AnalysisOptions createAnalysisOptions(bool strongMode) {
   return new AnalysisOptionsImpl()
     ..strongMode = strongMode
     ..enableGenericMethods = strongMode
-    ..generateImplicitErrors = true
-    ..generateSdkErrors = true
+    ..generateImplicitErrors = false
+    ..generateSdkErrors = false
     ..preserveComments = false
     ..hint = false
     ..enableSuperMixins = true;

pkg/kernel/lib/ast.dart

@@ -1254,7 +1254,11 @@ class VariableGet extends Expression {
     promotedType?.accept(v);
   }
 
-  transformChildren(Transformer v) {}
+  transformChildren(Transformer v) {
+    if (promotedType != null) {
+      promotedType = v.visitDartType(promotedType);
+    }
+  }
 }
 
 /// Assign a local variable or function parameter.
@@ -1952,6 +1956,7 @@ class ConditionalExpression extends Expression {
     condition?.accept(v);
     then?.accept(v);
     otherwise?.accept(v);
+    staticType?.accept(v);
   }
 
   transformChildren(Transformer v) {
@@ -1967,6 +1972,9 @@ class ConditionalExpression extends Expression {
       otherwise = otherwise.accept(v);
       otherwise?.parent = this;
     }
+    if (staticType != null) {
+      staticType = v.visitDartType(staticType);
+    }
   }
 }
 

pkg/kernel/lib/target/flutter.dart

@@ -3,11 +3,12 @@
 // BSD-style license that can be found in the LICENSE file.
 library kernel.target.flutter;
 
-import 'targets.dart';
 import '../ast.dart';
-import '../transformations/mixin_full_resolution.dart' as mix;
 import '../transformations/continuation.dart' as cont;
+import '../transformations/erasure.dart';
+import '../transformations/mixin_full_resolution.dart' as mix;
 import '../transformations/setup_builtin_library.dart' as setup_builtin_library;
+import 'targets.dart';
 
 class FlutterTarget extends Target {
   final TargetFlags flags;
@@ -54,5 +55,9 @@ class FlutterTarget extends Target {
     // Repair `_getMainClosure()` function in dart:{_builtin,ui} libraries.
     setup_builtin_library.transformProgram(program);
     setup_builtin_library.transformProgram(program, libraryUri: 'dart:ui');
+
+    if (strongMode) {
+      new Erasure().transform(program);
+    }
   }
 }

pkg/kernel/lib/target/vm.dart

@@ -7,6 +7,7 @@ import 'targets.dart';
 import '../ast.dart';
 import '../transformations/mixin_full_resolution.dart' as mix;
 import '../transformations/continuation.dart' as cont;
+import '../transformations/erasure.dart';
 import '../transformations/setup_builtin_library.dart' as setup_builtin_library;
 
 /// Specializes the kernel IR to the Dart VM.
@@ -49,5 +50,9 @@ class VmTarget extends Target {
 
     // Repair `_getMainClosure()` function in dart:_builtin.
     setup_builtin_library.transformProgram(program);
+
+    if (strongMode) {
+      new Erasure().transform(program);
+    }
   }
 }

pkg/kernel/lib/transformations/erasure.dart

@@ -0,0 +1,78 @@
+// 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 kernel.transformations.erasure;
+
+import '../ast.dart';
+import '../type_algebra.dart';
+
+/// Erases all function type parameter lists and replaces all uses of them with
+/// their upper bounds.
+///
+/// This is a temporary measure to run strong mode code in the VM, which does
+/// not yet support function type parameters.
+///
+/// This does not preserve dynamic type safety.
+class Erasure extends Transformer {
+  final Map<TypeParameter, DartType> substitution = <TypeParameter, DartType>{};
+
+  void transform(Program program) {
+    program.accept(this);
+  }
+
+  @override
+  visitDartType(DartType type) => substitute(type, substitution);
+
+  @override
+  visitProcedure(Procedure node) {
+    if (node.kind == ProcedureKind.Factory) {
+      assert(node.enclosingClass != null);
+      assert(node.enclosingClass.typeParameters.length ==
+          node.function.typeParameters.length);
+      // Factories can have function type parameters as long as they correspond
+      // exactly to those on the enclosing class.
+      // Skip the visitFunctionNode but traverse body for local functions.
+      node.function.transformChildren(this);
+    } else {
+      node.transformChildren(this);
+    }
+    return node;
+  }
+
+  @override
+  visitFunctionNode(FunctionNode node) {
+    for (var parameter in node.typeParameters) {
+      substitution[parameter] = const DynamicType();
+    }
+    for (var parameter in node.typeParameters) {
+      substitution[parameter] = substitute(parameter.bound, substitution);
+    }
+    node.transformChildren(this);
+    node.typeParameters.forEach(substitution.remove);
+    node.typeParameters.clear();
+    return node;
+  }
+
+  @override
+  visitStaticInvocation(StaticInvocation node) {
+    if (node.target.kind != ProcedureKind.Factory) {
+      node.arguments.types.clear();
+    }
+    node.transformChildren(this);
+    return node;
+  }
+
+  @override
+  visitMethodInvocation(MethodInvocation node) {
+    node.arguments.types.clear();
+    node.transformChildren(this);
+    return node;
+  }
+
+  @override
+  visitDirectMethodInvocation(DirectMethodInvocation node) {
+    node.arguments.types.clear();
+    node.transformChildren(this);
+    return node;
+  }
+}