       ? nil : Builtin.castToNativeObject(
       IndirectArrayBuffer(
         nativeBuffer: ContiguousArrayBuffer<T>(),
-        isMutable: false))
+        isMutable: false,
+        needsElementTypeCheck: false
+      ))
   }
 
   init(_ cocoa: CocoaArray) {
     _sanityCheck(_isClassOrObjCExistential(T.self))
-    storage = Builtin.castToNativeObject(IndirectArrayBuffer(cocoa: cocoa))
+    storage = Builtin.castToNativeObject(
+      IndirectArrayBuffer(
+        cocoa: cocoa,
+        needsElementTypeCheck: !(AnyObject.self is T.Type)))
   }
 
   /// An ArrayBuffer<T> containing the same elements.

    }
    return indirect.isMutable && Swift.isUniquelyReferenced(&indirect.buffer)
  }
  
  /// If this buffer is backed by a uniquely-referenced mutable
  /// ContiguousArrayBuffer that can be grown in-place to allow the self
  /// buffer store minimumCapacity elements, returns that buffer.

    if result { return result }
    return nil
  }

  func _typeCheck(subRange: Range<Int>) {
    if !_isClassOrObjCExistential(T.self) {
      return
    }
    if _slowPath(indirect.needsElementTypeCheck) {
      if _fastPath(_isNative) {
        for x in _native[subRange] {
          assert(reinterpretCast(x) as AnyObject is T)
        }
      }
      else if (subRange) {
        let ns = _nonNative!
        // Could be sped up, e.g. by using
        // enumerateObjectsAtIndexes:options:usingBlock:
        for i in subRange {
          assert(ns.objectAtIndex(i) is T)
        }
      }
    }
  }
  
  /// Copy the given subRange of this buffer into uninitialized memory
  /// starting at target.  Return a pointer past-the-end of the
  /// just-initialized memory.
  func _uninitializedCopy(subRange: Range<Int>, target: T*) -> T* {
    _typeCheck(subRange)
    if _fastPath(_isNative) {
      return _native._uninitializedCopy(subRange, target: target)
    }
