Merge up to 8597 to experimental/gc from the bleeding edge.

src/prettyprinter.cc

-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// Copyright 2011 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
 //       with the distribution.
@@ skipping 104 matching lines @@
 }
 
 
 void PrettyPrinter::VisitReturnStatement(ReturnStatement* node) {
   Print("return ");
   Visit(node->expression());
   Print(";");
 }
 
 
-void PrettyPrinter::VisitWithEnterStatement(WithEnterStatement* node) {
-  Print("<enter with> (");
+void PrettyPrinter::VisitEnterWithContextStatement(
+    EnterWithContextStatement* node) {
+  Print("<enter with context> (");
   Visit(node->expression());
   Print(") ");
 }
 
 
-void PrettyPrinter::VisitWithExitStatement(WithExitStatement* node) {
-  Print("<exit with>");
+void PrettyPrinter::VisitExitContextStatement(ExitContextStatement* node) {
+  Print("<exit context>");
 }
 
 
 void PrettyPrinter::VisitSwitchStatement(SwitchStatement* node) {
   PrintLabels(node->labels());
   Print("switch (");
   Visit(node->tag());
   Print(") { ");
   ZoneList<CaseClause*>* cases = node->cases();
   for (int i = 0; i < cases->length(); i++)
@@ skipping 49 matching lines @@
   Visit(node->enumerable());
   Print(") ");
   Visit(node->body());
 }
 
 
 void PrettyPrinter::VisitTryCatchStatement(TryCatchStatement* node) {
   Print("try ");
   Visit(node->try_block());
   Print(" catch (");
-  Visit(node->catch_var());
+  const bool quote = false;
+  PrintLiteral(node->variable()->name(), quote);
   Print(") ");
   Visit(node->catch_block());
 }
 
 
 void PrettyPrinter::VisitTryFinallyStatement(TryFinallyStatement* node) {
   Print("try ");
   Visit(node->try_block());
   Print(" finally ");
   Visit(node->finally_block());
@@ skipping 60 matching lines @@
 void PrettyPrinter::VisitArrayLiteral(ArrayLiteral* node) {
   Print("[ ");
   for (int i = 0; i < node->values()->length(); i++) {
     if (i != 0) Print(",");
     Visit(node->values()->at(i));
   }
   Print(" ]");
 }
 
 
-void PrettyPrinter::VisitCatchExtensionObject(CatchExtensionObject* node) {
-  Print("{ ");
-  Visit(node->key());
-  Print(": ");
-  Visit(node->value());
-  Print(" }");
-}
-
-
 void PrettyPrinter::VisitSlot(Slot* node) {
   switch (node->type()) {
     case Slot::PARAMETER:
       Print("parameter[%d]", node->index());
       break;
     case Slot::LOCAL:
       Print("local[%d]", node->index());
       break;
     case Slot::CONTEXT:
       Print("context[%d]", node->index());
@@ skipping 494 matching lines @@
 void AstPrinter::VisitBreakStatement(BreakStatement* node) {
   PrintLabelsIndented("BREAK", node->target()->labels());
 }
 
 
 void AstPrinter::VisitReturnStatement(ReturnStatement* node) {
   PrintIndentedVisit("RETURN", node->expression());
 }
 
 
-void AstPrinter::VisitWithEnterStatement(WithEnterStatement* node) {
-  PrintIndentedVisit("WITH ENTER", node->expression());
+void AstPrinter::VisitEnterWithContextStatement(
+    EnterWithContextStatement* node) {
+  PrintIndentedVisit("ENTER WITH CONTEXT", node->expression());
 }
 
 
-void AstPrinter::VisitWithExitStatement(WithExitStatement* node) {
-  PrintIndented("WITH EXIT\n");
+void AstPrinter::VisitExitContextStatement(ExitContextStatement* node) {
+  PrintIndented("EXIT CONTEXT\n");
 }
 
 
 void AstPrinter::VisitSwitchStatement(SwitchStatement* node) {
   IndentedScope indent(this, "SWITCH");
   PrintLabelsIndented(NULL, node->labels());
   PrintIndentedVisit("TAG", node->tag());
   for (int i = 0; i < node->cases()->length(); i++) {
     PrintCaseClause(node->cases()->at(i));
   }
@@ skipping 30 matching lines @@
   IndentedScope indent(this, "FOR IN");
   PrintIndentedVisit("FOR", node->each());
   PrintIndentedVisit("IN", node->enumerable());
   PrintIndentedVisit("BODY", node->body());
 }
 
 
 void AstPrinter::VisitTryCatchStatement(TryCatchStatement* node) {
   IndentedScope indent(this, "TRY CATCH");
   PrintIndentedVisit("TRY", node->try_block());
-  PrintIndentedVisit("CATCHVAR", node->catch_var());
+  PrintLiteralWithModeIndented("CATCHVAR",
+                               node->variable(),
+                               node->variable()->name());
   PrintIndentedVisit("CATCH", node->catch_block());
 }
 
 
 void AstPrinter::VisitTryFinallyStatement(TryFinallyStatement* node) {
   IndentedScope indent(this, "TRY FINALLY");
   PrintIndentedVisit("TRY", node->try_block());
   PrintIndentedVisit("FINALLY", node->finally_block());
 }
 
@@ skipping 79 matching lines @@
   IndentedScope indent(this, "ARRAY LITERAL");
   if (node->values()->length() > 0) {
     IndentedScope indent(this, "VALUES");
     for (int i = 0; i < node->values()->length(); i++) {
       Visit(node->values()->at(i));
     }
   }
 }
 
 
-void AstPrinter::VisitCatchExtensionObject(CatchExtensionObject* node) {
-  IndentedScope indent(this, "CatchExtensionObject");
-  PrintIndentedVisit("KEY", node->key());
-  PrintIndentedVisit("VALUE", node->value());
-}
-
-
 void AstPrinter::VisitSlot(Slot* node) {
   PrintIndented("SLOT ");
   PrettyPrinter::VisitSlot(node);
   Print("\n");
 }
 
 
 void AstPrinter::VisitVariableProxy(VariableProxy* node) {
   PrintLiteralWithModeIndented("VAR PROXY", node->AsVariable(), node->name());
   Variable* var = node->var();
@@ skipping 216 matching lines @@
   TagScope tag(this, "BreakStatement");
 }
 
 
 void JsonAstBuilder::VisitReturnStatement(ReturnStatement* stmt) {
   TagScope tag(this, "ReturnStatement");
   Visit(stmt->expression());
 }
 
 
-void JsonAstBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) {
-  TagScope tag(this, "WithEnterStatement");
+void JsonAstBuilder::VisitEnterWithContextStatement(
+    EnterWithContextStatement* stmt) {
+  TagScope tag(this, "EnterWithContextStatement");
   Visit(stmt->expression());
 }
 
 
-void JsonAstBuilder::VisitWithExitStatement(WithExitStatement* stmt) {
-  TagScope tag(this, "WithExitStatement");
+void JsonAstBuilder::VisitExitContextStatement(ExitContextStatement* stmt) {
+  TagScope tag(this, "ExitContextStatement");
 }
 
 
 void JsonAstBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
   TagScope tag(this, "SwitchStatement");
 }
 
 
 void JsonAstBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
   TagScope tag(this, "DoWhileStatement");
@@ skipping 21 matching lines @@
 void JsonAstBuilder::VisitForInStatement(ForInStatement* stmt) {
   TagScope tag(this, "ForInStatement");
   Visit(stmt->each());
   Visit(stmt->enumerable());
   Visit(stmt->body());
 }
 
 
 void JsonAstBuilder::VisitTryCatchStatement(TryCatchStatement* stmt) {
   TagScope tag(this, "TryCatchStatement");
+  { AttributesScope attributes(this);
+    AddAttribute("variable", stmt->variable()->name());
+  }
   Visit(stmt->try_block());
-  Visit(stmt->catch_var());
   Visit(stmt->catch_block());
 }
 
 
 void JsonAstBuilder::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
   TagScope tag(this, "TryFinallyStatement");
   Visit(stmt->try_block());
   Visit(stmt->finally_block());
 }
 
@@ skipping 84 matching lines @@
 void JsonAstBuilder::VisitObjectLiteral(ObjectLiteral* expr) {
   TagScope tag(this, "ObjectLiteral");
 }
 
 
 void JsonAstBuilder::VisitArrayLiteral(ArrayLiteral* expr) {
   TagScope tag(this, "ArrayLiteral");
 }
 
 
-void JsonAstBuilder::VisitCatchExtensionObject(CatchExtensionObject* expr) {
-  TagScope tag(this, "CatchExtensionObject");
-  Visit(expr->key());
-  Visit(expr->value());
-}
-
-
 void JsonAstBuilder::VisitAssignment(Assignment* expr) {
   TagScope tag(this, "Assignment");
   {
     AttributesScope attributes(this);
     AddAttribute("op", Token::Name(expr->op()));
   }
   Visit(expr->target());
   Visit(expr->value());
 }
 
 
 void JsonAstBuilder::VisitThrow(Throw* expr) {
   TagScope tag(this, "Throw");
   Visit(expr->exception());
 }
 
 
 void JsonAstBuilder::VisitProperty(Property* expr) {
   TagScope tag(this, "Property");
-  {
-    AttributesScope attributes(this);
-    AddAttribute("type", expr->is_synthetic() ? "SYNTHETIC" : "NORMAL");
-  }
   Visit(expr->obj());
   Visit(expr->key());
 }
 
 
 void JsonAstBuilder::VisitCall(Call* expr) {
   TagScope tag(this, "Call");
   Visit(expr->expression());
   VisitExpressions(expr->arguments());
 }
@@ skipping 81 matching lines @@
     AddAttribute("mode", Variable::Mode2String(decl->mode()));
   }
   Visit(decl->proxy());
   if (decl->fun() != NULL) Visit(decl->fun());
 }
 
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal