Make more JS files beter match the coding standard.

test/mjsunit/debug-scopes.js

 // 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
@@ skipping 448 matching lines @@
 
 
 // Simple closure formed by returning an inner function referering the outer
 // functions arguments.
 BeginTest("Closure 1");
 
 function closure_1(a) {
   function f() {
     debugger;
     return a;
-  };
+  }
   return f;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1}, 1, exec_state);
 };
 closure_1(1)();
 EndTest();
 
 
 // Simple closure formed by returning an inner function referering the outer
 // functions arguments. Due to VM optimizations parts of the actual closure is
 // missing from the debugger information.
 BeginTest("Closure 2");
 
 function closure_2(a, b) {
   var x = a + 2;
   var y = b + 2;
   function f() {
     debugger;
     return a + x;
-  };
+  }
   return f;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,x:3}, 1, exec_state);
 };
 closure_2(1, 2)();
 EndTest();
 
 
 // Simple closure formed by returning an inner function referering the outer
 // functions arguments. Using all arguments and locals from the outer function
 // in the inner function makes these part of the debugger information on the
 // closure.
 BeginTest("Closure 3");
 
 function closure_3(a, b) {
   var x = a + 2;
   var y = b + 2;
   function f() {
     debugger;
     return a + b + x + y;
-  };
+  }
   return f;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4}, 1, exec_state);
 };
 closure_3(1, 2)();
 EndTest();
 
 
 
 // Simple closure formed by returning an inner function referering the outer
 // functions arguments. Using all arguments and locals from the outer function
 // in the inner function makes these part of the debugger information on the
 // closure. Use the inner function as well...
 BeginTest("Closure 4");
 
 function closure_4(a, b) {
   var x = a + 2;
   var y = b + 2;
   function f() {
     debugger;
     if (f) {
       return a + b + x + y;
     }
-  };
+  }
   return f;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,f:function(){}}, 1, exec_state);
 };
 closure_4(1, 2)();
 EndTest();
 
 
 
 // Simple closure formed by returning an inner function referering the outer
 // functions arguments. In the presence of eval all arguments and locals
 // (including the inner function itself) from the outer function becomes part of
 // the debugger infformation on the closure.
 BeginTest("Closure 5");
 
 function closure_5(a, b) {
   var x = 3;
   var y = 4;
   function f() {
     eval('');
     debugger;
     return 1;
-  };
+  }
   return f;
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4,f:function(){}}, 1, exec_state);
 };
 closure_5(1, 2)();
@@ skipping 211 matching lines @@
   var f = createClosure(0);
   f();
 }
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.With,
                    debug.ScopeType.Local,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
-}
+};
 closure_in_with_3();
 EndTest();
 
 
 BeginTest("Closure inside With 4");
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.With,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({x: 2}, 0, exec_state);
@@ skipping 17 matching lines @@
 EndTest();
 
 
 BeginTest("Catch block 1");
 function catch_block_1() {
   try {
     throw 'Exception';
   } catch (e) {
     debugger;
   }
-};
+}
 
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Catch,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({e:'Exception'}, 0, exec_state);
 };
 catch_block_1();
 EndTest();
 
 
 BeginTest("Catch block 2");
 function catch_block_2() {
   try {
     throw 'Exception';
   } catch (e) {
     with({n:10}) {
       debugger;
     }
   }
-};
+}
 
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.With,
                    debug.ScopeType.Catch,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({n:10}, 0, exec_state);
   CheckScopeContent({e:'Exception'}, 1, exec_state);
 };
 catch_block_2();
 EndTest();
 
 
 BeginTest("Catch block 3");
 function catch_block_3() {
   // Do eval to dynamically declare a local variable so that the context's
   // extension slot is initialized with JSContextExtensionObject.
   eval("var y = 78;");
   try {
     throw 'Exception';
   } catch (e) {
     debugger;
   }
-};
+}
 
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Catch,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({e:'Exception'}, 0, exec_state);
   CheckScopeContent({y:78}, 1, exec_state);
 };
 catch_block_3();
 EndTest();
 
 
 BeginTest("Catch block 4");
 function catch_block_4() {
   // Do eval to dynamically declare a local variable so that the context's
   // extension slot is initialized with JSContextExtensionObject.
   eval("var y = 98;");
   try {
     throw 'Exception';
   } catch (e) {
     with({n:10}) {
       debugger;
     }
   }
-};
+}
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.With,
                    debug.ScopeType.Catch,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({n:10}, 0, exec_state);
   CheckScopeContent({e:'Exception'}, 1, exec_state);
   CheckScopeContent({y:98}, 2, exec_state);
 };
@@ skipping 40 matching lines @@
 
 // Catch block in function that is marked for optimization while being executed.
 BeginTest("Catch block 7");
 function catch_block_7() {
   %OptimizeFunctionOnNextCall(catch_block_7);
   try {
     throw 'Exception';
   } catch (e) {
     debugger;
   }
-};
+}
 
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Catch,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({e:'Exception'}, 0, exec_state);
 };
 catch_block_7();
 EndTest();
 
 
 assertEquals(begin_test_count, break_count,
              'one or more tests did not enter the debugger');
 assertEquals(begin_test_count, end_test_count,
              'one or more tests did not have its result checked');