Improve constant propagation to handle InstantiateTypeArguments.

runtime/vm/flow_graph_optimizer.cc

Index: runtime/vm/flow_graph_optimizer.cc
===================================================================
--- runtime/vm/flow_graph_optimizer.cc	(revision 15377)
+++ runtime/vm/flow_graph_optimizer.cc	(working copy)
@@ -3438,6 +3438,19 @@
 
 void ConstantPropagator::VisitInstantiateTypeArguments(
     InstantiateTypeArgumentsInstr* instr) {
+  const Object& object =
+      instr->instantiator()->definition()->constant_value();
+  if (IsNonConstant(object)) {

[Kevin Millikin (Google), 2012/11/28 07:57:25]

If the value is unknown (bottom) it should not move up the lattice to
non-constant (top) because it prevents us discovering it is constant later.

I don't personally like the early return in such a small function, either.  In
my opinion, this is clearer:

if (IsNonConstant(object)) {
  SetValue(instr, non_constant_);
} else if (IsConstant(object)) {
  if (!object.IsNull() &&
      object.IsTypeArguments() &&
      TypeArguments::Cast(object).Length() == instr->type_arguments().Length()))
{
    SetValue(instr, object);
  } else {
    SetValue(instr, non_constant_);
  }
}

[Florian Schneider, 2012/11/28 13:02:59]

Thanks. Done.

+    SetValue(instr, non_constant_);
+    return;
+  }
+  if (!object.IsNull() && object.IsTypeArguments()) {

[srdjan, 2012/11/30 00:49:54]

You need to handle also the case for null otherwise "new List()" is not
optimized. (check generated code for "new List()" vs "new List<int>()").

[Florian Schneider, 2012/12/04 11:40:09]

Yes, that's a good suggestion. I'll add that case.

+    const TypeArguments& instantiator = TypeArguments::Cast(object);
+    if (instantiator.Length() == instr->type_arguments().Length()) {
+      SetValue(instr, instantiator);
+      return;
+    }
+  }
   SetValue(instr, non_constant_);
 }
 
@@ -3713,7 +3726,8 @@
       // TODO(kmillikin): Extend this to handle booleans, other number
       // types, etc.
       if ((defn != NULL) &&
-          defn->constant_value().IsSmi() &&
+          (defn->constant_value().IsSmi() ||
+           defn->constant_value().IsTypeArguments()) &&
           !defn->IsConstant() &&
           !defn->IsPushArgument() &&
           !defn->IsStoreIndexed() &&