a === b -> identical(a, b)

runtime/lib/byte_array.dart

 // Copyright (c) 2012, 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.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
 
   /* patch */ factory Int8List.view(ByteArray array,
@@ skipping 136 matching lines @@
 
   bool every(bool f(element)) {
     return Collections.every(this, f);
   }
 
   bool some(bool f(element)) {
     return Collections.some(this, f);
   }
 
   bool get isEmpty {
-    return this.length === 0;
+    return this.length == 0;
   }
 
   int get length {
     return _length();
   }
 
   // Methods implementing the List interface.
 
   set length(newLength) {
     throw new UnsupportedError(
@@ skipping 17 matching lines @@
 
   void sort([Comparator compare = Comparable.compare]) {
     coreSort(this, compare);
   }
 
   int indexOf(element, [int start = 0]) {
     return Arrays.indexOf(this, element, start, this.length);
   }
 
   int lastIndexOf(element, [int start = null]) {
-    if (start === null) start = length - 1;
+    if (start == null) start = length - 1;
     return Arrays.lastIndexOf(this, element, start);
   }
 
   void clear() {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
   int removeLast() {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
   get last {
     return this[length - 1];
   }
 
   void removeRange(int start, int length) {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
   void insertRange(int start, int length, [initialValue]) {
     throw new UnsupportedError(
         "Cannot add to a non-extendable array");
   }
 
   ByteArray asByteArray([int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = this.length;
     }
     _rangeCheck(this.length, start, length);
     return new _ByteArrayView(this,
                               start * this.bytesPerElement(),
                               length * this.bytesPerElement());
   }
 
   int _length() native "ByteArray_getLength";
 
@@ skipping 89 matching lines @@
     return object;
   }
   throw new ArgumentError("$object is not an integer");
 }
 
 
 int _requireIntegerOrNull(object, value) {
   if (object is int) {
     return object;
   }
-  if (object === null) {
+  if (object == null) {
     return _requireInteger(value);
   }
   throw new ArgumentError("$object is not an integer or null");
 }
 
 
 class _Int8Array extends _ByteArrayBase implements Int8List {
   factory _Int8Array(int length) {
     return _new(length);
   }
 
   factory _Int8Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = array.lengthInBytes();
     }
     return new _Int8ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, int value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, int value) native "Int8Array_setIndexed";
 }
 
 
 class _Uint8Array extends _ByteArrayBase implements Uint8List {
   factory _Uint8Array(int length) {
     return _new(length);
   }
 
   factory _Uint8Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = array.lengthInBytes();
     }
     return new _Uint8ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, int value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, int value) native "Uint8Array_setIndexed";
 }
 
 
 class _Int16Array extends _ByteArrayBase implements Int16List {
   factory _Int16Array(int length) {
     return _new(length);
   }
 
   factory _Int16Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Int16ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, int value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, int value) native "Int16Array_setIndexed";
 }
 
 
 class _Uint16Array extends _ByteArrayBase implements Uint16List {
   factory _Uint16Array(int length) {
     return _new(length);
   }
 
   factory _Uint16Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Uint16ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, int value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, int value) native "Uint16Array_setIndexed";
 }
 
 
 class _Int32Array extends _ByteArrayBase implements Int32List {
   factory _Int32Array(int length) {
     return _new(length);
   }
 
   factory _Int32Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Int32ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, int value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, int value) native "Int32Array_setIndexed";
 }
 
 
 class _Uint32Array extends _ByteArrayBase implements Uint32List {
   factory _Uint32Array(int length) {
     return _new(length);
   }
 
   factory _Uint32Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Uint32ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, int value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, int value) native "Uint32Array_setIndexed";
 }
 
 
 class _Int64Array extends _ByteArrayBase implements Int64List {
   factory _Int64Array(int length) {
     return _new(length);
   }
 
   factory _Int64Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Int64ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, int value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, int value) native "Int64Array_setIndexed";
 }
 
 
 class _Uint64Array extends _ByteArrayBase implements Uint64List {
   factory _Uint64Array(int length) {
     return _new(length);
   }
 
   factory _Uint64Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Uint64ArrayView(array, start, length);
   }
 
   int operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, int value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, int value) native "Uint64Array_setIndexed";
 }
 
 
 class _Float32Array extends _ByteArrayBase implements Float32List {
   factory _Float32Array(int length) {
     return _new(length);
   }
 
   factory _Float32Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Float32ArrayView(array, start, length);
   }
 
   double operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, double value) {
@@ skipping 42 matching lines @@
   int _setIndexed(int index, double value) native "Float32Array_setIndexed";
 }
 
 
 class _Float64Array extends _ByteArrayBase implements Float64List {
   factory _Float64Array(int length) {
     return _new(length);
   }
 
   factory _Float64Array.view(ByteArray array, [int start = 0, int length]) {
-    if (length === null) {
+    if (length == null) {
       length = (array.lengthInBytes() - start) ~/ _BYTES_PER_ELEMENT;
     }
     return new _Float64ArrayView(array, start, length);
   }
 
   double operator[](int index) {
     return _getIndexed(index);
   }
 
   int operator[]=(int index, double value) {
@@ skipping 584 matching lines @@
   _ByteArrayView(this._array, this._offset, this._length) {
     _rangeCheck(_array.lengthInBytes(), _offset, _length);
   }
 
   int lengthInBytes() {
     return _length;
   }
 
   ByteArray subByteArray([int start = 0, int length]) {
     if (start is! int) throw new ArgumentError("start is not an int");
-    if (length === null) {
+    if (length == null) {
       length = this.lengthInBytes() - start;
     } else if (length is! int) {
       throw new ArgumentError("length is not an int");
     }
     return new _ByteArrayView(_array, _offset + start, length);
   }
 
   int getInt8(int byteOffset) {
     return _array._getInt8(_offset + byteOffset);
   }
@@ skipping 97 matching lines @@
 
   bool every(bool f(element)) {
     return Collections.every(this, f);
   }
 
   bool some(bool f(element)) {
     return Collections.some(this, f);;
   }
 
   bool get isEmpty {
-    return this.length === 0;
+    return this.length == 0;
   }
 
   abstract int get length;
 
   // Methods implementing the List interface.
 
   set length(newLength) {
     throw new UnsupportedError(
         "Cannot resize a non-extendable array");
   }
@@ skipping 15 matching lines @@
 
   void sort([Comparator compare = Comparable.compare]) {
     coreSort(this, compare);
   }
 
   int indexOf(element, [int start = 0]) {
     return Arrays.indexOf(this, element, start, this.length);
   }
 
   int lastIndexOf(element, [int start = null]) {
-    if (start === null) start = length - 1;
+    if (start == null) start = length - 1;
     return Arrays.lastIndexOf(this, element, start);
   }
 
   void clear() {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
   int removeLast() {
     throw new UnsupportedError(
@@ skipping 727 matching lines @@
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }