void JSGenericLowering::LowerJSToName(Node* node) {
- ReplaceWithBuiltinCall(node, Context::TO_NAME_BUILTIN_INDEX, 1);
+ ReplaceWithRuntimeCall(node, Runtime::kToName);
}
case Runtime::kInlineToPrimitive_String:
case Runtime::kInlineOrdinaryToPrimitive:
case Runtime::kInlineToNumber:
+ case Runtime::kInlineToName:
return 1;
case Runtime::kInlineDeoptimizeNow:
case Runtime::kInlineThrowNotDateError:
V(SPREAD_ARGUMENTS_INDEX, JSFunction, spread_arguments) \
V(SPREAD_ITERABLE_INDEX, JSFunction, spread_iterable) \
V(TO_LENGTH_FUN_INDEX, JSFunction, to_length_fun) \
- V(TO_NAME_INDEX, JSFunction, to_name) \
V(TO_NUMBER_FUN_INDEX, JSFunction, to_number_fun) \
V(TO_PRIMITIVE_INDEX, JSFunction, to_primitive) \
V(TO_STRING_FUN_INDEX, JSFunction, to_string_fun)
V(STRING_ADD_RIGHT_BUILTIN_INDEX, JSFunction, string_add_right_builtin) \
V(SUB_BUILTIN_INDEX, JSFunction, sub_builtin) \
V(SUB_STRONG_BUILTIN_INDEX, JSFunction, sub_strong_builtin) \
- V(TO_NAME_BUILTIN_INDEX, JSFunction, to_name_builtin) \
V(TO_STRING_BUILTIN_INDEX, JSFunction, to_string_builtin)
ObjectMirror.prototype.property = function(name) {
- var details = %DebugGetPropertyDetails(this.value_, builtins.$toName(name));
+ var details = %DebugGetPropertyDetails(this.value_, TO_NAME(name));
if (details) {
return new PropertyMirror(this, name, details);
}
void FullCodeGenerator::EmitPropertyKey(ObjectLiteralProperty* property,
BailoutId bailout_id) {
VisitForStackValue(property->key());
- __ InvokeBuiltin(Context::TO_NAME_BUILTIN_INDEX, CALL_FUNCTION);
+ __ CallRuntime(Runtime::kToName, 1);
PrepareForBailoutForId(bailout_id, NO_REGISTERS);
__ Push(result_register());
}
macro TO_PRIMITIVE(arg) = (%_ToPrimitive(arg));
macro TO_PRIMITIVE_NUMBER(arg) = (%_ToPrimitive_Number(arg));
macro TO_PRIMITIVE_STRING(arg) = (%_ToPrimitive_String(arg));
+macro TO_NAME(arg) = (%_ToName(arg));
macro JSON_NUMBER_TO_STRING(arg) = ((%_IsSmi(%IS_VAR(arg)) || arg - arg == 0) ? %_NumberToString(arg) : "null");
macro HAS_OWN_PROPERTY(arg, index) = (%_CallFunction(arg, index, ObjectHasOwnProperty));
macro SHOULD_CREATE_WRAPPER(functionName, receiver) = (!IS_SPEC_OBJECT(receiver) && %IsSloppyModeFunction(functionName));
var $sameValueZero;
var $toInteger;
var $toLength;
-var $toName;
var $toNumber;
var $toPositiveInteger;
var $toPrimitive;
}
return %HasElement(x, this);
}
- return %HasProperty(x, %to_name(this));
+ return %HasProperty(x, this);
}
}
-// Convert the receiver to a string or symbol - forward to ToName.
-function TO_NAME() {
- return %to_name(this);
-}
-
-
/* -------------------------------------
- - - C o n v e r s i o n s - - -
-------------------------------------
}
-// ES6 symbols
-function ToName(x) {
- return IS_SYMBOL(x) ? x : ToString(x);
-}
-
-
// ECMA-262, section 9.4, page 34.
function ToInteger(x) {
if (%_IsSmi(x)) return x;
$sameValueZero = SameValueZero;
$toInteger = ToInteger;
$toLength = ToLength;
-$toName = ToName;
$toNumber = ToNumber;
$toPositiveInteger = ToPositiveInteger;
$toPrimitive = ToPrimitive;
"string_add_right_builtin", STRING_ADD_RIGHT,
"sub_builtin", SUB,
"sub_strong_builtin", SUB_STRONG,
- "to_name_builtin", TO_NAME,
"to_string_builtin", TO_STRING,
]);
"non_string_to_string", NonStringToString,
"to_integer_fun", ToInteger,
"to_length_fun", ToLength,
- "to_name", ToName,
"to_number_fun", ToNumber,
"to_primitive", ToPrimitive,
"to_string_fun", ToString,
utils.Export(function(to) {
to.ToBoolean = ToBoolean;
to.ToLength = ToLength;
- to.ToName = ToName;
to.ToNumber = ToNumber;
to.ToPrimitive = ToPrimitive;
to.ToString = ToString;
HandleScope scope(isolate);
DCHECK(args.length() == 2);
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
+ CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
- Maybe<bool> maybe = JSReceiver::HasProperty(receiver, key);
+ Handle<Name> name;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
+ Object::ToName(isolate, key));
+ Maybe<bool> maybe = JSReceiver::HasProperty(receiver, name);
if (!maybe.IsJust()) return isolate->heap()->exception();
return isolate->heap()->ToBoolean(maybe.FromJust());
}
}
+RUNTIME_FUNCTION(Runtime_ToName) {
+ HandleScope scope(isolate);
+ DCHECK_EQ(1, args.length());
+ CONVERT_ARG_HANDLE_CHECKED(Object, input, 0);
+ Handle<Object> result;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
+ Object::ToName(isolate, input));
+ return *result;
+}
+
+
RUNTIME_FUNCTION(Runtime_StrictEquals) {
SealHandleScope scope(isolate);
DCHECK_EQ(2, args.length());
F(ToPrimitive_String, 1, 1) \
F(OrdinaryToPrimitive, 2, 1) \
F(ToNumber, 1, 1) \
+ F(ToName, 1, 1) \
F(StrictEquals, 2, 1) \
F(InstanceOf, 2, 1) \
F(HasInPrototypeChain, 2, 1)
// ECMA-262 - 15.2.4.5
function ObjectHasOwnProperty(value) {
- var name = $toName(value);
+ var name = TO_NAME(value);
var object = TO_OBJECT(this);
if (%_IsJSProxy(object)) {
// ECMA-262 - 15.2.4.6
function ObjectPropertyIsEnumerable(V) {
- var P = $toName(V);
+ var P = TO_NAME(V);
if (%_IsJSProxy(this)) {
// TODO(rossberg): adjust once there is a story for symbols vs proxies.
if (IS_SYMBOL(V)) return false;
desc.setGet(fun);
desc.setEnumerable(true);
desc.setConfigurable(true);
- DefineOwnProperty(TO_OBJECT(receiver), $toName(name), desc, false);
+ DefineOwnProperty(TO_OBJECT(receiver), TO_NAME(name), desc, false);
}
if (IS_NULL(receiver) || IS_UNDEFINED(receiver)) {
receiver = %GlobalProxy(ObjectLookupGetter);
}
- return %LookupAccessor(TO_OBJECT(receiver), $toName(name), GETTER);
+ return %LookupAccessor(TO_OBJECT(receiver), TO_NAME(name), GETTER);
}
desc.setSet(fun);
desc.setEnumerable(true);
desc.setConfigurable(true);
- DefineOwnProperty(TO_OBJECT(receiver), $toName(name), desc, false);
+ DefineOwnProperty(TO_OBJECT(receiver), TO_NAME(name), desc, false);
}
if (IS_NULL(receiver) || IS_UNDEFINED(receiver)) {
receiver = %GlobalProxy(ObjectLookupSetter);
}
- return %LookupAccessor(TO_OBJECT(receiver), $toName(name), SETTER);
+ return %LookupAccessor(TO_OBJECT(receiver), TO_NAME(name), SETTER);
}
// ES5 section 8.12.1.
function GetOwnPropertyJS(obj, v) {
- var p = $toName(v);
+ var p = TO_NAME(v);
if (%_IsJSProxy(obj)) {
// TODO(rossberg): adjust once there is a story for symbols vs proxies.
if (IS_SYMBOL(v)) return UNDEFINED;
// ES5 8.12.9.
function DefineObjectProperty(obj, p, desc, should_throw) {
- var current_array = %GetOwnProperty(obj, $toName(p));
+ var current_array = %GetOwnProperty(obj, TO_NAME(p));
var current = ConvertDescriptorArrayToDescriptor(current_array);
var extensible = %IsExtensible(obj);
var realLength = 0;
var names = { __proto__: null }; // TODO(rossberg): use sets once ready.
for (var index = 0; index < n; index++) {
- var s = $toName(obj[index]);
+ var s = TO_NAME(obj[index]);
// TODO(rossberg): adjust once there is a story for symbols vs proxies.
if (IS_SYMBOL(s) && !includeSymbols) continue;
if (%HasOwnProperty(names, s)) {
if (!IS_SPEC_OBJECT(obj)) {
throw MakeTypeError(kCalledOnNonObject, "Object.defineProperty");
}
- var name = $toName(p);
+ var name = TO_NAME(p);
if (%_IsJSProxy(obj)) {
// Clone the attributes object for protection.
// TODO(rossberg): not spec'ed yet, so not sure if this should involve
--- /dev/null
+// Copyright 2015 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.
+
+// Flags: --allow-natives-syntax
+
+assertEquals("1", %ToName(1));
+assertEquals("1", %_ToName(1));
+
+assertEquals("0.5", %ToName(.5));
+assertEquals("0.5", %_ToName(.5));
+
+assertEquals("null", %ToName(null));
+assertEquals("null", %_ToName(null));
+
+assertEquals("true", %ToName(true));
+assertEquals("true", %_ToName(true));
+
+assertEquals("false", %ToName(false));
+assertEquals("false", %_ToName(false));
+
+assertEquals("undefined", %ToName(undefined));
+assertEquals("undefined", %_ToName(undefined));
+
+assertEquals("random text", %ToName("random text"));
+assertEquals("random text", %_ToName("random text"));
+
+assertEquals(Symbol.toPrimitive, %ToName(Symbol.toPrimitive));
+assertEquals(Symbol.toPrimitive, %_ToName(Symbol.toPrimitive));
+
+var a = { toString: function() { return "xyz" }};
+assertEquals("xyz", %ToName(a));
+assertEquals("xyz", %_ToName(a));
+
+var b = { valueOf: function() { return 42 }};
+assertEquals("[object Object]", %ToName(b));
+assertEquals("[object Object]", %_ToName(b));
+
+var c = {
+ toString: function() { return "x"},
+ valueOf: function() { return 123 }
+};
+assertEquals("x", %ToName(c));
+assertEquals("x", %_ToName(c));
+
+var d = {
+ [Symbol.toPrimitive]: function(hint) { return hint }
+};
+assertEquals("string", %ToName(d));
+assertEquals("string", %_ToName(d));