Make sure that the name accessor on functions return the expected...

src/debug-delay.js

 // Copyright 2006-2008 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 57 matching lines @@
 var next_break_point_number = 1;
 var break_points = [];
 var script_break_points = [];
 
 
 // Create a new break point object and add it to the list of break points.
 function MakeBreakPoint(source_position, opt_line, opt_column, opt_script_break_point) {
   var break_point = new BreakPoint(source_position, opt_line, opt_column, opt_script_break_point);
   break_points.push(break_point);
   return break_point;
-};
+}
 
 
 // Object representing a break point.
 // NOTE: This object does not have a reference to the function having break
 // point as this would cause function not to be garbage collected when it is
 // not used any more. We do not want break points to keep functions alive.
 function BreakPoint(source_position, opt_line, opt_column, opt_script_break_point) {
   this.source_position_ = source_position;
   this.source_line_ = opt_line;
   this.source_column_ = opt_column;
   if (opt_script_break_point) {
     this.script_break_point_ = opt_script_break_point;
   } else {
     this.number_ = next_break_point_number++;
   }
   this.hit_count_ = 0;
   this.active_ = true;
   this.condition_ = null;
   this.ignoreCount_ = 0;
-};
+}
 
 
 BreakPoint.prototype.number = function() {
   return this.number_;
 };
 
 
 BreakPoint.prototype.func = function() {
   return this.func_;
 };
@@ skipping 88 matching lines @@
 
   // Break point triggered.
   return true;
 };
 
 
 // Function called from the runtime when a break point is hit. Returns true if
 // the break point is triggered and supposed to break execution.
 function IsBreakPointTriggered(break_id, break_point) {
   return break_point.isTriggered(MakeExecutionState(break_id));
-};
+}
 
 
 // Object representing a script break point. The script is referenced by its
 // script name and the break point is represented as line and column.
 function ScriptBreakPoint(script_name, opt_line, opt_column) {
   this.script_name_ = script_name;
   this.line_ = opt_line || 0;
   this.column_ = opt_column;
   this.hit_count_ = 0;
   this.active_ = true;
   this.condition_ = null;
   this.ignoreCount_ = 0;
-};
+}
 
 
 ScriptBreakPoint.prototype.number = function() {
   return this.number_;
 };
 
 
 ScriptBreakPoint.prototype.script_name = function() {
   return this.script_name_;
 };
@@ skipping 116 matching lines @@
 
 
 // Function called from runtime when a new script is compiled to set any script
 // break points set in this script.
 function UpdateScriptBreakPoints(script) {
   for (var i = 0; i < script_break_points.length; i++) {
     if (script_break_points[i].script_name() == script.name) {
       script_break_points[i].set(script);
     }
   }
-};
+}
 
 
 // Function called from the runtime to handle a debug request receiced from the
 // debugger. When this function is called the debugger is in the broken state
 // reflected by the exec_state parameter. When pending requests are handled the
 // parameter stopping indicate the expected running state.
 function ProcessDebugRequest(exec_state, request, stopping) {
   return exec_state.debugCommandProcessor().processDebugJSONRequest(request, stopping);
 }
 
@@ skipping 301 matching lines @@
 
 // Get all the scripts currently loaded. Locating all the scripts is based on
 // scanning the heap.
 Debug.scripts = function() {
   // Collect all scripts in the heap.
   return %DebugGetLoadedScripts();
 }
 
 function MakeExecutionState(break_id) {
   return new ExecutionState(break_id);
-};
+}
 
 function ExecutionState(break_id) {
   this.break_id = break_id;
   this.selected_frame = 0;
-};
+}
 
 ExecutionState.prototype.prepareStep = function(opt_action, opt_count) {
   var action = Debug.StepAction.StepIn;
   if (!IS_UNDEFINED(opt_action)) action = %ToNumber(opt_action);
   var count = opt_count ? %ToNumber(opt_count) : 1;
 
   return %PrepareStep(this.break_id, action, count);
 }
 
 ExecutionState.prototype.evaluateGlobal = function(source, disable_break) {
@@ skipping 25 matching lines @@
   return this.selected_frame;
 };
 
 ExecutionState.prototype.debugCommandProcessor = function(protocol) {
   return new DebugCommandProcessor(this, protocol);
 };
 
 
 function MakeBreakEvent(exec_state, break_points_hit) {
   return new BreakEvent(exec_state, break_points_hit);
-};
+}
 
 
 function BreakEvent(exec_state, break_points_hit) {
   this.exec_state_ = exec_state;
   this.break_points_hit_ = break_points_hit;
-};
+}
 
 
 BreakEvent.prototype.func = function() {
   return this.exec_state_.frame(0).func();
 };
 
 
 BreakEvent.prototype.sourceLine = function() {
   return this.exec_state_.frame(0).sourceLine();
 };
@@ skipping 92 matching lines @@
       o.body.breakpoints.push(number);
     }
   }
 
   return SimpleObjectToJSON_(o);
 };
 
 
 function MakeExceptionEvent(exec_state, exception, uncaught) {
   return new ExceptionEvent(exec_state, exception, uncaught);
-};
+}
 
 function ExceptionEvent(exec_state, exception, uncaught) {
   this.exec_state_ = exec_state;
   this.exception_ = exception;
   this.uncaught_ = uncaught;
-};
+}
 
 ExceptionEvent.prototype.uncaught = function() {
   return this.uncaught_;
 }
 
 ExceptionEvent.prototype.func = function() {
   return this.exec_state_.frame(0).func();
 };
 
 
@@ skipping 58 matching lines @@
                       columnOffset: script.columnOffset(),
                       lineCount: script.lineCount()
                     };
   }
 
   return SimpleObjectToJSON_(o);
 };
 
 function MakeCompileEvent(script_source, script_name, script_function) {
   return new CompileEvent(script_source, script_name, script_function);
-};
+}
 
 function CompileEvent(script_source, script_name, script_function) {
   this.scriptSource = script_source;
   this.scriptName = script_name;
   this.scriptFunction = script_function;
-};
+}
 
 CompileEvent.prototype.details = function() {
   var result = "";
   result = "Script added"
   if (this.scriptData) {
     result += ": '";
     result += this.scriptData;
     result += "'";
   }
   return result;
 };
 
 CompileEvent.prototype.debugPrompt = function() {
   var result = "source"
   if (this.scriptData) {
     result += " '";
     result += this.scriptData;
     result += "'";
   }
   if (this.func) {
     result += " added";
   } else {
     result += " compiled";
   }
   return result;
 };
 
 function MakeNewFunctionEvent(func) {
   return new NewFunctionEvent(func);
-};
+}
 
 function NewFunctionEvent(func) {
   this.func = func;
-};
+}
 
 NewFunctionEvent.prototype.details = function() {
   var result = "";
   result = "Function added: ";
   result += this.func.name;
   return result;
 };
 
 NewFunctionEvent.prototype.debugPrompt = function() {
   var result = "function";
@@ skipping 322 matching lines @@
     if (source_text[i] == '\t') {
       underline += '\t';
     } else {
       underline += ' ';
     }
   }
   underline += '^';
 
   // Return the source line text with the underline beneath.
   return source_text + '\n' + underline;
-};
+}
 
 
 function FrameSourceUnderline(frame) {
   var location = frame.sourceLocation();
   if (location) {
     return SourceUnderline(location.sourceText(), location.position - location.start);
   }
-};
+}
 
 
 function RequestPacket(command) {
   this.seq = 0;
   this.type = 'request';
   this.command = command;
-};
+}
 
 
 RequestPacket.prototype.toJSONProtocol = function() {
   // Encode the protocol header.
   var json = '{';
   json += '"seq":' + this.seq;
   json += ',"type":"' + this.type + '"';
   if (this.command) {
     json += ',"command":' + StringToJSON_(this.command);
   }
@@ skipping 17 matching lines @@
 
 
 function ResponsePacket(request) {
   // Build the initial response from the request.
   this.seq = next_response_seq++;
   this.type = 'response';
   if (request) this.request_seq = request.seq;
   if (request) this.command = request.command;
   this.success = true;
   this.running = false;
-};
+}
 
 
 ResponsePacket.prototype.failed = function(message) {
   this.success = false;
   this.message = message;
 }
 
 
 ResponsePacket.prototype.toJSONProtocol = function() {
   // Encode the protocol header.
@@ skipping 607 matching lines @@
 
       // Add the property if relevant.
       if (property_value_json) {
         content.push(StringToJSON_(key) + ':' + property_value_json);
       }
     }
   }
 
   // Make JSON object representation.
   return '{' + content.join(',') + '}';
-};
+}
 
 /**
  * Convert an array to its JSON representation. This is a VERY simple
  * implementation just to support what is needed for the debugger.
  * @param {Array} arrya The array to format as JSON
  * @return {string} JSON formatted array value
  */
 function SimpleArrayToJSON_(array) {
   // Make JSON array representation.
   var json = '[';
@@ skipping 11 matching lines @@
     } else if (IS_NUMBER(elem)) {
       json += NumberToJSON_(elem);
     } else if (IS_STRING(elem)) {
       json += StringToJSON_(elem);
     } else {
       json += elem;
     }
   }
   json += ']';
   return json;
-};
+}