Default value constants are created only call uses them

pkg/compiler/lib/src/ssa/builder_kernel.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 14 matching lines @@
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/element_map.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/nodes.dart' show Node;
 import '../types/masks.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart' show SideEffects;
-import '../universe/use.dart' show DynamicUse;
+import '../universe/use.dart' show ConstantUse, DynamicUse;
 import '../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'ssa.dart';
@@ skipping 92 matching lines @@
       } else if (target is ir.Field) {
         if (handleConstantField(targetElement, registry, closedWorld)) {
           // No code is generated for `targetElement`: All references inline the
           // constant value.
           return null;
         } else if (targetElement.isStatic || targetElement.isTopLevel) {
           backend.constants.registerLazyStatic(targetElement);
         }
         buildField(target);
       } else if (target is ir.Constructor) {
+        _targetFunction = (target as ir.Constructor).function;
         if (targetElement is ConstructorBodyEntity) {
           buildConstructorBody(target);
         } else {
           buildConstructor(target);
         }
       } else if (target is ir.FunctionExpression) {
         _targetFunction = (target as ir.FunctionExpression).function;
         buildFunctionNode(_targetFunction);
       } else if (target is ir.FunctionDeclaration) {
         _targetFunction = (target as ir.FunctionDeclaration).function;
         buildFunctionNode(_targetFunction);
       } else {
         throw 'No case implemented to handle target: '
             '$target for $targetElement';
       }
       assert(graph.isValid());
+      if (_targetFunction != null) {
+        _ensureDefaultArgumentValues(_targetFunction);
+      }
       return graph;
     });
   }
 
+  void _ensureDefaultArgumentValues(ir.FunctionNode function) {
+    // Register all [function]'s default argument values.
+    //
+    // Default values might be (or contain) functions that are not referenced
+    // from anywhere else so we need to ensure these are enqueued.  Stubs and
+    // `Function.apply` data are created after the codegen queue is closed, so
+    // we force these functions into the queue by registering the constants as
+    // used in advance. See language/cyclic_default_values_test.dart for an
+    // example.
+    //
+    // TODO(sra): We could be more precise if stubs and `Function.apply` data
+    // were generated by the codegen enqueuer. In practice even in huge programs
+    // there are only very small number of constants created here that are not
+    // actually used.
+    void registerDefaultValue(ir.VariableDeclaration node) {
+      ConstantValue constantValue =
+          _elementMap.getConstantValue(node.initializer, implicitNull: true);
+      assert(
+          constantValue != null,
+          failedAt(_elementMap.getMethod(function.parent),
+              'No constant computed for $node'));
+      registry?.registerConstantUse(new ConstantUse.init(constantValue));
+    }
+
+    function.positionalParameters
+        .skip(function.requiredParameterCount)
+        .forEach(registerDefaultValue);
+    function.namedParameters.forEach(registerDefaultValue);
+  }
+
   @override
   ConstantValue getFieldInitialConstantValue(FieldEntity field) {
     assert(field == targetElement);
     return _elementMap.getFieldConstantValue(target);
   }
 
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
       field.initializer.accept(this);
@@ skipping 3338 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }