dart2js cps: Retain refinement nodes and update refinements after GVN.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart

 // Copyright (c) 2014, 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 tree_ir_builder;
 
 import '../common.dart';
 import '../constants/values.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../elements/elements.dart';
@@ skipping 80 matching lines @@
 
   VariableUse getMutableVariableUse(
         cps_ir.Reference<cps_ir.MutableVariable> reference) {
     Variable variable = getMutableVariable(reference.definition);
     return new VariableUse(variable);
   }
 
   /// Obtains the variable representing the given primitive. Returns null for
   /// primitives that have no reference and do not need a variable.
   Variable getVariable(cps_ir.Primitive primitive) {
+    primitive = primitive.effectiveDefinition;
     return primitive2variable.putIfAbsent(primitive,
         () => new Variable(currentElement, primitive.hint));
   }
 
   /// Obtains a reference to the tree Variable corresponding to the IR primitive
   /// referred to by [reference].
   /// This increments the reference count for the given variable, so the
   /// returned expression must be used in the tree.
   Expression getVariableUse(cps_ir.Reference<cps_ir.Primitive> reference) {
-    if (thisParameter != null && reference.definition == thisParameter) {
+    if (thisParameter != null &&
+        reference.definition.effectiveDefinition == thisParameter) {
       return new This();
     }
     return new VariableUse(getVariable(reference.definition));
   }
 
   Label getLabel(cps_ir.Continuation cont) {
     return labels.putIfAbsent(cont, () => new Label());
   }
 
   Variable addFunctionParameter(cps_ir.Parameter parameter) {
@@ skipping 324 matching lines @@
   Expression visitCreateInstance(cps_ir.CreateInstance node) {
     return new CreateInstance(
         node.classElement,
         translateArguments(node.arguments),
         translateArguments(node.typeInformation),
         node.sourceInformation);
   }
 
   Expression visitGetField(cps_ir.GetField node) {
     return new GetField(getVariableUse(node.object), node.field,
-        objectIsNotNull: node.objectIsNotNull);
+        objectIsNotNull: !node.object.definition.type.isNullable);

[sra1, 2015/12/11 02:44:15]

Explain why the refined type is not appropriate

[asgerf, 2015/12/11 10:18:18]

It is the refined type.

   }
 
   Expression visitCreateBox(cps_ir.CreateBox node) {
     return new CreateBox();
   }
 
   Expression visitCreateInvocationMirror(cps_ir.CreateInvocationMirror node) {
     return new CreateInvocationMirror(
         node.selector,
         translateArguments(node.arguments));
@@ skipping 80 matching lines @@
       return new Not(getVariableUse(node.arguments.single));
     }
     return new ApplyBuiltinOperator(node.operator,
                                     translateArguments(node.arguments));
   }
 
   Expression visitApplyBuiltinMethod(cps_ir.ApplyBuiltinMethod node) {
     return new ApplyBuiltinMethod(node.method,
         getVariableUse(node.receiver),
         translateArguments(node.arguments),
-        receiverIsNotNull: node.receiverIsNotNull);
+        receiverIsNotNull: !node.receiver.definition.type.isNullable);
   }
 
   Expression visitGetLength(cps_ir.GetLength node) {
     return new GetLength(getVariableUse(node.object));
   }
 
   Expression visitGetIndex(cps_ir.GetIndex node) {
     return new GetIndex(getVariableUse(node.object),
                         getVariableUse(node.index));
   }
@@ skipping 10 matching lines @@
                                          node.sourceInformation);
   }
 
   Expression visitInvokeMethod(cps_ir.InvokeMethod node) {
     InvokeMethod invoke = new InvokeMethod(
         getVariableUse(node.receiver),
         node.selector,
         node.mask,
         translateArguments(node.arguments),
         node.sourceInformation);
-    invoke.receiverIsNotNull = node.receiverIsNotNull;
+    // Sometimes we know the Dart receiver is non-null because it has been
+    // refined, which implies that the JS receiver also can not be null at the
+    // use-site.  Interceptors are not refined, so this information is not
+    // always available on the JS receiver.
+    // Also check the JS receiver's type, however, because sometimes we know an
+    // interceptor is non-null because it intercepts JSNull.
+    invoke.receiverIsNotNull =
+        !node.dartReceiver.type.isNullable ||
+        !node.receiver.definition.type.isNullable;
     return invoke;
   }
 
   Expression visitInvokeMethodDirectly(cps_ir.InvokeMethodDirectly node) {
     Expression receiver = getVariableUse(node.receiver);
     List<Expression> arguments = translateArguments(node.arguments);
     return new InvokeMethodDirectly(receiver, node.target,
         node.selector, arguments, node.sourceInformation);
   }
 
@@ skipping 57 matching lines @@
       return new Yield(getVariableUse(node.input), node.hasStar, next);
     };
   }
 
   @override
   Expression visitAwait(cps_ir.Await node) {
     return new Await(getVariableUse(node.input));
   }
 
   @override
-  Expression visitRefinement(cps_ir.Refinement node) {
-    throw 'Unexpected Refinement node in tree builder';
+  visitRefinement(cps_ir.Refinement node) {
+    return (Statement next) => next; // Compile to nothing.
   }
 
   /********** UNUSED VISIT METHODS *************/
 
   unexpectedNode(cps_ir.Node node) {
     internalError(CURRENT_ELEMENT_SPANNABLE, 'Unexpected IR node: $node');
   }
 
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
     unexpectedNode(node);
@@ skipping 20 matching lines @@
     --enclosingFunctions;
   }
 
   @override
   visitInterpolatedNode(js.InterpolatedNode node) {
     if (enclosingFunctions > 0) {
       found = true;
     }
   }
 }