Optimize isFinite and isNaN.

test/mjsunit/harmony/debug-blockscopes.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 184 matching lines @@
 // Simple empty block scope in local scope.
 BeginTest("Local block 1");
 
 function local_block_1() {
   {
     debugger;
   }
 }
 
 listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.Local,
+  CheckScopeChain([debug.ScopeType.Block,
+                   debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
+  CheckScopeContent({}, 1, exec_state);
 };
 local_block_1();
 EndTest();
 
 
-// Simple empty block scope in local scope with a parameter.
+// Local scope with a parameter.
 BeginTest("Local 2");
 
 function local_2(a) {
   {
     debugger;
   }
 }
 
 listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.Local,
+  CheckScopeChain([debug.ScopeType.Block,
+                   debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
-  CheckScopeContent({a:1}, 0, exec_state);
+  CheckScopeContent({a:1}, 1, exec_state);
 };
 local_2(1);
 EndTest();
 
 
 // Local scope with a parameter and a local variable.
 BeginTest("Local 3");
 
 function local_3(a) {
   let x = 3;
@@ skipping 20 matching lines @@
 
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({a:1,b:2,x:3,y:4}, 0, exec_state);
 };
 local_4(1, 2);
 EndTest();
 
 
-// Single variable in a block scope.
-BeginTest("Local 5");
-
-function local_5(a) {
-  {
-    let x = 5;
-    debugger;
-  }
-}
-
-listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.Block,
-                   debug.ScopeType.Local,
-                   debug.ScopeType.Global], exec_state);
-  CheckScopeContent({x:5}, 0, exec_state);
-  CheckScopeContent({a:1}, 1, exec_state);
-};
-local_5(1);
-EndTest();
-
-
-// Two variables in a block scope.
-BeginTest("Local 6");
-
-function local_6(a) {
-  {
-    let x = 6;
-    let y = 7;
-    debugger;
-  }
-}
-
-listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.Block,
-                   debug.ScopeType.Local,
-                   debug.ScopeType.Global], exec_state);
-  CheckScopeContent({x:6,y:7}, 0, exec_state);
-  CheckScopeContent({a:1}, 1, exec_state);
-};
-local_6(1);
-EndTest();
-
-
-// Two variables in a block scope.
-BeginTest("Local 7");
-
-function local_7(a) {
-  {
-    {
-      let x = 8;
-      debugger;
-    }
-  }
-}
-
-listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.Block,
-                   debug.ScopeType.Local,
-                   debug.ScopeType.Global], exec_state);
-  CheckScopeContent({x:8}, 0, exec_state);
-  CheckScopeContent({a:1}, 1, exec_state);
-};
-local_7(1);
-EndTest();
-
-
 // Single empty with block.
 BeginTest("With block 1");
 
 function with_block_1() {
   with({}) {
     debugger;
   }
 }
 
 listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.With,
+  CheckScopeChain([debug.ScopeType.Block,
+                   debug.ScopeType.With,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
   CheckScopeContent({}, 1, exec_state);
 };
 with_block_1();
 EndTest();
 
 
 // Nested empty with blocks.
 BeginTest("With block 2");
 
 function with_block_2() {
   with({}) {
     with({}) {
       debugger;
     }
   }
 }
 
 listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.With,
+  CheckScopeChain([debug.ScopeType.Block,
+                   debug.ScopeType.With,
+                   debug.ScopeType.Block,
                    debug.ScopeType.With,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
   CheckScopeContent({}, 1, exec_state);
   CheckScopeContent({}, 2, exec_state);
+  CheckScopeContent({}, 3, exec_state);
 };
 with_block_2();
 EndTest();
 
 
 // With block using an in-place object literal.
 BeginTest("With block 3");
 
 function with_block_3() {
   with({a:1,b:2}) {
     debugger;
   }
 }
 
 listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.With,
+  CheckScopeChain([debug.ScopeType.Block,
+                   debug.ScopeType.With,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
-  CheckScopeContent({a:1,b:2}, 0, exec_state);
+  CheckScopeContent({}, 0, exec_state);
+  CheckScopeContent({a:1,b:2}, 1, exec_state);
 };
 with_block_3();
 EndTest();
 
 
 // Nested with blocks using in-place object literals.
 BeginTest("With block 4");
 
 function with_block_4() {
   with({a:1,b:2}) {
     with({a:2,b:1}) {
       debugger;
     }
   }
 }
 
 listener_delegate = function(exec_state) {
-  CheckScopeChain([debug.ScopeType.With,
+  CheckScopeChain([debug.ScopeType.Block,
+                   debug.ScopeType.With,
+                   debug.ScopeType.Block,
                    debug.ScopeType.With,
                    debug.ScopeType.Local,
                    debug.ScopeType.Global], exec_state);
-  CheckScopeContent({a:2,b:1}, 0, exec_state);
-  CheckScopeContent({a:1,b:2}, 1, exec_state);
+  CheckScopeContent({a:2,b:1}, 1, exec_state);
+  CheckScopeContent({a:1,b:2}, 3, exec_state);
 };
 with_block_4();
 EndTest();
 
 
 // Simple closure formed by returning an inner function referering to an outer
 // block local variable and an outer function's parameter.
 BeginTest("Closure 1");
 
 function closure_1(a) {
@@ skipping 12 matching lines @@
 listener_delegate = function(exec_state) {
   CheckScopeChain([debug.ScopeType.Local,
                    debug.ScopeType.Block,
                    debug.ScopeType.Closure,
                    debug.ScopeType.Global], exec_state);
   CheckScopeContent({}, 0, exec_state);
   CheckScopeContent({a:1,x:2,y:3}, 2, exec_state);
 };
 closure_1(1)();
 EndTest();