Add hint for .runtimeType.toString()

Change-Id: I0a20f1fc42bc475c9acdf40b3d8aae16edbc8ea9
Reviewed-on: https://dart-review.googlesource.com/64845
Commit-Queue: Johnni Winther <[email protected]>
Reviewed-by: Sigmund Cherem <[email protected]>

Author: johnniwinther

pkg/compiler/lib/src/dart2js.dart

@@ -682,6 +682,12 @@ safe to use:
     Note: a well-typed program is not guaranteed to have valid inputs. For
     example, an int index argument may be null or out of range.
 
+  --lax-runtime-type-to-string
+    Omits reified class type arguments when these are only needed for `toString`
+    on `runtimeType`. This is useful if `runtimeType.toString()` is only used
+    for debugging. Note that semantics of other uses of `.runtimeType`, for
+    instance `a.runtimeType == b.runtimeType`, is not affected by this flag.
+
 The following options are only used for compiler development and may
 be removed in a future version:
 

pkg/compiler/lib/src/diagnostics/messages.dart

@@ -17,6 +17,7 @@ library dart2js.messages;
 import 'package:front_end/src/fasta/scanner.dart' show ErrorToken, Token;
 import 'generated/shared_messages.dart' as shared_messages;
 import '../constants/expressions.dart' show ConstantExpression;
+import '../commandline_options.dart';
 import 'invariant.dart' show failedAt;
 import 'spannable.dart' show CURRENT_ELEMENT_SPANNABLE;
 
@@ -90,6 +91,8 @@ enum MessageKind {
   RETHROW_OUTSIDE_CATCH,
   RETURN_IN_GENERATIVE_CONSTRUCTOR,
   RETURN_IN_GENERATOR,
+  RUNTIME_TYPE_TO_STRING_OBJECT,
+  RUNTIME_TYPE_TO_STRING_SUBTYPE,
   STRING_EXPECTED,
   UNDEFINED_GETTER,
   UNDEFINED_INSTANCE_GETTER_BUT_SETTER,
@@ -609,6 +612,25 @@ become a compile-time error in the future."""),
           "Overriding 'noSuchMethod' causes the compiler to generate "
           "more code and prevents the compiler from doing some optimizations.",
           howToFix: "Consider removing this 'noSuchMethod' implementation."),
+
+      MessageKind.RUNTIME_TYPE_TO_STRING_OBJECT: const MessageTemplate(
+          MessageKind.RUNTIME_TYPE_TO_STRING_OBJECT,
+          "Using '.runtimeType.toString()' causes the compiler to generate "
+          "more code because it needs to preserve type arguments on all "
+          "generic classes, even if they are not necessary elsewhere.",
+          howToFix: "If used only for debugging, consider using option "
+              "${Flags.laxRuntimeTypeToString} to reduce the code size "
+              "impact."),
+
+      MessageKind.RUNTIME_TYPE_TO_STRING_SUBTYPE: const MessageTemplate(
+          MessageKind.RUNTIME_TYPE_TO_STRING_SUBTYPE,
+          "Using '.runtimeType.toString()' here causes the compiler to "
+          "generate more code because it needs to preserve type arguments on "
+          "all generic subtypes of '#{receiverType}', even if they are not "
+          "necessary elsewhere.",
+          howToFix: "If used only for debugging, consider using option "
+              "${Flags.laxRuntimeTypeToString} to reduce the code size "
+              "impact."),
     }); // End of TEMPLATES.
 
   String toString() => template;

pkg/compiler/lib/src/options.dart

@@ -189,7 +189,7 @@ class CompilerOptions implements DiagnosticOptions {
   bool omitImplicitChecks = false;
 
   /// Whether to omit class type arguments only needed for `toString` on
-  /// `RuntimeType`.
+  /// `Object.runtimeType`.
   bool laxRuntimeTypeToString = false;
 
   /// What should the compiler do with type assertions of assignments.

pkg/compiler/lib/src/ssa/kernel_impact.dart

@@ -639,6 +639,27 @@ class KernelImpactBuilder extends ir.Visitor {
     if (node.name.name == Identifiers.runtimeType_) {
       if (_options.strongMode) {
         RuntimeTypeUse runtimeTypeUse = computeRuntimeTypeUse(elementMap, node);
+        if (_options.omitImplicitChecks) {
+          switch (runtimeTypeUse.kind) {
+            case RuntimeTypeUseKind.string:
+              if (!_options.laxRuntimeTypeToString) {
+                if (runtimeTypeUse.receiverType == commonElements.objectType) {
+                  reporter.reportHintMessage(
+                      computeSourceSpanFromTreeNode(node),
+                      MessageKind.RUNTIME_TYPE_TO_STRING_OBJECT);
+                } else {
+                  reporter.reportHintMessage(
+                      computeSourceSpanFromTreeNode(node),
+                      MessageKind.RUNTIME_TYPE_TO_STRING_SUBTYPE,
+                      {'receiverType': '${runtimeTypeUse.receiverType}.'});
+                }
+              }
+              break;
+            case RuntimeTypeUseKind.equals:
+            case RuntimeTypeUseKind.unknown:
+              break;
+          }
+        }
         impactBuilder.registerRuntimeTypeUse(runtimeTypeUse);
       } else {
         impactBuilder.registerRuntimeTypeUse(new RuntimeTypeUse(

tests/compiler/dart2js/rti/runtime_type_hint_test.dart

@@ -0,0 +1,55 @@
+// Copyright (c) 2018, 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.
+
+import 'package:async_helper/async_helper.dart';
+import 'package:compiler/src/commandline_options.dart';
+import 'package:compiler/src/diagnostics/messages.dart';
+import 'package:expect/expect.dart';
+
+import '../memory_compiler.dart';
+
+test(String code, List<String> options, List<MessageKind> expectedHints) async {
+  DiagnosticCollector collector = new DiagnosticCollector();
+  CompilationResult result = await runCompiler(
+      memorySourceFiles: {'main.dart': code},
+      options: options,
+      diagnosticHandler: collector);
+  Expect.isTrue(result.isSuccess);
+  List<MessageKind> actualHints =
+      collector.hints.map((c) => c.messageKind).toList();
+  String message = "Unexpected hints for $options on\n$code\n"
+      "Expected: ${expectedHints}\n"
+      "Actual  : ${actualHints}";
+  Expect.listEquals(expectedHints, actualHints, message);
+}
+
+String runtimeTypeToStringObject = '''
+main() {
+  print(new Object().runtimeType.toString());
+}
+''';
+
+String runtimeTypeToStringClass = '''
+class Class {}
+
+main() {
+  print(new Class().runtimeType.toString());
+}
+''';
+
+main() {
+  asyncTest(() async {
+    await test(runtimeTypeToStringObject, [], []);
+    await test(runtimeTypeToStringObject, [Flags.omitImplicitChecks],
+        [MessageKind.RUNTIME_TYPE_TO_STRING_OBJECT]);
+    await test(runtimeTypeToStringObject,
+        [Flags.omitImplicitChecks, Flags.laxRuntimeTypeToString], []);
+
+    await test(runtimeTypeToStringClass, [], []);
+    await test(runtimeTypeToStringClass, [Flags.omitImplicitChecks],
+        [MessageKind.RUNTIME_TYPE_TO_STRING_SUBTYPE]);
+    await test(runtimeTypeToStringClass,
+        [Flags.omitImplicitChecks, Flags.laxRuntimeTypeToString], []);
+  });
+}