Optimize identical based on types.

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' show Pass, ParentVisitor;
 
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../resolution/operators.dart';
 import '../constants/values.dart';
@@ skipping 15 matching lines @@
   T get boolType;
   T get intType;
   T get stringType;
   T get listType;
   T get mapType;
 
   T getReturnType(FunctionElement element);
   T getSelectorReturnType(Selector selector);
   T getParameterType(ParameterElement element);
   T join(T a, T b);
-  T typeOf(ConstantValue constant);
+  T getTypeOf(ConstantValue constant);
 
   /// True if all values satisfying [type] are booleans (null is not a boolean).
   bool isDefinitelyBool(T type);
+
+  bool areDisjoint(T left, T right);
 }
 
 class UnitTypeSystem implements TypeSystem<String> {
   static const String UNIT = 'unit';
 
   get boolType => UNIT;
   get dynamicType => UNIT;
   get functionType => UNIT;
   get intType => UNIT;
   get listType => UNIT;
   get mapType => UNIT;
   get stringType => UNIT;
   get typeType => UNIT;
 
   getParameterType(_) => UNIT;
   getReturnType(_) => UNIT;
   getSelectorReturnType(_) => UNIT;
   join(a, b) => UNIT;
-  typeOf(_) => UNIT;
+  getTypeOf(_) => UNIT;
 
   bool isDefinitelyBool(_) => false;
+
+  @override
+  bool areDisjoint(a, b) => false;
 }
 
 class TypeMaskSystem implements TypeSystem<TypeMask> {
   final TypesTask inferrer;
   final ClassWorld classWorld;
 
   TypeMask get dynamicType => inferrer.dynamicType;
   TypeMask get typeType => inferrer.typeType;
   TypeMask get functionType => inferrer.functionType;
   TypeMask get boolType => inferrer.boolType;
@@ skipping 18 matching lines @@
   TypeMask getSelectorReturnType(Selector selector) {
     return inferrer.getGuaranteedTypeOfSelector(selector);
   }
 
   @override
   TypeMask join(TypeMask a, TypeMask b) {
     return a.union(b, classWorld);
   }
 
   @override
-  TypeMask typeOf(ConstantValue constant) {
+  TypeMask getTypeOf(ConstantValue constant) {
     return computeTypeMask(inferrer.compiler, constant);
   }
 
   bool isDefinitelyBool(TypeMask t) {
     return t.containsOnlyBool(classWorld) && !t.isNullable;
   }
+
+  bool areDisjoint(TypeMask left, TypeMask right) {
+    TypeMask intersection = left.intersection(right, classWorld);
+    return intersection.isEmpty && !intersection.isNullable;
+  }
 }
 
 /**
  * Propagates types (including value types for constants) throughout the IR, and
  * replaces branches with fixed jumps as well as side-effect free expressions
  * with known constant results.
  *
  * Should be followed by the [ShrinkingReducer] pass.
  *
  * Implemented according to 'Constant Propagation with Conditional Branches'
@@ skipping 452 matching lines @@
       if (operation != null) {
         result = operation.fold(lhs.constant, rhs.constant);
       }
     }
 
     // Update value of the continuation parameter. Again, this is effectively
     // a phi.
     if (result == null) {
       setValues(nonConstant());
     } else {
-      T type = typeSystem.typeOf(result);
+      T type = typeSystem.getTypeOf(result);
       setValues(constantValue(result, type));
     }
    }
 
   void visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     Continuation cont = node.continuation.definition;
     setReachable(cont);
 
     assert(cont.parameters.length == 1);
     Parameter returnValue = cont.parameters[0];
@@ skipping 139 matching lines @@
   }
 
   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;
-    setValue(node, constantValue(value, typeSystem.typeOf(value)));
+    setValue(node, constantValue(value, typeSystem.getTypeOf(value)));
   }
 
   void visitCreateFunction(CreateFunction node) {
     setReachable(node.definition);
     ConstantValue constant =
         new FunctionConstantValue(node.definition.element);
     setValue(node, constantValue(constant, typeSystem.functionType));
   }
 
   void visitGetMutableVariable(GetMutableVariable node) {
@@ skipping 70 matching lines @@
     _AbstractValue<T> leftConst = getValue(node.left.definition);
     _AbstractValue<T> rightConst = getValue(node.right.definition);
     ConstantValue leftValue = leftConst.constant;
     ConstantValue rightValue = rightConst.constant;
     if (leftConst.isNothing || rightConst.isNothing) {
       // Come back later.
       return;
     } else if (!leftConst.isConstant || !rightConst.isConstant) {
       T leftType = leftConst.type;
       T rightType = rightConst.type;
-      setValue(node, nonConstant(typeSystem.boolType));
+      if (typeSystem.areDisjoint(leftType, rightType)) {
+        setValue(node,
+            constantValue(new FalseConstantValue(), typeSystem.boolType));
+      } else {
+        setValue(node, nonConstant(typeSystem.boolType));
+      }
     } else if (leftValue.isPrimitive && rightValue.isPrimitive) {
       assert(leftConst.isConstant && rightConst.isConstant);
       PrimitiveConstantValue left = leftValue;
       PrimitiveConstantValue right = rightValue;
       ConstantValue result =
           new BoolConstantValue(left.primitiveValue == right.primitiveValue);
       setValue(node, constantValue(result, typeSystem.boolType));
     }
   }
 
@@ skipping 188 matching lines @@
   ConstantExpression visitString(StringConstantValue constant, arg) {
     return new StringConstantExpression(
         constant.primitiveValue.slowToString(), constant);
   }
 
   @override
   ConstantExpression visitType(TypeConstantValue constant, arg) {
     throw new UnsupportedError("ConstantExpressionCreator.visitType");
   }
 }