[strong] Implement strong mode restrictions on property access

src/runtime/runtime-classes.cc

Index: src/runtime/runtime-classes.cc
diff --git a/src/runtime/runtime-classes.cc b/src/runtime/runtime-classes.cc
index 51247b728cf60730d3089b4a5bce6472673172ab..66154ab85c47007693bd9fc00c183e48b6e92a8a 100644
--- a/src/runtime/runtime-classes.cc
+++ b/src/runtime/runtime-classes.cc
@@ -120,7 +120,8 @@ RUNTIME_FUNCTION(Runtime_DefineClass) {
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
           isolate, prototype_parent,
           Runtime::GetObjectProperty(isolate, super_class,
-                                     isolate->factory()->prototype_string()));
+                                     isolate->factory()->prototype_string(),
+                                     Strength::WEAK));
       if (!prototype_parent->IsNull() && !prototype_parent->IsSpecObject()) {
         THROW_NEW_ERROR_RETURN_FAILURE(
             isolate, NewTypeError(MessageTemplate::kPrototypeParentNotAnObject,
@@ -252,7 +253,8 @@ RUNTIME_FUNCTION(Runtime_ClassGetSourceCode) {
 
 
 static Object* LoadFromSuper(Isolate* isolate, Handle<Object> receiver,
-                             Handle<JSObject> home_object, Handle<Name> name) {
+                             Handle<JSObject> home_object, Handle<Name> name,
+                             LanguageMode language_mode) {
   if (home_object->IsAccessCheckNeeded() && !isolate->MayAccess(home_object)) {
     isolate->ReportFailedAccessCheck(home_object);
     RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
@@ -260,18 +262,27 @@ static Object* LoadFromSuper(Isolate* isolate, Handle<Object> receiver,
 
   PrototypeIterator iter(isolate, home_object);
   Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
-  if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
+  if (!proto->IsJSReceiver()) {

[Toon Verwaest, 2015/06/09 11:58:04]

Helper method. If you just change the return type to MaybeHandle<Object> and
ASSIGN_RETURN_FAILURE_ON_EXCEPTION in the client you can use the same here as in
objects.cc

[conradw, 2015/06/09 13:09:27]

Done.

+    if (is_strong(language_mode)) {
+      THROW_NEW_ERROR_RETURN_FAILURE(
+          isolate,
+          NewTypeError(MessageTemplate::kStrongPropertyAccess, proto, name));
+    }
+    return isolate->heap()->undefined_value();
+  }
 
   LookupIterator it(receiver, name, Handle<JSReceiver>::cast(proto));
   Handle<Object> result;
-  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, Object::GetProperty(&it));
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+      isolate, result, Object::GetProperty(&it, strength(language_mode)));
   return *result;
 }
 
 
 static Object* LoadElementFromSuper(Isolate* isolate, Handle<Object> receiver,
                                     Handle<JSObject> home_object,
-                                    uint32_t index) {
+                                    uint32_t index,
+                                    LanguageMode language_mode) {
   if (home_object->IsAccessCheckNeeded() && !isolate->MayAccess(home_object)) {
     isolate->ReportFailedAccessCheck(home_object);
     RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
@@ -279,45 +290,58 @@ static Object* LoadElementFromSuper(Isolate* isolate, Handle<Object> receiver,
 
   PrototypeIterator iter(isolate, home_object);
   Handle<Object> proto = PrototypeIterator::GetCurrent(iter);
-  if (!proto->IsJSReceiver()) return isolate->heap()->undefined_value();
+  if (!proto->IsJSReceiver()) {
+    if (is_strong(language_mode)) {
+      Handle<Object> name = isolate->factory()->NewNumberFromUint(index);
+      THROW_NEW_ERROR_RETURN_FAILURE(
+          isolate,
+          NewTypeError(MessageTemplate::kStrongPropertyAccess, proto, name));
+    }
+    return isolate->heap()->undefined_value();
+  }
 
   LookupIterator it(isolate, receiver, index, Handle<JSReceiver>::cast(proto));
   Handle<Object> result;
-  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, Object::GetProperty(&it));
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+      isolate, result, Object::GetProperty(&it, strength(language_mode)));
   return *result;
 }
 
 
 RUNTIME_FUNCTION(Runtime_LoadFromSuper) {
   HandleScope scope(isolate);
-  DCHECK(args.length() == 3);
+  DCHECK(args.length() == 4);
   CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
   CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
   CONVERT_ARG_HANDLE_CHECKED(Name, name, 2);
+  CONVERT_LANGUAGE_MODE_ARG_CHECKED(language_mode, 3);
 
-  return LoadFromSuper(isolate, receiver, home_object, name);
+  return LoadFromSuper(isolate, receiver, home_object, name, language_mode);
 }
 
 
 RUNTIME_FUNCTION(Runtime_LoadKeyedFromSuper) {
   HandleScope scope(isolate);
-  DCHECK(args.length() == 3);
+  DCHECK(args.length() == 4);
   CONVERT_ARG_HANDLE_CHECKED(Object, receiver, 0);
   CONVERT_ARG_HANDLE_CHECKED(JSObject, home_object, 1);
   CONVERT_ARG_HANDLE_CHECKED(Object, key, 2);
+  CONVERT_LANGUAGE_MODE_ARG_CHECKED(language_mode, 3);
 
   uint32_t index = 0;
   if (key->ToArrayIndex(&index)) {
-    return LoadElementFromSuper(isolate, receiver, home_object, index);
+    return LoadElementFromSuper(isolate, receiver, home_object, index,
+                                language_mode);

[Toon Verwaest, 2015/06/09 11:58:04]

Not clear when you use strength and when language_mode ...

[conradw, 2015/06/09 13:09:27]

Currently language_mode is used for runtime functions (and associated helpers)
that never get called from stubs, and strength is used for functions that could
be called from stubs. There's not a particularly good reason for this, it just
naturally fell out from trying to keep the full language mode around for as long
as possible.

Everything could be changed to talk in terms of Strength instead.

   }
 
   Handle<Name> name;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
                                      Runtime::ToName(isolate, key));
   if (name->AsArrayIndex(&index)) {
-    return LoadElementFromSuper(isolate, receiver, home_object, index);
+    return LoadElementFromSuper(isolate, receiver, home_object, index,
+                                language_mode);
   }
-  return LoadFromSuper(isolate, receiver, home_object, name);
+  return LoadFromSuper(isolate, receiver, home_object, name, language_mode);
 }