VM: [KERNEL] handle single-argument string interpolation in VM

runtime/vm/kernel_to_il.cc

 // 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.
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 2731 matching lines @@
 
 Fragment FlowGraphBuilder::StringInterpolate(TokenPosition position) {
   Value* array = Pop();
   StringInterpolateInstr* interpolate =
       new (Z) StringInterpolateInstr(array, position);
   Push(interpolate);
   return Fragment(interpolate);
 }
 
 
+Fragment FlowGraphBuilder::StringInterpolateSingle(TokenPosition position) {
+  const int kNumberOfArguments = 1;
+  const Array& kNoArgumentNames = Object::null_array();
+  const dart::Class& cls = dart::Class::Handle(
+      dart::Library::LookupCoreClass(Symbols::StringBase()));
+  ASSERT(!cls.IsNull());
+  const Function& function = dart::Function::ZoneHandle(
+      Z, dart::Resolver::ResolveStatic(cls, dart::Library::PrivateCoreLibName(
+                                                Symbols::InterpolateSingle()),
+                                       kNumberOfArguments, kNoArgumentNames));
+  Fragment instructions;
+  instructions += PushArgument();
+  instructions += StaticCall(position, function, 1);
+  return instructions;
+}
+
+
 Fragment FlowGraphBuilder::ThrowTypeError() {
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::TypeError()));
   ASSERT(!klass.IsNull());
   const dart::Function& constructor = dart::Function::ZoneHandle(
       Z,
       klass.LookupConstructorAllowPrivate(H.DartSymbol("_TypeError._create")));
   ASSERT(!constructor.IsNull());
 
   const dart::String& url = H.DartString(
@@ skipping 2400 matching lines @@
 void FlowGraphBuilder::VisitThisExpression(ThisExpression* node) {
   fragment_ = LoadLocal(scopes_->this_variable);
 }
 
 
 void FlowGraphBuilder::VisitStringConcatenation(StringConcatenation* node) {
   List<Expression>& expressions = node->expressions();
 
   Fragment instructions;
 
-  // The type arguments for CreateArray.
-  instructions += Constant(TypeArguments::ZoneHandle(Z));
-  instructions += IntConstant(expressions.length());
-  instructions += CreateArray();
-  LocalVariable* array = MakeTemporary();
+  if (node->expressions().length() == 1) {
+    instructions += TranslateExpression(node->expressions()[0]);
+    instructions += StringInterpolateSingle(node->position());
+  } else {
+    // The type arguments for CreateArray.
+    instructions += Constant(TypeArguments::ZoneHandle(Z));
+    instructions += IntConstant(expressions.length());
+    instructions += CreateArray();
+    LocalVariable* array = MakeTemporary();
 
-  for (intptr_t i = 0; i < node->expressions().length(); i++) {
-    instructions += LoadLocal(array);
-    instructions += IntConstant(i);
-    instructions += TranslateExpression(node->expressions()[i]);
-    instructions += StoreIndexed(kArrayCid);
-    instructions += Drop();
+    for (intptr_t i = 0; i < node->expressions().length(); i++) {
+      instructions += LoadLocal(array);
+      instructions += IntConstant(i);
+      instructions += TranslateExpression(node->expressions()[i]);
+      instructions += StoreIndexed(kArrayCid);
+      instructions += Drop();
+    }
+
+    instructions += StringInterpolate(node->position());
   }
-
-  instructions += StringInterpolate(node->position());
-
   fragment_ = instructions;
 }
 
 
 void FlowGraphBuilder::VisitListLiteral(ListLiteral* node) {
   if (node->is_const()) {
     fragment_ = Constant(constant_evaluator_.EvaluateListLiteral(node));
     return;
   }
 
@@ skipping 1246 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)