OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 1 // Copyright 2015 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 // | 4 // |
5 // Flags: --harmony-destructuring --harmony-arrow-functions | 5 // Flags: --harmony-destructuring --harmony-arrow-functions |
6 // Flags: --harmony-default-parameters --harmony-rest-parameters | 6 // Flags: --harmony-default-parameters --harmony-rest-parameters |
7 | 7 |
8 (function TestObjectLiteralPattern() { | 8 (function TestObjectLiteralPattern() { |
9 var { x : x, y : y } = { x : 1, y : 2 }; | 9 var { x : x, y : y } = { x : 1, y : 2 }; |
10 assertEquals(1, x); | 10 assertEquals(1, x); |
(...skipping 723 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
734 })(); | 734 })(); |
735 | 735 |
736 | 736 |
737 (function TestParameterScoping() { | 737 (function TestParameterScoping() { |
738 var x = 1; | 738 var x = 1; |
739 | 739 |
740 function f1({a = x}) { var x = 2; return a; } | 740 function f1({a = x}) { var x = 2; return a; } |
741 assertEquals(1, f1({})); | 741 assertEquals(1, f1({})); |
742 function f2({a = x}) { function x() {}; return a; } | 742 function f2({a = x}) { function x() {}; return a; } |
743 assertEquals(1, f2({})); | 743 assertEquals(1, f2({})); |
744 function f3({a = x}) { 'use strict'; let x = 2; return a; } | 744 (function() { |
745 assertEquals(1, f3({})); | 745 'use strict'; |
746 function f4({a = x}) { 'use strict'; const x = 2; return a; } | 746 function f3({a = x}) { let x = 2; return a; } |
747 assertEquals(1, f4({})); | 747 assertEquals(1, f3({})); |
748 function f5({a = x}) { 'use strict'; function x() {}; return a; } | 748 function f4({a = x}) { const x = 2; return a; } |
749 assertEquals(1, f5({})); | 749 assertEquals(1, f4({})); |
| 750 function f5({a = x}) { function x() {}; return a; } |
| 751 assertEquals(1, f5({})); |
| 752 })(); |
750 function f6({a = eval("x")}) { var x; return a; } | 753 function f6({a = eval("x")}) { var x; return a; } |
751 assertEquals(1, f6({})); | 754 assertEquals(1, f6({})); |
752 function f61({a = eval("x")}) { 'use strict'; var x; return a; } | 755 (function() { |
753 assertEquals(1, f61({})); | 756 'use strict'; |
| 757 function f61({a = eval("x")}) { var x; return a; } |
| 758 assertEquals(1, f61({})); |
| 759 })(); |
754 function f62({a = eval("'use strict'; x")}) { var x; return a; } | 760 function f62({a = eval("'use strict'; x")}) { var x; return a; } |
755 assertEquals(1, f62({})); | 761 assertEquals(1, f62({})); |
756 function f7({a = function() { return x }}) { var x; return a(); } | 762 function f7({a = function() { return x }}) { var x; return a(); } |
757 assertEquals(1, f7({})); | 763 assertEquals(1, f7({})); |
758 function f8({a = () => x}) { var x; return a(); } | 764 function f8({a = () => x}) { var x; return a(); } |
759 assertEquals(1, f8({})); | 765 assertEquals(1, f8({})); |
760 function f9({a = () => eval("x")}) { var x; return a(); } | 766 function f9({a = () => eval("x")}) { var x; return a(); } |
761 assertEquals(1, f9({})); | 767 assertEquals(1, f9({})); |
762 function f91({a = () => eval("x")}) { 'use strict'; var x; return a(); } | 768 (function TestInitializedWithEvalArrowStrict() { |
763 assertEquals(1, f91({})); | 769 'use strict'; |
| 770 function f91({a = () => eval("x")}) { var x; return a(); } |
| 771 assertEquals(1, f91({})); |
| 772 })(); |
764 function f92({a = () => { 'use strict'; return eval("x") }}) { var x; return a
(); } | 773 function f92({a = () => { 'use strict'; return eval("x") }}) { var x; return a
(); } |
765 assertEquals(1, f92({})); | 774 assertEquals(1, f92({})); |
766 function f93({a = () => eval("'use strict'; x")}) { var x; return a(); } | 775 function f93({a = () => eval("'use strict'; x")}) { var x; return a(); } |
767 assertEquals(1, f93({})); | 776 assertEquals(1, f93({})); |
768 | 777 |
769 var g1 = ({a = x}) => { var x = 2; return a; }; | 778 var g1 = ({a = x}) => { var x = 2; return a; }; |
770 assertEquals(1, g1({})); | 779 assertEquals(1, g1({})); |
771 var g2 = ({a = x}) => { function x() {}; return a; }; | 780 var g2 = ({a = x}) => { function x() {}; return a; }; |
772 assertEquals(1, g2({})); | 781 assertEquals(1, g2({})); |
773 var g3 = ({a = x}) => { 'use strict'; let x = 2; return a; }; | 782 (function() { |
774 assertEquals(1, g3({})); | 783 'use strict'; |
775 var g4 = ({a = x}) => { 'use strict'; const x = 2; return a; }; | 784 var g3 = ({a = x}) => { let x = 2; return a; }; |
776 assertEquals(1, g4({})); | 785 assertEquals(1, g3({})); |
777 var g5 = ({a = x}) => { 'use strict'; function x() {}; return a; }; | 786 var g4 = ({a = x}) => { const x = 2; return a; }; |
778 assertEquals(1, g5({})); | 787 assertEquals(1, g4({})); |
| 788 var g5 = ({a = x}) => { function x() {}; return a; }; |
| 789 assertEquals(1, g5({})); |
| 790 })(); |
779 var g6 = ({a = eval("x")}) => { var x; return a; }; | 791 var g6 = ({a = eval("x")}) => { var x; return a; }; |
780 assertEquals(1, g6({})); | 792 assertEquals(1, g6({})); |
781 var g61 = ({a = eval("x")}) => { 'use strict'; var x; return a; }; | 793 (function() { |
782 assertEquals(1, g61({})); | 794 'use strict'; |
| 795 var g61 = ({a = eval("x")}) => { var x; return a; }; |
| 796 assertEquals(1, g61({})); |
| 797 })(); |
783 var g62 = ({a = eval("'use strict'; x")}) => { var x; return a; }; | 798 var g62 = ({a = eval("'use strict'; x")}) => { var x; return a; }; |
784 assertEquals(1, g62({})); | 799 assertEquals(1, g62({})); |
785 var g7 = ({a = function() { return x }}) => { var x; return a(); }; | 800 var g7 = ({a = function() { return x }}) => { var x; return a(); }; |
786 assertEquals(1, g7({})); | 801 assertEquals(1, g7({})); |
787 var g8 = ({a = () => x}) => { var x; return a(); }; | 802 var g8 = ({a = () => x}) => { var x; return a(); }; |
788 assertEquals(1, g8({})); | 803 assertEquals(1, g8({})); |
789 var g9 = ({a = () => eval("x")}) => { var x; return a(); }; | 804 var g9 = ({a = () => eval("x")}) => { var x; return a(); }; |
790 assertEquals(1, g9({})); | 805 assertEquals(1, g9({})); |
791 var g91 = ({a = () => eval("x")}) => { 'use strict'; var x; return a(); }; | 806 (function() { |
792 assertEquals(1, g91({})); | 807 'use strict'; |
793 var g92 = ({a = () => { 'use strict'; return eval("x") }}) => { var x; return
a(); }; | 808 var g91 = ({a = () => eval("x")}) => { var x; return a(); }; |
794 assertEquals(1, g92({})); | 809 assertEquals(1, g91({})); |
| 810 var g92 = ({a = () => { return eval("x") }}) => { var x; return a(); }; |
| 811 assertEquals(1, g92({})); |
| 812 })(); |
795 var g93 = ({a = () => eval("'use strict'; x")}) => { var x; return a(); }; | 813 var g93 = ({a = () => eval("'use strict'; x")}) => { var x; return a(); }; |
796 assertEquals(1, g93({})); | 814 assertEquals(1, g93({})); |
797 | 815 |
798 var f11 = function f({x = f}) { var f; return x; } | 816 var f11 = function f({x = f}) { var f; return x; } |
799 assertSame(f11, f11({})); | 817 assertSame(f11, f11({})); |
800 var f12 = function f({x = f}) { function f() {}; return x; } | 818 var f12 = function f({x = f}) { function f() {}; return x; } |
801 assertSame(f12, f12({})); | 819 assertSame(f12, f12({})); |
802 var f13 = function f({x = f}) { 'use strict'; let f; return x; } | 820 (function() { |
803 assertSame(f13, f13({})); | 821 'use strict'; |
804 var f14 = function f({x = f}) { 'use strict'; const f = 0; return x; } | 822 var f13 = function f({x = f}) { let f; return x; } |
805 assertSame(f14, f14({})); | 823 assertSame(f13, f13({})); |
806 var f15 = function f({x = f}) { 'use strict'; function f() {}; return x; } | 824 var f14 = function f({x = f}) { const f = 0; return x; } |
807 assertSame(f15, f15({})); | 825 assertSame(f14, f14({})); |
| 826 var f15 = function f({x = f}) { function f() {}; return x; } |
| 827 assertSame(f15, f15({})); |
| 828 })(); |
808 var f16 = function f({f = 7, x = f}) { return x; } | 829 var f16 = function f({f = 7, x = f}) { return x; } |
809 assertSame(7, f16({})); | 830 assertSame(7, f16({})); |
810 | 831 |
811 var y = 'a'; | 832 var y = 'a'; |
812 function f20({[y]: x}) { var y = 'b'; return x; } | 833 function f20({[y]: x}) { var y = 'b'; return x; } |
813 assertEquals(1, f20({a: 1, b: 2})); | 834 assertEquals(1, f20({a: 1, b: 2})); |
814 function f21({[eval('y')]: x}) { var y = 'b'; return x; } | 835 function f21({[eval('y')]: x}) { var y = 'b'; return x; } |
815 assertEquals(1, f21({a: 1, b: 2})); | 836 assertEquals(1, f21({a: 1, b: 2})); |
816 var g20 = ({[y]: x}) => { var y = 'b'; return x; }; | 837 var g20 = ({[y]: x}) => { var y = 'b'; return x; }; |
817 assertEquals(1, g20({a: 1, b: 2})); | 838 assertEquals(1, g20({a: 1, b: 2})); |
818 var g21 = ({[eval('y')]: x}) => { var y = 'b'; return x; }; | 839 var g21 = ({[eval('y')]: x}) => { var y = 'b'; return x; }; |
819 assertEquals(1, g21({a: 1, b: 2})); | 840 assertEquals(1, g21({a: 1, b: 2})); |
820 })(); | 841 })(); |
821 | 842 |
822 | 843 |
823 (function TestParameterDestructuringTDZ() { | 844 (function TestParameterDestructuringTDZ() { |
824 function f1({a = x}, x) { return a } | 845 function f1({a = x}, x) { return a } |
825 assertThrows(() => f1({}, 4), ReferenceError); | 846 assertThrows(() => f1({}, 4), ReferenceError); |
826 assertEquals(4, f1({a: 4}, 5)); | 847 assertEquals(4, f1({a: 4}, 5)); |
827 function f2({a = eval("x")}, x) { return a } | 848 function f2({a = eval("x")}, x) { return a } |
828 assertThrows(() => f2({}, 4), ReferenceError); | 849 assertThrows(() => f2({}, 4), ReferenceError); |
829 assertEquals(4, f2({a: 4}, 5)); | 850 assertEquals(4, f2({a: 4}, 5)); |
830 function f3({a = eval("x")}, x) { 'use strict'; return a } | 851 (function() { |
831 assertThrows(() => f3({}, 4), ReferenceError); | 852 'use strict'; |
832 assertEquals(4, f3({a: 4}, 5)); | 853 function f3({a = eval("x")}, x) { return a } |
| 854 assertThrows(() => f3({}, 4), ReferenceError); |
| 855 assertEquals(4, f3({a: 4}, 5)); |
| 856 })(); |
833 function f4({a = eval("'use strict'; x")}, x) { return a } | 857 function f4({a = eval("'use strict'; x")}, x) { return a } |
834 assertThrows(() => f4({}, 4), ReferenceError); | 858 assertThrows(() => f4({}, 4), ReferenceError); |
835 assertEquals(4, f4({a: 4}, 5)); | 859 assertEquals(4, f4({a: 4}, 5)); |
836 | 860 |
837 function f5({a = () => x}, x) { return a() } | 861 function f5({a = () => x}, x) { return a() } |
838 assertEquals(4, f5({a: () => 4}, 5)); | 862 assertEquals(4, f5({a: () => 4}, 5)); |
839 function f6({a = () => eval("x")}, x) { return a() } | 863 function f6({a = () => eval("x")}, x) { return a() } |
840 assertEquals(4, f6({a: () => 4}, 5)); | 864 assertEquals(4, f6({a: () => 4}, 5)); |
841 function f7({a = () => eval("x")}, x) { 'use strict'; return a() } | 865 (function() { |
842 assertEquals(4, f7({a: () => 4}, 5)); | 866 'use strict'; |
| 867 function f7({a = () => eval("x")}, x) { return a() } |
| 868 assertEquals(4, f7({a: () => 4}, 5)); |
| 869 })(); |
843 function f8({a = () => eval("'use strict'; x")}, x) { return a() } | 870 function f8({a = () => eval("'use strict'; x")}, x) { return a() } |
844 assertEquals(4, f8({a: () => 4}, 5)); | 871 assertEquals(4, f8({a: () => 4}, 5)); |
845 | 872 |
846 function f11({a = b}, {b}) { return a } | 873 function f11({a = b}, {b}) { return a } |
847 assertThrows(() => f11({}, {b: 4}), ReferenceError); | 874 assertThrows(() => f11({}, {b: 4}), ReferenceError); |
848 assertEquals(4, f11({a: 4}, {b: 5})); | 875 assertEquals(4, f11({a: 4}, {b: 5})); |
849 function f12({a = eval("b")}, {b}) { return a } | 876 function f12({a = eval("b")}, {b}) { return a } |
850 assertThrows(() => f12({}, {b: 4}), ReferenceError); | 877 assertThrows(() => f12({}, {b: 4}), ReferenceError); |
851 assertEquals(4, f12({a: 4}, {b: 5})); | 878 assertEquals(4, f12({a: 4}, {b: 5})); |
852 function f13({a = eval("b")}, {b}) { 'use strict'; return a } | 879 (function() { |
853 assertThrows(() => f13({}, {b: 4}), ReferenceError); | 880 'use strict'; |
854 assertEquals(4, f13({a: 4}, {b: 5})); | 881 function f13({a = eval("b")}, {b}) { return a } |
| 882 assertThrows(() => f13({}, {b: 4}), ReferenceError); |
| 883 assertEquals(4, f13({a: 4}, {b: 5})); |
| 884 })(); |
855 function f14({a = eval("'use strict'; b")}, {b}) { return a } | 885 function f14({a = eval("'use strict'; b")}, {b}) { return a } |
856 assertThrows(() => f14({}, {b: 4}), ReferenceError); | 886 assertThrows(() => f14({}, {b: 4}), ReferenceError); |
857 assertEquals(4, f14({a: 4}, {b: 5})); | 887 assertEquals(4, f14({a: 4}, {b: 5})); |
858 | 888 |
859 function f15({a = () => b}, {b}) { return a() } | 889 function f15({a = () => b}, {b}) { return a() } |
860 assertEquals(4, f15({a: () => 4}, {b: 5})); | 890 assertEquals(4, f15({a: () => 4}, {b: 5})); |
861 function f16({a = () => eval("b")}, {b}) { return a() } | 891 function f16({a = () => eval("b")}, {b}) { return a() } |
862 assertEquals(4, f16({a: () => 4}, {b: 5})); | 892 assertEquals(4, f16({a: () => 4}, {b: 5})); |
863 function f17({a = () => eval("b")}, {b}) { 'use strict'; return a() } | 893 (function() { |
864 assertEquals(4, f17({a: () => 4}, {b: 5})); | 894 'use strict'; |
| 895 function f17({a = () => eval("b")}, {b}) { return a() } |
| 896 assertEquals(4, f17({a: () => 4}, {b: 5})); |
| 897 })(); |
865 function f18({a = () => eval("'use strict'; b")}, {b}) { return a() } | 898 function f18({a = () => eval("'use strict'; b")}, {b}) { return a() } |
866 assertEquals(4, f18({a: () => 4}, {b: 5})); | 899 assertEquals(4, f18({a: () => 4}, {b: 5})); |
867 | 900 |
868 // TODO(caitp): TDZ for rest parameters is not working yet. | 901 // TODO(caitp): TDZ for rest parameters is not working yet. |
869 // function f30({x = a}, ...a) { return x[0] } | 902 // function f30({x = a}, ...a) { return x[0] } |
870 // assertThrows(() => f30({}), ReferenceError); | 903 // assertThrows(() => f30({}), ReferenceError); |
871 // assertEquals(4, f30({a: [4]}, 5)); | 904 // assertEquals(4, f30({a: [4]}, 5)); |
872 // function f31({x = eval("a")}, ...a) { return x[0] } | 905 // function f31({x = eval("a")}, ...a) { return x[0] } |
873 // assertThrows(() => f31({}), ReferenceError); | 906 // assertThrows(() => f31({}), ReferenceError); |
874 // assertEquals(4, f31({a: [4]}, 5)); | 907 // assertEquals(4, f31({a: [4]}, 5)); |
875 // function f32({x = eval("a")}, ...a) { 'use strict'; return x[0] } | 908 // function f32({x = eval("a")}, ...a) { 'use strict'; return x[0] } |
876 // assertThrows(() => f32({}), ReferenceError); | 909 // assertThrows(() => f32({}), ReferenceError); |
877 // assertEquals(4, f32({a: [4]}, 5)); | 910 // assertEquals(4, f32({a: [4]}, 5)); |
878 // function f33({x = eval("'use strict'; a")}, ...a) { return x[0] } | 911 // function f33({x = eval("'use strict'; a")}, ...a) { return x[0] } |
879 // assertThrows(() => f33({}), ReferenceError); | 912 // assertThrows(() => f33({}), ReferenceError); |
880 // assertEquals(4, f33({a: [4]}, 5)); | 913 // assertEquals(4, f33({a: [4]}, 5)); |
881 | 914 |
882 function f34({x = function() { return a }}, ...a) { return x()[0] } | 915 function f34({x = function() { return a }}, ...a) { return x()[0] } |
883 assertEquals(4, f34({}, 4)); | 916 assertEquals(4, f34({}, 4)); |
884 function f35({x = () => a}, ...a) { return x()[0] } | 917 function f35({x = () => a}, ...a) { return x()[0] } |
885 assertEquals(4, f35({}, 4)); | 918 assertEquals(4, f35({}, 4)); |
886 function f36({x = () => eval("a")}, ...a) { return x()[0] } | 919 function f36({x = () => eval("a")}, ...a) { return x()[0] } |
887 assertEquals(4, f36({}, 4)); | 920 assertEquals(4, f36({}, 4)); |
888 function f37({x = () => eval("a")}, ...a) { 'use strict'; return x()[0] } | 921 (function() { |
889 assertEquals(4, f37({}, 4)); | 922 'use strict'; |
| 923 function f37({x = () => eval("a")}, ...a) { return x()[0] } |
| 924 assertEquals(4, f37({}, 4)); |
| 925 })(); |
890 function f38({x = () => { 'use strict'; return eval("a") }}, ...a) { return x(
)[0] } | 926 function f38({x = () => { 'use strict'; return eval("a") }}, ...a) { return x(
)[0] } |
891 assertEquals(4, f38({}, 4)); | 927 assertEquals(4, f38({}, 4)); |
892 function f39({x = () => eval("'use strict'; a")}, ...a) { return x()[0] } | 928 function f39({x = () => eval("'use strict'; a")}, ...a) { return x()[0] } |
893 assertEquals(4, f39({}, 4)); | 929 assertEquals(4, f39({}, 4)); |
894 | 930 |
895 // var g30 = ({x = a}, ...a) => {}; | 931 // var g30 = ({x = a}, ...a) => {}; |
896 // assertThrows(() => g30({}), ReferenceError); | 932 // assertThrows(() => g30({}), ReferenceError); |
897 // var g31 = ({x = eval("a")}, ...a) => {}; | 933 // var g31 = ({x = eval("a")}, ...a) => {}; |
898 // assertThrows(() => g31({}), ReferenceError); | 934 // assertThrows(() => g31({}), ReferenceError); |
899 // var g32 = ({x = eval("a")}, ...a) => { 'use strict'; }; | 935 // var g32 = ({x = eval("a")}, ...a) => { 'use strict'; }; |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
962 assertEquals(1, (function({}, ...a) {}).length); | 998 assertEquals(1, (function({}, ...a) {}).length); |
963 assertEquals(1, (function({x}, {y} = {}) {}).length); | 999 assertEquals(1, (function({x}, {y} = {}) {}).length); |
964 assertEquals(1, (function({x}, {y} = {}, ...a) {}).length); | 1000 assertEquals(1, (function({x}, {y} = {}, ...a) {}).length); |
965 assertEquals(2, (function(x, {y}, {z} = {}) {}).length); | 1001 assertEquals(2, (function(x, {y}, {z} = {}) {}).length); |
966 assertEquals(2, (function({x}, {}, {z} = {}, ...a) {}).length); | 1002 assertEquals(2, (function({x}, {}, {z} = {}, ...a) {}).length); |
967 assertEquals(1, (function(x, {y} = {}, {z}) {}).length); | 1003 assertEquals(1, (function(x, {y} = {}, {z}) {}).length); |
968 assertEquals(1, (function({x}, {y} = {}, {z}, ...a) {}).length); | 1004 assertEquals(1, (function({x}, {y} = {}, {z}, ...a) {}).length); |
969 assertEquals(1, (function(x, {y} = {}, {z}, {v} = {}) {}).length); | 1005 assertEquals(1, (function(x, {y} = {}, {z}, {v} = {}) {}).length); |
970 assertEquals(1, (function({x}, {y} = {}, {z}, {v} = {}, ...a) {}).length); | 1006 assertEquals(1, (function({x}, {y} = {}, {z}, {v} = {}, ...a) {}).length); |
971 })(); | 1007 })(); |
| 1008 |
| 1009 |
| 1010 (function TestDirectiveThrows() { |
| 1011 "use strict"; |
| 1012 |
| 1013 assertThrows(function(){ eval("function({}){'use strict';}") }, SyntaxError); |
| 1014 assertThrows(function(){ eval("({}) => {'use strict';}") }, SyntaxError); |
| 1015 assertThrows( |
| 1016 function(){ eval("(class{foo({}) {'use strict';}});") }, SyntaxError); |
| 1017 |
| 1018 assertThrows( |
| 1019 function(){ eval("function(a, {}){'use strict';}") }, SyntaxError); |
| 1020 assertThrows(function(){ eval("(a, {}) => {'use strict';}") }, SyntaxError); |
| 1021 assertThrows( |
| 1022 function(){ eval("(class{foo(a, {}) {'use strict';}});") }, SyntaxError); |
| 1023 })(); |
OLD | NEW |