Class syntax parsing

src/prettyprinter.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 <stdarg.h>
 
 #include "src/v8.h"
 
 #include "src/ast-value-factory.h"
 #include "src/base/platform/platform.h"
@@ skipping 35 matching lines @@
 
 void PrettyPrinter::VisitFunctionDeclaration(FunctionDeclaration* node) {
   Print("function ");
   PrintLiteral(node->proxy()->name(), false);
   Print(" = ");
   PrintFunctionLiteral(node->fun());
   Print(";");
 }
 
 
+void PrettyPrinter::VisitClassDeclaration(ClassDeclaration* node) {
+  Print("class ");
+  PrintLiteral(node->proxy()->name(), false);
+  Print(" = ");
+  PrintClassLiteral(node->classLiteral());
+  Print(";");
+}
+
+
 void PrettyPrinter::VisitModuleDeclaration(ModuleDeclaration* node) {
   Print("module ");
   PrintLiteral(node->proxy()->name(), false);
   Print(" = ");
   Visit(node->module());
   Print(";");
 }
 
 
 void PrettyPrinter::VisitImportDeclaration(ImportDeclaration* node) {
@@ skipping 216 matching lines @@
 }
 
 
 void PrettyPrinter::VisitFunctionLiteral(FunctionLiteral* node) {
   Print("(");
   PrintFunctionLiteral(node);
   Print(")");
 }
 
 
+void PrettyPrinter::VisitClassLiteral(ClassLiteral* node) {
+  Print("(");
+  PrintClassLiteral(node);
+  Print(")");
+}
+
+
 void PrettyPrinter::VisitNativeFunctionLiteral(NativeFunctionLiteral* node) {
   Print("(");
   PrintLiteral(node->name(), false);
   Print(")");
 }
 
 
 void PrettyPrinter::VisitConditional(Conditional* node) {
   Visit(node->condition());
   Print(" ? ");
@@ skipping 14 matching lines @@
   Print(",");
   PrintLiteral(node->flags(), false);
   Print(") ");
 }
 
 
 void PrettyPrinter::VisitObjectLiteral(ObjectLiteral* node) {
   Print("{ ");
   for (int i = 0; i < node->properties()->length(); i++) {
     if (i != 0) Print(",");
-    ObjectLiteral::Property* property = node->properties()->at(i);
-    Print(" ");
-    Visit(property->key());
-    Print(": ");
-    Visit(property->value());
+    PrintObjectLiteralProperty(node->properties()->at(i));
   }
   Print(" }");
 }
 
 
+void PrettyPrinter::PrintObjectLiteralProperty(
+    ObjectLiteralProperty* property) {
+  // TODO(arv): Better printing of methods etc.
+  Print(" ");
+  Visit(property->key());
+  Print(": ");
+  Visit(property->value());
+}
+
+
 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(" ]");
 }
 
 
@@ skipping 269 matching lines @@
   Print("function ");
   PrintLiteral(function->name(), false);
   PrintParameters(function->scope());
   Print(" { ");
   PrintDeclarations(function->scope()->declarations());
   PrintStatements(function->body());
   Print(" }");
 }
 
 
+void PrettyPrinter::PrintClassLiteral(ClassLiteral* class_literal) {
+  Print("class ");
+  PrintLiteral(class_literal->name(), false);
+  if (class_literal->extends()) {
+    Print(" extends ");
+    Visit(class_literal->extends());
+  }
+  Print(" { ");
+  for (int i = 0; i < class_literal->properties()->length(); i++) {
+    PrintObjectLiteralProperty(class_literal->properties()->at(i));
+  }
+  Print(" }");
+}
+
+
 //-----------------------------------------------------------------------------
 
 class IndentedScope BASE_EMBEDDED {
  public:
   IndentedScope(AstPrinter* printer, const char* txt)
       : ast_printer_(printer) {
     ast_printer_->PrintIndented(txt);
     ast_printer_->Print("\n");
     ast_printer_->inc_indent();
   }
@@ skipping 132 matching lines @@
 // TODO(svenpanne) Start with IndentedScope.
 void AstPrinter::VisitFunctionDeclaration(FunctionDeclaration* node) {
   PrintIndented("FUNCTION ");
   PrintLiteral(node->proxy()->name(), true);
   Print(" = function ");
   PrintLiteral(node->fun()->name(), false);
   Print("\n");
 }
 
 
+void AstPrinter::VisitClassDeclaration(ClassDeclaration* node) {
+  PrintIndented("CLASS ");
+  PrintLiteral(node->proxy()->name(), true);
+  Print(" = class ");
+  PrintLiteral(node->classLiteral()->name(), false);
+  Print("\n");
+}
+
+
 void AstPrinter::VisitModuleDeclaration(ModuleDeclaration* node) {
   IndentedScope indent(this, "MODULE");
   PrintLiteralIndented("NAME", node->proxy()->name(), true);
   Visit(node->module());
 }
 
 
 void AstPrinter::VisitImportDeclaration(ImportDeclaration* node) {
   IndentedScope indent(this, "IMPORT");
   PrintLiteralIndented("NAME", node->proxy()->name(), true);
@@ skipping 175 matching lines @@
   PrintLiteralIndented("NAME", node->name(), false);
   PrintLiteralIndented("INFERRED NAME", node->inferred_name(), false);
   PrintParameters(node->scope());
   // We don't want to see the function literal in this case: it
   // will be printed via PrintProgram when the code for it is
   // generated.
   // PrintStatements(node->body());
 }
 
 
+void AstPrinter::VisitClassLiteral(ClassLiteral* node) {
+  IndentedScope indent(this, "CLASS LITERAL");
+  PrintLiteralIndented("NAME", node->name(), false);
+}
+
+
 void AstPrinter::VisitNativeFunctionLiteral(NativeFunctionLiteral* node) {
   IndentedScope indent(this, "NATIVE FUNC LITERAL");
   PrintLiteralIndented("NAME", node->name(), false);
 }
 
 
 void AstPrinter::VisitConditional(Conditional* node) {
   IndentedScope indent(this, "CONDITIONAL");
   PrintIndentedVisit("CONDITION", node->condition());
   PrintIndentedVisit("THEN", node->then_expression());
@@ skipping 169 matching lines @@
 }
 
 
 void AstPrinter::VisitSuperReference(SuperReference* node) {
   IndentedScope indent(this, "SUPER-REFERENCE");
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal