Properly implement identical() test in analyzer constant evaluation.

pkg/analyzer/lib/src/generated/constant.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.constant;
 
 import 'dart:collection';
@@ skipping 56 matching lines @@
   StringState convertToString() {
     if (value == null) {
       return StringState.UNKNOWN_VALUE;
     }
     return new StringState(value ? "true" : "false");
   }
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (value == null) {
       return UNKNOWN_VALUE;
     }
     if (rightOperand is BoolState) {
       bool rightValue = rightOperand.value;
       if (rightValue == null) {
         return UNKNOWN_VALUE;
       }
       return BoolState.from(identical(value, rightValue));
     } else if (rightOperand is DynamicState) {
@@ skipping 1159 matching lines @@
       FunctionElement function = element;
       if (function.name == "identical") {
         NodeList<Expression> arguments = node.argumentList.arguments;
         if (arguments.length == 2) {
           Element enclosingElement = function.enclosingElement;
           if (enclosingElement is CompilationUnitElement) {
             LibraryElement library = enclosingElement.library;
             if (library.isDartCore) {
               DartObjectImpl leftArgument = arguments[0].accept(this);
               DartObjectImpl rightArgument = arguments[1].accept(this);
-              return _dartObjectComputer.equalEqual(node, leftArgument, rightArgument);
+              return _dartObjectComputer.isIdentical(node, leftArgument,
+                  rightArgument);
             }
           }
         }
       }
     }
     // TODO(brianwilkerson) Figure out which error to report.
     _error(node, null);
     return null;
   }
 
@@ skipping 453 matching lines @@
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.integerDivide(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
         _errorReporter.reportErrorForNode(exception.errorCode, node, []);
       }
     }
     return null;
   }
 
+  DartObjectImpl isIdentical(Expression node, DartObjectImpl leftOperand,
+                             DartObjectImpl rightOperand) {
+    if (leftOperand != null && rightOperand != null) {
+      try {
+        return leftOperand.isIdentical(_typeProvider, rightOperand);
+      } on EvaluationException catch (exception) {
+        _errorReporter.reportErrorForNode(exception.errorCode, node, []);
+      }
+    }
+    return null;
+  }
+
   DartObjectImpl lessThan(BinaryExpression node, DartObjectImpl leftOperand, DartObjectImpl rightOperand) {
     if (leftOperand != null && rightOperand != null) {
       try {
         return leftOperand.lessThan(_typeProvider, rightOperand);
       } on EvaluationException catch (exception) {
         _errorReporter.reportErrorForNode(exception.errorCode, node, []);
       }
     }
     return null;
   }
@@ skipping 372 matching lines @@
    * Return the result of invoking the '~/' operator on this object with the given argument.
    *
    * @param typeProvider the type provider used to find known types
    * @param rightOperand the right-hand operand of the operation
    * @return the result of invoking the '~/' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   DartObjectImpl integerDivide(TypeProvider typeProvider, DartObjectImpl rightOperand) => new DartObjectImpl(typeProvider.intType, _state.integerDivide(rightOperand._state));
 
   /**
+   * Return the result of invoking the identical function on this object with
+   * the given argument.
+   *
+   * @param typeProvider the type provider used to find known types
+   * @param rightOperand the right-hand operand of the operation
+   * @return the result of invoking the identical function on this object with
+   *         the given argument
+   */
+  DartObjectImpl isIdentical(TypeProvider typeProvider,
+                             DartObjectImpl rightOperand) {
+    return new DartObjectImpl(typeProvider.boolType,
+        _state.isIdentical(rightOperand._state));
+  }
+
+  /**
    * Return `true` if this object represents an object whose type is 'bool'.
    *
    * @return `true` if this object represents a boolean value
    */
   bool get isBool => _state.isBool;
 
   /**
    * Return `true` if this object represents an object whose type is either 'bool', 'num',
    * 'String', or 'Null'.
    *
@@ skipping 378 matching lines @@
       return new DoubleState(value / rightValue);
     } else if (rightOperand is DynamicState || rightOperand is NumState) {
       return UNKNOWN_VALUE;
     }
     throw new EvaluationException(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
   }
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (value == null) {
       return BoolState.UNKNOWN_VALUE;
     }
     if (rightOperand is DoubleState) {
       double rightValue = rightOperand.value;
       if (rightValue == null) {
         return BoolState.UNKNOWN_VALUE;
       }
       return BoolState.from(value == rightValue);
     } else if (rightOperand is IntState) {
@@ skipping 287 matching lines @@
     return _unknownNum(rightOperand);
   }
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
     return BoolState.UNKNOWN_VALUE;
   }
 
   @override
+  BoolState isIdentical(InstanceState rightOperand) {
+    return BoolState.UNKNOWN_VALUE;
+  }
+
+  @override
   String get typeName => "dynamic";
 
   @override
   BoolState greaterThan(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
     return BoolState.UNKNOWN_VALUE;
   }
 
   @override
   BoolState greaterThanOrEqual(InstanceState rightOperand) {
@@ skipping 236 matching lines @@
       return StringState.UNKNOWN_VALUE;
     }
     return new StringState(_element.name);
   }
 
   @override
   bool operator ==(Object object) => object is FunctionState && (_element == object._element);
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (_element == null) {
       return BoolState.UNKNOWN_VALUE;
     }
     if (rightOperand is FunctionState) {
       ExecutableElement rightElement = rightOperand._element;
       if (rightElement == null) {
         return BoolState.UNKNOWN_VALUE;
       }
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
@@ skipping 38 matching lines @@
    * @param fieldMap the values of the fields of this instance
    */
   GenericState(this._fieldMap);
 
   @override
   StringState convertToString() => StringState.UNKNOWN_VALUE;
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.from(this == rightOperand);
   }
 
   @override
   bool operator ==(Object object) {
     if (object is! GenericState) {
       return false;
@@ skipping 218 matching lines @@
    * @return the result of invoking the '~/' operator on this object with the given argument
    * @throws EvaluationException if the operator is not appropriate for an object of this kind
    */
   IntState integerDivide(InstanceState rightOperand) {
     assertNumOrNull(this);
     assertNumOrNull(rightOperand);
     throw new EvaluationException(CompileTimeErrorCode.INVALID_CONSTANT);
   }
 
   /**
+   * Return the result of invoking the identical function on this object with
+   * the given argument.
+   *
+   * @param rightOperand the right-hand operand of the operation
+   * @return the result of invoking the identical function on this object with
+   *         the given argument
+   */
+  BoolState isIdentical(InstanceState rightOperand);
+
+  /**
    * Return `true` if this object represents an object whose type is 'bool'.
    *
    * @return `true` if this object represents a boolean value
    */
   bool get isBool => false;
 
   /**
    * Return `true` if this object represents an object whose type is either 'bool', 'num',
    * 'String', or 'Null'.
    *
@@ skipping 364 matching lines @@
       return new DoubleState(value.toDouble() / rightValue);
     } else if (rightOperand is DynamicState || rightOperand is NumState) {
       return UNKNOWN_VALUE;
     }
     throw new EvaluationException(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
   }
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (value == null) {
       return BoolState.UNKNOWN_VALUE;
     }
     if (rightOperand is IntState) {
       int rightValue = rightOperand.value;
       if (rightValue == null) {
         return BoolState.UNKNOWN_VALUE;
       }
       return BoolState.from(value == rightValue);
     } else if (rightOperand is DoubleState) {
@@ skipping 300 matching lines @@
    * @param elements the elements of the list
    */
   ListState(this._elements);
 
   @override
   StringState convertToString() => StringState.UNKNOWN_VALUE;
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.from(this == rightOperand);
   }
 
   @override
   bool operator ==(Object object) {
     if (object is! ListState) {
       return false;
@@ skipping 68 matching lines @@
    * @param entries the entries in the map
    */
   MapState(this._entries);
 
   @override
   StringState convertToString() => StringState.UNKNOWN_VALUE;
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.from(this == rightOperand);
   }
 
   @override
   bool operator ==(Object object) {
     if (object is! MapState) {
       return false;
@@ skipping 64 matching lines @@
   BoolState convertToBool() {
     throw new EvaluationException(CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION);
   }
 
   @override
   StringState convertToString() => new StringState("null");
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.from(rightOperand is NullState);
   }
 
   @override
   bool operator ==(Object object) => object is NullState;
 
   @override
@@ skipping 42 matching lines @@
     return UNKNOWN_VALUE;
   }
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
     return BoolState.UNKNOWN_VALUE;
   }
 
   @override
+  BoolState isIdentical(InstanceState rightOperand) {
+    return BoolState.UNKNOWN_VALUE;
+  }
+
+  @override
   bool operator ==(Object object) => object is NumState;
 
   @override
   String get typeName => "num";
 
   @override
   BoolState greaterThan(InstanceState rightOperand) {
     assertNumOrNull(rightOperand);
     return BoolState.UNKNOWN_VALUE;
   }
@@ skipping 205 matching lines @@
     }
     return super.concatenate(rightOperand);
   }
 
   @override
   StringState convertToString() => this;
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (value == null) {
       return BoolState.UNKNOWN_VALUE;
     }
     if (rightOperand is StringState) {
       String rightValue = rightOperand.value;
       if (rightValue == null) {
         return BoolState.UNKNOWN_VALUE;
       }
       return BoolState.from(value == rightValue);
     } else if (rightOperand is DynamicState) {
@@ skipping 53 matching lines @@
   StringState convertToString() {
     if (value == null) {
       return StringState.UNKNOWN_VALUE;
     }
     return new StringState(value);
   }
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (value == null) {
       return BoolState.UNKNOWN_VALUE;
     }
     if (rightOperand is SymbolState) {
       String rightValue = rightOperand.value;
       if (rightValue == null) {
         return BoolState.UNKNOWN_VALUE;
       }
       return BoolState.from(value == rightValue);
     } else if (rightOperand is DynamicState) {
@@ skipping 41 matching lines @@
     }
     return new StringState(_element.name);
   }
 
   @override
   bool operator ==(Object object) => object is TypeState && (_element == object._element);
 
   @override
   BoolState equalEqual(InstanceState rightOperand) {
     assertBoolNumStringOrNull(rightOperand);
+    return isIdentical(rightOperand);
+  }
+
+  @override
+  BoolState isIdentical(InstanceState rightOperand) {
     if (_element == null) {
       return BoolState.UNKNOWN_VALUE;
     }
     if (rightOperand is TypeState) {
       Element rightElement = rightOperand._element;
       if (rightElement == null) {
         return BoolState.UNKNOWN_VALUE;
       }
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String get typeName => "Type";
 
   @override
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }