[destructuring] More tests for object literal pattern

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 4115 matching lines @@
       Runtime::FunctionForId(Runtime::kThrowConstructorNonCallableError),
       arguments, pos);
   IfStatement* if_statement = factory()->NewIfStatement(
       factory()->NewUnaryOperation(Token::NOT, construct_check, pos),
       factory()->NewReturnStatement(non_callable_error, pos),
       factory()->NewEmptyStatement(pos), pos);
   body->Add(if_statement, zone());
 }
 
 
+Statement* Parser::BuildAssertIsCoercible(Variable* var) {
+  // if (var === null || var === undefined || %_IsUndetectableObject(var))

[arv (Not doing code reviews), 2015/05/18 13:12:53]

Is this right? Why can I not do?

let {someId} = document.all;

The ES spec knows nothing about undetectable objects.

[Dmitry Lomov (no reviews), 2015/05/18 13:41:46]

The truth is, I have just copied logic from CHECK_OBJECT_COERCIBLE in macros.py.
Tell me what the right semantics is.

+  //     return %ThrowNonCoercible(var);
+
+  ZoneList<Expression*>* non_coercible_arguments =
+      new (zone()) ZoneList<Expression*>(0, zone());
+  ZoneList<Expression*>* is_undetectable_arguments =
+      new (zone()) ZoneList<Expression*>(1, zone());
+  is_undetectable_arguments->Add(factory()->NewVariableProxy(var), zone());
+  Expression* condition = factory()->NewBinaryOperation(
+      Token::OR,
+      factory()->NewBinaryOperation(
+          Token::OR, factory()->NewCompareOperation(
+                         Token::EQ_STRICT, factory()->NewVariableProxy(var),
+                         factory()->NewUndefinedLiteral(RelocInfo::kNoPosition),
+                         RelocInfo::kNoPosition),
+          factory()->NewCompareOperation(
+              Token::EQ_STRICT, factory()->NewVariableProxy(var),
+              factory()->NewNullLiteral(RelocInfo::kNoPosition),
+              RelocInfo::kNoPosition),
+          RelocInfo::kNoPosition),
+      factory()->NewCallRuntime(
+          ast_value_factory()->empty_string(),
+          Runtime::FunctionForId(Runtime::kInlineIsUndetectableObject),
+          is_undetectable_arguments, RelocInfo::kNoPosition),
+      RelocInfo::kNoPosition);
+  CallRuntime* non_callable_error = factory()->NewCallRuntime(
+      ast_value_factory()->empty_string(),
+      Runtime::FunctionForId(Runtime::kThrowNonCoercible),
+      non_coercible_arguments, RelocInfo::kNoPosition);
+  IfStatement* if_statement = factory()->NewIfStatement(
+      condition,
+      factory()->NewReturnStatement(non_callable_error, RelocInfo::kNoPosition),
+      factory()->NewEmptyStatement(RelocInfo::kNoPosition),
+      RelocInfo::kNoPosition);
+  return if_statement;
+}
+
+
 ZoneList<Statement*>* Parser::ParseEagerFunctionBody(
     const AstRawString* function_name, int pos, Variable* fvar,
     Token::Value fvar_init_op, FunctionKind kind, bool* ok) {
   // Everything inside an eagerly parsed function will be parsed eagerly
   // (see comment above).
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
   ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(8, zone());
   if (fvar != NULL) {
     VariableProxy* fproxy = scope_->NewUnresolved(factory(), function_name);
     fproxy->BindTo(fvar);
@@ skipping 1602 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 } }  // namespace v8::internal