Properly set the element type of literal lists.

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/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 1149 matching lines @@
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   // Translate the array elements and collect their values.
   ZoneGrowableArray<Value*>* values =
       new ZoneGrowableArray<Value*>(node->length());
   for (int i = 0; i < node->length(); ++i) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->ElementAt(i)->Visit(&for_value);
     Append(for_value);
     values->Add(for_value.value());
   }
-  CreateArrayComp* create = new CreateArrayComp(node,
+  Value* element_type = new UseVal(
+      BuildInstantiatedTypeArguments(node->token_index(),
+                                     node->type_arguments()));
+  CreateArrayComp* create = new CreateArrayComp(node->token_index(),
                                                 owner()->try_index(),
-                                                values);
+                                                values,
+                                                element_type);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
   if (function.IsNonImplicitClosureFunction()) {
     const ContextScope& context_scope = ContextScope::ZoneHandle(
         node->scope()->PreserveOuterScope(owner()->context_level()));
@@ skipping 165 matching lines @@
                          node->arguments()->names(),
                          values);
   AddInstruction(new DoInstr(call));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<Value*>* factory_arguments =
         new ZoneGrowableArray<Value*>();
-    factory_arguments->Add(new UseVal(BuildFactoryTypeArguments(node)));
+    factory_arguments->Add(
+        new UseVal(BuildInstantiatedTypeArguments(node->token_index(),
+                                                  node->type_arguments())));
     ASSERT(factory_arguments->length() == 1);
     TranslateArgumentList(*node->arguments(), factory_arguments);
     StaticCallComp* call =
         new StaticCallComp(node->token_index(),
                            owner()->try_index(),
                            node->constructor(),
                            node->arguments()->names(),
                            factory_arguments);
     ReturnComputation(call);
     return;
@@ skipping 50 matching lines @@
 
   BindInstr* load =
       new BindInstr(new NativeLoadFieldComp(
                         for_instantiator.value(),
                         type_arguments_instance_field_offset));
   AddInstruction(load);
   return new UseVal(load);
 }
 
 
-Definition* EffectGraphVisitor::BuildFactoryTypeArguments(
-    ConstructorCallNode* node) {
-  ASSERT(node->constructor().IsFactory());
-  if (node->type_arguments().IsNull() ||
-      node->type_arguments().IsInstantiated()) {
+Definition* EffectGraphVisitor::BuildInstantiatedTypeArguments(
+    intptr_t token_index,
+    const AbstractTypeArguments& type_arguments) {
+  if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     BindInstr* type_args =
-        new BindInstr(new ConstantVal(node->type_arguments()));
+        new BindInstr(new ConstantVal(type_arguments));
     AddInstruction(type_args);
     return type_args;
   }
   // The type arguments are uninstantiated.
-  Value* instantiator_value =
-      BuildInstantiatorTypeArguments(node->token_index());
-  BindInstr* extract =
-      new BindInstr(new ExtractFactoryTypeArgumentsComp(node,
-                                                        owner()->try_index(),
-                                                        instantiator_value));
-  AddInstruction(extract);
-  return extract;
+  Value* instantiator_value = BuildInstantiatorTypeArguments(token_index);
+  BindInstr* instantiate =
+      new BindInstr(new InstantiateTypeArgumentsComp(token_index,
+                                                     owner()->try_index(),
+                                                     type_arguments,
+                                                     instantiator_value));
+  AddInstruction(instantiate);
+  return instantiate;
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
     ZoneGrowableArray<Value*>* args) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   ASSERT(cls.HasTypeArguments() && !node->constructor().IsFactory());
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
@@ skipping 14 matching lines @@
   // Place holder to hold uninstantiated constructor type arguments.
   BindInstr* placeholder =
       new BindInstr(new ConstantVal(Object::ZoneHandle()));
   AddInstruction(placeholder);
   Value* instantiator =
       BuildInstantiatorTypeArguments(node->token_index());
   ASSERT(instantiator->IsUse());
   PickTempInstr* duplicate_instantiator =
       new PickTempInstr(instantiator->AsUse()->definition()->temp_index());
   AddInstruction(duplicate_instantiator);
-  BindInstr* extract_type_arguments =
-      new BindInstr(new ExtractConstructorTypeArgumentsComp(
-                        node, new UseVal(duplicate_instantiator)));
+  BindInstr* extract_type_arguments = new BindInstr(
+      new ExtractConstructorTypeArgumentsComp(
+          node->token_index(),
+          owner()->try_index(),
+          node->type_arguments(),
+          new UseVal(duplicate_instantiator)));
   AddInstruction(extract_type_arguments);
   AddInstruction(new TuckTempInstr(placeholder->temp_index(),
                                    extract_type_arguments->temp_index()));
   BindInstr* extract_instantiator =
       new BindInstr(new ExtractConstructorInstantiatorComp(
                         node,
                         instantiator,
                         new UseVal(extract_type_arguments)));
   AddInstruction(extract_instantiator);
   args->Add(new UseVal(placeholder));
@@ skipping 785 matching lines @@
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitCreateArray(CreateArrayComp* comp) {
   OS::Print("CreateArray(");
   for (int i = 0; i < comp->ElementCount(); ++i) {
     if (i != 0) OS::Print(", ");
     comp->ElementAt(i)->Accept(this);
   }
+  if (comp->ElementCount() > 0) OS::Print(", ");
+  comp->element_type()->Accept(this);
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitCreateClosure(CreateClosureComp* comp) {
   OS::Print("CreateClosure(%s", comp->function().ToCString());
   if (comp->type_arguments() != NULL) {
     OS::Print(", ");
     comp->type_arguments()->Accept(this);
   }
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitNativeLoadField(NativeLoadFieldComp* comp) {
   OS::Print("NativeLoadField(");
   comp->value()->Accept(this);
   OS::Print(", %d)", comp->offset_in_bytes());
 }
 
 
-void FlowGraphPrinter::VisitExtractFactoryTypeArguments(
-    ExtractFactoryTypeArgumentsComp* comp) {
-  OS::Print("ExtractFactoryTypeArguments(");
+void FlowGraphPrinter::VisitInstantiateTypeArguments(
+    InstantiateTypeArgumentsComp* comp) {
+  const String& type_args = String::Handle(comp->type_arguments().Name());
+  OS::Print("InstantiateTypeArguments(%s, ", type_args.ToCString());
   comp->instantiator()->Accept(this);
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitExtractConstructorTypeArguments(
     ExtractConstructorTypeArgumentsComp* comp) {
-  OS::Print("ExtractConstructorTypeArguments(");
+  const String& type_args = String::Handle(comp->type_arguments().Name());
+  OS::Print("ExtractConstructorTypeArguments(%s, ", type_args.ToCString());
   comp->instantiator()->Accept(this);
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitExtractConstructorInstantiator(
     ExtractConstructorInstantiatorComp* comp) {
   OS::Print("ExtractConstructorInstantiator(");
   comp->instantiator()->Accept(this);
   OS::Print(", ");
@@ skipping 244 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