[es6] Initial steps towards a correct implementation of IsCallable.

src/object-observe.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 var $observeEnqueueSpliceRecord;
 var $observeBeginPerformSplice;
 var $observeEndPerformSplice;
 
 var $observeObjectMethods;
 var $observeArrayMethods;
@@ skipping 160 matching lines @@
   if (IS_UNDEFINED(acceptList))
     return callback;
   var observer = nullProtoObject();
   observer.callback = callback;
   observer.accept = acceptList;
   return observer;
 }
 
 
 function ObserverGetCallback(observer) {
-  return IS_SPEC_FUNCTION(observer) ? observer : observer.callback;
+  return IS_CALLABLE(observer) ? observer : observer.callback;
 }
 
 
 function ObserverGetAcceptTypes(observer) {
-  return IS_SPEC_FUNCTION(observer) ? defaultAcceptTypes : observer.accept;
+  return IS_CALLABLE(observer) ? defaultAcceptTypes : observer.accept;
 }
 
 
 function ObserverIsActive(observer, objectInfo) {
   return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(objectInfo),
                                ObserverGetAcceptTypes(observer));
 }
 
 
 function ObjectInfoGetOrCreate(object) {
@@ skipping 34 matching lines @@
     objectInfo.notifier = notifier;
     %WeakCollectionSet(GetObservationStateJS().notifierObjectInfoMap,
                        notifier, objectInfo, $getHash(notifier));
   }
 
   return objectInfo.notifier;
 }
 
 
 function ChangeObserversIsOptimized(changeObservers) {
-  return IS_SPEC_FUNCTION(changeObservers) ||
-         IS_SPEC_FUNCTION(changeObservers.callback);
+  return IS_CALLABLE(changeObservers) ||
+         IS_CALLABLE(changeObservers.callback);
 }
 
 
 // The set of observers on an object is called 'changeObservers'. The first
 // observer is referenced directly via objectInfo.changeObservers. When a second
 // is added, changeObservers "normalizes" to become a mapping of callback
 // priority -> observer and is then stored on objectInfo.changeObservers.
 function ObjectInfoNormalizeChangeObservers(objectInfo) {
   if (ChangeObserversIsOptimized(objectInfo.changeObservers)) {
     var observer = objectInfo.changeObservers;
@@ skipping 128 matching lines @@
   }
   return callbackInfo;
 }
 
 
 function ObjectObserve(object, callback, acceptList) {
   if (!IS_SPEC_OBJECT(object))
     throw MakeTypeError(kObserveNonObject, "observe", "observe");
   if (%IsJSGlobalProxy(object))
     throw MakeTypeError(kObserveGlobalProxy, "observe");
-  if (!IS_SPEC_FUNCTION(callback))
+  if (!IS_CALLABLE(callback))
     throw MakeTypeError(kObserveNonFunction, "observe");
   if (ObjectIsFrozen(callback))
     throw MakeTypeError(kObserveCallbackFrozen);
 
   var objectObserveFn = %GetObjectContextObjectObserve(object);
   return objectObserveFn(object, callback, acceptList);
 }
 
 
 function NativeObjectObserve(object, callback, acceptList) {
   var objectInfo = ObjectInfoGetOrCreate(object);
   var typeList = ConvertAcceptListToTypeMap(acceptList);
   ObjectInfoAddObserver(objectInfo, callback, typeList);
   return object;
 }
 
 
 function ObjectUnobserve(object, callback) {
   if (!IS_SPEC_OBJECT(object))
     throw MakeTypeError(kObserveNonObject, "unobserve", "unobserve");
   if (%IsJSGlobalProxy(object))
     throw MakeTypeError(kObserveGlobalProxy, "unobserve");
-  if (!IS_SPEC_FUNCTION(callback))
+  if (!IS_CALLABLE(callback))
     throw MakeTypeError(kObserveNonFunction, "unobserve");
 
   var objectInfo = ObjectInfoGet(object);
   if (IS_UNDEFINED(objectInfo))
     return object;
 
   ObjectInfoRemoveObserver(objectInfo, callback);
   return object;
 }
 
@@ skipping 156 matching lines @@
 
 function ObjectNotifierPerformChange(changeType, changeFn) {
   if (!IS_SPEC_OBJECT(this))
     throw MakeTypeError(kCalledOnNonObject, "performChange");
 
   var objectInfo = ObjectInfoGetFromNotifier(this);
   if (IS_UNDEFINED(objectInfo))
     throw MakeTypeError(kObserveNotifyNonNotifier);
   if (!IS_STRING(changeType))
     throw MakeTypeError(kObservePerformNonString);
-  if (!IS_SPEC_FUNCTION(changeFn))
+  if (!IS_CALLABLE(changeFn))
     throw MakeTypeError(kObservePerformNonFunction);
 
   var performChangeFn = %GetObjectContextNotifierPerformChange(objectInfo);
   performChangeFn(objectInfo, changeType, changeFn);
 }
 
 
 function NativeObjectNotifierPerformChange(objectInfo, changeType, changeFn) {
   ObjectInfoAddPerformingType(objectInfo, changeType);
 
@@ skipping 47 matching lines @@
   // TODO: combine the following runtime calls for perf optimization.
   var delivered = [];
   %MoveArrayContents(callbackInfo, delivered);
   %DeliverObservationChangeRecords(callback, delivered);
 
   return true;
 }
 
 
 function ObjectDeliverChangeRecords(callback) {
-  if (!IS_SPEC_FUNCTION(callback))
+  if (!IS_CALLABLE(callback))
     throw MakeTypeError(kObserveNonFunction, "deliverChangeRecords");
 
   while (CallbackDeliverPending(callback)) {}
 }
 
 
 function ObserveMicrotaskRunner() {
   var pendingObservers = GetPendingObservers();
   if (!IS_NULL(pendingObservers)) {
     SetPendingObservers(null);
@@ skipping 37 matching lines @@
   "native_object_get_notifier", NativeObjectGetNotifier,
   "native_object_notifier_perform_change", NativeObjectNotifierPerformChange,
   "native_object_observe", NativeObjectObserve,
   "observers_begin_perform_splice", BeginPerformSplice,
   "observers_end_perform_splice", EndPerformSplice,
   "observers_enqueue_splice", EnqueueSpliceRecord,
   "observers_notify_change", NotifyChange,
 ]);
 
 })