[CFE] Record const constructor coverage when evaluating constants

This CL records which const constructors were evaluated
(i.e. contributes coverage) but doesn't actually
save the coverage into the dill file.

runtimes for constant evaluation:
dart2js: No difference proven at 95.0% confidence
flutter gallery: No difference proven at 95.0% confidence
big internal app: No difference proven at 95.0% confidence

sdk sizes:
vm: no change
dart2js: no change
flutter: no change

compile sizes:
dart2js: no change
flutter gallery: no change
big internal app: no change

Change-Id: I2567446c1b78180d73fd7613bc9e780e1a067f5b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/170435
Commit-Queue: Jens Johansen <jensj@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>

Author: jensjoha

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

@@ -104,7 +104,7 @@ Component transformComponent(
   return component;
 }
 
-void transformLibraries(
+ConstantCoverage transformLibraries(
     List<Library> libraries,
     ConstantsBackend backend,
     Map<String, String> environmentDefines,
@@ -132,6 +132,7 @@ void transformLibraries(
   for (final Library library in libraries) {
     constantsTransformer.convertLibrary(library);
   }
+  return constantsTransformer.constantEvaluator.getConstantCoverage();
 }
 
 void transformProcedure(
@@ -1010,6 +1011,18 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
     return lower(constant, backend.lowerMapConstant(constant));
   }
 
+  Map<Uri, Set<Reference>> _constructorCoverage = {};
+
+  ConstantCoverage getConstantCoverage() {
+    return new ConstantCoverage(_constructorCoverage);
+  }
+
+  void _recordConstructorCoverage(Constructor constructor, TreeNode caller) {
+    Uri currentUri = getFileUri(caller);
+    Set<Reference> uriCoverage = _constructorCoverage[currentUri] ??= {};
+    uriCoverage.add(constructor.reference);
+  }
+
   /// Evaluate [node] and possibly cache the evaluation result.
   ///
   /// Returns [_AbortDueToErrorConstant] or
@@ -1344,13 +1357,13 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
       if (shouldBeUnevaluated) {
         enterLazy();
         AbortConstant error = handleConstructorInvocation(
-            constructor, typeArguments, positionals, named);
+            constructor, typeArguments, positionals, named, node);
         if (error != null) return error;
         leaveLazy();
         return unevaluated(node, instanceBuilder.buildUnevaluatedInstance());
       }
       AbortConstant error = handleConstructorInvocation(
-          constructor, typeArguments, positionals, named);
+          constructor, typeArguments, positionals, named, node);
       if (error != null) return error;
       if (shouldBeUnevaluated) {
         return unevaluated(node, instanceBuilder.buildUnevaluatedInstance());
@@ -1547,11 +1560,15 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
       Constructor constructor,
       List<DartType> typeArguments,
       List<Constant> positionalArguments,
-      Map<String, Constant> namedArguments) {
+      Map<String, Constant> namedArguments,
+      TreeNode caller) {
     return withNewEnvironment(() {
       final Class klass = constructor.enclosingClass;
       final FunctionNode function = constructor.function;
 
+      // Mark in file of the caller that we evaluate this specific constructor.
+      _recordConstructorCoverage(constructor, caller);
+
       // We simulate now the constructor invocation.
 
       // Step 1) Map type arguments and normal arguments from caller to
@@ -1626,8 +1643,8 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
           }
           assert(_gotError == null);
           assert(namedArguments != null);
-          error = handleConstructorInvocation(
-              init.target, types, positionalArguments, namedArguments);
+          error = handleConstructorInvocation(init.target, types,
+              positionalArguments, namedArguments, constructor);
           if (error != null) return error;
         } else if (init is RedirectingInitializer) {
           // Since a redirecting constructor targets a constructor of the same
@@ -1654,8 +1671,8 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
           assert(_gotError == null);
           assert(namedArguments != null);
 
-          error = handleConstructorInvocation(
-              init.target, typeArguments, positionalArguments, namedArguments);
+          error = handleConstructorInvocation(init.target, typeArguments,
+              positionalArguments, namedArguments, constructor);
           if (error != null) return error;
         } else if (init is AssertInitializer) {
           AbortConstant error = checkAssert(init.statement);
@@ -2824,6 +2841,12 @@ class ConstantEvaluator extends RecursiveVisitor<Constant> {
   }
 }
 
+class ConstantCoverage {
+  final Map<Uri, Set<Reference>> constructorCoverage;
+
+  ConstantCoverage(this.constructorCoverage);
+}
+
 /// Holds the necessary information for a constant object, namely
 ///   * the [klass] being instantiated
 ///   * the [typeArguments] used for the instantiation

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

@@ -105,7 +105,11 @@ import '../source/source_loader.dart' show SourceLoader;
 import '../target_implementation.dart' show TargetImplementation;
 import '../uri_translator.dart' show UriTranslator;
 import 'constant_evaluator.dart' as constants
-    show EvaluationMode, transformLibraries, transformProcedure;
+    show
+        EvaluationMode,
+        transformLibraries,
+        transformProcedure,
+        ConstantCoverage;
 import 'kernel_constants.dart' show KernelConstantErrorReporter;
 import 'metadata_collector.dart' show MetadataCollector;
 import 'verifier.dart' show verifyComponent, verifyGetStaticType;
@@ -126,6 +130,10 @@ class KernelTarget extends TargetImplementation {
 
   Component component;
 
+  /// Temporary field meant for testing only. Follow-up CLs should get rid of
+  /// this and integrate coverage properly.
+  constants.ConstantCoverage constantCoverageForTesting;
+
   // 'dynamic' is always nullable.
   // TODO(johnniwinther): Why isn't this using a FixedTypeBuilder?
   final TypeBuilder dynamicType = new NamedTypeBuilder(
@@ -1231,7 +1239,7 @@ class KernelTarget extends TargetImplementation {
         new TypeEnvironment(loader.coreTypes, loader.hierarchy);
     constants.EvaluationMode evaluationMode = _getConstantEvaluationMode();
 
-    constants.transformLibraries(
+    constants.ConstantCoverage coverage = constants.transformLibraries(
         loader.libraries,
         backendTarget.constantsBackend(loader.coreTypes),
         environmentDefines,
@@ -1244,6 +1252,7 @@ class KernelTarget extends TargetImplementation {
             isExperimentEnabledGlobally(ExperimentalFlag.tripleShift),
         errorOnUnevaluatedConstant: errorOnUnevaluatedConstant);
     ticker.logMs("Evaluated constants");
+    constantCoverageForTesting = coverage;
 
     if (loader.target.context.options
         .isExperimentEnabledGlobally(ExperimentalFlag.valueClass)) {

pkg/front_end/test/fasta/testing/suite.dart

@@ -1115,16 +1115,16 @@ class Outline extends Step<TestDescription, ComponentResult, FastaContext> {
             await instrumentation.fixSource(description.uri, false);
           } else {
             return new Result<ComponentResult>(
-                new ComponentResult(
-                    description, p, userLibraries, options, sourceTarget),
+                new ComponentResult(description, p, userLibraries, options,
+                    sourceTarget, sourceTarget.constantCoverageForTesting),
                 context.expectationSet["InstrumentationMismatch"],
                 instrumentation.problemsAsString,
                 autoFixCommand: '${UPDATE_COMMENTS}=true');
           }
         }
       }
-      return pass(new ComponentResult(
-          description, p, userLibraries, options, sourceTarget));
+      return pass(new ComponentResult(description, p, userLibraries, options,
+          sourceTarget, sourceTarget.constantCoverageForTesting));
     });
   }
 

pkg/front_end/test/spell_checking_list_code.txt

@@ -245,6 +245,7 @@ corrections
 cosmetic
 counters
 covariances
+coverage
 cr
 creator
 criterion
@@ -547,6 +548,7 @@ inspired
 inst
 instanceof
 instantiator
+integrate
 intentionally
 interim
 interior

pkg/front_end/test/utils/kernel_chain.dart

@@ -23,6 +23,8 @@ import 'package:front_end/src/compute_platform_binaries_location.dart'
 import 'package:front_end/src/fasta/compiler_context.dart' show CompilerContext;
 
 import 'package:front_end/src/fasta/fasta_codes.dart' show templateUnspecified;
+import 'package:front_end/src/fasta/kernel/constant_evaluator.dart'
+    show ConstantCoverage;
 
 import 'package:front_end/src/fasta/kernel/kernel_target.dart'
     show KernelTarget;
@@ -293,6 +295,24 @@ class MatchExpectation
         buffer.writeln(extraConstantString);
       }
     }
+    // TODO(jensj): Don't comment this out. Will be done in a follow-up-CL.
+    // if (result.constantCoverage != null) {
+    //   ConstantCoverage constantCoverage = result.constantCoverage;
+    //   if (constantCoverage.constructorCoverage.isNotEmpty) {
+    //     buffer.writeln("");
+    //     buffer.writeln("");
+    //     buffer.writeln("Constructor coverage from constants:");
+    //     for (MapEntry<Uri, Set<Reference>> entry
+    //         in constantCoverage.constructorCoverage.entries) {
+    //       buffer.writeln("${entry.key}:");
+    //       for (Reference reference in entry.value) {
+    //         buffer.writeln(
+    //             "- ${reference.node} (from ${reference.node.location})");
+    //       }
+    //       buffer.writeln("");
+    //     }
+    //   }
+    // }
 
     String actual = "$buffer";
     String binariesPath =
@@ -393,8 +413,14 @@ class WriteDill extends Step<ComponentResult, ComponentResult, ChainContext> {
     Uri uri = tmp.uri.resolve("generated.dill");
     File generated = new File.fromUri(uri);
     IOSink sink = generated.openWrite();
-    result = new ComponentResult(result.description, result.component,
-        result.userLibraries, result.options, result.sourceTarget, uri);
+    result = new ComponentResult(
+        result.description,
+        result.component,
+        result.userLibraries,
+        result.options,
+        result.sourceTarget,
+        result.constantCoverage,
+        uri);
     try {
       new BinaryPrinter(sink).writeComponentFile(component);
     } catch (e, s) {
@@ -493,9 +519,10 @@ class ComponentResult {
   final ProcessedOptions options;
   final KernelTarget sourceTarget;
   final List<String> extraConstantStrings = [];
+  final ConstantCoverage constantCoverage;
 
   ComponentResult(this.description, this.component, this.userLibraries,
-      this.options, this.sourceTarget,
+      this.options, this.sourceTarget, this.constantCoverage,
       [this.outputUri]);
 
   bool isUserLibrary(Library library) {

pkg/front_end/testcases/general/constants/const_constructor_coverage.dart

@@ -0,0 +1,27 @@
+// Copyright (c) 2020, 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 "const_constructor_coverage_lib1.dart";
+import "const_constructor_coverage_lib2.dart";
+
+const Foo foo1 = const Foo();
+const Foo foo2 = const Foo.named1();
+const Foo foo3 = const Foo.named2();
+const Foo foo4 = const Foo.named3();
+
+main() {
+  print(foo1);
+}
+
+// This file in itself should mark the following as const-constructor-covered:
+// * "Foo", "Foo.named1", "Foo.named2" and "Foo.named3" from constant-evaluating
+//   the const fields.
+
+// Notice, that combined these 3 files should have coverage for:
+// * "Foo", "Foo.named1", "Foo.named2", "Foo.named3",
+// * "Bar", "Bar.named1", "Bar.named2", "Bar.named3",
+// * "Baz", "Baz.named1", "Baz.named4", "Baz.named5", "Baz.named6"
+// but NOT have any coverage for
+// * "Bar.named4",
+// * "Baz.named2" and "Baz.named3".