dart2js cps: Use dummy constant in dummy receiver optimization.

pkg/compiler/lib/src/cps_ir/type_propagation.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.
 
 import 'optimizers.dart';
 
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' as dart2js show
     Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../dart_types.dart' as types;
 import '../diagnostics/invariant.dart' as dart2js show
     InternalErrorFunction;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
-import '../js_backend/js_backend.dart' show JavaScriptBackend;
+import '../js_backend/js_backend.dart' show JavaScriptBackend,
+    SyntheticConstantKind;
 import '../js_backend/codegen/task.dart' show CpsFunctionCompiler;
 import '../resolution/access_semantics.dart';
 import '../resolution/operators.dart';
 import '../resolution/send_structure.dart';
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
 import '../types/constants.dart' show computeTypeMask;
 import '../universe/universe.dart';
 import '../world.dart' show World;
 import 'cps_fragment.dart';
@@ skipping 1573 matching lines @@
     node.receiverIsNotNull = receiver.isDefinitelyNotNull;
 
     if (isInterceptedSelector(node.selector) &&
         node.receiver.definition == node.arguments[0].definition) {
       // The receiver and first argument are the same; that means we already
       // determined in visitInterceptor that we are targeting a non-interceptor.
 
       // Check if any of the possible targets depend on the extra receiver
       // argument. Mixins do this, and tear-offs always needs the extra receiver
       // argument because BoundClosure uses it for equality and hash code.
+      // TODO(15933): Make automatically generated property extraction
+      // closures work with the dummy receiver optimization.
       bool needsReceiver(Element target) {
         if (target is! FunctionElement) return false;
         FunctionElement function = target;
         return typeSystem.methodUsesReceiverArgument(function) ||
                node.selector.isGetter && !function.isGetter;
       }
       if (!getAllTargets(receiver.type, node.selector).any(needsReceiver)) {
         // Replace the extra receiver argument with a dummy value if the
         // target definitely does not use it.
-        Constant dummy = makeConstantPrimitive(new IntConstantValue(0));
+        ConstantValue constant = new SyntheticConstantValue(
+            SyntheticConstantKind.DUMMY_INTERCEPTOR,
+            receiver.type);
+        Constant dummy = makeConstantPrimitive(constant);
         insertLetPrim(node, dummy);
         node.arguments[0].unlink();
         node.arguments[0] = new Reference<Primitive>(dummy);
       }
     }
   }
 
   void visitTypeCast(TypeCast node) {
     Continuation cont = node.continuation.definition;
 
@@ skipping 837 matching lines @@
     setValue(node, nonConstant(typeSystem.extendableNativeListType));
   }
 
   void visitLiteralMap(LiteralMap node) {
     // Constant maps are translated into (Constant MapConstant(...)) IR nodes,
     // and thus LiteralMap nodes are NonConst.
     setValue(node, nonConstant(typeSystem.mapType));
   }
 
   void visitConstant(Constant node) {
-    ConstantValue value = node.value;
-    if (value.isDummy || !value.isConstant) {
-      // TODO(asgerf): Explain how this happens and why we don't want them.
-      setValue(node, nonConstant(typeSystem.getTypeOf(value)));
-    } else {
-      setValue(node, constantValue(value, typeSystem.getTypeOf(value)));
-    }
+    setValue(node, constantValue(node.value, typeSystem.getTypeOf(node.value)));
   }
 
   void visitCreateFunction(CreateFunction node) {
     throw 'CreateFunction is not used';
   }
 
   void visitGetMutable(GetMutable node) {
     setValue(node, getValue(node.variable.definition));
   }
 
@@ skipping 132 matching lines @@
   final TypeMask type;
 
   AbstractValue._internal(this.kind, this.constant, this.type) {
     assert(kind != CONSTANT || constant != null);
     assert(constant is! SyntheticConstantValue);
   }
 
   AbstractValue.nothing()
       : this._internal(NOTHING, null, new TypeMask.nonNullEmpty());
 
-  AbstractValue.constantValue(ConstantValue constant, TypeMask type)
-      : this._internal(CONSTANT, constant, type);
+  factory AbstractValue.constantValue(ConstantValue constant, TypeMask type) {
+    if (constant.isDummy || !constant.isConstant) {
+      return new AbstractValue._internal(NONCONST, null, type);
+    } else {
+      return new AbstractValue._internal(CONSTANT, constant, type);
+    }
+  }
 
   factory AbstractValue.nonConstant(TypeMask type) {
     if (type.isEmpty) {
       if (type.isNullable)
         return new AbstractValue.constantValue(new NullConstantValue(), type);
       else
         return new AbstractValue.nothing();
     } else {
       return new AbstractValue._internal(NONCONST, null, type);
     }
@@ skipping 68 matching lines @@
   }
 
   processLetPrim(LetPrim node) {
     values.remove(node.primitive);
   }
 
   processLetMutable(LetMutable node) {
     values.remove(node.variable);
   }
 }