Enable references and assignments to lookup slots in the toplevel code...

src/full-codegen.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 115 matching lines @@
   CHECK_BAILOUT;
   Visit(stmt->else_statement());
 }
 
 
 void FullCodeGenSyntaxChecker::VisitContinueStatement(ContinueStatement* stmt) {
   // Supported.
 }
 
 
-void FullCodeGenSyntaxChecker::VisitBreakStatement(BreakStatement* stmt) {}
+void FullCodeGenSyntaxChecker::VisitBreakStatement(BreakStatement* stmt) {
+  // Supported.
+}
 
 
 void FullCodeGenSyntaxChecker::VisitReturnStatement(ReturnStatement* stmt) {
   Visit(stmt->expression());
 }
 
 
 void FullCodeGenSyntaxChecker::VisitWithEnterStatement(
     WithEnterStatement* stmt) {
   Visit(stmt->expression());
@@ skipping 87 matching lines @@
   Visit(expr->else_expression());
 }
 
 
 void FullCodeGenSyntaxChecker::VisitSlot(Slot* expr) {
   UNREACHABLE();
 }
 
 
 void FullCodeGenSyntaxChecker::VisitVariableProxy(VariableProxy* expr) {
-  Variable* var = expr->var();
-  if (!var->is_global()) {
-    Slot* slot = var->slot();
-    if (slot != NULL) {
-      Slot::Type type = slot->type();
-      // When LOOKUP slots are enabled, some currently dead code
-      // implementing unary typeof will become live.
-      if (type == Slot::LOOKUP) {
-        BAILOUT("Lookup slot");
-      }
-    } else {
-      // If not global or a slot, it is a parameter rewritten to an explicit
-      // property reference on the (shadow) arguments object.
-#ifdef DEBUG
-      Property* property = var->AsProperty();
-      ASSERT_NOT_NULL(property);
-      Variable* object = property->obj()->AsVariableProxy()->AsVariable();
-      ASSERT_NOT_NULL(object);
-      ASSERT_NOT_NULL(object->slot());
-      ASSERT_NOT_NULL(property->key()->AsLiteral());
-      ASSERT(property->key()->AsLiteral()->handle()->IsSmi());
-#endif
-    }
-  }
+  // Supported.
 }
 
 
 void FullCodeGenSyntaxChecker::VisitLiteral(Literal* expr) {
   // Supported.
 }
 
 
 void FullCodeGenSyntaxChecker::VisitRegExpLiteral(RegExpLiteral* expr) {
   // Supported.
@@ skipping 28 matching lines @@
 
 void FullCodeGenSyntaxChecker::VisitCatchExtensionObject(
     CatchExtensionObject* expr) {
   Visit(expr->key());
   CHECK_BAILOUT;
   Visit(expr->value());
 }
 
 
 void FullCodeGenSyntaxChecker::VisitAssignment(Assignment* expr) {
-  // We support plain non-compound assignments to properties, parameters and
-  // non-context (stack-allocated) locals, and global variables.
   Token::Value op = expr->op();
   if (op == Token::INIT_CONST) BAILOUT("initialize constant");
 
   Variable* var = expr->target()->AsVariableProxy()->AsVariable();
   Property* prop = expr->target()->AsProperty();
   ASSERT(var == NULL || prop == NULL);
   if (var != NULL) {
-    if (var->mode() == Variable::CONST) {
-      BAILOUT("Assignment to const");
-    }
-    // All global variables are supported.
-    if (!var->is_global()) {
-      ASSERT(var->slot() != NULL);
-      Slot::Type type = var->slot()->type();
-      if (type == Slot::LOOKUP) {
-        BAILOUT("Lookup slot");
-      }
-    }
+    if (var->mode() == Variable::CONST) BAILOUT("Assignment to const");
+    // All other variables are supported.
   } else if (prop != NULL) {
     Visit(prop->obj());
     CHECK_BAILOUT;
     Visit(prop->key());
     CHECK_BAILOUT;
   } else {
     // This is a throw reference error.
     BAILOUT("non-variable/non-property assignment");
   }
 
@@ skipping 722 matching lines @@
 
 
 void FullCodeGenerator::VisitLiteral(Literal* expr) {
   Comment cmnt(masm_, "[ Literal");
   Apply(context_, expr);
 }
 
 
 void FullCodeGenerator::VisitAssignment(Assignment* expr) {
   Comment cmnt(masm_, "[ Assignment");
+  ASSERT(expr->op() != Token::INIT_CONST);
   // Left-hand side can only be a property, a global or a (parameter or local)
   // slot. Variables with rewrite to .arguments are treated as KEYED_PROPERTY.
   enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
   LhsKind assign_type = VARIABLE;
   Property* prop = expr->target()->AsProperty();
   if (prop != NULL) {
     assign_type =
         (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
   }
 
@@ skipping 30 matching lines @@
         __ push(result_register());
         break;
     }
     location_ = saved_location;
   }
 
   // Evaluate RHS expression.
   Expression* rhs = expr->value();
   VisitForValue(rhs, kAccumulator);
 
-  // If we have a compount assignment: Apply operator.
+  // If we have a compound assignment: Apply operator.
   if (expr->is_compound()) {
     Location saved_location = location_;
     location_ = kAccumulator;
     EmitBinaryOp(expr->binary_op(), Expression::kValue);
     location_ = saved_location;
   }
 
   // Record source position before possible IC call.
   SetSourcePosition(expr->position());
 
@@ skipping 47 matching lines @@
   __ Drop(stack_depth);
   __ PopTryHandler();
   return 0;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal