Improve rendering of callsite with non-function target.

src/ast/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 "src/ast/prettyprinter.h"
 
 #include <stdarg.h>
 
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/scopes.h"
 #include "src/base/platform/platform.h"
 
 namespace v8 {
 namespace internal {
 
-CallPrinter::CallPrinter(Isolate* isolate) {
+CallPrinter::CallPrinter(Isolate* isolate, bool is_builtin) {
   output_ = NULL;
   size_ = 0;
   pos_ = 0;
   position_ = 0;
   found_ = false;
   done_ = false;
+  is_builtin_ = is_builtin;
   InitializeAstVisitor(isolate);
 }
 
 
 CallPrinter::~CallPrinter() { DeleteArray(output_); }
 
 
 const char* CallPrinter::Print(FunctionLiteral* program, int position) {
   Init();
   position_ = position;
@@ skipping 152 matching lines @@
 
 void CallPrinter::VisitForInStatement(ForInStatement* node) {
   Find(node->each());
   Find(node->enumerable());
   Find(node->body());
 }
 
 
 void CallPrinter::VisitForOfStatement(ForOfStatement* node) {
   Find(node->each());
-  Find(node->iterable());
+  Find(node->assign_iterator());
   Find(node->body());
+  Find(node->next_result());
 }
 
 
 void CallPrinter::VisitTryCatchStatement(TryCatchStatement* node) {
   Find(node->try_block());
   Find(node->catch_block());
 }
 
 
 void CallPrinter::VisitTryFinallyStatement(TryFinallyStatement* node) {
@@ skipping 25 matching lines @@
 
 
 void CallPrinter::VisitConditional(Conditional* node) {
   Find(node->condition());
   Find(node->then_expression());
   Find(node->else_expression());
 }
 
 
 void CallPrinter::VisitLiteral(Literal* node) {
-  PrintLiteral(node->value(), true);
+  PrintLiteral(*node->value(), true);
 }
 
 
 void CallPrinter::VisitRegExpLiteral(RegExpLiteral* node) {
   Print("/");
-  PrintLiteral(node->pattern(), false);
+  PrintLiteral(*node->pattern(), false);
   Print("/");
   if (node->flags() & RegExp::kGlobal) Print("g");
   if (node->flags() & RegExp::kIgnoreCase) Print("i");
   if (node->flags() & RegExp::kMultiline) Print("m");
   if (node->flags() & RegExp::kUnicode) Print("u");
   if (node->flags() & RegExp::kSticky) Print("y");
 }
 
 
 void CallPrinter::VisitObjectLiteral(ObjectLiteral* node) {
   for (int i = 0; i < node->properties()->length(); i++) {
     Find(node->properties()->at(i)->value());
   }
 }
 
 
 void CallPrinter::VisitArrayLiteral(ArrayLiteral* node) {
   Print("[");
   for (int i = 0; i < node->values()->length(); i++) {
     if (i != 0) Print(",");
     Find(node->values()->at(i), true);
   }
   Print("]");
 }
 
 
 void CallPrinter::VisitVariableProxy(VariableProxy* node) {
-  PrintLiteral(node->name(), false);
+  if (is_builtin_) {
+    // Variable names of builtins are meaningless due to minification.
+    Print("(var)");
+  } else {
+    PrintLiteral(*node->name(), false);
+  }
 }
 
 
 void CallPrinter::VisitAssignment(Assignment* node) {
   Find(node->target());
   Find(node->value());
 }
 
 
 void CallPrinter::VisitYield(Yield* node) { Find(node->expression()); }
 
 
 void CallPrinter::VisitThrow(Throw* node) { Find(node->exception()); }
 
 
 void CallPrinter::VisitProperty(Property* node) {
   Expression* key = node->key();
   Literal* literal = key->AsLiteral();
   if (literal != NULL && literal->value()->IsInternalizedString()) {
     Find(node->obj(), true);
     Print(".");
-    PrintLiteral(literal->value(), false);
+    PrintLiteral(*literal->value(), false);
   } else {
     Find(node->obj(), true);
     Print("[");
     Find(key, true);
     Print("]");
   }
 }
 
 
 void CallPrinter::VisitCall(Call* node) {
   bool was_found = !found_ && node->position() == position_;
-  if (was_found) found_ = true;
+  if (was_found) {
+    // Bail out if the error is caused by a direct call to a variable in builtin
+    // code. The variable name is meaningless due to minification.
+    if (is_builtin_ && node->expression()->IsVariableProxy()) {
+      done_ = true;
+      return;
+    }
+    found_ = true;
+  }
   Find(node->expression(), true);
   if (!was_found) Print("(...)");
   FindArguments(node->arguments());
   if (was_found) done_ = true;
 }
 
 
 void CallPrinter::VisitCallNew(CallNew* node) {
   bool was_found = !found_ && node->position() == position_;
-  if (was_found) found_ = true;
+  if (was_found) {
+    // Bail out if the error is caused by a direct call to a variable in builtin
+    // code. The variable name is meaningless due to minification.
+    if (is_builtin_ && node->expression()->IsVariableProxy()) {
+      done_ = true;
+      return;
+    }
+    found_ = true;
+  }
   Find(node->expression(), was_found);
   FindArguments(node->arguments());
   if (was_found) done_ = true;
 }
 
 
 void CallPrinter::VisitCallRuntime(CallRuntime* node) {
   if (!node->is_jsruntime() &&
       node->function() ==
           Runtime::FunctionForId(Runtime::kInlineDefaultConstructorCallSuper)) {
@@ skipping 75 matching lines @@
 
 
 void CallPrinter::FindArguments(ZoneList<Expression*>* arguments) {
   if (found_) return;
   for (int i = 0; i < arguments->length(); i++) {
     Find(arguments->at(i));
   }
 }
 
 
-void CallPrinter::PrintLiteral(Handle<Object> value, bool quote) {
-  Object* object = *value;
+void CallPrinter::PrintLiteral(Object* value, bool quote) {
+  Object* object = value;
   if (object->IsString()) {
-    String* string = String::cast(object);
     if (quote) Print("\"");
-    for (int i = 0; i < string->length(); i++) {
-      Print("%c", string->Get(i));
-    }
+    Print("%s", String::cast(object)->ToCString().get());
     if (quote) Print("\"");
   } else if (object->IsNull()) {
     Print("null");
   } else if (object->IsTrue()) {
     Print("true");
   } else if (object->IsFalse()) {
     Print("false");
   } else if (object->IsUndefined()) {
     Print("undefined");
   } else if (object->IsNumber()) {
     Print("%g", object->Number());
+  } else if (object->IsSymbol()) {
+    // Symbols can only occur as literals if they were inserted by the parser.
+    PrintLiteral(Symbol::cast(object)->name(), false);
   }
 }
 
 
 void CallPrinter::PrintLiteral(const AstRawString* value, bool quote) {
-  PrintLiteral(value->string(), quote);
+  PrintLiteral(*value->string(), quote);
 }
 
 
 //-----------------------------------------------------------------------------
 
 
 #ifdef DEBUG
 
 // A helper for ast nodes that use FeedbackVectorSlots.
 static int FormatSlotNode(Vector<char>* buf, Expression* node,
@@ skipping 1205 matching lines @@
 
 void AstPrinter::VisitSuperCallReference(SuperCallReference* node) {
   IndentedScope indent(this, "SUPER-CALL-REFERENCE", node->position());
 }
 
 
 #endif  // DEBUG
 
 }  // namespace internal
 }  // namespace v8