First step of refactoring expression contexts in the toplevel code...

src/compiler.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 28 matching lines @@
 #include "usage-analyzer.h"
 
 namespace v8 {
 namespace internal {
 
 
 class CodeGenSelector: public AstVisitor {
  public:
   enum CodeGenTag { NORMAL, FAST };
 
-  CodeGenSelector()
-      : has_supported_syntax_(true),
-        context_(Expression::kUninitialized) {
-  }
+  CodeGenSelector() : has_supported_syntax_(true) {}
 
   CodeGenTag Select(FunctionLiteral* fun);
 
  private:
-  // Visit an expression in a given expression context.
-  void ProcessExpression(Expression* expr, Expression::Context context) {
-    ASSERT(expr->context() == Expression::kUninitialized ||
-           expr->context() == context);
-    Expression::Context saved = context_;
-    context_ = context;
-    Visit(expr);
-    expr->set_context(context);
-    context_ = saved;
-  }
-
   void VisitDeclarations(ZoneList<Declaration*>* decls);
   void VisitStatements(ZoneList<Statement*>* stmts);
 
   // AST node visit functions.
 #define DECLARE_VISIT(type) virtual void Visit##type(type* node);
   AST_NODE_LIST(DECLARE_VISIT)
 #undef DECLARE_VISIT
 
   bool has_supported_syntax_;
 
-  // The desired expression context of the currently visited expression.
-  Expression::Context context_;
-
   DISALLOW_COPY_AND_ASSIGN(CodeGenSelector);
 };
 
 
 static Handle<Code> MakeCode(FunctionLiteral* literal,
                              Handle<Script> script,
                              Handle<Context> context,
                              bool is_eval,
                              Handle<SharedFunctionInfo> shared) {
   ASSERT(literal != NULL);
@@ skipping 551 matching lines @@
   for (int i = 0, len = stmts->length(); i < len; i++) {
     Visit(stmts->at(i));
     CHECK_BAILOUT;
   }
 }
 
 
 void CodeGenSelector::VisitDeclaration(Declaration* decl) {
   Property* prop = decl->proxy()->AsProperty();
   if (prop != NULL) {
-    ProcessExpression(prop->obj(), Expression::kValue);
-    ProcessExpression(prop->key(), Expression::kValue);
+    Visit(prop->obj());
+    Visit(prop->key());
   }
 
   if (decl->fun() != NULL) {
-    ProcessExpression(decl->fun(), Expression::kValue);
+    Visit(decl->fun());
   }
 }
 
 
 void CodeGenSelector::VisitBlock(Block* stmt) {
   VisitStatements(stmt->statements());
 }
 
 
 void CodeGenSelector::VisitExpressionStatement(ExpressionStatement* stmt) {
-  ProcessExpression(stmt->expression(), Expression::kEffect);
+  Visit(stmt->expression());
 }
 
 
-void CodeGenSelector::VisitEmptyStatement(EmptyStatement* stmt) {
-  // EmptyStatement is supported.
-}
+void CodeGenSelector::VisitEmptyStatement(EmptyStatement* stmt) {}
 
 
 void CodeGenSelector::VisitIfStatement(IfStatement* stmt) {
-  ProcessExpression(stmt->condition(), Expression::kTest);
+  Visit(stmt->condition());
   CHECK_BAILOUT;
   Visit(stmt->then_statement());
   CHECK_BAILOUT;
   Visit(stmt->else_statement());
 }
 
 
-void CodeGenSelector::VisitContinueStatement(ContinueStatement* stmt) {
-}
+void CodeGenSelector::VisitContinueStatement(ContinueStatement* stmt) {}
 
 
-void CodeGenSelector::VisitBreakStatement(BreakStatement* stmt) {
-}
+void CodeGenSelector::VisitBreakStatement(BreakStatement* stmt) {}
 
 
 void CodeGenSelector::VisitReturnStatement(ReturnStatement* stmt) {
-  ProcessExpression(stmt->expression(), Expression::kValue);
+  Visit(stmt->expression());
 }
 
 
 void CodeGenSelector::VisitWithEnterStatement(WithEnterStatement* stmt) {
-  ProcessExpression(stmt->expression(), Expression::kValue);
+  Visit(stmt->expression());
 }
 
 
-void CodeGenSelector::VisitWithExitStatement(WithExitStatement* stmt) {
-  // Supported.
-}
+void CodeGenSelector::VisitWithExitStatement(WithExitStatement* stmt) {}
 
 
 void CodeGenSelector::VisitSwitchStatement(SwitchStatement* stmt) {
   BAILOUT("SwitchStatement");
 }
 
 
 void CodeGenSelector::VisitDoWhileStatement(DoWhileStatement* stmt) {
-  // We do not handle loops with breaks or continue statements in their
-  // body.  We will bailout when we hit those statements in the body.
-  ProcessExpression(stmt->cond(), Expression::kTest);
+  Visit(stmt->cond());
   CHECK_BAILOUT;
   Visit(stmt->body());
 }
 
 
 void CodeGenSelector::VisitWhileStatement(WhileStatement* stmt) {
-  // We do not handle loops with breaks or continue statements in their
-  // body.  We will bailout when we hit those statements in the body.
-  ProcessExpression(stmt->cond(), Expression::kTest);
+  Visit(stmt->cond());
   CHECK_BAILOUT;
   Visit(stmt->body());
 }
 
 
 void CodeGenSelector::VisitForStatement(ForStatement* stmt) {
   BAILOUT("ForStatement");
 }
 
 
 void CodeGenSelector::VisitForInStatement(ForInStatement* stmt) {
   BAILOUT("ForInStatement");
 }
 
 
 void CodeGenSelector::VisitTryCatchStatement(TryCatchStatement* stmt) {
   Visit(stmt->try_block());
   CHECK_BAILOUT;
   Visit(stmt->catch_block());
 }
 
 
 void CodeGenSelector::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
   Visit(stmt->try_block());
   CHECK_BAILOUT;
   Visit(stmt->finally_block());
 }
 
 
-void CodeGenSelector::VisitDebuggerStatement(DebuggerStatement* stmt) {
-  // Debugger statement is supported.
-}
+void CodeGenSelector::VisitDebuggerStatement(DebuggerStatement* stmt) {}
 
 
-void CodeGenSelector::VisitFunctionLiteral(FunctionLiteral* expr) {
-  // Function literal is supported.
-}
+void CodeGenSelector::VisitFunctionLiteral(FunctionLiteral* expr) {}
 
 
 void CodeGenSelector::VisitFunctionBoilerplateLiteral(
     FunctionBoilerplateLiteral* expr) {
   BAILOUT("FunctionBoilerplateLiteral");
 }
 
 
 void CodeGenSelector::VisitConditional(Conditional* expr) {
-  ProcessExpression(expr->condition(), Expression::kTest);
+  Visit(expr->condition());
   CHECK_BAILOUT;
-  ProcessExpression(expr->then_expression(), context_);
+  Visit(expr->then_expression());
   CHECK_BAILOUT;
-  ProcessExpression(expr->else_expression(), context_);
+  Visit(expr->else_expression());
 }
 
 
 void CodeGenSelector::VisitSlot(Slot* expr) {
   UNREACHABLE();
 }
 
 
 void CodeGenSelector::VisitVariableProxy(VariableProxy* expr) {
-  Expression* rewrite = expr->var()->rewrite();
-  // A rewrite of NULL indicates a global variable.
-  if (rewrite != NULL) {
-    // Non-global.
-    Slot* slot = rewrite->AsSlot();
+  Variable* var = expr->var();
+  if (!var->is_global()) {

[fschneider, 2010/01/19 12:36:10]

This is clearer than before and should be fine.

It just seems confusing that VariableProxy::AsVariable() checks var_ for NULL
explicitly. Is there any case where it  still can be NULL?

+    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
-      // Only remaining possibility is a property where the object is
-      // a slotted variable and the key is a smi.
-      Property* property = rewrite->AsProperty();
+      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
     }
   }
 }
 
 
-void CodeGenSelector::VisitLiteral(Literal* expr) {
-  /* Nothing to do. */
-}
+void CodeGenSelector::VisitLiteral(Literal* expr) {}
 
 
-void CodeGenSelector::VisitRegExpLiteral(RegExpLiteral* expr) {
-  /* Nothing to do. */
-}
+void CodeGenSelector::VisitRegExpLiteral(RegExpLiteral* expr) {}
 
 
 void CodeGenSelector::VisitObjectLiteral(ObjectLiteral* expr) {
   ZoneList<ObjectLiteral::Property*>* properties = expr->properties();
 
   for (int i = 0, len = properties->length(); i < len; i++) {
     ObjectLiteral::Property* property = properties->at(i);
     if (property->IsCompileTimeValue()) continue;
-
-    switch (property->kind()) {
-      case ObjectLiteral::Property::CONSTANT:
-        UNREACHABLE();
-
-      // For (non-compile-time) materialized literals and computed
-      // properties with symbolic keys we will use an IC and therefore not
-      // generate code for the key.
-      case ObjectLiteral::Property::COMPUTED:  // Fall through.
-      case ObjectLiteral::Property::MATERIALIZED_LITERAL:
-        if (property->key()->handle()->IsSymbol()) {
-          break;
-        }
-        // Fall through.
-
-      // In all other cases we need the key's value on the stack
-      // for a runtime call.  (Relies on TEMP meaning STACK.)
-      case ObjectLiteral::Property::GETTER:  // Fall through.
-      case ObjectLiteral::Property::SETTER:  // Fall through.
-      case ObjectLiteral::Property::PROTOTYPE:
-        ProcessExpression(property->key(), Expression::kValue);
-        CHECK_BAILOUT;
-        break;
-    }
-    ProcessExpression(property->value(), Expression::kValue);
+    Visit(property->key());
+    CHECK_BAILOUT;
+    Visit(property->value());
     CHECK_BAILOUT;
   }
 }
 
 
 void CodeGenSelector::VisitArrayLiteral(ArrayLiteral* expr) {
   ZoneList<Expression*>* subexprs = expr->values();
   for (int i = 0, len = subexprs->length(); i < len; i++) {
     Expression* subexpr = subexprs->at(i);
     if (subexpr->AsLiteral() != NULL) continue;
     if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
-    ProcessExpression(subexpr, Expression::kValue);
+    Visit(subexpr);
     CHECK_BAILOUT;
   }
 }
 
 
 void CodeGenSelector::VisitCatchExtensionObject(CatchExtensionObject* expr) {
-  ProcessExpression(expr->key(), Expression::kValue);
+  Visit(expr->key());
   CHECK_BAILOUT;
-  ProcessExpression(expr->value(), Expression::kValue);
+  Visit(expr->value());
 }
 
 
 void CodeGenSelector::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");
       }
     }
   } else if (prop != NULL) {
-    ProcessExpression(prop->obj(), Expression::kValue);
+    Visit(prop->obj());
     CHECK_BAILOUT;
-    // We will only visit the key during code generation for keyed property
-    // stores.  Leave its expression context uninitialized for named
-    // property stores.
-    if (!prop->key()->IsPropertyName()) {
-      ProcessExpression(prop->key(), Expression::kValue);
-      CHECK_BAILOUT;
-    }
+    Visit(prop->key());
+    CHECK_BAILOUT;
   } else {
     // This is a throw reference error.
     BAILOUT("non-variable/non-property assignment");
   }
 
-  ProcessExpression(expr->value(), Expression::kValue);
+  Visit(expr->value());
 }
 
 
 void CodeGenSelector::VisitThrow(Throw* expr) {
-  ProcessExpression(expr->exception(), Expression::kValue);
+  Visit(expr->exception());
 }
 
 
 void CodeGenSelector::VisitProperty(Property* expr) {
-  ProcessExpression(expr->obj(), Expression::kValue);
+  Visit(expr->obj());
   CHECK_BAILOUT;
-  ProcessExpression(expr->key(), Expression::kValue);
+  Visit(expr->key());
 }
 
 
 void CodeGenSelector::VisitCall(Call* expr) {
   Expression* fun = expr->expression();
   ZoneList<Expression*>* args = expr->arguments();
   Variable* var = fun->AsVariableProxy()->AsVariable();
 
   // Check for supported calls
   if (var != NULL && var->is_possibly_eval()) {
     BAILOUT("call to the identifier 'eval'");
   } else if (var != NULL && !var->is_this() && var->is_global()) {
     // Calls to global variables are supported.
   } else if (var != NULL && var->slot() != NULL &&
              var->slot()->type() == Slot::LOOKUP) {
     BAILOUT("call to a lookup slot");
   } else if (fun->AsProperty() != NULL) {
     Property* prop = fun->AsProperty();
     Literal* literal_key = prop->key()->AsLiteral();
-    if (literal_key != NULL && literal_key->handle()->IsSymbol()) {
-      ProcessExpression(prop->obj(), Expression::kValue);
-      CHECK_BAILOUT;
-    } else {
-      ProcessExpression(prop->obj(), Expression::kValue);
-      CHECK_BAILOUT;
-      ProcessExpression(prop->key(), Expression::kValue);
-      CHECK_BAILOUT;
-    }
+    Visit(prop->obj());
+    CHECK_BAILOUT;
+    Visit(prop->key());
+    CHECK_BAILOUT;
   } else {
     // Otherwise the call is supported if the function expression is.
-    ProcessExpression(fun, Expression::kValue);
+    Visit(fun);
   }
   // Check all arguments to the call.
   for (int i = 0; i < args->length(); i++) {
-    ProcessExpression(args->at(i), Expression::kValue);
+    Visit(args->at(i));
     CHECK_BAILOUT;
   }
 }
 
 
 void CodeGenSelector::VisitCallNew(CallNew* expr) {
-  ProcessExpression(expr->expression(), Expression::kValue);
+  Visit(expr->expression());
   CHECK_BAILOUT;
   ZoneList<Expression*>* args = expr->arguments();
   // Check all arguments to the call
   for (int i = 0; i < args->length(); i++) {
-    ProcessExpression(args->at(i), Expression::kValue);
+    Visit(args->at(i));
     CHECK_BAILOUT;
   }
 }
 
 
 void CodeGenSelector::VisitCallRuntime(CallRuntime* expr) {
   // Check for inline runtime call
   if (expr->name()->Get(0) == '_' &&
       CodeGenerator::FindInlineRuntimeLUT(expr->name()) != NULL) {
     BAILOUT("inlined runtime call");
   }
   // Check all arguments to the call.  (Relies on TEMP meaning STACK.)
   for (int i = 0; i < expr->arguments()->length(); i++) {
-    ProcessExpression(expr->arguments()->at(i), Expression::kValue);
+    Visit(expr->arguments()->at(i));
     CHECK_BAILOUT;
   }
 }
 
 
 void CodeGenSelector::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
     case Token::VOID:
-      ProcessExpression(expr->expression(), Expression::kEffect);
+    case Token::NOT:
+    case Token::TYPEOF:
+      Visit(expr->expression());
       break;
-    case Token::NOT:
-      ProcessExpression(expr->expression(), Expression::kTest);
-      break;
-    case Token::TYPEOF:
-      ProcessExpression(expr->expression(), Expression::kValue);
-      break;
+    case BIT_NOT:
+      BAILOUT("UnaryOperataion: BIT_NOT");
+    case DELETE:
+      BAILOUT("UnaryOperataion: DELETE");
     default:
-      BAILOUT("UnaryOperation");
+      UNREACHABLE();
   }
 }
 
 
 void CodeGenSelector::VisitCountOperation(CountOperation* expr) {
   Variable* var = expr->expression()->AsVariableProxy()->AsVariable();
   Property* prop = expr->expression()->AsProperty();
   ASSERT(var == NULL || prop == NULL);
   if (var != NULL) {
     // All global variables are supported.
     if (!var->is_global()) {
       ASSERT(var->slot() != NULL);
       Slot::Type type = var->slot()->type();
       if (type == Slot::LOOKUP) {
         BAILOUT("CountOperation with lookup slot");
       }
     }
   } else if (prop != NULL) {
-    ProcessExpression(prop->obj(), Expression::kValue);
+    Visit(prop->obj());
     CHECK_BAILOUT;
-    // We will only visit the key during code generation for keyed property
-    // stores.  Leave its expression context uninitialized for named
-    // property stores.
-    if (!prop->key()->IsPropertyName()) {
-      ProcessExpression(prop->key(), Expression::kValue);
-      CHECK_BAILOUT;
-    }
+    Visit(prop->key());
+    CHECK_BAILOUT;
   } else {
     // This is a throw reference error.
     BAILOUT("CountOperation non-variable/non-property expression");
   }
 }
 
 
 void CodeGenSelector::VisitBinaryOperation(BinaryOperation* expr) {
-  switch (expr->op()) {
-    case Token::COMMA:
-      ProcessExpression(expr->left(), Expression::kEffect);
-      CHECK_BAILOUT;
-      ProcessExpression(expr->right(), context_);
-      break;
-
-    case Token::OR:
-      switch (context_) {
-        case Expression::kUninitialized:
-          UNREACHABLE();
-        case Expression::kEffect:  // Fall through.
-        case Expression::kTest:  // Fall through.
-        case Expression::kTestValue:
-          // The left subexpression's value is not needed, it is in a pure
-          // test context.
-          ProcessExpression(expr->left(), Expression::kTest);
-          break;
-        case Expression::kValue:  // Fall through.
-        case Expression::kValueTest:
-          // The left subexpression's value is needed, it is in a hybrid
-          // value/test context.
-          ProcessExpression(expr->left(), Expression::kValueTest);
-          break;
-      }
-      CHECK_BAILOUT;
-      ProcessExpression(expr->right(), context_);
-      break;
-
-    case Token::AND:
-      switch (context_) {
-        case Expression::kUninitialized:
-          UNREACHABLE();
-        case Expression::kEffect:  // Fall through.
-        case Expression::kTest:  // Fall through.
-        case Expression::kValueTest:
-          // The left subexpression's value is not needed, it is in a pure
-          // test context.
-          ProcessExpression(expr->left(), Expression::kTest);
-          break;
-        case Expression::kValue:  // Fall through.
-        case Expression::kTestValue:
-          // The left subexpression's value is needed, it is in a hybrid
-          // test/value context.
-          ProcessExpression(expr->left(), Expression::kTestValue);
-          break;
-      }
-      CHECK_BAILOUT;
-      ProcessExpression(expr->right(), context_);
-      break;
-
-    case Token::ADD:
-    case Token::SUB:
-    case Token::DIV:
-    case Token::MOD:
-    case Token::MUL:
-    case Token::BIT_OR:
-    case Token::BIT_AND:
-    case Token::BIT_XOR:
-    case Token::SHL:
-    case Token::SHR:
-    case Token::SAR:
-      ProcessExpression(expr->left(), Expression::kValue);
-      CHECK_BAILOUT;
-      ProcessExpression(expr->right(), Expression::kValue);
-      break;
-
-    default:
-      BAILOUT("Unsupported binary operation");
-  }
+  Visit(expr->left());
+  CHECK_BAILOUT;
+  Visit(expr->right());
 }
 
 
 void CodeGenSelector::VisitCompareOperation(CompareOperation* expr) {
-  ProcessExpression(expr->left(), Expression::kValue);
+  Visit(expr->left());
   CHECK_BAILOUT;
-  ProcessExpression(expr->right(), Expression::kValue);
+  Visit(expr->right());
 }
 
 
-void CodeGenSelector::VisitThisFunction(ThisFunction* expr) {
-  // ThisFunction is supported.
-}
+void CodeGenSelector::VisitThisFunction(ThisFunction* expr) {}
 
 #undef BAILOUT
 #undef CHECK_BAILOUT
 
 
 } }  // namespace v8::internal