Implement StringConcatNode in flow graph builder (it is ised on for "+" on strings, will be soon re…

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, 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 "vm/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
+#include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
+#include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/parser.h"
+#include "vm/resolver.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, print_ast);
 
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
@@ skipping 275 matching lines @@
           new BindInstr(temp_index(), new ConstantVal(bool_true)));
       Join(for_test, for_true, for_right);
     }
     ReturnValue(new TempVal(AllocateTempIndex()));
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
-void EffectGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
-  Bailout("EffectGraphVisitor::VisitStringConcatNode");
+void EffectGraphVisitor::CompiletimeStringInterpolation(
+    const Function& interpol_func, const Array& literals) {
+  // Do nothing.
 }
 
 
+void ValueGraphVisitor::CompiletimeStringInterpolation(
+    const Function& interpol_func, const Array& literals) {
+  // Build argument array to pass to the interpolation function.
+  GrowableArray<const Object*> interpolate_arg;
+  interpolate_arg.Add(&literals);
+  const Array& kNoArgumentNames = Array::Handle();
+  // Call the interpolation function.
+  String& concatenated = String::ZoneHandle();
+  concatenated ^= DartEntry::InvokeStatic(interpol_func,
+                                          interpolate_arg,
+                                          kNoArgumentNames);
+  if (concatenated.IsUnhandledException()) {
+    // TODO(srdjan): Remove this node and this UNREACHABLE.
+    UNREACHABLE();
+  }
+  ASSERT(!concatenated.IsNull());
+  concatenated = String::NewSymbol(concatenated);
+  ReturnValue(new ConstantVal(concatenated));
+}
+
+
+
+// TODO(srdjan): Remove this node once the "+" string operator has been
+// eliminated.
+void EffectGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
+  const String& cls_name = String::Handle(String::NewSymbol("StringBase"));
+  const Library& core_lib = Library::Handle(
+      Isolate::Current()->object_store()->core_library());
+  const Class& cls = Class::Handle(core_lib.LookupClass(cls_name));
+  ASSERT(!cls.IsNull());
+  const String& func_name = String::Handle(String::NewSymbol("_interpolate"));
+  const int number_of_parameters = 1;
+  const Function& interpol_func = Function::ZoneHandle(
+      Resolver::ResolveStatic(cls, func_name,
+                              number_of_parameters,
+                              Array::Handle(),
+                              Resolver::kIsQualified));
+  ASSERT(!interpol_func.IsNull());
+
+  // First try to concatenate and canonicalize the values at compile time.
+  bool compile_time_interpolation = true;
+  Array& literals = Array::Handle(Array::New(node->values()->length()));
+  for (int i = 0; i < node->values()->length(); i++) {
+    if (node->values()->ElementAt(i)->IsLiteralNode()) {
+      LiteralNode* lit = node->values()->ElementAt(i)->AsLiteralNode();
+      literals.SetAt(i, lit->literal());
+    } else {
+      compile_time_interpolation = false;
+      break;
+    }
+  }
+  if (compile_time_interpolation) {
+    // Not needed for effect, only for value
+    CompiletimeStringInterpolation(interpol_func, literals);
+    return;
+  }
+  // Runtime string interpolation.
+  ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
+  ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_index());
+  interpol_arg->Add(node->values());
+  TranslateArgumentList(*interpol_arg, temp_index(), values);
+  StaticCallComp* call =
+      new StaticCallComp(node->token_index(),
+                         interpol_func,
+                         interpol_arg->names(),
+                         values);
+  ReturnComputation(call);
+}
+
+
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsInstanceofOperator(node->kind())) {
     ArgumentGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     InstanceOfComp* instance_of = new InstanceOfComp(
         node->id(),
@@ skipping 1790 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart