dart2js cps: Count size of JS expressions in inliner.

pkg/compiler/lib/src/cps_ir/inline.dart

 // Copyright (c) 2015, 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 cps_ir.optimization.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
 import 'type_mask_system.dart' show TypeMaskSystem;
 import '../dart_types.dart' show DartType, GenericType;
 import '../world.dart' show World;
 import '../elements/elements.dart';
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../js_backend/codegen/task.dart' show CpsFunctionCompiler;
 import '../types/types.dart' show
     FlatTypeMask, ForwardingTypeMask, TypeMask, UnionTypeMask;
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart' show Selector;
+import 'package:js_ast/js_ast.dart' as js;
 
 /// Inlining stack entries.
 ///
 /// During inlining, a stack is used to detect cycles in the call graph.
 class StackEntry {
   // Dynamically resolved calls might be targeting an adapter function that
   // fills in optional arguments not passed at the call site.  Therefore these
   // calls are represented by the eventual target and the call structure at
   // the call site, which together identify the target.  Statically resolved
   // calls are represented by the target element and a null call structure.
@@ skipping 221 matching lines @@
   processThrow(Throw nose) => ++size;
   processRethrow(Rethrow node) => ++size;
 
   // Discount primitives that do not generate code.
   processRefinement(Refinement node) => --size;
   processBoundsCheck(BoundsCheck node) {
     if (node.hasNoChecks) {
       --size;
     }
   }
+
+  processForeignCode(ForeignCode node) {
+    // Count the number of nodes in the JS fragment, and discount the size
+    // originally added by LetPrim.
+    JsSizeVisitor visitor = new JsSizeVisitor();
+    node.codeTemplate.ast.accept(visitor);
+    size += visitor.size - 1;
+  }
 }
 
+class JsSizeVisitor extends js.BaseVisitor {
+  int size = 0;
+
+  visitNode(js.Node node) {
+    ++size;
+    return super.visitNode(node);
+  }
+
+  visitInterpolatedExpression(js.InterpolatedExpression node) {
+    // Suppress call to visitNode.  Placeholders should not be counted, because
+    // the argument has already been counted, and will in most cases be inserted
+    // directly in the placeholder.
+  }
+}
+
+
 class InliningVisitor extends TrampolineRecursiveVisitor {
   final Inliner _inliner;
 
   // A successful inlining attempt returns the [Primitive] that represents the
   // result of the inlined call or null.  If the result is non-null, the body
   // of the inlined function is available in this field.
   CpsFragment _fragment;
 
   InliningVisitor(this._inliner);
 
@@ skipping 321 matching lines @@
         (enclosingClass == backend.helpers.jsNumberClass ||
          enclosingClass == backend.helpers.jsDoubleClass ||
          enclosingClass == backend.helpers.jsIntClass)) {
       // These should be handled by operator specialization.
       return true;
     }
     if (target == backend.helpers.stringInterpolationHelper) return true;
     return false;
   }
 }